An agent doing real work accumulates debris. Every file it reads, every search that comes back empty, every test log and dead end lands in the context window and stays there, because the window is the model's only memory. On a large task the debris wins: a context meant for reasoning fills with raw material, retrieval from the middle of it degrades, and eventually the harness has to summarize the history to make room, which throws detail away at exactly the moment detail might matter.
A subagent is the escape hatch. Spawn a fresh model instance with its own empty window, hand it one scoped job, and take back a distilled result. The subagent reads the fifty files and burns its context doing so; the parent, usually called the orchestrator, receives three sentences of conclusion. Its window carries decisions and findings while the process that produced them gets thrown away with the worker.
The economics
Delegation costs more tokens in total and less of everything that matters. Four workers reading 40,000 tokens each spend four times what one agent would to read the same material serially, and finish in roughly the wall-clock time of the slowest one. Meanwhile the orchestrator's window, the scarce resource on a long-running task, stays almost empty: it holds the plan and four short results instead of 160,000 tokens of raw reading. You are trading money for the two things a single context cannot buy: parallel wall-clock time and headroom to keep reasoning at full quality.
One agent
Orchestrated
The corollary is that a subagent's prompt carries unusual weight. A worker wakes up with no conversation history, no idea what you have already tried, no access to the reasoning that scoped its task. The prompt is its entire world. Orchestration failures trace back to underspecified delegation more often than to any model limitation: say what the worker should return, in what form, and what it should not bother doing, or plan to pay for the round trip twice.
The patterns
A handful of shapes cover nearly everything people build with subagents.
Fan-out
Independent shards of the same job run in parallel: one worker per module in an audit, or per search angle in a research sweep. Fan-out is the default and the least fragile, because workers never need to know about each other. The orchestrator's job is picking shard boundaries so that stays true.
Pipeline
Each item flows through stages, find, then fix, then check, with no barrier between stages: item A can be in review while item B is still being searched for. Pipelines beat staged batches on wall-clock time whenever stage durations vary, which is always. The orchestrator only forces a barrier when a stage needs every prior result at once, to deduplicate findings, say, or to stop early if there is nothing to do.
Judge and jury
Verification as its own delegation. Each finding from the discovery stage goes to one or more fresh skeptics prompted to refute it, and only claims that survive get integrated. Independent contexts are the point: a verifier that watched the discovery happen inherits its blind spots, while a fresh one has to reconstruct the evidence, and plausible-but-wrong findings die in the reconstruction. For expensive claims, several skeptics vote.
Loop until dry
For discovery jobs with unknown size, bug hunts, dependency audits, keep dispatching finder waves until a couple of consecutive waves come back empty. A fixed worker count encodes a guess about how much there is to find; the loop replaces the guess with evidence.
What goes wrong
- Workers collide. Two subagents editing the same file produce garbage merges. Either shard by disjoint scope or give each worker an isolated copy of the workspace and reconcile afterward.
- Findings get trusted raw. A worker's confident summary is a claim, and claims from a context you cannot inspect deserve the judge treatment before they drive decisions.
- The orchestrator micromanages. If the parent re-reads everything a worker read to check its work, the ledger collapses back to one fat context that cost four times as much.
- Everything gets orchestrated. A task that fits comfortably in one window with room to think is cheaper, simpler, and easier to debug as a single agent. Orchestration pays off past a threshold of scale or required confidence, and below it, it is pure overhead.
When to reach for it
Three signals, any one of which is sufficient. The reading exceeds the window, as in audits and codebase-wide questions. The work shards into independent units whose results are easy to state compactly. Or the answer needs confidence that one perspective cannot provide, so you buy independent perspectives and let them disagree. Absent all three, stay in one context, which is cheaper and easier to debug.
Effort levels compose with all of this: the previous piece covered spending serial compute within one agent, and orchestration spends across agents. Mechanical shards run cheap and low; the judge that decides what ships runs high. The knobs are orthogonal, and mature setups turn both.