I spawned three sub-agents last week to review a 40-line script. One checked style. One checked logic. One checked "best practices," whatever that meant to it that day. Four minutes later I had three summaries that disagreed with each other on the same function, and I still had to read the actual code to figure out who was right.
I could've just read the code first. It was 40 lines.
Sub-agents aren't free. Every one you spawn costs latency, costs tokens, and costs you the one thing that actually matters mid-task: a model that remembers what happened five minutes ago. We're so deep into the "delegate everything" era that nobody's asking the obvious question. Delegate it to who, and why.
Here's why everyone reaches for sub-agents now: a clean context window produces better decisions than a noisy one. That part's true. Anthropic shipped nested sub-agents, the hype cycle did what it does, and suddenly every workflow looks like a candidate for delegation. Researching a topic? Spawn a sub-agent. Reviewing a file? Spawn a sub-agent. Checking if a test passed? You guessed it. The architecture works exactly as advertised when the task is genuinely noisy: heavy exploration, lots of dead ends, a result that only matters once it's been filtered. That's the use case. It is not the default state of every task you'll ever run.
A sub-agent isn't a function call. It's a separate session that has to be spun up, given context, run to completion, and then summarized back to you. That round trip has a fixed cost whether the task takes the sub-agent ten seconds or ten minutes. If the task is small enough that you'd read the output in ten seconds anyway, you didn't save context. You added a translation layer between you and the answer, and translation layers lose information. The sub-agent has to decide what's "clean" enough to report back, and it's guessing at what you actually needed. If you could've just read the result yourself in the time it took to spawn the sub-agent, you didn't need delegation. You needed to read it yourself.
The whole pitch of sub-agents is that they hand back a clean result and discard the noise. Sometimes the noise is the point. Debugging is the clearest case. When you're tracing a bug, the dead ends matter. The thing that didn't work tells you almost as much as the thing that did. A sub-agent that "cleanly" reports back "checked the auth module, wasn't the issue" has thrown away the exact trail you'd want to retrace if the next three theories also fail. You're not debugging anymore. You're reading press releases about debugging that already happened somewhere you can't see. Same problem with anything iterative. If you're going to look at the result and immediately want to adjust, refine, or ask a follow-up that depends on nuance the sub-agent didn't think was worth keeping, you've built yourself a worse version of just doing it in the main session.
This is the one nobody talks about. A sub-agent's context dies with it. Every layer of delegation is a hard boundary, and decisions made on one side of that boundary don't automatically carry to the other. I've watched a Layer 2 sub-agent make a perfectly reasonable choice in isolation that directly contradicted something decided three messages earlier in the main session, because nobody told it. Not a hallucination. Not a bug. Just a model doing exactly what it was asked, without the one piece of context that would've changed the answer, because that piece of context lived on the other side of a wall I built on purpose. The deeper the nesting, the worse this gets. Five layers down, you're not running one coherent task anymore. You're running five separate ones that happen to be talking to each other through summaries, hoping nothing important got lost in translation. Sometimes that's fine. Sometimes it's how you ship a confident, well-reasoned, completely wrong result.
Before you spawn one, ask what you're actually buying. Is the task genuinely noisy, heavy search, heavy exploration, a result that's only useful once it's filtered? Then delegate. If it's already small and clean, you're not filtering noise, you're adding it. Do you need the dead ends, where understanding why something failed matters as much as that it failed? Keep it in the main session where you can see the whole trail. Does the next step depend on context the sub-agent won't have? Then the summary it hands back will be missing exactly the thing you need. And would you honestly read this faster yourself? If yes, the sub-agent didn't save you anything. It just moved the work somewhere you can't see it happening.
None of this means sub-agents are bad. The nested architecture is genuinely useful for what it's built for: research at scale, parallel verification, anything where noise is the cost of doing business. But "useful for some things" and "default for everything" are not the same claim, and right now most people are treating them like they are.
Delegation isn't free just because it's invisible. It's just a cost you stopped tracking.