Preporato
Build & submit taskBetaintermediate

Build a Hub-and-Spoke Multi-Agent System with Claude

Build a coordinator that dispatches a task to specialist Claude subagents in parallel, each with its own isolated context and an explicit brief, then aggregates their results, recovers when one subagent fails, and can export and resume its session. Submit a single script or notebook for instant, rubric-based feedback.

3.5 hrs

Est. time

4

Outcomes

7

Rubric criteria

65%

Pass score

What you'll learn

Skills you'll have real reps in after shipping this.

Hub-and-spoke orchestration
A coordinator decomposes work and fans it out to specialist subagents, then merges their results.
Context isolation
Each subagent gets a clean, explicit brief. Sharing one growing context across agents causes interference and degradation.
Parallel dispatch
Independent subtasks run concurrently, so wall-clock time is the slowest subagent, not the sum.
Recovery and resume
A failed subagent yields partial results, and exported state lets an interrupted run resume instead of restarting.

See how it works

Hub-and-spoke routing

supervisor routing
→ research
incoming request
research
3
matches
finance
1
match
comms
0
matches
Send it to the worker that fits best. A supervisor reads the request and hands it to the specialist built for it; the workers never talk to each other, everything routes through the center. Here that decision is keyword overlap: the worker matching the most of the request wins, not the first to match at all, so a query touching several areas goes to its strongest fit. And a request that matches no specialist returns no_match, so the supervisor can fall back rather than route nonsense to whoever happens to be first.

A coordinator routes each subtask to the specialist best suited to it, then merges the results. The spokes never talk to each other.

Production multi-agent shape

production agent architecture
the four boxes
→→
↑ every step writes to ↓
Trace store
Every step, tool call, token, and cost is written here. The trace view is the most important UI you build: debugging an agent means replaying what it did.
Four boxes that do not go away. Whatever framework you use, a production agent system converges on the same shape. A queue, because agent runs are too long to handle inline. Workers that run the loop and honor the step budget. Tool servers kept separate so a flaky tool cannot sink the agent and so tools scale on their own. And a trace store, because an agent is non-deterministic and multi-step, so the only way to debug one is to replay exactly what it perceived, decided, and did. Build these four and the framework on top is a detail.

Isolated subagent contexts, parallel dispatch, and recoverable state are what make a multi-agent system survive contact with production.

The scenario

You are building a research assistant that answers a broad question by splitting it into independent investigations: market sizing, competitor scan, and patent search. A single agent doing all three in one context gets slow, mixes findings together, and degrades as the context fills up.

The fix is a hub-and-spoke design: a coordinator decomposes the question, hands each specialist subagent a clean, explicit brief, runs them in parallel, and merges the results. You also need it to survive a subagent failing and to resume if the process is interrupted.

Your role

You are a Claude solutions architect designing a multi-agent system. Your deliverable is one module that shows the hub-and-spoke pattern done correctly: explicit context passing, parallel dispatch, failure recovery in the chain, and a session you can export and resume.

Start the task to unlock the full brief

You'll get the step-by-step requirements, setup commands, the 7-criterion grading rubric, tips, and the ability to submit your solution for instant AI grading.

Free to start · submit when you're ready

Learning resources

Anthropic API: messages
The Messages API used by each agent.
docs.anthropic.com
Building effective agents
Orchestrator-workers and when to fan out to subagents.
anthropic.com
Anthropic Python SDK
AsyncAnthropic for concurrent subagent calls.
github.com

What you'll build in this multi-agent orchestration task

This is a build-and-submit task, not a guided lab. You build the hub-and-spoke pattern at the heart of real multi-agent systems: a Claude coordinator that decomposes a question, hands each specialist subagent a clean and explicit brief, runs the independent subagents in parallel, and merges their findings. The deliverable is one Python module that shows the pattern done right.

The hard parts are the ones that decide whether a multi-agent system works in production: keeping each subagent's context isolated so they do not interfere, dispatching them concurrently so the system is fast, recovering when one subagent fails, and exporting state so an interrupted run can resume. You demonstrate all of it on a single run plus a resume.

Grading is rubric-based and explainable. Your submission is scored against weighted criteria (SDK integration, coordinator, context isolation, parallel dispatch, failure recovery, session resume, and the demonstration) with per-criterion feedback quoted from your code. The pass threshold is 65 percent and you can resubmit. These are the orchestration skills the Claude Certified Architect exam weights most heavily.

Frequently asked questions

Why isolate each subagent's context?

Sharing one growing message list across subagents causes interference: each agent sees the others' reasoning, the context fills up, and quality degrades. Passing each subagent an explicit brief with only what it needs keeps them focused and parallelizable.

How do I run subagents in parallel?

Use AsyncAnthropic with asyncio.gather, or the sync client inside a ThreadPoolExecutor. The point is that three independent subtasks finish in roughly the time of the slowest one, not the sum of all three.

What does resume need to store?

Very little: the original task, the status of each subtask, and any completed results, as JSON. On resume you load it and only run the subtasks that are not yet done.

What counts as a complete submission?

A single .py or .ipynb on the Anthropic SDK with a coordinator and 2-3 specialist subagents, explicit per-subagent briefs, parallel dispatch, failure recovery, exported session state, and a demonstrated full run plus resume.