Fan work out to a team of subagents and the intuition splits two ways: either you pay for every extra model, or the orchestrator finally stops drowning in file dumps it never rereads. The research points firmly at the second — if, and only if, the returns stay compact.
Does distributing across subordinates reduce the bill, or grow it?
Distributing work across subagents reduces the bill when the compression is real. A subagent that reads roughly 6,100 tokens of files and returns a ~420-token summary keeps the ~9,500 tokens of intermediate work out of the orchestrator's context entirely . The mechanism is compression, not delegation: what saves tokens is reading less irrelevant context into the shared window, not making fewer model calls.
Quick Answer: The orchestrator-worker pattern cuts tokens because subagents work in isolated context and return only distilled results. LangChain's benchmark shows a routed subagent approach using ~9,000 tokens across 5 calls versus ~15,000 for a monolithic approach — 40% fewer tokens despite more model calls.
The clearest numeric case comes from LangChain's multi-agent documentation: a monolithic "skills" approach costs about 15,000 tokens across 3 model calls because loaded context accumulates and is reprocessed, while a routed subagent approach costs about 9,000 tokens across 5 calls . More calls, 40% fewer tokens. Anthropic's Research system, published June 13, 2025, applies the same shape: a lead agent spins up 3–5 parallel subagents and synthesizes only their distilled findings, so orchestrator context does not grow proportionally with task breadth .
| Approach | Model calls | Total tokens |
|---|---|---|
| Monolithic "skills" | 3 | ~15,000 |
| Routed subagents | 5 | ~9,000 |
The baseline reality tempers the enthusiasm. Anthropic reports that agents use roughly 4× the tokens of chat and multi-agent systems reach about 15× . The pattern only nets positive when output contracts keep each subordinate's return compact.
"Token usage by itself explains 80% of the variance" in performance — the empirical basis for distributing work across separate-context agents (source: Anthropic Engineering, 2025-06).
Sizing your brief before you decompose
Sizing the brief means handing each subordinate only the query and its constraints — never the full document corpus. Pre-loading the orchestrator with everything before delegating defeats the purpose: the point is that noisy reads happen downstream, in isolated context, so the lead never ingests them. Scope the rule-loading per subordinate too. On one real monorepo, a full-scope run loaded roughly 16,800 tokens of rules before reading any code, while a backend-scoped subordinate loaded about 4,300 — a 4× cut before file reads even begin.
Before splitting the work, confirm the sub-tasks are genuinely parallelizable. Anthropic notes that coding has fewer truly separable sub-tasks than research ; forcing subordinates onto interdependent work produces redundant retrievals and conflicting results. Then assign model tiers deliberately — lead on a frontier-tier model, subordinates on a faster, lighter one like Haiku. The reported 5–10× per-query savings come from that tier split, not from the distributed structure alone.
Enforce a tight return contract for every downstream handoff
Isolation only saves tokens if each subordinate returns a compressed result, not a wall of text. The compression — not the delegation — is where the savings live, so define the return contract before any downstream agent runs. A subordinate that does 10,000 tokens of internal work but hands back a 500-token structured summary saves 9,500 tokens; one that returns an 8,000-token report saves only 2,000 . Follow four steps to lock that in.
- Define the output schema first. Set a maximum bullet count, required fields per finding (severity level, a file reference, a one-sentence description), and a hard character ceiling on the response body. Without an explicit cap, subordinate isolation is not free context savings.
- Persist, then pass a reference. Have subordinates write full outputs to a filesystem or artifact store and return only a lightweight pointer to the orchestrator. Anthropic recommends this because copying large outputs through conversation history raises overhead and degrades fidelity ; Microsoft's Azure guidance similarly advises persisting shared state externally and scoping it to the minimum necessary .
- Separate roles by permission. Strip edit/write access from any agent holding the delegation (Task) tool, and block executors from spawning their own sub-delegations. Praetorian enforces exactly this split in production to stop coordinators doing the work and executors opening runaway context loops .
- Evaluate outcomes, not paths. Score final factuality and citation quality, not whether a fixed intermediate route was followed. The subordinate's reasoning trace is discarded by design, so path-checking evals measure the wrong thing.
"Have subagents write their outputs to a filesystem to minimize the 'game of telephone,'" — Anthropic Engineering, on its multi-agent research system (source: Anthropic).
When the invoice rises despite the extra hops
Delegation raises the bill whenever the compression that justifies it never happens. The most common misfire is a subordinate that returns a wall of text: one that burns 10,000 tokens of internal reasoning but hands back 8,000 saves only 2,000, versus the 9,500 saved by a 500-token structured summary . Without an enforced output contract, isolation stops paying for itself.
Three failure modes recur:
- Shared-thread architectures. AutoGen's Group Chat Manager exposes all prior participant messages to each new speaker, so context accumulates every turn and isolation never holds unless you constrain it .
- Overlapping responsibilities. Redundant retrievals inflate synthesis overhead; Amazon Bedrock's supervisor guidance explicitly advises minimizing overlap between collaborators .
- No parallelizable surface. For sequential procedural tasks with low breadth, a 2026 arXiv paper finds in-context prompting can outperform external orchestration — the per-call floor of a distributed arrangement exceeds any savings when there is nothing to fan out .
Anthropic's own note that coding has fewer truly parallelizable tasks than research is the practical tell: match the pattern to breadth, or the extra hops just add cost.
Extending breadth horizontally on a fraction of the bill
With return contracts enforced, breadth becomes the cheap axis to scale. Anthropic's Research system reports parallelization cut research time by up to 90% on complex, multi-domain queries — a gain that only holds when tight output schemas keep each subagent's return small. Breadth also lifts quality: on OpenAI's BrowseComp (released April 10, 2025; 1,266 hard, verifiable browsing problems), aggregating 64 sampled outputs improved performance 15–25% over a single attempt , evidence that persistence and search strategy beat dumping more documents into one prompt.
Two levers come next. Claude Code's sub-agent docs recommend Haiku-tier models for subordinates doing file reads or log searches — the concrete model-tier split after output contracts are tight. And MAO-ARAG (arXiv, August 1, 2025) trains the coordinator as an RL policy with a cost penalty, selecting executors by query complexity — pointing toward learned, not hand-coded, decomposition. The takeaway: fan out for breadth, cap every return, route the grunt work to a cheaper tier.
Frequently asked questions
Why do multi-agent systems use 15× more tokens than regular chat?
Because every agent call carries its own full context load, and the orchestrator additionally processes the aggregated summaries each subordinate returns. Anthropic reports that agents use roughly 4× the tokens of a chat interaction and multi-agent systems around 15× . That figure is a system-level total, not a per-call cost — tight output contracts on subordinates (a capped bullet count, required fields, a hard character ceiling) bring it down substantially, which is why the pattern only pays off when task value is high .
How does a subagent actually keep the orchestrator's context small?
The subordinate does the noisy work — file reads, searches, log exploration — inside its own isolated context window and returns only a distilled summary. The orchestrator receives the result, not the raw file contents or the intermediate reasoning trace, so a task decomposed across subagents does not grow the parent's context in proportion to its complexity . Claude Code's docs frame this exactly: reach for a subagent when a side task would otherwise flood the main conversation with output you won't reference again .
What makes a return contract tight enough to actually save tokens?
An explicit schema, not a vague instruction. Specify a maximum bullet count, the required fields per finding — for example a severity level, a file reference, and a one-sentence description — plus a hard character ceiling. A subagent that does 10,000 tokens of internal work but returns a 500-token structured summary saves 9,500 tokens; one that returns an 8,000-token report saves only 2,000 . Instructions like "summarize what you found" reliably produce oversized, expensive responses, so the compression — not the delegation — is where the savings live.
When is the orchestrator-subagent pattern the wrong choice?
When sub-tasks are tightly interdependent and cannot genuinely run in parallel, or for short procedural tasks where the per-call floor of a distributed arrangement exceeds any compression gain. Anthropic notes that coding has fewer truly parallelizable tasks than research , LangChain warns that not every complex task needs multi-agent architecture , and a 2026 arXiv paper argues that for procedural tasks in-context prompting can outperform external orchestration.
Does Anthropic's multi-agent Research system actually improve quality, or just reduce spend?
Both. Anthropic's internal benchmark found a multi-agent setup with Claude Opus 4 as lead and Claude Sonnet 4 subagents outperformed single-agent Claude Opus 4 by 90.2% on breadth-first research queries, and reports parallelization cut research time by up to 90% for complex tasks . The same work found token usage alone explains 80% of the variance in performance, which is the empirical basis for distributing work across separate-context agents rather than dumping everything into one prompt .
Enjoyed this article? Subscribe to get new stories by email whenever they're published.
