Multi-Agent vs Single-Agent Cost
More agents looks like a free efficiency win — each does less, so it should cost less. It isn't: every agent duplicates the shared context. This calculator finds the exact step-count break-even.
For engineers deciding whether to split a task across specialized sub-agents — computes the exact step-count break-even against the shared-context duplication tax splitting actually costs, not a 'more agents is more efficient' assumption.
Model prices from OpenRouter · updated 2026-07-13
01 Shared context tax vs quadratic accumulation
02 One agent vs 5, at this step count
Splitting wins by $1.02/task (57%).
Break-even: 7.3 steps
At 30,000 tasks/mo: $53,130 (1 agent) vs $22,650 (5 agents)
Related cost calculators
Inference prices from OpenRouter, snapshot 2026-07-13, synced daily. No separate hand-verified data source — this is an architecture comparison (shared-context duplication vs quadratic accumulation), not a pricing lookup. All math runs in your browser.
How the math works
Splitting your workload across 5 sub-agents looks like a free efficiency win — each agent does less work, so it should cost less. It isn't automatic: every sub-agent is its own context window, so the 8,000-token shared task brief has to be re-sent to each one — $0.08 in duplicated context, a tax that scales linearly with agent count.
What splitting buys back: a single agent handling all 30 steps re-reads every prior step's output before each new one — cumulative input that grows quadratically, $1.31 here. Divide the same steps across 5 agents and each one only accumulates over its own share — the quadratic cost drops to $0.23.
Same baseline, one identity: single-agent cost (shared context once + quadratic accumulation + output) = $1.77/task. Multi-agent cost (shared context × 5 + reduced quadratic + the same output cost) = $0.76/task. Splitting wins by $1.02/task (57%) at this step count.
The number that matters isn't "how many agents" — it's the break-even: 7.3 steps. This is a pure function of shared-context size, step-token size, and agent count — it doesn't depend on price or volume, so it holds even if the model changes. Below it, one agent handling everything is cheaper; above it, the quadratic savings from splitting overtake the duplication tax.
Not modeled: the orchestrator's own cost to read and merge sub-agent outputs (a real coordinating-agent call this page ignores) — so the true step count needed for splitting to win is likely a bit higher than shown here. Inference prices sync daily from OpenRouter (updated 2026-07-13); this comparison is architecture, not pricing — all math runs client-side with tested code.
Frequently asked questions
Should your workload be split across multiple agents?
At this page's defaults — 30 steps, 5 agents, 8,000-token shared context — yes: splitting saves $1.02/task (57%). Tune the sliders for your real workload.
How many steps until splitting into multiple agents pays off?
7.3 steps — the point where a single agent's quadratic context-accumulation cost equals the multi-agent shared-context duplication tax. This break-even is set only by shared-context size, step size, and agent count; it doesn't move with token prices or task volume.
Why does splitting into agents cost anything extra at all?
Because each sub-agent is a separate context window — it can't see what the other sub-agents already know, so the shared task brief or reference docs have to be sent again in every sub-agent's prompt. At 5 agents that's the 8,000-token brief repeated 5 times: $0.08 total, versus reading it once ($0.02) in a single continuous conversation.
Why does a single agent get expensive as the task grows?
Because it has to re-read everything it generated so far before every new step — a conversation history that grows with each step, so the total re-read cost grows quadratically, not linearly. At 30 steps that's $1.31 just in re-reads, on top of the actual output.
Does this include the cost of coordinating the sub-agents?
No — this page compares only the shared-context duplication tax against the quadratic-accumulation savings. A real orchestrator that merges sub-agent outputs adds its own (usually smaller) cost, which would push the true break-even step count slightly higher than shown here.
Are these prices current?
Inference prices sync daily from OpenRouter (updated 2026-07-13). This mold uses no separate hand-verified data source — it's a pure architecture comparison (context duplication vs quadratic accumulation), not a pricing lookup, so it stays accurate as prices change automatically.