Multi-Agent System Cost: Why Orchestrators Cost 3 to 6x

A manager agent delegating to four workers reads 362,600 input tokens and writes 17,100 output tokens to complete a task that a single 12-step agent finishes with 172,800 input and 4,800 output. That is 2.1 times the input, 3.6 times the output. All on Claude Sonnet 5 ($2 / $10 per million) the system costs $0.90 against $0.39 for the single agent. All on Claude Opus 5 ($5 / $25) it costs $2.24, 5.7 times the single Sonnet run.

Frameworks are not the cost; LangGraph, CrewAI, the OpenAI Agents SDK and the Claude Agent SDK are open source. The cost is context: every agent rebuilds it, every handoff copies it, every manager turn re-sends it.

Here is the accounting behind those numbers. A single agent has a 4,000-token prefix (system prompt plus tools), a 500-token task, and twelve steps that each add a 300-token tool call and a 1,500-token result. Its input summed over twelve steps is 172,800 tokens; output is 4,800.

Now split the same task. Four workers each get a 3,000-token prefix, a 500-token brief, and run eight steps. Per worker: 8 × 3,500 + 1,800 × 28 = 78,400 input, 8 × 300 + a 1,000-token report = 3,400 output. Four workers: 313,600 input, 13,600 output.

The manager has a 4,500-token starting context. It plans (800 tokens out), then for each worker it sends a 300-token dispatch and receives a 1,500-token wrapped report, then writes a 1,500-token synthesis. Its six turns send 4,500 + 5,300 + 7,100 + 8,900 + 10,700 + 12,500 = 49,000 input tokens and 3,500 output.

Four things drive the multiplier: four separate prefixes instead of one, eight-step workers that each re-send their growing context, a manager that re-sends its own, and 3.6 times the output tokens because every worker writes a report and the manager rewrites them. Output is five times the price of input on every model in the table, so that last factor hurts most.

A worker's 1,000-token report is paid for once as worker output ($10 per million on Sonnet 5) and then again as manager input on every subsequent manager turn. In the sequential pattern above the first report is re-sent four more times, the second three, and so on. That is 15 re-sends of 1,500-token wrapped reports, or 22,500 of the manager's 49,000 input tokens, spent re-reading things it already read.

Handoffs also carry framing: the brief repeats the task, the report repeats context. In our experience that adds 20 to 40% to the raw finding, so cap worker output by instruction ("at most 300 words, no preamble").

Sequential dispatch lets worker 2 see what worker 1 found, but grows the manager's context every turn. Parallel dispatch sends all four briefs in one turn and reads all four reports in one turn: 4,500 + 5,300 + 11,900 = 21,700 manager input tokens instead of 49,000, and about a quarter of the wall-clock time.

On an Opus 5 manager the difference is 27,300 × $5 = $0.14 per run; on Sonnet 5 it is $0.05. But if the sub-tasks overlap, parallel workers repeat each other's tool calls, and four repeated 1,500-token searches cost more than the manager saved. Use parallel for independent sub-tasks, sequential when later workers depend on earlier findings.

The planner reads the fewest tokens and makes the decisions that cost the most when wrong, so it is the one node where a flagship earns its price. Workers execute well-specified sub-tasks with tools, which is what cheap models do reliably.

Suggested pairings with per-million rates:

• Planner: Claude Opus 5 ($5 / $25) or GPT-5.5 ($5 / $30)
• Workers: Claude Haiku 4.5 ($1 / $5), GPT-5.4 mini ($0.75 / $4.50), Gemini 3.8 Flash ($0.75 / $3.75) or DeepSeek V4 Flash ($0.05 / $0.16)
• Middle ground when workers need judgement: Claude Sonnet 5 ($2 / $10) or GPT-5.4 ($2.50 / $15)

