Agentic Architecture and Orchestration Exam: Domain 1 Guide

Domain 1 is the single heaviest section of the agentic architecture and orchestration exam, accounting for 27% of the 60-item CCAR-F. If you pass the exam with a scaled score of 720, Domain 1 contributed more to that score than any other section. Understanding not just what it covers but how the exam actually tests it is the difference between surface-level prep and targeted study that moves scores.

What weight does Domain 1 carry on the CCAR-F exam?

At 27%, Domain 1 is the most heavily weighted domain on the exam, per Anthropic's official exam guide. The table below shows how all five domains are distributed.

Anthropics does not publish the raw-to-scaled conversion for CCAR-F, so we do not name an exact question count as the pass threshold. What the weighting tells you: Domain 1 is approximately one question in four. No other domain comes close.

What depth does the CCAR-F scenario format actually require?

Every CCAR-F item is scenario-based. The exam does not ask you to name a pattern; it gives you a system that is misbehaving and asks you to identify what is architecturally wrong and select the proportionate fix. That distinction changes what studying this domain actually means.

Three habits score well across the board:

1. Root-cause tracing. Identify the source of the failure before evaluating answer choices.
2. Proportionate fixes. A targeted change that addresses the cause outscores a broader architectural redesign, even if the redesign is technically valid.
3. Deterministic over probabilistic. When stakes are high, the exam favours programmatic enforcement over prompting Claude to behave correctly.

Candidates who have studied only at the pattern-name level consistently underperform candidates who can trace a failure through an architecture and identify the exact boundary where the system broke.

Which orchestration patterns does Domain 1 test most heavily?

How does the coordinator-subagent model appear in exam scenarios?

The coordinator-subagent split is the foundational pattern in Domain 1. A coordinator orchestrates the overall task: it decomposes work, dispatches subtasks to subagents, collects results, and synthesises a final output. Subagents execute narrow, bounded tasks and return results upstream.

The exam tests coordinator responsibilities concretely. A coordinator that takes on too much state degrades as a session progresses. A coordinator that delegates too broadly loses the ability to synthesise coherent outputs. Exam scenarios often present one of these failure modes and ask you to identify the architectural violation.

Coordinator dynamic subagent selection goes one level further: rather than assigning subagents at design time, the coordinator inspects intermediate results and selects the next subagent at runtime. The exam tests whether you can identify when this pattern is appropriate versus when it introduces unnecessary non-determinism into a pipeline that would be safer with pre-configured routing.

What is the hub-and-spoke architecture and when does it break?

Hub-and-spoke architecture places a single coordinator at the centre and multiple stateless subagents at the spokes. The coordinator owns all routing logic; no spoke communicates with another spoke directly.

This topology is robust when subtasks are independent and synthesis is straightforward. It breaks under two conditions: when the coordinator accumulates so much state that its context degrades, and when a subtask requires output from another subtask before it can complete. The second failure is particularly common in exam scenarios involving multi-step data pipelines.

When is parallel subagent spawning the right choice?

Parallel subagent spawning reduces wall-clock time for genuinely independent subtasks. The exam tests independence carefully. Two subtasks are independent if and only if neither requires a result from the other.

The common exam trap: a scenario presents three subtasks that look independent but share a data dependency hidden in their definitions. Selecting parallel spawning in that case is incorrect; the correct answer identifies the dependency and proposes sequential execution for the dependent pair.

What failure modes does the exam expect you to diagnose?

Domain 1 scenario questions frequently present a broken system. Four failure modes appear most often.

What are agentic loop anti-patterns?

Agentic loop anti-patterns describe the ways an agent's internal tool-call loop goes wrong: infinite retries, premature termination, ignoring stop_reason, and failing to append tool results before the next model call.

The exam distinguishes these carefully. A loop that terminates early because stop_reason was not inspected is a different defect from one that retries indefinitely because the exit condition was never bounded. The correct fix differs in each case, and selecting the fix for the wrong failure mode scores zero.

What is narrow decomposition failure?

Narrow decomposition failure occurs when a task is split too finely. Each subtask succeeds individually, but the coordinator cannot synthesise results because the decomposition discarded the contextual glue connecting them. The symptom is attribution loss: the final output cannot trace which finding came from which source.

The fix is not to retry the synthesis step. It is to redesign the decomposition so that subagents preserve source provenance through structured context passing. The exam credits the answer that addresses the structural cause, not the one that treats the symptom.

