What a Multi-Agent AI Team Actually Costs Per Month (Every Line Item, One Real Invoice)

Every "AI agents are cheap now" post quotes the price of a thousand tokens and stops there. Then you run a real team for a month and the invoice has line items nobody mentioned. The token price was the smallest surprise.

We ran a 5-agent team in production for 30 days. Last time we wrote about the org chart that survived and what broke. This one is the bill — every line, the estimate we got wrong, and where the money actually went.

The estimate that was wrong by 5x

We modeled cost the way everyone does the first time: average tokens per task, times tasks per day, times the model's price. That math said ~$800/month.

The first invoice was $4,200.

The gap wasn't a pricing surprise. It was a call-count surprise. We'd assumed a task was about 3 LLM calls — plan, do, done. Real tasks averaged 11 calls each. Intake normalizes, Planner expands, Executor calls a tool, reads the result, calls another, Verifier checks, something fails and a step repeats. Every one of those is a separate billable inference, and they stack fast.

Lesson 1: your bill is call-count times context size, not task-count times token-price. If you estimate agent cost from a single round-trip, you will be wrong by the number of round-trips you forgot to count.

We budgeted for 3 calls per task. Real work averaged 11. That gap is the whole overrun.

How many tokens an AI agent burns per task, the honest number

So how much does one agent task actually cost, and how many tokens does it really burn? For our pipeline, a simple single-step task ran 4–6 calls and landed around $0.02–$0.05. A multi-step task that woke the Planner and looped through the Executor ran 10–20 calls and cost $0.15–$0.60. A rare deep task that chained many tool calls could touch $1+.

The number that matters isn't the average — it's the tail. A handful of expensive conversations per day drove more than half the monthly spend. Budget for the tail, not the median, or the median will lie to you.

The hidden driver underneath all of it: accumulated context. Every call sends the entire conversation history, not just the new message. Turn one costs a little, turn two re-sends turn one, turn ten re-sends everything before it. On a long agent conversation the input tokens grow every step, and input is where the money is — not the output.

Lesson 2: the cost of a conversation is dominated by context you re-send, not text you generate. Trim, summarize, or reset context between phases or you pay for the whole history on every single step.

Every turn re-sends the full history. Input tokens compound — that's the tax nobody quotes.

The full monthly line items

Here's the part the tutorials skip — the whole bill, not just the model.

Line item	What it is	Share of spend
LLM API tokens	Every agent call, dominated by re-sent context	~60%
Vector database	Memory/retrieval store, hosted	~12%
Compute / hosting	The always-on service running the loop	~10%
Monitoring & tracing	Per-step traces, error tracking, dashboards	~8%
Prompt tuning (human hours)	10–20 hrs/month keeping prompts from drifting	~10%

That last row is the one no calculator shows you. Someone on the team spends real hours every month re-tuning prompts as inputs shift, and that time is a running cost even though it never appears on the API invoice. Count it, or your "cost per task" is fiction.

Lesson 3: tokens are the majority of the bill, not all of it. Vector DB, hosting, tracing, and human tuning hours are 30–40% combined. A cost model that only counts tokens undershoots by roughly a third.

Where the overrun actually came from: retry loops

We covered this in the last post, but it's the single biggest cost story so it belongs on the invoice page too. The 5x overrun wasn't the model being expensive — it was retry loops with no ceiling. An agent hits a transient failure, retries, fails, retries again, forever. Each retry is a full billable pass, and because context grows, retry ten costs far more than retry one. One stuck task ran up hundreds of calls overnight.

The fix cost two lines of policy: exponential backoff plus a hard max-retry count, and a per-task token budget that fails the task loudly when it's hit. A failed task is cheap. A runaway task is a $47K horror story you'll find plenty of on Medium.

Lesson 4: an uncapped retry is an uncapped invoice. Circuit breakers and per-task budgets are cost controls, not reliability nice-to-haves.

Uncapped retries compound because context grows each pass. A hard budget stops the bleed.

How we cut it 40–60% without changing what it does

Same tasks, same outputs, most of the bill gone — from a few boring moves:

• Model mix, not one frontier model everywhere. We were running every agent on a Sonnet-tier model. The coordinator and Verifier genuinely need it; Intake and the worker steps do not. Moving the workers to a Haiku-tier model cut token cost 40–60% with no measurable quality drop. Most of your agents are doing shape-work, not reasoning — stop paying reasoning prices for it.
• Context resets between phases. Intake doesn't need the Planner's history. Resetting context at phase boundaries stopped us re-sending dead history on every call.
• Skip agents that don't need to run. Single-step tasks bypass the Planner entirely. Work that doesn't run isn't billed.
• Cache the stable prefixes. System prompts and tool definitions repeat on every call. Prompt caching them took a real chunk off input cost for free.

Lesson 5: cost optimization is model routing plus context hygiene, not a smaller model everywhere. Match each agent to the cheapest model that does its job, and stop shipping context that agent doesn't need.

Coordinator and verifier stay frontier-tier. Workers drop to a cheaper tier. Half the bill, same output.

The shape of a cost model that doesn't lie

Strip it down and an honest monthly estimate for an agent team is:

• Calls per task, measured — not assumed. Instrument it before you extrapolate.
• Context size per call, including re-sent history. The compounding part is where budgets die.
• The tail, not the median. A few expensive conversations set your bill.
• Non-token lines. Vector DB, hosting, tracing, and human tuning hours — roughly a third on top.
• Hard ceilings. Retry caps and per-task token budgets, wired in before launch, not after the invoice.

We got tired of rebuilding these controls — the model routing, the per-task budgets, the context resets, the traces — for every project, so we packaged them into one-team. If you'd rather not learn the $4,200 lesson firsthand, that's what it's for.

The tokens were never the expensive part. The calls you forgot to count were.

---

What did your first real agent invoice look like versus your estimate? Curious where other teams got surprised.