# What a Claude Code subagent actually costs: measuring the ~436k-token fixed overhead > Source: > Published: 2026-08-10 15:55:22+00:00 Spawning a subagent in Claude Code feels free. It isn't. We measured it across a real 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.** This post explains where that number comes from, how to reproduce the measurement on your own setup, and what it changes about how you should split work between agents. We run a weekly review pipeline over a catalog of digital products (Markdown-heavy repos: rules files, skills, templates). The pipeline embeds each product's full content into a reviewer prompt and asks for structured findings. We ran the same product, same full content, two ways: Billed token totals, from the session transcript: | Arm A (3 agents) | Arm B (1 agent) | | |---|---|---| | Total tokens | 2,150,310 | 809,070 | | Distinct defect classes found | 20 | 11 | | Primary-source fetches performed | 0 | 2 | Arm B cost 37.6% of Arm A. The naive expectation — "three agents read the same content, so about 3x" — roughly holds, but the *reason* is not the content. Breaking the transcript down per turn, each agent carried about **436k tokens of overhead that had nothing to do with the review itself**: the initial context load at spin-up plus the cache write on its final turn. The embedded product content — the thing we assumed dominated cost — was only about **46k tokens** per agent. That's a 9.5:1 ratio of fixed cost to payload. Two consequences fall out immediately: You don't need any special tooling. Claude Code writes full transcripts as JSONL under `~/.claude/projects//` , and each assistant message records its token usage. `usage` fields per agent: input tokens, output tokens, cache creation, cache reads.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 *per agent* and *independent of the task*. **Merge reviewers whose perspectives overlap.** In Arm A, two of our three perspectives (buyer value and compliance) produced overlapping findings — 4 of 7 findings duplicated across them. We were paying the fixed cost twice to hear the same defect twice. We now run those as one agent with explicit perspective switching, and keep only genuinely orthogonal perspectives (spec verification against primary sources) separate. **Spawn for independence, not for tidiness.** A subagent is worth its 436k when you need something a single context can't give you: 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. **Don't starve the agents you do spawn.** Since payload is the cheap part, hand each agent everything it needs — full files, full context, explicit instructions to fetch primary sources. The quality difference in our experiment came from exactly that: the one agent that fetched two official docs pages found the most serious defect (a fabricated quote presented as official documentation) that all three narrow agents missed. One honest caveat: this is n=1, one pipeline, one week, measured on our workload. The 436k figure is ours, not a constant of the platform. But the *structure* of the result — fixed cost per agent dwarfing content cost — held on every agent we inspected, and it inverted how we design review fleets. *We publish AI-coding field notes like this daily, and maintain Rulestack — rules files, skills, and templates for Claude Code, Cursor, and Codex that hold up in real projects.* *Follow us on Bluesky for the daily short-form version: @ai-shop.bsky.social*