Rubric
Contents — domains, guide and mocks

Coordinator–subagent orchestration

CCAR-F 1.211 min read · checked 21 September 2026

Task statementOrchestrate multi-agent systems with coordinator-subagent patterns

Hub and spoke

Coordinatordecomposes, delegates, checks coverage
  • Web searchfinds public sources
  • Document analysisreads supplied files
  • Synthesismerges findings into a draft
  • Report writerformats the final output
Every arrow runs through the coordinator. Subagents never see each other's work unless the coordinator passes it on — which is exactly what gives you one place to observe, control and recover.

Hub and spoke

In the pattern the exam tests, one coordinator talks to every subagent and subagents do not talk to each other. The coordinator decomposes the task, delegates, collects results, aggregates them, and decides whether coverage is sufficient. Subagents are specialists — search, document analysis, synthesis, report writing — each with its own context.

Routing everything through the hub is a deliberate cost. It adds a hop, but it gives you one place to observe the system, one place to handle errors consistently, and control over what information reaches which agent. A mesh where subagents message each other is harder to reason about and harder to debug.

There is a second reason the hub works: context stays small. Each subagent can read dozens of pages in its own context window and send back only a condensed summary. Anthropic's context-engineering write-up describes subagents that spend tens of thousands of tokens exploring and return something like 1,000–2,000 tokens. The coordinator reasons over those summaries, not over every page every subagent read.

Choosing which subagents to call

A good coordinator reads the query and selects the agents it needs. A simple factual question may need one search pass and no synthesis agent at all; routing it through the full pipeline wastes time and money. The guide frames this as analysing query requirements and dynamically selecting subagents rather than always running every stage.

Anthropic's research-system post shows why this matters. Its lead agent was given explicit effort-scaling rules in its prompt, because agents found it hard to judge how much effort a query deserved. The post also puts numbers on the trade-off: the multi-agent setup beat a single agent by a wide margin on its internal research evaluation, but used roughly fifteen times the tokens of an ordinary chat. That is worth paying for a broad question and wasteful for a narrow one.

Scale the team to the question

What does the query actually need?
  • One fact, one source
    One agent, a few callsroughly 3–10 tool calls
  • Compare a few things
    2–4 subagentsabout 10–15 tool calls each
  • Broad, many-sided research
    Many subagentsclearly divided responsibilities
Effort-scaling rules from Anthropic's research system, paraphrased. The coordinator decides this before it spawns anything.

Decomposition is where coverage is won or lost

The guide calls out a specific failure: a coordinator that decomposes a broad topic too narrowly, so whole areas are never researched and the final report looks confident but incomplete. The fix is at decomposition time — partition the scope so subagents cover distinct subtopics or source types, with little overlap and no gaps.

The opposite failure is duplication. Anthropic describes an early version of its system in which a vague instruction on semiconductor shortages sent one subagent to the 2021 automotive chip crisis while two others both investigated current supply chains. The lesson it drew: each delegated task needs an objective, an output format, guidance on which tools and sources to use, and clear task boundaries. A subagent cannot avoid overlapping with siblings it cannot see; only the coordinator can draw the lines.

SymptomWhere the fault isFix
Two subagents return the same sourcesScope partitioningAssign distinct subtopics or source types to each
Report omits an obvious areaDecomposition too narrowBroaden the plan; evaluate coverage before finishing
Simple queries are slow and expensiveAlways running the full pipelineSelect subagents per query
Errors handled differently in each agentSubagents talking directlyRoute through the coordinator

Iterative refinement

Coverage is checked, not assumed. After synthesis, the coordinator evaluates the draft for gaps, re-delegates targeted queries to search or analysis agents, and runs synthesis again — repeating until coverage is sufficient. This loop lives in the coordinator because only the coordinator sees the whole picture.

The coordinator's refine loop

  1. Decomposedistinct subtopics, clear boundaries
  2. Delegateparallel subagents, one scope each
  3. Synthesisemerge findings with sources
  4. Check coveragewhich parts of the question are thin?

gaps found → targeted re-delegation · coverage sufficient → final report

The second pass is narrow: only the gaps are re-delegated, not the whole question.

Anthropic's own research system follows this shape: a lead agent plans the approach and spawns several subagents in parallel to explore different aspects, then combines what they return. Its “Building effective agents” post calls the general pattern orchestrator–workers, and notes what separates it from simple parallel fan-out: the subtasks are not fixed in advance but decided by the orchestrator from the input.

Traps the wrong answers are built from

