Evidence correction, 2 November 2026: an earlier version of this post showed a code sample that sent a shared system prompt as an
@cache:<id>reference and said it was "referenced by ID, not retransmitted". No provider supports that, and neither does Nadir: prompt caching discounts a resent prefix, but every request still sends it. The sample and the checklist are fixed below. The post also understated the MCP tool-schema load, credited a GitHub user report to an independent audit, cited a Codex subagent limit its docs no longer state, and attributed Anthropic's 80% variance figure to the wrong evaluation. Those are corrected, and the cost model is now labelled with the July 2026 prices it uses.
Anthropic's multi-agent research system, and the 15x number
Anthropic's multi-agent research system, described in its June 13, 2025 engineering post, uses a Claude Opus 4 lead agent that plans a research task and spawns Claude Sonnet 4 subagents to search in parallel. It beat a single Opus 4 agent by 90.2% on Anthropic's internal research eval. The cost: "agents typically use about 4× more tokens than chat interactions, and multi-agent systems use about 15× more tokens than chats." Source: Anthropic Engineering, "How we built our multi-agent research system," June 13, 2025
That is not a warning buried in a limitations section. It is stated as the cost of the architecture doing its job well. Anthropic's data explains why teams pay it: on the BrowseComp evaluation, token usage by itself explained 80% of the performance variance. Multi-agent systems are measurably better at the tasks they are built for. On Anthropic's own numbers, they also use about 3.75x the tokens of a single agent, and 15x a chat, while most cost-optimization advice is still written for the single agent.
Multi-agent went from research pattern to standard infrastructure in about six months
Google donated its Agent2Agent (A2A) protocol to the Linux Foundation in June 2025, with more than 100 companies, including AWS, Cisco, Microsoft, Salesforce, SAP and ServiceNow, signing on as supporters. Source: Linux Foundation, "Linux Foundation Launches the Agent2Agent Protocol Project," June 2025. Six months later, Anthropic donated the Model Context Protocol to a newly formed Agentic AI Foundation, co-founded with Block and OpenAI and backed by Google, Microsoft, AWS, Cloudflare and Bloomberg. It reported more than 10,000 active public MCP servers, 97 million-plus monthly SDK downloads and 75+ Claude connectors already in production. Source: Anthropic, "Donating the Model Context Protocol and establishing the Agentic AI Foundation," December 9, 2025.
Two of the largest labs standardized how agents talk to each other and to tools, and put the governance in the hands of neutral foundations instead of either vendor. That is not the behavior of an experimental pattern people will grow out of. Multi-agent orchestration, an orchestrator spawning subagents that each have their own context window, tool bindings and model call, is now default infrastructure for anything more complex than a single tool-use loop. Its token bill scales with every subagent you add to a workflow, not with every task the workflow completes.

