When you're using an AI coding agent like Claude Code, spawning a subagent feels like a magic trick. You type a command, a new context spins up, and it starts working in parallel. But it isn't free. We measured the real cost across a weekly review pipeline, and the number that matters is one almost nobody talks about: each subagent costs roughly 436,000 tokens in fixed overhead before it does any useful work.
We run a pipeline over a catalog of Markdown-heavy digital products. The pipeline embeds each product's full content into a reviewer prompt and asks for structured findings. The task is simple: review these files.
The Cost of Parallelism
We benchmarked two approaches. Arm A: We used three different reviewer agents, each running on the full product content, but each focusing on a specific perspective (buyer value, niche accuracy, compliance). Arm B: We used a single agent running on the same content, with an explicit instruction to analyze all three perspectives at once.
The result was surprising. Arm B cost only 37.6% of Arm A. The naive expectation that three agents reading the same content would cost about 3x roughly held, but the cost was not the content.
Breaking down the transcript, each agent carried about 436,000 tokens in fixed overhead. This is the initial context load at spin-up plus the cache write on its final turn. The embedded product content was only about 46,000 tokens per agent. The overhead was 10x the payload!
The Takeaway: Payload is Cheap, Agents are Expensive
This measurement led to two key realizations:
- Truncation is a false economy. We had been truncating embedded files to save tokens, which quietly excluded the files that carried the product's actual value from review. Full-content embedding turned out to cost almost nothing relative to the per-agent overhead.
- The cost lever is the number of agents, not the size of what you hand them. Three agents reading 46k tokens each cost far more than one agent reading 138k tokens.
How to Measure Your Own Overhead
You don't need special tooling. Claude Code writes full transcripts as JSONL under ~/.claude/projects/. Each assistant message records its token usage. The process is simple:
- Find the transcript for a subagent session.
- Sum the input tokens from every assistant message in the transcript.
- Separate the first turn (spin-up) and last turn (final cache write) from the middle turns. The first and last are your fixed overhead; the middle is your actual work.
The exact overhead number will vary with your system prompt, MCP servers, and loaded skills. Every always-on tool schema is part of the spin-up payload. Ours landed at ~436k. Yours may be smaller or much larger. The point is that it is measurable and material.
Designing a More Efficient Review Fleet
Our old architecture was paying the fixed cost twice to hear the same defect twice. We now run buyer value and compliance as one agent with explicit perspective switching, keeping only genuinely orthogonal perspectives separate.
A subagent is worth its 436k tokens when you need an opinion formed without seeing your reasoning, a parallel read of material you don't want polluting your main context, or true wall-clock parallelism. "This feels like a separate concern" is not, by itself, worth 436k tokens.
Since the payload is the cheap part, hand each agent everything it needs. The one agent that fetched two official docs pages found the most serious defect (a fabricated quote) that all three narrow agents missed.
This is n=1, one pipeline, measured on our workload. But the shape of the result—fixed cost per agent dwarfing content cost—held on every agent we inspected, and it inverted how we design review fleets.