Coordinator and subagent patterns: CCAR-F task statement 1.2

Task statement 1.2 sits in Agentic Architecture & Orchestration, the largest CCAR-F domain at 27% of the exam. It tests one design skill: building a coordinator agent that splits the work, sends each part to the right subagent, collects the results and checks for gaps before it answers.

What the official guide covers

The Claude Certified Architect Foundations exam guide (version 1.0, effective July 2026) lists this under task statement 1.2, "Orchestrate multi-agent systems with coordinator-subagent patterns":

How hub-and-spoke works

The coordinator is the hub. Each subagent is a spoke. Subagents never talk to each other directly.

1. The coordinator reads the request and decides what work it needs.
2. It writes a task for each subagent it chooses: the goal, the scope, the sources to use and the format of the answer.
3. Each subagent runs in its own fresh context, does its work with its own tools and returns only its final message to the coordinator.
4. The coordinator reads the results, handles any failures, and decides what happens next: answer, ask for more, or pass findings to another subagent.

In the Claude Agent SDK, a subagent's context starts without the parent's conversation history, the parent's system prompt or the parent's tool results. The only thing that crosses from coordinator to subagent is the task prompt the coordinator writes. Task statement 1.3 covers how to write that prompt and what to put in it: see 1.3 Subagent invocation and context passing.

Isolation works in both directions. A search subagent can read 40 pages, and none of that reaches the coordinator except the summary it returns. That keeps the coordinator's context small, and it is why the coordinator must ask for exactly what it needs back.

What the coordinator decides

Match effort to the query. A single fact needs one subagent or none. A comparison of three vendors might need one subagent per vendor. A broad research question needs several subagents with clear, separate scopes. Anthropic's write-up of its own research system describes the lead agent giving each subagent an objective, an output format, guidance on tools and sources, and clear task boundaries. Without those, subagents duplicate work and leave gaps.

A coordinator in the Agent SDK (Python)

This coordinator has three subagents. Each has a description that tells the coordinator when to use it, its own system prompt and a restricted tool list. None of the subagents has the Agent tool, so they cannot spawn subagents of their own and every hand-off goes back through the coordinator.

import asyncio
from claude_agent_sdk import query, ClaudeAgentOptions, AgentDefinition

COORDINATOR_PROMPT = """You coordinate a research team. For each request:
1. Decide which subagents the request needs. Simple fact checks need only web-search.
2. Give each subagent a distinct scope (subtopic or source type) so work does not overlap.
3. Pass all findings to synthesis yourself. Subagents never talk to each other.
4. Check the synthesis against the original question. If a part is not covered,
   send a targeted follow-up to web-search or doc-analysis, then run synthesis again.
5. Stop when every part of the question is covered or a gap is explained."""

agents = {
    "web-search": AgentDefinition(
        description="Finds current public sources on one assigned subtopic. Returns claims with URLs.",
        prompt="Search only within the scope you are given. Return each finding with its source URL and date.",
        tools=["WebSearch", "WebFetch"],
    ),
    "doc-analysis": AgentDefinition(
        description="Analyses internal documents in ./library on one assigned question.",
        prompt="Read only the documents relevant to your question. Cite file name and page for every finding.",
        tools=["Read", "Grep", "Glob"],
    ),
    "synthesis": AgentDefinition(
        description="Combines findings supplied in the prompt into a cited report. Does no new research.",
        prompt="Use only the findings in your prompt. Keep every citation. List any part of the question the findings do not answer.",
        tools=["Read"],
    ),
}

async def main():
    options = ClaudeAgentOptions(
        system_prompt=COORDINATOR_PROMPT,
        # auto-approve spawning subagents and the tools the subagents use
        allowed_tools=["Agent", "WebSearch", "WebFetch", "Read", "Grep", "Glob"],
        agents=agents,
    )
    async for message in query(prompt="How is AI changing the creative industries?", options=options):
        if hasattr(message, "result"):
            print(message.result)

asyncio.run(main())

The synthesis subagent lists unanswered parts of the question. That list is what drives the coordinator's refinement loop in step 4.

The refinement loop

A single pass of search, analysis and synthesis often leaves holes. The guide expects the coordinator to close them:

1. Run synthesis on the first round of findings.
2. Compare the synthesis with the original question. List the parts it does not cover.
3. Send targeted queries for only those parts to the search or analysis subagent.
4. Run synthesis again with the old and new findings.
5. Stop when coverage is sufficient or the remaining gap is reported in the answer.

The loop is coordinator logic. Subagents do not decide that more research is needed and do not call each other to get it.

Handling failures at the hub

Every result comes back through the coordinator, so the coordinator is where failures are caught. They do not all carry the same risk:

A subagent failure is usually recoverable, because the coordinator still holds the goal. A coordinator failure usually is not. Design for that difference: make subagent tasks safe to re-run, and protect the coordinator's state.