The cheapest worker that still does this reliably, for structured tool calls on clear briefs, is DeepSeek V4 Flash; see [DeepSeek V4 for AI agents](/guides/deepseek-v4-for-ai-agents-cost) for where it fails. Pay for Sonnet 5 or GPT-5.4 workers when sub-tasks are ambiguous or run more than ten steps, because a cheap worker that wanders re-sends its context on every wasted step and the manager then pays to read a bad report. The wider ranking is in [cheapest LLM for AI agents](/guides/cheapest-llm-for-ai-agents).

Task: "Compare three vendors' pricing pages and write a recommendation." One planner, three workers each running eight steps (78,400 input, 3,400 output per worker; 235,200 and 10,200 combined), sequential dispatch, manager turns of 4,500 + 5,300 + 7,100 + 8,900 + 10,700 = 36,500 input and 3,200 output.

For comparison, a single Sonnet 5 agent doing the whole thing in 12 steps is $0.39. Multi-agent only wins on cost when the workers are cheap. Prompt caching (roughly 10% for cache reads on Anthropic and OpenAI) applies to every row and mostly to the workers, whose prefix is re-sent eight times each; the [prompt caching comparison](/compare/ai-prompt-caching-costs) has the rates. Model your own split in the [calculator](/calculator).

LangGraph, CrewAI, the OpenAI Agents SDK and the Claude Agent SDK are free to install and run; their vendors sell optional hosting and observability, priced on their own pages. What each framework does cost you is scaffolding: role and goal templates, tool-use instructions, handoff descriptions and output-format rules that get prepended to every model call. In our experience this runs from a few hundred tokens per step on the thinner SDKs to a couple of thousand on the more opinionated ones, and it is re-sent on every step of every agent.

Measure it once with the vendor's token counter, with and without the framework's default prompt, and override the template if it outweighs your own. The same measurement applies to MCP tool lists, covered in [MCP server token cost](/guides/mcp-server-token-cost).

With the OpenAI Agents SDK, each Agent carries its own model, so the planner and workers are priced independently and the worker is exposed to the planner as a tool:

from agents import Agent, Runner, function_tool

@function_tool
def fetch_pricing_page(url: str) -> str:
    return http_get(url)[:6000]          # cap the result: ~1,500 tokens

worker = Agent(
    name="researcher", model="gpt-5.4-mini",            # $0.75 / $4.50 per 1M
    instructions="Answer one sub-question with the tool. Max 300 words, no preamble.",
    tools=[fetch_pricing_page],
)
planner = Agent(
    name="planner", model="gpt-5.5",                    # $5 / $30 per 1M
    instructions="Split the task into at most 3 sub-questions, delegate, then write the recommendation.",
    tools=[worker.as_tool(tool_name="research", tool_description="Research one sub-question")],
)
result = Runner.run_sync(planner, task, max_turns=8)
planner_in = sum(r.usage.input_tokens for r in result.raw_responses)
planner_out = sum(r.usage.output_tokens for r in result.raw_responses)
# planner cost = planner_in * 5 / 1e6 + planner_out * 30 / 1e6; workers log their own

In LangGraph, give each node its own model client; in CrewAI, set llm per agent. See [OpenAI Agents API cost](/guides/openai-agents-api-cost) for how the SDK reports usage.

Multi-agent systems fail expensively because one confused worker can loop while the manager waits. Apply the guardrails per agent, not just per run:

• max_tokens on every call, and an output word limit in every worker's instructions
• max_turns (or the framework equivalent) on each worker, typically 8 to 12, and on the manager, typically 6 to 10
• A stop condition each worker can trigger: a report tool that ends its loop
• A per-run dollar budget summed from every agent's usage fields, with the manager aborting when it is exceeded

The [token budget guardrails](/guides/ai-agent-token-budget-guardrails) article has a runner you can wrap around each node. For overnight fan-out where latency does not matter, the Batch API at roughly 50% off applies to workers as easily as to single calls; see [batch API pricing compared](/compare/llm-batch-api-pricing).