What is the stale context problem?

When an agentic session runs long enough, early context is compressed or lost. The stale context problem manifests as an agent that contradicts an earlier decision or fails to apply information provided at the start of the session. The exam distinguishes this from a prompt-engineering failure: stale context is an architectural issue that requires session management, not rephrasing.

What is attention dilution and why does it matter architecturally?

The attention dilution problem describes a well-documented behaviour: as context length grows, the model distributes attention less evenly, and facts placed in the middle of a long context receive less weight. A coordinator that concatenates all subagent outputs into a single long context window before synthesis is architecturally vulnerable to this.

The correct response is to summarise or segment before synthesis, not to increase the context window. Adding more context to an attention-dilution problem makes the problem worse, and the exam consistently rewards the answer that redesigns the synthesis stage.

How should you choose a decomposition strategy for an exam scenario?

Choosing a decomposition strategy turns on two variables: whether the task structure is known in advance, and whether intermediate state must persist across subtasks.

Task structure known in advance?
  YES --> Fixed sequential pipeline (prompt chaining)
  NO  --> Dynamic adaptive decomposition

Intermediate state must persist across subtasks?
  YES --> Structured context passing required
  NO  --> Stateless spoke agents acceptable

Fixed sequential pipelines work when the task graph is deterministic: step A always precedes step B, and step B's inputs are always the outputs of step A. Dynamic adaptive decomposition is appropriate when step B's inputs depend on what step A found at runtime, which cannot be known at design time.

The per-file and cross-file pass pattern is a concrete instance: a first pass processes each file independently; a second pass synthesises cross-file findings. This pattern appears frequently in exam scenarios involving large codebases or multi-source analysis tasks, and it illustrates why decomposition strategy and synthesis design must be planned together.

How do hooks fit into agentic orchestration on the exam?

Hooks are deterministic interception points that fire before or after tool calls. Domain 1 uses hooks to test prompt-based vs programmatic enforcement: when should a constraint live in a system prompt, and when should it be enforced programmatically?

The high-stakes enforcement decision rule resolves this: if the cost of a violation is high and the constraint is expressible as a rule, use a hook. A hook fires reliably regardless of conversational context; a prompt instruction can be reasoned around when the model encounters a sufficiently compelling downstream instruction.

Consider a scenario where an agent must never write to a production database during a dry-run session. A hook that inspects the tool name and rejects database-write calls is the correct architecture. A system prompt instruction is insufficient, because the model may encounter a downstream instruction that appears to justify the write. The exam consistently favours the deterministic mechanism in high-stakes scenarios.

How does session management appear in Domain 1 scenarios?

Session management appears at the boundary between architectural patterns and practical execution. The exam asks you to choose between resuming a session, forking it for divergent exploration, or starting fresh.

The when to resume vs fork vs fresh start decision depends on how much of the prior context is still valid. A session with stale context should not be resumed; the cost of a fresh start with a summary injection is lower than the cost of a coordinator that contradicts its earlier decisions mid-task.

Forking is the correct choice when you want to explore two different solution paths without contaminating either with the other's intermediate results. It is not a general-purpose alternative to a fresh start, and exam scenarios test whether you can distinguish the appropriate use case for each option.

What does a high-scoring candidate know that others miss?

Candidates who score well on the agentic architecture and orchestration exam domain treat each scenario as a debugging exercise. They read the symptom, hypothesise the failure mode, and check which answer choice addresses the root cause rather than the surface behaviour.

The two most common scoring errors:

Fixing the symptom, not the cause. If a coordinator produces inconsistent synthesis results because of attribution loss from narrow decomposition, increasing the coordinator's context window delays the symptom but does not fix the cause. The exam credits the answer that restructures the decomposition.

Over-engineering the fix. If a scenario describes a two-step sequential pipeline and asks how to make it more reliable, the correct answer is almost never to introduce a full hub-and-spoke topology with dynamic routing. Proportionate fixes score better than architecturally ambitious ones.

With over 10,000 individuals certified across the Claude Partner Network as of 3 June 2026, the CCAR-F has established a meaningful benchmark for production-grade agentic system design. Our full Agentic Architecture & Orchestration concept library covers all concepts mapped to Domain 1's task statements, including every failure mode discussed above. AI Skill Certs is an independent prep platform; we are not affiliated with or endorsed by Anthropic.