Why the multiplier compounds instead of adding up
A single agent's cost problem is well documented by now: every turn resends the full conversation history, so a 10-step task doesn't pay for 10 turns of context, it pays for the 1+2+3…+10 accumulation of all of them. It's the same pattern we've measured in ordinary multi-turn conversations. A multi-agent workflow inherits that problem, multiplies it by every subagent in the fan-out, and adds three costs a single agent pays only once or never:
- Duplicated static context. The system prompt and the tool-schema catalog aren't shared once across a task. The orchestrator and every subagent it spawns each send them in full. GitHub's MCP server alone ships about 55,000 tokens of tool schemas, and a GitHub, Slack and Sentry setup loads roughly 143,000 before the agent sees its first message.
- Full-transcript handoffs. The naive way to pass work from an orchestrator to a subagent, and back, is to hand over the entire message history instead of a condensed result. Every hop re-bills tokens that were already paid for once, upstream.
- Fixed per-spawn overhead. Spinning up a subagent costs tokens before it does anything useful: system instructions, tool bindings, role framing. Amit Kothari's audit of Claude Code subagents put that load at roughly 20,000 tokens per spawn in 2025. His re-measurement on July 30, 2026 found a general-purpose subagent that made zero tool calls still reporting 111,253 tokens, on a setup with a 28,620-word instruction hierarchy, so the floor grows with your instruction files. Source: Amit Kothari, "Claude Code: Task Tool vs. Subagents" Users in a Claude Code GitHub issue report subagents spending 160,000 tokens on work that takes about 3,000 in the main context. These are practitioner measurements, not vendor benchmarks, but they match the shape of Anthropic's 4x-to-15x jump.
Stack those three on top of the 4x single-agent baseline and Anthropic's 15x stops looking like an outlier. It's the expected outcome of an architecture where every subagent separately pays for the system prompt, the tool schemas and its own startup.
The fix isn't "don't use multi-agent." It's to stop billing every subagent at the orchestrator's rate
None of the published fixes ask teams to give up the architecture that's winning on quality. They target the three costs above directly.
| Technique | What it does | Reported effect |
|---|---|---|
| Context editing | Drops stale tool results, including old subagent handoffs, once a session crosses a token threshold | 70,000 → 25,000 tokens, a 64% cut, on Anthropic's own worked example. Source: Anthropic, "Context editing," Claude Platform Docs |
| Result-only handoffs | Subagent returns a condensed answer to the orchestrator, not its full transcript | Standard pattern in Anthropic's own architecture and Claude Code's subagent docs. Source: Claude Code documentation, "Workflows" |
| Supervisor-managed fan-out | A lightweight supervisor role prunes redundant subagent calls before they run | 15.45% supervisor overhead paid back as an 18.9-29.7% net token reduction across GAIA, HumanEval and AIME. Source: Lin et al., "Stop Wasting Your Tokens: Towards Efficient Runtime Multi-Agent Systems," arXiv:2510.26585, March 2026 |
| Fan-out limits | Cap concurrent and total subagent spawns per task instead of letting depth grow unbounded | Codex exposes a per-session cap on concurrent subagent threads. Source: OpenAI, Codex subagents documentation |
| Stable, cacheable prefixes | Send the shared system prompt and tools byte-identical on every call, so repeats bill at the cache-read rate | Cache reads cost 2.5% to 10% of base input on current Claude models. Source: Anthropic pricing |
| Role-based model routing | Route each subagent's calls to the cheapest model that role needs, not whatever the orchestrator is running | Worked example below |
Most teams that ship a multi-agent workflow have implemented one or two of these. Routing is the one this post focuses on, because it doesn't require rewriting your fan-out logic.
Implementation: route subagents by role, not by default
Most multi-agent codebases hardcode one model string, and every role, whether orchestrator, lookup, analysis or verification, calls it. That's the same mistake single-model defaults make everywhere else, multiplied by the number of subagents in the fan-out. A bounded, single-purpose lookup subagent and the orchestrator planning the whole task are not the same job, and there's no reason they should be billed on the same model by default.
from dataclasses import dataclass
from enum import Enum
class Role(Enum):
ORCHESTRATOR = "orchestrator"
LOOKUP = "lookup" # bounded, single-purpose retrieval
ANALYSIS = "analysis" # multi-step reasoning over retrieved data
VERIFICATION = "verification" # checks a claim against a source
# Map each subagent role to the cheapest model that role has been
# benchmarked to handle. The orchestrator keeps the frontier model:
# it's the one place a bad call is expensive to recover from.
ROLE_MODEL = {
Role.ORCHESTRATOR: "claude-opus-5-5",
Role.LOOKUP: "auto", # bounded, low-stakes: let the router pick
Role.ANALYSIS: "claude-sonnet-5-5",
Role.VERIFICATION: "auto",
}
# Identical bytes on every call, so providers can serve the prefix from cache.
# Caches are per model: a subagent on a different model than the orchestrator
# pays a cache write on its own first call.
SHARED_SYSTEM_PROMPT = open("prompts/research_agent.md").read()
@dataclass
class SubagentCall:
role: Role
prompt: str
parent_task_id: str
def dispatch(call: SubagentCall, client, tools: list) -> str:
"""Send a subagent call through the shared gateway, routed by role.
Returns only the condensed result, never the raw transcript, so the
orchestrator's context doesn't inherit the subagent's intermediate
tool calls."""
response = client.chat.completions.create(
model=ROLE_MODEL[call.role],
messages=[
{"role": "system", "content": SHARED_SYSTEM_PROMPT}, # stable prefix
{"role": "user", "content": call.prompt}, # varies per call
],
tools=tools, # same list, same order, every call
extra_headers={"X-Task-Id": call.parent_task_id},
)
return response.choices[0].message.content # condensed handoff, not the full trace
Two changes here have nothing to do with prompt engineering. First, the system prompt and tool list are sent byte-identical on every call and placed before anything that varies, so the provider can bill repeats at the cache-read rate. The tokens still cross the wire on every request. Caching discounts them, it doesn't remove them. OpenAI caches a repeated prefix automatically, and on Anthropic's API you mark the cacheable block with cache_control. Second, every role except the orchestrator points at model="auto" or a cheaper fixed model, so a lookup subagent doing a bounded retrieval never runs on the model the orchestrator uses to plan the entire task.
Nadir sits at that dispatch point. Point a subagent's OpenAI-compatible call at Nadir with model=auto and each request routes on its own prompt's difficulty and cost, with no hardcoded model string in your orchestration code. The role mapping stays in your ROLE_MODEL. Nadir doesn't see roles, only prompts. Context Optimize can strip redundant structure out of whatever handoff payload still crosses the wire.
What the multiplier costs at 10,000 tasks a day
Model a workflow with one orchestrator and four subagents, two bounded lookups, one multi-step analysis pass and one verification check, running 10,000 times a day. Priced at July 2026 list rates entirely on Claude Opus 4.8 ($5/M input, $25/M output), because that's what "every role calls the same model" defaults to in practice, the naive version costs $54,750 a month, about $0.18 per task. Keep the orchestrator's planning and synthesis on Opus, route the two lookups and the verification pass to a small, fast model, run the analysis step on a mid-tier model, and the same 10,000 tasks a day cost $27,600 a month.
Same five roles. Same task. A 49.6% reduction, without changing what the orchestrator is allowed to do or how the workflow is structured.

