I run a fleet of Claude Code subagents daily, and for months I got the sizing backwards. The instinct was: fewer agents, less overhead, cheaper bill. I measured it. It is the opposite. Delegating a turn costs about a third what carrying it in the parent session does, and the session that never delegates is the expensive one, not the frugal one.
Here is the actual number, from my own global config where I track every dispatch:
| avg context | $/response | |
|---|---|---|
| parent session | 503k | $0.302 |
| subagent | 249k | $0.109 |
| fork | 392k | $0.249 |
Source: /Users/Ben/.claude/CLAUDE-SOP.md, § “The cost of a dispatch is its CONTEXT, not its count,” measured 2026-09-18 across every local transcript on this machine. A subagent runs at roughly a third the cost of the parent, and 92% of total spend happens above 200k tokens of context. You are not billed for the work a turn does. You are billed for the size of the conversation it has to carry to do it.
Why smaller wins: it’s cache reads, not compute
The mechanism is a ratio, not a guess. Across every local transcript since the measurement window opened, cache-read tokens outnumbered output tokens 1,150 to 1, 8.05 billion against 0.007 billion. That is the same source file. Every turn in a long session re-sends everything before it, and the model reads that history back in full before it produces one new token. A parent session at 503k context is paying to re-read 503k tokens of prior conversation on every single turn, whether or not that turn needed any of it.
A subagent starts fresh. It gets exactly the brief you write it, not the accumulated transcript of everything the parent has done today. That is the entire saving, and it is why the naive fix (dispatch fewer, bigger agents to “reduce overhead”) makes the bill worse: it keeps more of the work inside the expensive, ever-growing parent context instead of moving it to a cheap, bounded one.
The trap: a fork isn’t the cheap option, it just has no brief
Look at that table again. A fork opens at 392k context, statistically indistinguishable from the parent’s own rate. It is not a discount tier. Its value is that it inherits the full conversation, so there is no brief to write, not that it is cheap. Reach for a fork because a question genuinely needs everything the parent already knows, and reach for a fresh subagent everywhere else.
There is a floor on the fresh side too, measured over 376 subagent streams in a 7-day window: a new worker opens at roughly 51k tokens of context before it does anything (a bulk-worker runs a median of 51k, minimum 42k; a heavier agent type runs closer to 96k). A fork, by contrast, opens at 278k just from inheriting context, about 5x a fresh dispatch’s starting cost, before it has done a single thing. One probe whose entire assigned task was to reply “PROBE OK” still burned 246k tokens, because inheriting the conversation was the whole cost regardless of the size of the job. Source: /Users/Ben/.claude/CLAUDE-SOP.md, same section. Below a handful of real tool calls, the setup costs more than doing the work inline, in either shape of dispatch.
The decision table
This is the one I actually use, copied from my own global config, which routes every dispatch through it before writing a brief:
| You are doing | Use | Why |
|---|---|---|
| Work built on what this session already established | Agent with subagent_type: "fork" | Inherits the full conversation, no brief to re-write |
| Parallel work that must not collide on files | Agent with isolation: "worktree" | Separate checkouts on disk; you merge afterward |
| An independent second opinion | /brainstorm, two models blind to each other, never a fork | Shared context defeats the point of a second opinion |
| Bulk, narrow, falsifiable grunt work | bulk-worker (Sonnet) | One topic each, structured output. The default tier |
| Pure retrieval at volume, no judgment inside the topic | haiku-worker | Inventories, call-site maps, existence checks |
Source: /Users/Ben/.claude/CLAUDE.md, § Delegating. The row that trips people up is the second opinion. A same-context fork sees everything the parent already believes, so its “independent” verdict is an echo of the parent’s own reasoning, not a check on it. The only way to get a real second opinion is a model that never read the parent’s context in the first place.
The $371 mistake that isn’t in the table
One more row belongs here, as a warning rather than a choice: never pass a model to an agent dispatch that is dearer than what the agent’s own definition already names. bulk-worker and other tiers declare their model in their own frontmatter. Overriding that to a pricier model, measured over 56 dispatches in a 30-day window on my own account, burned $371, which was 48% of all subagent spend for that period, on work the cheaper tier’s definition had already priced correctly. Forty-one of those fifty-six dispatches carried no stated reason for the override at all. Source: /Users/Ben/.claude/CLAUDE-SOP.md, same cost section. The fix costs nothing: omit the model parameter and let the agent’s own definition decide. Passing one at all should mean going cheaper than the default, never dearer.
Where the decision actually gets made
Everything above assumes you’re weighing the tiers before the first edit. That is not what happens by default. A 30-day study across 788 real sessions on this machine, bucketed by how many tool calls each one ran, found delegation showing up reliably only once a session was already enormous.
Small sessions, under 20 tool calls (281 measured)
2% used any subagent at all
Medium, 20-99 calls (284 measured)
6% used any subagent
Large, 100-299 calls (138 measured)
21% used any subagent, though two thirds of these sessions had already touched 5 or more files
Very large, 300+ calls (85 measured)
72% used any subagent, and only 18% of even this bucket opened a worktree lane
Source: /Users/Ben/.claude/CLAUDE.md, Golden Rule 12, measured 2026-09-09 across ~/.claude/projects/**/*.jsonl. Read the large-session row again: 138 sessions ran 100 to 299 tool calls, most of them already touching five or more files, and 95% of them never opened a worktree agent at all. Delegation was being reached for as a rescue after a session had already become enormous, not as the plan. By the time a session has run 100 tool calls, the scoping decision that would have made delegation cheap has already been made, by drift, roughly 200 tool calls before the fleet shows up in the data at all.
What this doesn’t cover
All of this is one operator’s own Claude Code usage, on one account, measured from local transcript logs rather than a controlled benchmark. The dollar figures are this account’s own rates and context sizes; a different workload with a different average conversation length will land on different numbers, though the mechanism (cache-read tokens dwarfing output tokens, cost rising with context rather than with work) should hold generally, because it is a property of how the API bills, not of this particular fleet. I have not measured whether the delegated work itself is of comparable quality to the parent doing it directly. Everything above is about what a dispatch costs, not whether the output was as good, which is a different question the source data does not answer.
The other unmeasured piece: whether a Claude Code subagent and a human delegating to an AI face the same tradeoff. They don’t, entirely. What to delegate to AI is about a different split, a human narrowing a problem before an AI explores it, but the underlying question is the same shape one level down: who owns which part of the work, and what does getting that assignment wrong cost. Here the answer is priced in dollars per response. There it’s priced in wrong answers.
Related:
- Claude Code Worktrees: 4 Gaps in the Default Setup: the mechanics of the parallel-lane tier in the table above, and the four setup gaps that make it quietly wrong by default.
- The Same Job Prices Out at $452 and $47: a different cost shape entirely, per-token pricing on one large job rather than per-dispatch context on a fleet of agents.
- What to Delegate to AI: Humans Narrow, Machines Explore: the same ownership question, one level up, between a person and a model instead of between two agents.
Sources
/Users/Ben/.claude/CLAUDE-SOP.md, § “The cost of a dispatch is its CONTEXT, not its count”: the $/response table, the 1,150:1 cache-read ratio, the dispatch floor (51k fresh / 278k fork / 246k for a trivial probe), the quadratic session-length cost curve, and the $371 Opus-override figure./Users/Ben/.claude/CLAUDE.md, § Delegating and Golden Rule 12: the agent-tier decision table and the 788-session study of when delegation actually gets used, bucketed by session size.