Note on selection
Orchestrate multi-agent systems with coordinator-subagent patterns
What you need to know
- Hub-and-spoke: the coordinator mediates every subagent interaction, so there are no direct subagent-to-subagent edges.
- Subagents have isolated context: none of the coordinator's conversation, findings or tool results crosses over, and nothing is shared between invocations unless you pass it. That is the property the exam tests. (The SDK does hand a subagent the project
CLAUDE.mdand the tool definitions, and a subagent can be resumed with its own history intact — neither changes the rule that findings must be passed explicitly.) - When every subagent succeeds but the output has coverage gaps, suspect the coordinator's task decomposition, not the subagents.
- A good coordinator selects subagents dynamically by query complexity instead of always running the full pipeline.
- Partition scope explicitly (distinct subtopics or source types) to minimize duplicated retrieval and wasted tokens.
- Iterative refinement — evaluate synthesis for gaps, re-delegate targeted queries, re-synthesize — is the mechanism that reaches sufficient coverage.
- Subagents recover from transient failures locally (bounded retry) and propagate to the coordinator only errors they cannot resolve — with the failure type, what was attempted and any partial results attached.
Once one loop is not enough, the exam expects a hub-and-spoke topology: a single coordinator agent at the hub, specialized subagents on the spokes, and no spoke-to-spoke edges. All inter-subagent communication, error handling and information routing pass through the coordinator.5
Why the hub matters
Routing everything through the coordinator buys three properties that a mesh cannot:
- Observability. Every delegation and every result crosses one boundary you can log, trace and cost-attribute.
- Consistent error handling. Unresolved failures arrive in one place, in one shape, from every spoke.
- Controlled information flow. The coordinator decides what each subagent is allowed to see, which keeps context windows small and attribution intact.
Consistent error handling is the one worth spelling out. When the search subagent times out and cannot recover locally, it returns structured error context to the coordinator: failure type, the query attempted, any partial results, plausible alternatives. The coordinator is the only component with enough view of the whole task to choose between retrying with a narrower query, substituting another source type, and proceeding with partial coverage.
Isolated context is the defining constraint
Subagents do not inherit the coordinator's conversation history, and they do not share memory between invocations.6 Whatever a subagent needs must be in the prompt the coordinator sends it. This is not a limitation to work around; it is what keeps a broad research task from collapsing into one enormous context window. But it means the coordinator's job is heavier than "call four things in order".
What the coordinator actually does
- Decompose the query into subtopics — and here is the failure mode the exam loves. If the coordinator decomposes "impact of AI on creative industries" into digital art, graphic design and photography, every subagent will succeed and the final report will still miss music, writing and film. Overly narrow decomposition produces incomplete coverage even when no component fails.4 Coverage is the coordinator's responsibility.
- Partition scope so subagents do not duplicate work — distinct subtopics, distinct source types, distinct time ranges.
- Select dynamically. A simple factual query should not traverse the full search → analyze → synthesize → report pipeline. The coordinator analyzes requirements and invokes only the subagents that query complexity warrants.
- Aggregate and refine. After synthesis, the coordinator evaluates the output for gaps, re-delegates targeted queries to search and analysis, and re-invokes synthesis. That iterative refinement loop — not a single forward pass — is how coverage converges.
Show that all communication radiates from the coordinator, that there are no spoke-to-spoke edges, and that each subagent has its own isolated context.
Click a subagent to isolate its own delegation and return edges — proof there is no direct spoke-to-spoke path.
Show that synthesis is evaluated for coverage gaps and re-delegated with targeted queries until coverage is sufficient, rather than emitted after one forward pass.
Worked examples
Diagnosing coverage gaps: blame the decomposition
Scenario 3 · Multi-Agent Research SystemA research system produces a report on "the impact of AI on creative industries" that covers only visual arts. Logs show the web-search subagent found relevant articles, the document-analysis subagent summarized them correctly, and the synthesis subagent produced coherent prose. The coordinator's log shows three subtasks: "AI in digital art creation", "AI in graphic design", "AI in photography".
Every downstream agent did exactly what it was asked. The root cause is upstream: the coordinator's decomposition collapsed a broad domain into one sector. Fixes that actually address it are (a) instructing the coordinator to enumerate the sectors of a domain before assigning subtopics, and (b) adding a coverage-evaluation step that compares synthesis output against the enumerated sectors and re-delegates for the missing ones. Fixes that do not address it: telling the synthesis agent to look for gaps in what it received (it never received music sources), broadening the search agent's queries (it was scoped to "digital art"), or loosening the document agent's relevance filter.
Dynamic subagent selection instead of a fixed pipeline
Scenario 3 · Multi-Agent Research System"What year was the Transformer paper published?" does not need document analysis, synthesis and report generation. "Compare regulatory approaches to AI in the EU, US and China across the last three years, with citations" needs all of them, plus multiple refinement rounds.
The coordinator should classify requirements — breadth, recency, whether sources must be cited, whether a formal deliverable is expected — and invoke only the matching subagents. A coordinator prompt that says "always run search, then analysis, then synthesis, then report" burns tokens and latency on trivial queries and, worse, teaches the system that the pipeline is the plan rather than the goal.
const coordinatorSystemPrompt = `
You coordinate a research team. Your goal is a comprehensive, correctly cited answer.
Available subagents: web-search, document-analysis, synthesis, report-generator.
Selection:
- Invoke only the subagents the query actually requires. A single-fact lookup
needs web-search alone; a broad comparative study needs the full team.
- Before assigning subtopics, enumerate the distinct sectors, regions or source
types the query spans. Assign each to exactly one subagent so scope does not overlap.
- Spawn independent subagents in the SAME response so they run in parallel.
Refinement:
- After synthesis, compare the output against your enumerated sectors.
- For each gap, re-delegate a targeted query to web-search or document-analysis,
then re-invoke synthesis. Repeat until coverage is sufficient.
Quality criteria: every claim carries a source URL; no sector left unaddressed;
contradictions between sources are surfaced, not averaged away.
`;Structured error context flowing back through the hub
Scenario 3 · Multi-Agent Research SystemThe web-search subagent times out on a complex topic. A timeout is a transient failure, so the subagent's first move is the right one: recover locally — a bounded retry with backoff, perhaps a narrower query. Subagents are expected to resolve transient failures themselves and propagate to the coordinator only what they cannot resolve locally.
What goes wrong is the shape of that propagation. Returning a generic "search unavailable" once the local retries are exhausted discards the failure type, the query attempted, the partial results already gathered and the plausible alternatives — precisely the material the only component with a whole-task view needs. The internal retry was correct; the information-free status is the defect. Return the structured payload instead and the coordinator can retry with a narrower query, switch to document analysis, or proceed with partial coverage and say so explicitly.
That payload goes to the coordinator and nowhere else: all subagent communication flows through the hub, which is what makes error handling observable and consistently handled across every spoke. (5.3 compares the candidate propagation designs side by side.)
The general rule: subagents recover locally, then report; coordinators decide. Unresolved error handling lives at the hub because that is where the whole-task view lives.
Anti-patterns
- Letting subagents call each other directly instead of routing through the coordinator because you lose the single observability, error-handling and information-flow boundary that makes the system debuggable.
- Decomposing a broad topic into a handful of narrow, same-flavor subtasks instead of first enumerating the domain's distinct sectors because every subagent then succeeds while the aggregate output silently misses whole areas.
- Always routing every query through the full subagent pipeline instead of selecting subagents by query complexity because trivial requests pay the full latency and token cost for no gain.
- Treating synthesis as a single forward pass instead of running an iterative refinement loop because gaps discovered at synthesis time then never get filled.
How it is examined
- When a stem says "each subagent completes successfully" but the output is incomplete, the answer is almost always the coordinator's decomposition — resist options that blame a downstream agent that worked within its assigned scope.
- For error-propagation items, prefer the option that returns rich structured context (failure type, attempted input, partial results, alternatives) to the coordinator; the distractors are a generic information-free status ("search unavailable"), empty-but-successful results, and workflow-killing exceptions. A bounded internal retry on a transient failure is not itself the flaw — swallowing the detail afterwards is.
- Options offering "give every subagent access to all tools so it can handle anything itself" test separation of concerns — prefer a narrowly scoped tool for the common case while complex work still routes through the coordinator.
References — 3 sources
- How we built our multi-agent research system Anthropic Engineering, 13 Jun 2025 The field report where narrow decomposition was observed and measured — one subagent on the 2021 chip crisis while two duplicated work on 2025 supply chains.
- Run agents in parallel Anthropic Where the hub is structurally enforced — and the one supported topology where it is not: agent teams, whose members share a task list and message each other directly.
- Subagents in the SDK Anthropic The "What subagents inherit" table, and the note that the spawning tool was renamed from `Task` to `Agent` in Claude Code v2.1.63.
Live product docs — where they differ from the exam guide, answer from the guide. All references
Exam guide, verbatim — what is measured
Knowledge of
- Hub-and-spoke architecture where a coordinator agent manages all inter-subagent communication, error handling, and information routing
- How subagents operate with isolated context—they do not inherit the coordinator's conversation history automatically
- The role of the coordinator in task decomposition, delegation, result aggregation, and deciding which subagents to invoke based on query complexity
- Risks of overly narrow task decomposition by the coordinator, leading to incomplete coverage of broad research topics
Skills in
- Designing coordinator agents that analyze query requirements and dynamically select which subagents to invoke rather than always routing through the full pipeline
- Partitioning research scope across subagents to minimize duplication (e.g., assigning distinct subtopics or source types to each agent)
- Implementing iterative refinement loops where the coordinator evaluates synthesis output for gaps, re-delegates to search and analysis subagents with targeted queries, and re-invokes synthesis until coverage is sufficient
- Routing all subagent communication through the coordinator for observability, consistent error handling, and controlled information flow