Prices moved since. Claude Opus 5.5 lists at $4 input and $20 output, 20% below Opus 4.8 on both, so at the same token counts the naive all-Opus line would be about $43,800 a month today. The cheaper rungs moved further: Claude Haiku 5.5 lists at $0.10 and $0.50. Source: Anthropic pricing The gap between an all-frontier fan-out and a routed one is wider now, not narrower.
These figures are illustrative, modeled on the published pricing and multipliers cited in this post, not measurements from a single production deployment. Your real numbers depend on how many subagents you fan out to, how much of their context is genuinely shared and how aggressively you prune handoffs. The direction holds regardless of the exact fan-out shape, and so does the fact that the saving comes from routing rather than from a smaller model everywhere.
Checklist before you add a second agent
- Measure your current fan-out. Log tokens per subagent spawn, separated from tokens per orchestrator turn. Most teams have only ever measured the total.
- Keep the shared prefix stable. Send the system prompt and tool schemas byte-identical, before anything that varies, so every subagent's repeat of them bills at the cache-read rate. Trim the tool list per role: tokens you don't send cost nothing.
- Return results, not transcripts. A subagent's handoff to the orchestrator should be the answer, not the trace that produced it.
- Cap the fan-out. Unbounded subagent spawning is where the token-variance patterns documented in single-agent research, the same task costing 30x more on one run than another, show up multiplied across every branch.
- Route by role, not by default. The orchestrator's planning step and a subagent's bounded lookup are not the same task, and shouldn't default to the same model.
Conclusion
Anthropic didn't publish the 15x number as a cautionary tale. They published it because the architecture wins on quality, and they use it in production anyway. That's the right call for tasks where the extra performance is worth the extra cost. What Anthropic's post doesn't spend much time on, because it isn't their problem to solve, is that almost no team fanning out to subagents routes each one to the model its role needs. In most multi-agent codebases shipping today, the orchestrator and a bounded lookup subagent are billed identically by default. Fixing that isn't a rewrite. It's a routing decision at the one point in the stack, the dispatch call, where every subagent's request already passes through.
Data in this post is illustrative, modeled from the published research and documentation cited throughout, not derived from proprietary production traces. Sources: [Anthropic Engineering, "How we built our multi-agent research system," June 13, 2025](https://www.anthropic.com/engineering/multi-agent-research-system). [Linux Foundation, "Linux Foundation Launches the Agent2Agent Protocol Project," June 2025](https://www.linuxfoundation.org/press/linux-foundation-launches-the-agent2agent-protocol-project-to-enable-secure-intelligent-communication-between-ai-agents). [Anthropic, "Donating the Model Context Protocol and establishing the Agentic AI Foundation," December 9, 2025](https://www.anthropic.com/news/donating-the-model-context-protocol-and-establishing-of-the-agentic-ai-foundation). [Amit Kothari, "Claude Code: Task Tool vs. Subagents"](https://amitkoth.com/claude-code-task-tool-vs-subagents/). [anthropics/claude-code issue #4911](https://github.com/anthropics/claude-code/issues/4911). [Anthropic, "Context editing," Claude Platform Docs](https://platform.claude.com/docs/en/build-with-claude/context-editing). [Claude Code documentation, "Workflows"](https://code.claude.com/docs/en/workflows). [Lin et al., "Stop Wasting Your Tokens," arXiv:2510.26585, March 2026](https://arxiv.org/html/2510.26585v2). [OpenAI, Codex subagents documentation](https://learn.chatgpt.com/docs/agent-configuration/subagents). [Anthropic, Claude pricing](https://platform.claude.com/docs/en/about-claude/pricing).