The Real Cost of Running a Personal AI Team (My Numbers)

People ask me this more than almost anything else. "Harel, this all sounds amazing — but what does it actually cost?" Fair question. I'm going to answer it with real numbers, not estimates, and I'm not going to round down to make it look cheap.

Running a 7-agent autonomous system is not free. It's also not as expensive as most people assume. Last month, my total spend was $94. The month before, $81. I'll show you exactly where every dollar goes.

---

The Setup You're Pricing

Before the numbers mean anything, you need to know what they're buying. My system has seven agents running continuously:

• Vision — morning orchestrator, reads the backlog, routes work
• Aria — runs the website, writes and ships articles autonomously
• Jams — LinkedIn content, social distribution
• Albert — financial tracking and analysis
• Martin — infrastructure, debugging, system health
• Ben — prototype shipping, frontend builds
• Tabu — sales, outreach, positioning

These agents share memory through Firestore. They communicate through a backlog queue. They run on Google Cloud Run, triggered by Cloud Scheduler. Some of them fire daily, some multiple times a day.

This is not a weekend experiment. It's production infrastructure. And it's been running for months.

---

The LLM API Bill

This is the biggest line item. I use Claude as the primary model across all agents. Let me break it down.

Monthly LLM spend: $51–$68

That range is real — it depends on how many autonomous runs fire and whether any agent hits a recursive loop (Martin has a circuit breaker for that now). The high end was early on, before I built ctxauditor.

ctxauditor is one of my prototypes. Its job is to audit the context window before every agent call — scoring each piece of injected memory for relevance on a 0–100 scale and stripping anything below threshold. Before I built it, I was sending an average of ~4,200 tokens of context per agent call. After, it dropped to ~2,900. That's a 31% reduction in input tokens, every single call.

If I run, say, 40 agent invocations in a day (which happens on heavy orchestration days), that's 52,000 tokens saved. At Claude's pricing for Sonnet, that's roughly $0.15/day or $4.50/month. Not dramatic — but it compounds, and it made my agents smarter because they stopped hallucinating from irrelevant context noise.

I also use LLM Cost Lens, another prototype, to watch spend in real time. It pulls from the Anthropic usage API, displays daily burn rate, flags unusual spikes, and sends me a WhatsApp alert if any single day crosses $4. I've gotten that alert twice. Both times it was a loop — once in Vision's morning run, once in Martin's debugging session. The alert let me kill it before it ran up a $30 day.

Without LLM Cost Lens, I'd be flying blind. I built it because the Anthropic console doesn't send alerts.

---

Infrastructure

Monthly infra spend: $18–$31

This splits across three things:

Google Cloud Run — $12–$22/month

Every agent runs as a Cloud Run service. I pay per CPU and memory per 100ms of invocation. Cloud Run goes to zero when not running, so I'm not paying for idle time.

The range reflects volume. On a slow week — fewer autonomous content runs, no heavy prototype testing — it's closer to $12. On a week where I'm shipping and debugging, it creeps toward $22. I've never blown past $25 in a single month.

One thing that surprised me: Cloud Run's cold start cost. When an agent hasn't run in a while, the first invocation takes 1.8–2.4 seconds just to spin up. That's not a cost issue, it's a latency issue — but I mention it because people assume serverless means instant. It doesn't.

Firestore — $3–$6/month

All shared memory lives in Firestore: agent session state, the backlog queue, published article indexes, citation logs, keyword maps. Seven agents reading and writing continuously. At Firebase's pricing, this runs $3–$6 depending on read/write volume.

I was worried this would scale aggressively. It hasn't. The document sizes are small — markdown, JSON — and I've been disciplined about not storing redundant state.

Domain and Vercel — $3/month

Flat. harelasaf.com through Google Domains, Vercel for deployment. Scratch that — I moved to Vercel's free tier for a while during a billing audit, but I switched back because Pro gives me better build logs and the $20/month felt right for production. I pay annual, so it averages about $3/month when you amortize it.

---

The Tools

Monthly tooling spend: $0–$15

This varies most. Some months I'm evaluating new dev tools; other months I'm running on the free tiers of everything.

Regular tools I actually pay for:

• GitHub — free tier, but I have one private org on Team for $4/month
• Notion — free for now; I migrated agent memory to Firestore, so I barely use it
• Anthropic API — already counted above
• Google Cloud — already counted above

I don't pay for Perplexity, ChatGPT Plus, or Gemini Advanced as separate subscriptions. The agents use API access, not consumer plans. This is an important distinction — consumer subscriptions give you the interface, API access gives you the actual capability at the cost of building your own interface. For an AI builder, API access wins every time.

---

The Math

Here's the full picture, last month:

Line Item	Cost
Claude API (Sonnet, Haiku mix)	$58
Google Cloud Run	$19
Firestore	$5
Vercel (amortized)	$3
GitHub Team (org)	$4
Misc tooling	$5
Total	$94

