Your Subagent Costs 34,000 Tokens Before It Reads a File

I asked a subagent to run one command. wc -w on a single file. It reported back seventy-four characters — a number and a path — and the harness billed the run at 34,172 tokens.¹

Nothing went wrong. That is the floor.

The two previous posts in this series measured what it costs to give a fleet of coding agents their own workspace: 132 ms for a git worktree, 48 seconds once and 4.1 kB per agent for a container. Both answered how do you isolate them. Neither answered the question that actually decides whether to run a fleet at all: what does the isolation cost in the only currency an agent spends, and what do you get back for it.

Two published positions, and the rule that reconciles them

The public record on multi-agent systems looks like a contradiction.

Anthropic reports that a multi-agent research system — Claude Opus 4 as lead, Claude Sonnet 4 as subagents — outperformed single-agent Opus 4 by 90.2% on their internal research eval.² Cognition published a post titled, flatly, “Don’t Build Multi-Agents”, whose worked example is a Flappy Bird clone that came back with a Super Mario background attached to a bird drawn in a different style.³

Both are primary sources. Both are right, and the thing that separates them is not quality of engineering.

Research reads. Coding writes. Anthropic’s own post says so directly — “most coding tasks involve fewer truly parallelizable tasks than research” — and Cognition has since published a follow-up conceding a narrower class of multi-agent patterns that do work.⁴ The rule they land on is one sentence:

Multiple agents contribute intelligence to a task while writes stay single-threaded.

Every pattern Cognition now endorses obeys it. A review agent that reads a PR and reports — and works best when it has no access to the coder’s context, catching around two bugs per PR. A stronger model consulted for an opinion. A manager that decomposes and coordinates through a structured protocol rather than a free-form agent mesh.

So the architectural question has a published answer. The cost question does not, beyond two multipliers: agents use about 4× the tokens of a chat, multi-agent systems about 15×,² and Anthropic’s own guidance puts multi-agent at 3–10× a single agent for equivalent tasks.⁵ Those are wide bands with no mechanism attached. I wanted the mechanism.

The experiment

One task, decomposable, read-only, deterministic: report the word count of each of the ten posts on this blog.

• Arm A — one subagent, all ten files.
• Arm B — five subagents, two files each.

Same model (Haiku 4.5), same agent type, same prompt template, same harness.¹ Both arms returned byte-identical numbers, so correctness is not in play — only cost.

Arm A: 35,364 tokens, 11,957 ms. Arm B: 171,542 tokens, and because the five ran concurrently, 6,666 ms wall clock.

That is 4.85× the tokens for a 1.79× speedup.

The shape of that chart is the finding. Five agents doing one fifth of the work each did not cost one fifth as much. They each cost essentially what the whole job cost.

The multiplier is a boot sequence

Three data points fix the curve. One file cost 34,172 tokens. Two files cost 34,308 on average across five independent runs. Ten files cost 35,364.

Nine extra files added 1,192 tokens. 132 tokens per file. Extrapolate back to zero files and the agent still costs 34,040 tokens — a fixed charge for existing, 258 times the cost of the work it was sent to do.

Correction, 2026-09-20. Zero files is not zero work: every run in this section still made one tool call. Measured directly at zero tool calls, the boot is 31,484 tokens and the first tool-calling turn is 2,688. The 34,040 above is boot plus one turn. The follow-up post decomposes the 31,484 and finds that almost none of it is the agent.

This is the whole multiplier, and it makes the published bands predictable rather than mysterious. Fan-out does not divide the work; it divides the marginal cost and multiplies the fixed one. So the token multiplier for splitting a job across N agents is bounded above by N, and it approaches N exactly as the per-shard work shrinks toward nothing. My shards did almost nothing, so I measured 4.85 out of a possible 5.00.

Anthropic’s 3–10× is the same law with real work in it. Their subagents actually search, so their marginal costs are large enough to pull the ratio below N. The number to carry is not “multi-agent costs 3–10×” but “each agent you spawn costs a boot sequence, and the boot sequence does not shrink when you give the agent less to do.”

Half the boot is tools the task never touched

If 34,040 tokens buy nothing but existence, what is in them? The documentation is specific: a subagent starts with a system prompt, the task message, CLAUDE.md files, git status, preloaded skills, a roster of its siblings — and its tool schemas.⁶

Only the last of those changes with the agent type, so that is the one to vary. I ran the identical one-file task again, changing exactly one thing: general-purpose, which carries every tool in the harness, became Explore, the read-only search agent — the same tools minus nine it is not permitted to use, most of them writers.¹

16,080 tokens. Less than half, for a task that called one tool.

Tool definitions are resident context — they are sent with the request whether or not the model uses them, which is the same mechanism that makes a long conversation expensive. A subagent is a fresh context window, so it pays for the entire toolbox on turn one, and it pays again on every turn after that. Fan out to five and you have bought five copies of nine tools nobody called.

This is the one lever in the whole system that costs nothing to pull. Picking the narrower agent type for a read-only shard cut the run by 53% and changed neither the answer nor the wall clock in any way I could measure.

What actually crosses the boundary

The other half of the trade is what you get back. Here the measurement is blunt.

