The AI Learning Hub Journal

Sub-Agents and the Cost of Delegation

Delegation buys a context window, not intelligencethe same model does the work — with less shared context and a lossy interface in the middleWHAT IT RELIABLY BUYSA SEPARATE CONTEXTthe worker reads twentyfiles and burns a bigbudget, then returns threeparagraphs — the parentstays clean for decisionsPARALLELISM, SECONDindependent subtasksfanned out togetherWHAT IT ADDSconfident wrong answers,trusted by a parent thatcannot check themfan-out waits on theslowest childparallel writes conflict asstate inconsistenciesbudgets multiply unlesschildren draw from theparent's allowancedebugging is two levelsdeep without nested tracesPARENT — THE ONE ACCOUNTABLE OWNERholds the decisions, verifies the returnsTHE BRIEF — DATAgoalconstraintssuccess criterionbudgetRETURN — SCHEMAthe fields theparent needsstatus: done,partial, failedSUB-AGENT — A COMPONENTa defined contract, not a colleaguesame model, same tools — the system did not get smarterMOST SUB-AGENT FAILURES ARE INTERFACE FAILURESan under-specified brief produces work that is reasonable for the wrong task · a prose return re-imports the ambiguityand full transcripts returned upward recreate the very bloat the split was meant to removeDELEGATE WHERE CONTEXT ISOLATION EARNS IT — KEEP ONE ACCOUNTABLE PARENTrole metaphors are a poor guide to a better trajectory — a hierarchy with one parent beats a mesh of peers
A sub-agent reliably buys a separate context window and nothing else — make the brief and the return a structured contract

Delegation Buys Context, Not Intelligence

A subagent gives you one thing reliably: a separate context window. A worker can read twenty files, run ten searches and burn a large budget, then return three paragraphs, leaving the parent context clean for decisions. That is a real and often decisive benefit, and it is the main honest reason to delegate. Genuine parallelism across independent subtasks is the second. What delegation does not do is make the system smarter — the same model with the same tools is doing the work, now with less shared context and a lossy interface in the middle. Treat every subagent as a component with a defined contract rather than as a colleague, and be suspicious of designs that add agents because the task feels like it has roles. Organisational metaphors are a poor guide to what actually improves a trajectory.

  • The reliable benefit is context isolation; parallelism is the second
  • Delegation does not add capability — same model, less shared context, lossy interface
  • Treat a subagent as a component with a contract, not as a colleague
  • Role metaphors are a poor guide to whether delegation improves a trajectory

Design the Brief and the Return Contract

Most subagent failures are interface failures, and they come in two shapes. Under-specified briefs: the parent passes a short instruction assuming context the child does not have, and the child does something reasonable for a task it has misunderstood. Unstructured returns: the child sends back prose that the parent must interpret, reintroducing exactly the ambiguity the boundary was supposed to remove. Fix both explicitly. The brief should carry the goal, the relevant constraints, the success criterion and the budget, as data rather than as a sentence. The return should be a schema with fields the parent actually needs, including a status that can express partial completion and failure. And returning a full transcript upward recreates the context bloat you delegated to avoid, which is the most common way this pattern quietly stops paying.

  • Under-specified briefs produce work that is reasonable for the wrong task
  • Pass goal, constraints, success criterion and budget as structured data
  • Return a schema with an honest status, including partial and failed
  • Returning transcripts upward recreates the bloat the split was meant to remove

The Failure Modes Delegation Adds

Be clear-eyed about what you take on. Errors compound: a child that returns a confident wrong answer is trusted by a parent that has no way to check it, and the trace of why is now two levels deep. Budgets multiply unless children draw from the parent allowance. Latency is bounded by the slowest child in a parallel fan-out, so one confused worker holds the whole run. Parallel children writing to the same resource conflict in ways single-agent designs never encounter, and the conflict surfaces as a state inconsistency rather than as an error. And debugging is genuinely harder: an incorrect final answer now has several candidate origins, and reconstructing which requires traces that nest properly. None of this argues against delegation. It argues for using it where context isolation earns it, and for a hierarchy with one accountable parent rather than a mesh of peers.

  • Confident wrong returns are trusted by a parent that cannot verify them
  • Fan-out latency is set by the slowest child; parallel writes create conflicts
  • Failure attribution needs properly nested traces or it becomes archaeology
  • Use it where context isolation pays, and keep one accountable parent

Prefer slides, quizzes, and saved progress? Read this lesson in the library — free, no sign-up.