Claude subagents: how coordinator patterns are tested on the architect exams

Claude subagents are separate workers a coordinator invokes to do a piece of a task. Each one begins empty: it sees only what the invocation hands it, never the parent conversation. All communication runs through the coordinator, and workers never address each other. Most exam items in this area turn on one of two things — what belongs in a worker's brief, and what the coordinator must confirm about the replies before it writes an answer from them.

Where claude subagents sit on the blueprint

Agentic Architecture and Orchestration is 27% of Architect Foundations — around sixteen of sixty questions, and the heaviest single domain across all four exams. Three of its seven published task statements are about coordination directly: orchestrating coordinator and worker patterns, configuring invocation and context passing, and designing how a complex task is broken up.

The material also appears on Architect Professional inside broader solution-design scenarios. If you are choosing where to spend preparation time, the published domain weights make this the single highest-value area on the architect track.

A subagent starts with nothing

This is the fact the largest family of items is built on. A worker does not carry over the conversation that spawned it. Anything agreed before it was invoked — a constraint, a rejected approach, a finding that took an hour to establish — simply is not there for it.

Scenarios exploit this in a specific shape: a worker returns something that contradicts a decision made earlier, and you are asked why. The answer is not that it misunderstood or needs a firmer instruction. It never saw the decision. The correction is to the invocation, not to the worker's behaviour.

Note the two entries at the bottom. Passing the whole parent conversation feels safe and recreates, in every worker, exactly the crowded context that delegating was supposed to relieve. Passing your preferred answer skips the investigation you were paying for.

Everything routes through the coordinator

The coordinator owns the division of work, the dispatching, the error handling and every message that passes between components. Workers do not address one another. When an option has them exchanging findings directly, it is describing a system where nothing has a view of what changed hands, failures have nowhere defined to go, and the result is built from a process nobody can audit afterwards.

A second version of the same error is a coordinator that keeps some of the job for itself. Handling three steps inline while delegating two puts all the detail from those three into the context that was meant to stay clear, and the quality of the final synthesis falls as the job proceeds.

Two ways to divide the work badly

Once you have several workers, the hard part is deciding what each one is responsible for. There are two ways to get it wrong, they fail in opposite directions, and — this is the examinable part — neither one produces an error.

Which shape a task takes is settled by one question: does any worker need something another one produces? If nothing is shared, they can proceed concurrently and the coordinator gathers the results afterwards. If one feeds another, that sequence belongs to the work itself and is not a preference. Splitting by file, or by any other convenient unit, makes the number of workers track the file tree instead of the job.

What should come back

The point of pushing work outward is that the bulk of it stays outward. A worker that hands back everything it read has shifted the bulk instead of containing it, and the coordinator ends up in the state you delegated to avoid — which is also where long-session drift starts.

What returns should be results shaped to the choice the coordinator now faces. Truncating to a fixed length cuts by size rather than by relevance. Handing back a pointer the coordinator has to follow reintroduces the volume one step later. And where a worker did part of its job and then failed, the useful reply carries both: what it completed, and what it could not, with enough detail on the failure that the coordinator can pick between retrying, escalating, and going on with a known hole.

Check what arrived before you synthesise

This is the habit the domain is really testing. Before a coordinator writes anything, it should establish that the replies it holds actually cover what it sent out. Four workers dispatched and three useful replies received is not three quarters of an answer — it is a whole answer about three quarters of the problem, written with the confidence of a complete one.

Reporting coverage alongside the result is what makes a partial answer visibly partial. It is also what turns disagreement into information: when two workers contradict each other, the contradiction and the evidence on both sides are the finding. Resolving it silently — by preferring the broader scope, averaging the positions, or re-running until they agree — presents a judgment as an observation.

For the decision that comes before any of this, see when not to build an agent; for the configuration layer around it, Claude Code configuration. If you have not chosen a track, the certification comparison guide is the place to start. Official outlines are published on the Anthropic Partner Academy certification pages.

Key takeaways

• A worker inherits nothing. Constraints, prior decisions and earlier findings exist for it only if the invocation carries them.
• Workers never address each other. An option showing direct exchange between them is a reliable wrong answer.
• Independence decides parallelism. If no worker consumes another output, run them together; if one does, the order belongs to the task.
• Both ways of dividing work badly are silent. Overlap costs multiples, a gap produces a confident partial answer, and neither raises an error.
• Return findings, not transcripts. Structured results sized to the pending decision, plus what failed and why when something did.
• Confirm coverage before writing an answer. Compare what came back against what went out, and report the gap rather than composing around it.