flowchart TB
O["Orchestrator context window"]
O -->|"the prompt — crosses"| T1
subgraph S["Subagent · its own context window"]
  T1["boot<br/>system prompt, CLAUDE.md, skills,<br/>sibling roster, tool schemas<br/><b>34,040 tokens</b>"]
  T2["the work<br/>tool calls, retries, discarded branches"]
  T1 --> T2
end
T2 -->|"416 characters + one token count — crosses"| O
T2 -.->|"everything else — never crosses<br/>transcript file: 0 bytes"| X["discarded"]

Arm A’s ten word counts arrived as 416 characters — roughly 104 tokens. The run that produced them cost 35,364. Arm B delivered the same 416 characters for 171,542.

And the intermediate work is not merely out of context; it is gone. The harness hands the orchestrator a path to what it calls the subagent’s full JSONL transcript, along with a warning not to read it because doing so would overflow the orchestrator’s context. After all eight subagents in this experiment finished, every one of those files was 0 bytes. The parent session transcript contains 0 sidechain records.¹ The only durable trace of 171,542 tokens of work is one integer per agent.

Cognition’s first principle is “share context, and share full agent traces, not just individual messages.”³ On this harness that is not a design choice you can make. The trace does not exist to be shared. Anthropic’s name for the resulting failure — the “context telephone game”, information lost at each handoff⁵ — is not a warning about sloppy prompting. It is a description of the wire.

When the boundary is worth 4.85×

None of this makes fan-out wrong. It makes the conditions narrow and checkable.

flowchart TD
A{"Do the shards<br/>write anything?"} -->|yes| B["Keep writes single-threaded.<br/>Agents may read, review, advise."]
A -->|no| C{"Does the reading fit<br/>one context window?"}
C -->|yes| D["Stay single.<br/>Fan-out buys speed, not capability."]
C -->|no| E{"Is the per-shard work<br/>bigger than 34,040 tokens?"}
E -->|no| F["Fan-out is mostly boot cost.<br/>Multiplier approaches N."]
E -->|yes| G["Fan out.<br/>Pick the narrowest agent type."]

The first branch is the one the two camps actually disagreed about, and it is settled. Anthropic adds three conditions of its own for reaching for a second agent — a subtask that would dump 1,000+ tokens of noise into the main context, genuinely independent facets, or a domain needing its own toolset — plus a verification subagent pattern it says works consistently across domains.⁵ Note that a verifier is a reader, and that its value comes precisely from not inheriting the writer’s context. The isolation that destroys a parallel-writer swarm is the same isolation that makes a reviewer useful.

Three things this measurement does not tell you.

It does not price failure. My task was deterministic and read-only, which is why both arms returned identical numbers. The empirical work on multi-agent failure is a different literature: MAST, built from 150 hand-annotated traces at κ = 0.88 and extended to 1,600+ traces across seven frameworks, sorts what goes wrong into 14 failure modes in three families — system design, inter-agent misalignment, and task verification.⁷ Two of those three families do not exist in a single-agent run. Fan-out buys new ways to be wrong, and none of them show up on a token meter.

The aggregate hides its own composition. subagent_tokens is a single integer. It does not split into input, output, cache reads and cache creation, so I cannot tell you how much of the 34,040 was served from a warm prompt cache and how much was billed at full rate. The token count is real; the dollar figure it implies is not one I can derive from it.

One run per arm, and the cheap kind of agent. The five Arm B shards are the honest variance estimate available — 34,236 to 34,343, a spread of 107 tokens, or 0.3%. That tightness is itself evidence for the fixed-cost model, but it is five samples of one trivial task on one machine on one day. Every agent here also ran in background mode, which the documentation says receives a smaller built-in tool set than a foreground subagent.⁶ 34,040 is therefore a floor under a floor.

Takeaways

• A subagent costs ~34,000 tokens before it does anything. Measured floor on this harness: 34,172 tokens for a single wc -w, decomposing to 34,040 plus 132 per file — a fixed-to-marginal ratio of 258:1. Measured again at zero tool calls, the boot alone is 31,484 and the first turn is 2,688; see the correction above.
• Fan-out multiplies the fixed cost, not the work. Five agents on one tenth of the job each cost 4.85× a single agent and returned the answer 1.79× sooner. The multiplier is bounded by N and approaches N as per-shard work shrinks — which is why Anthropic’s 3–10× band is a range rather than a constant.
• Agent type is the free 53%. The same task run as Explore instead of general-purpose cost 16,080 instead of 34,172. You are paying resident context for every tool the shard is permitted to call, on every turn, in every agent.
• Writes stay single-threaded. The Anthropic/Cognition disagreement dissolves along the read–write axis, and both parties now say so. Parallel readers converge; parallel writers make conflicting implicit decisions and hand a coordinator the job of reconciling them.
• The orchestrator gets a paragraph, not a trace. 416 characters came back from 171,542 tokens of work; the subagent transcript files were 0 bytes and the parent transcript held 0 sidechain records. “Share full agent traces” is not implementable here — plan the decomposition so the summary is genuinely sufficient.
• Measure your own floor before you fan out. Eight subagents and about fifteen minutes produced every number above. The ratio that matters is your per-shard work against your harness’s boot cost, and only one of those two is in the docs.

References