The most damaging failure is the silent one. A coordinator splits a due diligence question across 12 subsidiaries, one subagent each. Two subagents time out and return nothing. Synthesis writes a fluent report on the other 10, and nothing in it says two are missing. The fix is a coverage check before synthesis: the result count must match the count of dispatched units, and each missing unit is either re-run or named in the answer.

When a coordinator is worth the cost

Each subagent works in its own context and spends its own tokens, so a coordinator with five subagents costs several times what one agent costs for the same question. Anthropic's write-up of its research system reports that multi-agent runs use many more tokens than a chat, and that the pattern suits broad questions that split into independent parts. It is a poor fit for tightly coupled work, such as most coding tasks, where each step waits on the one before. There, a single agent with good context is cheaper and just as good.

Two levers keep the cost in line. Select subagents per query, as above. And use the model field on AgentDefinition to run narrow subagent tasks on a faster, cheaper model while the coordinator keeps the more capable one.

Rules that decide exam answers

• Look at the decomposition first. If every subagent did its job well but the report misses whole areas, the coordinator split the topic too narrowly. Do not blame the subagents downstream.
• Route everything through the coordinator. Options where subagents call each other directly lose observability and consistent error handling. The hub-and-spoke answer is the right one.
• Match the team to the query. A design that runs the full pipeline for a one-line fact check wastes time and tokens, so the coordinator should choose. Fan out only when the parts can run without waiting on each other; for tightly coupled work, one agent with good context is the better answer.
• Partition scope explicitly. When two subagents return the same sources, give them distinct subtopics or source types in their task prompts.
• Subagents start with nothing. A subagent does not see the coordinator's history. Any option that relies on it "already knowing" the earlier findings is wrong.
• Count before you synthesise. If a report looks complete but some units never came back, the fix is a coverage check at the coordinator (results returned must match units dispatched), not a better synthesis prompt.

Where it appears in the exam

Domain 1 is a primary domain in three of the six exam scenarios: Customer Support Resolution Agent, Multi-Agent Research System and Developer Productivity with Claude. Coordinator questions fit the Multi-Agent Research System scenario most closely, where a coordinator delegates to search, document analysis, synthesis and report subagents. The guide's preparation exercise "Design and Debug a Multi-Agent Research Pipeline" reinforces this domain.

Two sample questions

These are original Timo practice questions. They are not official exam questions.

Question 1

A market research system has a coordinator and two search subagents. For the question "How do EU and US rules on AI in hiring differ?", both subagents return mostly the same articles, and the US position is thin. Both subagents received the task "Research AI hiring regulation." What should the architect change?

A. Add a third search subagent so more articles are found.B. Let the two search subagents share results with each other before they finish.C. Have the coordinator give one subagent EU sources and the other US sources, each with its own scope.D. Ask the synthesis subagent to remove duplicate articles from the report.

Answer: C. Distinct scopes stop the overlap and make sure both jurisdictions get full coverage. A adds a third copy of the same vague task. B breaks the hub-and-spoke rule and still leaves both agents with the same scope. D hides the duplicates but does nothing to fix the thin US coverage.

Question 2

A coordinator always runs four subagents in order: search, document analysis, synthesis and report. Users who ask simple questions such as "What year was this standard published?" wait as long as users with deep research questions. Accuracy is fine. What is the best change?

A. Have the coordinator assess each query and call only the subagents it needs.B. Run all four subagents in parallel instead of in sequence.C. Replace the coordinator with a fixed routing table based on keywords.D. Give the report subagent search tools so it can answer simple questions alone.

Answer: A. The guide expects coordinators to select subagents dynamically based on query complexity. B still runs work the query does not need, and synthesis cannot run before findings exist. C replaces Claude's judgement with brittle keyword rules. D gives a subagent tools outside its role and bypasses the coordinator.

Build exercise

1. Build the coordinator above with the Python Agent SDK and run one simple question and one broad question. Log which subagents the coordinator calls for each.
2. Give both search subagents the same vague task and note the overlap in their sources. Then add distinct scopes to the coordinator prompt and compare.
3. Ask a broad question and check whether the synthesis lists uncovered parts. Confirm the coordinator sends targeted follow-ups and runs synthesis again.
4. Make the doc-analysis subagent fail (point it at an empty folder) and check that the coordinator reports the gap instead of inventing findings.

Practise this topic

• Claude Certified Architect practice exam: free, 20 questions, no sign-up
• Claude Certified Architect hub
• CCAR-F study guide: all topics
• Same topic in another exam: CCDV-F Agent Architecture
• Previous topic: 1.1 Agentic loops
• Next topic: 1.3 Subagent invocation and context passing

Sources

• Claude Certified Architect Foundations Exam Guide, version 1.0, effective July 2026 (Anthropic), task statement 1.2
• Claude Agent SDK documentation: Subagents in the SDK
• Anthropic: How we built our multi-agent research system
• Anthropic: Building effective agents