For $94/month, I have seven autonomous agents handling content creation, social distribution, financial tracking, infrastructure management, frontend shipping, and sales — running without me. The only thing I do is review outputs and make strategic decisions.

Compare that to a single junior contractor for a few hours a week. Or a monthly SaaS subscription to a bloated "AI platform" that gives you 10% of the capability and 200% of the friction.

---

Where People Over-Spend (And Where They Under-Invest)

I was wrong about this for a week when I first started: I thought infra would be the expensive part. It's not. LLM API tokens are the cost driver. Everything else is marginal.

The mistake most people make early: they don't build cost visibility. They let agents run, the API bill grows, and they have no idea which agent or which pattern is expensive. LLM Cost Lens took me two days to build. It's paid for itself dozens of times over.

The second mistake: not pruning context. Every token you send to an LLM costs money. If your agent is injecting 6,000 tokens of boilerplate system context on every call, you're burning cash on noise. ctxauditor showed me that 38% of my pre-optimization context was below a relevance score of 40 — essentially garbage tokens I was paying to send.

The under-investment I see most: agent memory architecture. People bolt on a vector database early, pay $30–$50/month for it, and never actually improve recall because the retrieval layer is poorly designed. I use Firestore with structured JSON, good field naming, and disciplined write hygiene. Simple, cheap, effective.

---

What This Buys You

At $94/month, I'm not saving money compared to doing nothing. I'm running at a scale of output that a single person cannot reach alone.

This month, the system shipped:

• 8 articles to harelasaf.com (Aria's daily loop)
• 14 LinkedIn posts (Jams)
• 3 financial reports (Albert)
• 2 prototype case studies (Ben and Vision)
• 1 sales outreach sequence (Tabu)

That's output that would take a full-time content team and a part-time dev. For $94 and my strategic direction.

The ROI question is real but it's not "does the AI pay for the $94." It's "does the compounding content and positioning surface business opportunities." The answer, so far, is yes — I've had three inbound inquiries from people who found me through harelasaf.com articles that Aria shipped autonomously.

---

Should You Build This?

Only if you're willing to architect it, not just assemble it. The cost is low. The cognitive investment to design the agent system, the memory architecture, the context strategy — that's the real price.

If you're a solo operator, founder, or consultant who wants to run at a higher scale of output: the infrastructure cost is not the barrier. The barrier is building agents that are actually reliable enough to run unsupervised.

That's what I do. And $94/month is what it currently costs me to do it.

---

FAQ

How much does it cost to run a personal AI agent system per month?

My 7-agent system runs for $81–$94/month. The biggest cost is Claude API calls ($51–$68), followed by Google Cloud Run ($12–$22), Firestore ($3–$6), and tooling. LLM tokens are the primary cost driver — everything else is marginal by comparison.

What LLM model do I use for AI agents?

I use Claude Sonnet as the primary model across most agents, with Claude Haiku for lightweight routing and classification tasks. I don't use consumer ChatGPT or Gemini plans — API access gives far more flexibility than subscription interfaces for autonomous agent systems.

What is ctxauditor and how does it save money?

ctxauditor is a prototype I built that audits the context window before every LLM call. It scores each piece of injected memory for relevance (0–100) and strips anything below threshold. This reduced my average context from ~4,200 to ~2,900 tokens — a 31% cut in input token costs, plus fewer hallucinations from irrelevant context noise.

What is LLM Cost Lens?

LLM Cost Lens is a monitoring prototype I built on top of the Anthropic usage API. It tracks daily spend, flags spikes, and sends a WhatsApp alert if any single day crosses a budget threshold. It caught two agent loops before they ran up large bills. Without real-time cost visibility, you're flying blind.

Is Google Cloud Run cheap for AI agents?

Yes, for this use case. Cloud Run scales to zero when idle, so I only pay for actual compute time. My 7-agent system costs $12–$22/month on Cloud Run — far cheaper than a VPS running 24/7. Cold starts (1.8–2.4 seconds) are the main tradeoff, not cost.

Do I need a vector database for AI agent memory?

Not necessarily. I store all shared agent memory in Firestore — structured JSON documents, disciplined field naming, no vector DB. Monthly Firestore cost is $3–$6. Many builders pay $30–$50/month for vector DBs without meaningfully better recall because the retrieval layer is poorly designed. Start simple.

How do I know which AI agent is costing the most?

Build cost attribution from day one. LLM Cost Lens tags every API call with the agent identifier, so I can see which agent is burning the most tokens and why. Without attribution, all you see is a total bill with no actionable breakdown.

Can a solo operator realistically run a 7-agent AI system?

Yes — but the challenge isn't cost, it's architecture. The $94/month infrastructure is accessible. What requires real investment is designing agents that are reliable enough to run unsupervised: clean memory architecture, context management, circuit breakers for loops, and a review layer for outputs that touch the public. That design work is the actual barrier.