Delegating to a subagent costs 1.72x and saves 6.4%

Subagents are sold on context, not cost: they do work in their own window and hand back a summary, so your main conversation stays clean. That is true. What it costs to buy that has not been measured.

Reading three 8KB files inline costs 126,825 tokens. Handing the same job to a general-purpose subagent costs about 218,000 and leaves the parent context 8,175 tokens smaller.

The measurement

	Total tokens	Parent context
Inline	126,825	126,825
Via subagent	~218,000	~118,650
Difference	+91,175 (1.72x)	−8,175 (6.4%)

Inline reproduced at 126,825 exactly, twice. The subagent runs are less tidy, because an agent’s behaviour is not deterministic: five of six clustered within 500 tokens of 218,000, and one outlier came in at 276,687. The figures above use the cluster.

The saving is exactly what you kept out

The parent shrank by 8,175 tokens. Three 8KB files is 24,000 bytes, and file text costs about 0.35 tokens per byte, so the content that never entered the parent was worth about 8,400 tokens.

Those match within 3%. That is the whole mechanism: delegation saves the parent precisely the material the subagent absorbed, and nothing else. There is no additional efficiency. You are paying a second agent’s full startup context to move some text out of your own.

That is why the saving is only 6.4% while the bill is 72% higher. The subagent had to build its own context from scratch to read 24KB of files.

When it actually pays off

The 8,175-token saving is not a one-off. Because every tool round trip re-sends the whole context, a smaller parent is cheaper on every subsequent round trip for the rest of the session.

So the trade is a one-off cost against a recurring saving:

extra cost to delegate   91,175 tokens
saving per round trip     8,175 tokens
break-even             ~11 round trips

If your session will run more than about 11 more tool round trips, delegating this work is cheaper. If you are near the end, it is not. For a quick one-off lookup, doing it inline wins comfortably.

Note what that means for the usual advice. “Use subagents to keep your context clean” is right, but it is an investment with a payback period, not a free saving. Delegating a small task at the end of a session is strictly worse than doing it yourself.

The break-even scales with how much you keep out. Delegating a search across a large codebase, where the subagent absorbs hundreds of thousands of tokens of file content, pays back almost immediately. Delegating a three-file read does not.

A measurement trap: .usage cannot see subagents

If you measure this yourself, use modelUsage, not usage.

Scenario	.usage sum	modelUsage sum	Gap
No subagent	120,910	120,910	0
No subagent, again	120,910	120,910	0
With subagent	118,681	212,128	93,447
With subagent, again	118,453	211,900	93,447

With no subagent the two agree exactly. With one, .usage misses 93,447 tokens, and the gap reproduced to the token across both runs.

.usage reports the main conversation only. Everything a subagent spends is invisible to it. Measure a delegating session that way and you will undercount by 44% while concluding that delegation is nearly free, which is the opposite of what happened.

Scope

One subagent type (general-purpose), one small task, on Claude Code 2.1.224. The absolute figures depend on your startup context, which sets both the inline cost and the subagent’s own startup. The structure is what transfers: a fixed premium to spawn, a saving equal to the content you kept out, and a break-even measured in round trips.

The break-even figure is arithmetic on the measured numbers rather than a separately measured result, and it assumes the parent’s later round trips would have carried that content. Both cost figures and the .usage gap are measured.