All posts
6 min read

When should an AI agent delegate? The economics of sub-agents

Multi-agent systems are having a moment, and most writing about them assumes more agents means better results. The guidance we ship inside our own agents' instructions opens with the opposite: use one agent by default. This post is that guidance, explained — when delegation pays, when it quietly makes the result worse, and the one rule about parallelism that decides most cases.

Delegation does not save you work

A sub-agent writes the same output the parent would have written. On top of that, the parent pays to brief it, the sub-agent pays to load its own context before it starts, and it pays again to report back. Per subtask, delegation is strictly more expensive than doing the work directly. It is worth buying anyway when — and only when — it buys one of exactly four things:

  • Context. The subtask reads a lot and returns a little, so the bulk never enters the parent's context window. On long tasks this is the strongest of the four: keeping the parent's context small is what keeps it from being compacted, and compaction is lossy — re-establishing lost detail costs more than the delegation would have.
  • Time. Independent subtasks run at the same time instead of one after another. Three research questions answered in parallel finish in one subtask's time, not three.
  • Capability. The sub-agent has tools, permissions or a model the parent doesn't. A cheap model for bulk extraction; a coding runtime for a build step.
  • Independence. A fresh worker checking work it didn't produce — a reviewer that hasn't seen how the answer was reached and so can't inherit its assumptions.

If none of the four applies, the honest move is to do the work yourself. An orchestrator that delegates everything is not managing — it is paying coordination overhead for its own job.

Reading parallelises; writing does not

This is the rule that decides most real cases. Any number of workers can read at once — investigate, review, extract, summarize — without colliding. Workers writing at the same time cannot see each other, and they will make conflicting assumptions. The classic failure is two subtasks that are each correct alone and incompatible together: one writes the design around assumption A, the other codes around assumption B, and the merge is nobody's fault and everybody's problem.

So: fan out reads freely. Give a concurrent writer its own isolated workspace, or do the writing yourself. And never delegate in loops — a sub-agent that delegates to a sub-agent that delegates again is paying the briefing tax at every level while accountability evaporates.

Workers narrow, never broaden

One security property makes all of this safe to automate: a sub-agent may inherit or narrow its parent's permissions, but can never broaden them — the platform enforces it in code, not in prompt text. We wrote up how that enforcement works separately. The operational corollary from the same guidance: treat worker output as unverified evidence. A confident summary from a sub-agent is a claim, not a fact, until the parent has checked it against something real.

Which runtimes can delegate at all

Precision matters here, because the sweeping version of this claim — every agent, one delegation mechanism — would be false. On Choreo, agents on our own loop and on Claude Code delegate through the platform's delegation tool — with the narrowing above. Codex agents use OpenAI's own native sub-agents instead: Codex solved multi-agent for itself, and running the real binary means using its real mechanism. Different runtimes, different delegation machinery, same principle: the work fans out only when one of the four things is actually being bought. If you want to see a lead agent hand work to specialists, the ready-made teams are built exactly this way.

See it for yourself — free, $2 of credits once you confirm your email, no card.

Start free