Your Subagents Are Carrying Your Whole Brain for a One-Line Job
Subagents are one of the best ideas in modern AI coding tools. Got a big job? Split it up. Let one agent research the codebase, another write the tests, another review the diff — while you watch it all come together. It feels like hiring a team.
Here is the part nobody puts on the box: every subagent you spawn gets handed a copy of your context. Not a summary. Not the relevant slice. Often the whole thing — the conversation, the files, the plan, the history of everything you have done in this session so far. And you pay for every token of it, every time.
I first noticed this the way most people notice a leak: not from one big charge, but from a bill that was bigger than the work felt. The tasks were small. The answers were short. The token counts were not.
Why a small job costs a big context
Think about what a subagent actually needs to do its job, versus what it usually receives.
A subagent asked to "check whether this function handles empty input" needs: the function, maybe its callers, and a one-line instruction. That is a few hundred tokens of real context.
What it often receives instead: the full session — thousands of tokens of earlier discussion, files you opened three tasks ago, a plan document that has grown through five revisions, and the output of every previous agent. The subagent reads all of it, because that is what it was given, and the meter runs on all of it.
The waste compounds because subagents breed. One orchestrator spawns three researchers; each researcher spawns two helpers; each helper gets the same bloated context. A job that should have cost one careful read of a file now costs six or seven reads of your entire session. The work itself is cheap. The briefing is the bill.
And it is invisible in the moment, because the cost shows up per agent, not per job. Each individual call looks reasonable. Add them up at the end of the week and the briefing tax is often the largest line on the bill — bigger than the flagship-model premium, bigger than long answers.
A worked example (illustrative numbers)
Say your session context has grown to 40,000 tokens — a normal size after an hour of real work. You spawn five subagents to handle five small checks in parallel. If each one receives the full 40,000-token context, that is 200,000 input tokens before any of them has done a single useful thing.
Now compare: if each agent had received only the 2,000 tokens actually relevant to its task, the same five checks would cost 10,000 input tokens. Same five answers. Twenty times less context billed.
These are illustrative numbers, not a quote from any provider — your tool's exact behaviour and your prices will differ. But the shape holds whenever subagents inherit the whole session: the briefing cost grows with the number of agents times the size of the session, while the useful work stays flat. That is why the bill can double on a day when the work itself felt light.
Four practical fixes
1. Brief the agent, don't forward the session. Before spawning a subagent, write two or three sentences: what to do, what "done" looks like, and which files matter. If your tool lets you pass a short prompt instead of the full context, use it. A good brief is the cheapest token you will ever spend.
2. Shrink the session before you fan out. If the context has grown large, start a fresh session for the parallel work, or summarize the plan into a short document and spawn agents from that document — not from the live session. The smaller the thing you hand over, the smaller the tax.
3. Ask whether it needs an agent at all. A one-line check, a single file read, a quick grep — these are jobs for a direct call, not a subagent. Every spawn has a fixed cost: the briefing. If the job is smaller than the briefing, you have already lost money. A good rule: if you can describe the job in one sentence and it touches one file, do it directly.
4. Cap the fan-out. Three agents working from tight briefs will usually beat eight agents working from the full session — on cost, and often on quality too, because each one is actually focused on its own slice instead of wading through everyone else's context. Parallelism has a price. Pay it only where the speedup is real.
One warning in the other direction: don't kill subagents entirely. For genuinely big, decomposable work — research across a codebase, a review pass, a multi-part build — they earn their keep many times over. The goal is not fewer agents. The goal is agents that arrive with a brief, not with your entire brain.
The question to take into your next session
Before you spawn your next subagent, pause and ask: what does this agent actually need to know — and what am I handing it that it doesn't? If the answer is "the whole session," write the three-sentence brief instead. Your bill will notice before your workflow does.
I write about the real cost of building with AI — and the tools I build to keep it under control — on my YouTube channel (https://www.youtube.com/@onyxaipk) and my Gumroad store (https://onyxailabs.gumroad.com), where my AI Spend Tracker helps you see exactly where your AI money goes.
What is the smallest job you ever handed to a subagent — and how much context did it carry to do it?
Top comments (0)