Cost of unnecessary subagent splits
What you'll learn
Subagents that don't run in parallel and don't need isolation are pure cost — they pay setup, round-trip, and integration overhead with no benefit.
- Cost = N× tokens (setup, round-trip, integration) for N unnecessary subagents.
- No latency win and no isolation win = pure waste.
- Sequential dependent work should stay inline.
Each subagent is its own model invocation chain — its own setup tokens (system prompt, tool definitions if any), its own back-and-forth, its own final summary. Spawning subagents for work that doesn't need parallelism or isolation costs N× the tokens of running it inline, with no offsetting benefit. The exam frames this as 'three subagents that could be one sequential call burn 3× tokens.'
The cost surfaces in three places. (1) **Setup overhead per subagent**: the system prompt, tool definitions, and brief are sent for each spawn. (2) **Round-trip overhead**: each subagent has its own tool-use loop replays. (3) **Integration overhead in the parent**: the parent has to read N summaries and integrate them, which itself takes context and tokens. For trivially-sequential work, all three are pure waste.
The decision rule from the cost angle: if the work is sequential and cheap to inline, inline it. The token math almost always favours the parent doing it directly. Subagents earn their token cost when *latency* matters (parallelism) or when *parent-context preservation* matters (isolation). Without one of those wins, the cost is unjustified.
Detection signature: a parent that dispatches subagents for tiny, sequential, dependent steps (extract → transform → load) where each subagent's input depends on the previous one's output. The parent ends up serialising the subagents anyway (waiting for each to finish before briefing the next), getting the worst of both worlds: subagent overhead with no parallelism win.
Key points
- Cost = N× tokens (setup, round-trip, integration) for N unnecessary subagents.
- No latency win and no isolation win = pure waste.
- Sequential dependent work should stay inline.
- Detection: parent serialises subagents (waits between briefs) — worst of both worlds.
Examples
Parent dispatches subagent A to read a file, then subagent B to transform it, then subagent C to write the result. Each waits for the previous. Net: ~3× the tokens of doing all three inline; same wall-clock; same context discipline (each subagent's scratch is small anyway).
Parent dispatches 6 subagents to review 6 independent PRs in parallel. Wall-clock drops 6×. Each subagent's intermediate review trail stays isolated. Parent integrates 6 brief summaries. Cost = 6× setup + 6× round-trip is real, but it's paid for the latency + isolation wins.
Pitfalls
- Spawning for 'organisational tidiness'. Tidiness in code, not in token spend.
- Forgetting setup overhead. Each subagent re-pays system prompt and tool-definition costs.
- Spawning subagents that depend on each other's outputs. You're serialising them; pay subagent cost for inline behaviour.
Source notes: 00-academy-basics/notes/08-subagents.md
Ask Claude
Build a prompt with this lesson + your question, copy it, and open the Claude Project in a new tab.