Tempting but wrongDo this instead
Running every subagent for every querySelect subagents from the query's actual requirements.
Letting subagents message each other directlyRoute all communication through the coordinator.
Narrow decomposition of a broad topicPartition scope to cover it, and check coverage before finishing.
Accepting the first synthesisEvaluate for gaps and re-delegate until coverage is sufficient.
Vague one-line task descriptions for subagentsGive each an objective, output format, source guidance and boundaries.

You should now be able to

  • Design a coordinator that chooses subagents per query rather than always running the full pipeline.
  • Partition research scope across subagents to minimise duplication.
  • Implement a refine loop: evaluate synthesis, re-delegate targeted queries, re-synthesise.
  • Justify routing all subagent communication through the coordinator.
  • Diagnose whether a coverage or duplication failure started in decomposition or in a subagent.

Practice questions

Original questions written for this lesson, in the exam’s style. Answer first, then open the reasoning — every option is explained, including why the wrong ones are tempting.

  1. Question 1

    A multi-agent research system is asked about the environmental impact of data centres. The report covers energy use thoroughly but says nothing about water consumption or e-waste. Each subagent completed its task without error.

    Where is the fault most likely to be?

    1. AThe search subagent's tool descriptions, which limit what it can find.
    2. BThe synthesis subagent's context window, which truncated findings.
    3. CThe coordinator's decomposition, which scoped the topic too narrowly.
    4. DThe model's temperature setting, which made the plan less varied.
    Show answer and reasoning
    1. AIncorrect. Search did what it was asked; nobody asked it about water or e-waste.
    2. BIncorrect. Synthesis cannot include findings that were never gathered, and nothing suggests truncation.
    3. CCorrect. Every agent succeeded at an incomplete plan. Coverage is decided when the coordinator decomposes the question.
    4. DIncorrect. Sampling settings do not create or remove whole subtopics from a plan.

  2. Question 2

    Which TWO are benefits of routing all subagent communication through the coordinator? (Select 2.)

    1. AOne place to observe and log the system's behaviour.
    2. BLower latency than direct agent-to-agent messages.
    3. CConsistent error handling across all subagents.
    4. DSubagents share conversation history automatically.
    5. ESubagents no longer need their own tool restrictions.
    Show answer and reasoning
    1. ACorrect. Centralising traffic makes the system observable from a single point.
    2. BIncorrect. The extra hop adds latency; the benefit is control, not speed.
    3. CCorrect. The coordinator can apply one recovery policy instead of each agent inventing its own.
    4. DIncorrect. They do not; context is passed explicitly regardless of topology.
    5. EIncorrect. Topology does not replace least privilege; each subagent should still get only the tools it needs.

  3. Question 3

    An internal research assistant runs search, analysis, synthesis and report-writing subagents for every request. Staff like the long reports, but finance flags that one-line questions such as “When was our Leeds office opened?” cost as much as full research tasks.

    What is the best change?

    1. AHave the coordinator assess each query and spawn only the subagents it needs.
    2. BSwitch every subagent to the smallest available model to cut the cost.
    3. CCap every run at two subagents so no request can become expensive.
    4. DTell users to put simple questions to a different chat tool instead.
    Show answer and reasoning
    1. ACorrect. Dynamic selection lets a one-fact question use one search pass while broad questions still get the full team.
    2. BIncorrect. Cheaper models reduce the bill but still run four stages for a one-line answer, and may hurt the broad reports.
    3. CIncorrect. A fixed cap starves broad questions of coverage; the problem is lack of per-query selection.
    4. DIncorrect. This moves the problem onto users instead of fixing the coordinator's routing.

  4. Question 4

    A coordinator asks three subagents to “research the semiconductor shortage.” Two of them return nearly identical reports on current supply chains; the third covers the history of the crisis.

    What change would most directly prevent the duplication?

    1. AGive the subagents a shared scratchpad so they can see each other.
    2. BRun the three subagents one after another instead of in parallel.
    3. CAdd a de-duplication step after synthesis to drop repeated material.
    4. DGive each subagent a distinct objective, boundaries and output format.
    Show answer and reasoning
    1. AIncorrect. It could help in some systems, but it bypasses the coordinator and still leaves scopes undefined.
    2. BIncorrect. Sequencing adds latency and does not tell any subagent what it owns.
    3. CIncorrect. This hides the waste after paying for it; two subagents still did the same work.
    4. DCorrect. Duplication starts at delegation. Clear, non-overlapping task descriptions are the coordinator's job.

Practise every question in Domain 1 →

Sources

Drafted with AI assistance and checked against the sources above; expert review is in progress. Spotted an error? Tell us and it gets fixed, dated and listed on how this is written.