What delegation costs
Lesson 3 of 5 in Subagents and Context Isolation: The Delegation Move.
Delegation has three costs, and none of them is optional. You pay all three on every spawn — the only question is whether the subtask is big and messy enough for the isolation to pay them back.
Fresh-context overhead. A subagent starts cold. Its window must be furnished from scratch: a system prompt, tool schemas, and the brief itself — setup the parent already paid for once. Then it re-derives orientation the parent already had (“what kind of codebase is this?”). For a big subtask this is rounding error; for a small one it can exceed the work.
Information loss at the boundary — in both directions. Going down, the brief is all the subagent knows (lesson 2). Coming up, the report is all the parent learns: a subagent that took 200 steps returns four sentences, and every judgment call it made along the way — which files it skipped, which anomaly it decided was irrelevant — is invisible unless the return format demanded it. The parent then reasons over a summary as if it were the ground truth. That is the same lossy-summary risk the supervisor–worker flow diagram warned about, now happening inside your own architecture.
Latency. A spawn is a round trip: create the context, let a cold reasoner find its footing, wait for the full run, parse the report. Fan out in parallel and wall-clock time approaches the slowest worker; chain delegations serially and latencies add.
| Cost | What you are paying for | When it bites hardest | Mitigation |
|---|---|---|---|
Fresh-context overhead | System prompt + tool schemas + brief + cold re-orientation, repaid per spawn | Tiny subtasks — the setup dwarfs the work | Don’t delegate one-call tasks; batch related questions into one brief |
Loss going down | Compression of parent knowledge into one message | Tasks entangled with conversation history and mid-run discoveries | Brief anatomy: goal, constraints, return format — with known findings included |
Loss coming up | A 200-step run compressed into a paragraph | Subtasks hiding judgment calls the parent would have made differently | Return format that demands evidence pointers and explicit uncertainties |
Latency | Spawn + cold start + full sub-run + report parsing, per hop | Serial chains of delegations | Parallelize independent workers; keep chains one level deep where possible |
Smell 1: the one-call task
One tool call, one small answer — a version lookup, a file-exists check, running the test suite once. The brief costs more than the work, and there is no bulk to isolate. Inline, always. Delegation overhead is fixed per spawn; it only amortizes over subtasks with real volume.
Smell 2: the raw-material task
“Read the config file so we can edit it.” The parent needs the contents, not a summary of the contents — the raw material must enter the parent’s window regardless. A subagent here adds a compression step in front of data that was never allowed to be compressed. Delegate only when the parent wants the answer and can afford to lose the material.
Smell 3: the tight-feedback task
The subtask needs the parent’s evolving judgment mid-flight — “explore the API and check with me before each call,” or anything where the user might redirect halfway. A brief is written once; it cannot answer questions. If you find yourself wanting the subagent to ask the parent things, the task boundary is wrong: either enrich the brief until it stands alone, or keep the work inline where the conversation lives.
Interactive checkpoint quiz (2 questions) — open this page in a browser to take it.