The standard sub-agent pattern is delegation-and-summary: the parent asks a question, the sub-agent goes off and researches, and the answer comes back as prose. It works, but notice what the parent’s context ends up holding — a summary about the answer, at whatever fidelity the sub-agent chose, with the underlying data lossily compressed through natural language.
The pattern that changed how our agents compose inverts the output: the sub-agent injects clean, executed tool calls into the parent’s queue. Our help-desk agent burns its own context on messy discovery — searching, reading source, dead-ending, backtracking — and when it finds the answer, it doesn’t describe it. It executes the two or three tool calls that fetch the canonical artifacts, and those calls plus their results land in the parent’s context directly.
The parent’s context ends up holding the answer — the actual routine definition, the actual concept document, the actual config file — not a search transcript or a paraphrase. Three properties fall out:
- No fidelity loss. The parent reasons over primary artifacts, not the sub-agent’s summary of them.
- The mess stays quarantined. Forty tool calls of discovery cost the sub-agent’s disposable context, and the parent pays for three.
- The result is verifiable. An injected tool call carries its own provenance — the parent can see exactly what was fetched and from where.
The same economy applies to capability. Our agents start lean and install tools at runtime when a task needs them — so the context budget is spent on the problem, not on tool definitions that might be needed someday. Context is the scarce resource; both patterns are just taking that seriously.
The generalization we’d offer to anyone building multi-agent systems: judge a sub-agent interaction by what the parent’s context looks like afterward. If it’s full of prose about work, you paid inference for a book report. If it’s full of the artifacts themselves, the delegation earned its cost.