CCA Domain 1: Agentic Architecture & Orchestration Explained

Domain 1 of the Claude Certified Architect – Foundations (CCA-F) exam, Agentic Architecture & Orchestration, is worth 27% of the score and tests whether you can build a correct agentic loop, decide when to split work across sub-agents, and enforce hard requirements with code rather than prompts. It is the heaviest domain by weight and the one where “the least bad design under these constraints” thinking pays off most.

This post walks through what the domain covers, why Anthropic weights it so heavily, the concepts you must recognise on sight, one worked scenario, and the traps we see people fall into in practice questions. It is built on top of the 30 study articles in our Domain 1 study guide; links below take you to the article that covers each point.

What does CCA Domain 1 actually cover?

The official blueprint groups Domain 1 into seven task areas. Here is how we map them, with the anchor article for each:

Task	What it tests	Start here
1.1 Agentic loop lifecycle	Loop control via stop_reason, appending tool results, model-driven vs hardcoded decisions	stop_reason Is the Only Loop Control That Matters
1.2 Hub-and-spoke orchestration	Coordinator/sub-agent structure, context isolation, decomposition scope	Hub-and-Spoke: All Roads Go Through the Coordinator
1.3 Task tool and allowedTools	AgentDefinition fields, resume, fork, parallel spawning, coordinator prompts	Task Tool, allowedTools, and the Full AgentDefinition Configuration Surface
1.4 Programmatic vs prompt enforcement	When a hook or code check is required instead of an instruction	The Model Will Override Your Instructions 4-15% of the Time
1.5 Hooks and triggers	Hook types, matchers, PreToolUse return values, PostToolUse normalisation	Five Hook Types Across the Full Session Lifecycle
1.6 Fixed vs dynamic decomposition	Prompt chaining vs adaptive planning, multi-pass review	Dynamic Adds 30% Overhead on Fixed Tasks: Match Strategy to Task Type
1.7 Named session resume	Resume vs fresh session, stale-data risk	Resume Saves 44% Time and 58% Tokens in CI Pipelines

If you only have time for one pass, read the seven anchor articles above in order. They are short and each ends with a one-line summary you can memorise.

Why is Domain 1 weighted at 27%?

Because every other domain sits inside it. Tool design (Domain 2) only matters once you have a loop that calls tools. Claude Code configuration (Domain 3) is mostly about shaping how an agent behaves. Prompt engineering (Domain 4) and context management (Domain 5) are things you do to an agent. An architect who cannot describe the loop, its termination signal, and its failure modes cannot reason about anything downstream.

The practical consequence for study time: at 27%, Domain 1 is roughly 16 of 60 questions on a standard form (confirm the current blueprint on the official Anthropic / Pearson VUE page before you register). Our domain weighting strategy post argues you should not spend 27% of your time here, though. Much of Domain 1 is conceptual and transfers across questions once it clicks, so it tends to be efficient to study.

The five concepts you must recognise on sight

1. stop_reason drives the loop, nothing else. tool_use means execute the tools and continue; end_turn means stop. Text presence is not a signal, because text and tool_use blocks coexist in the same response. Iteration limits are a generous safety net, not primary control. The full six-value table is in stop_reason Is the Only Loop Control That Matters, and the companion piece The API Is Stateless: Send Full History Every Time covers why every request must carry the full message history including tool results.

2. Sub-agents start with an empty context. A coordinator that “knows” the customer’s order ID has not told the billing sub-agent anything unless it puts it in the prompt. Sub-Agents See Nothing: Context Must Be Explicitly Passed is the single most-tested idea in this domain, and Structured Data Preserves Attribution; Plain Text Destroys It covers the follow-on question of how to pass it.

3. Prompts guide, hooks guarantee. If the consequence of a miss is financial, legal, security or data-integrity, the requirement belongs in a PreToolUse hook or a post-processing check. If it is a style preference, a prompt line is fine. Stronger wording (“ABSOLUTELY MUST”) does not change a probabilistic instruction into a deterministic one. The decision table lives in The Model Will Override Your Instructions 4-15% of the Time; the mechanics of returning deny, allow, or allow with updatedInput are in PreToolUse Returns: deny, allow, modify — and the Bugs Between Them.

4. Match decomposition strategy to task shape. Fixed pipelines (security scan, then perf audit, then style check) want prompt chaining. Discovery-driven work (“understand this legacy codebase”) wants dynamic decomposition. Mixed tasks want a chained backbone with extension points. Defaulting to dynamic everywhere costs latency for no quality gain on the fixed portion.

5. Every AgentDefinition field is a design decision. description drives when the coordinator delegates, tools enforces least privilege, model trades cost against capability, and prompt sets goals and standards rather than step-by-step scripts. AgentDefinition: Every Field Matters, Nothing Should Be Left to Defaults and Goals + Standards Beat Step-by-Step cover this.

How does the exam test Domain 1?

Every question is a scenario. You are given a system (a support agent, a CI review bot, a research coordinator), a symptom or a constraint, and four designs. Three of them are plausible; one is the least bad. Typical framings:

• “The agent sometimes stops before finishing a multi-step task. Which change fixes it?” (Answer pattern: the loop is terminating on text presence or a low iteration cap; use stop_reason.)
• “A sub-agent returns findings that ignore the customer’s tier. Why?” (The coordinator did not pass tier into the sub-agent prompt.)
• “Refunds over $500 must go to a human. The system prompt says so, but 4% slip through. What is the fix?” (PreToolUse hook on the refund tool that inspects the amount and denies with redirect guidance.)
• “A CI job re-analyses the whole repo on every run. How do you cut cost without losing accuracy?” (Named session resume for stable context, with a rule for when to start fresh because data may be stale, see The Agent Can’t Detect Stale Data.)
• “Three independent sub-agents are being run sequentially. What is the cheapest improvement?” (Spawn them in parallel, see Parallel Execution: 80% Wall-Clock Reduction, Zero Extra Cost.)

Notice that none of these ask you to recall a definition. They ask you to diagnose a symptom and pick a mechanism. When you practise, say the mechanism out loud before you look at the options.

Worked scenario: a support agent that skips verification

Setup. A customer-support agent has tools get_customer, verify_identity, get_orders, and process_refund. The system prompt says identity must be verified before any account data is accessed. Monitoring shows about 7% of sessions access account data without a verification call, almost always when the customer opens with an account number and an urgent tone.

Options you might be offered.

A. Rewrite the system prompt in capitals and move the rule to the top. B. Add a PreToolUse hook that denies get_orders and process_refund unless verify_identity has returned confirmed in this session, with a reason that tells the model to verify first. C. Split into a verification sub-agent and a support sub-agent, with the coordinator calling verification first. D. Reduce the tool count so the model is less likely to pick the wrong tool.

Reasoning. A is the trap: the model is not missing the instruction, it is judging the instruction redundant under urgency, so emphasis does not help. D solves a different problem (tool selection accuracy, a Domain 2 topic). C works but adds latency and a coordinator whose own prompt could be overridden the same way. B is deterministic, cheap, and gives the model a redirect so the conversation continues gracefully. B is the least bad answer.

Where to read more. The 7% figure and the graduated-enforcement version of this scenario (tiered refund limits) are in The Model Will Override Your Instructions. The trap of writing a hook that logs “Blocked!” but returns {} (which allows the call) is in PreToolUse Returns: deny, allow, modify. The MCP-prefixed tool name trap (mcp__payments__process_refund bypassing a matcher for process_refund) is in HookMatcher: Targeted Matchers Save 40% Hook Processing Time.

Common traps in Domain 1 questions

• Reaching for multi-agent when one agent will do. If the task is fixed, small, and the tool set is under about five tools, a single agent with a good prompt is usually the least bad design. Orchestration is the answer when work is parallelisable, needs isolation, or exceeds one agent’s reliable tool count. Don’t Run Every Agent for Every Query covers dynamic selection when you do orchestrate.
• Confusing “parallel” with “faster for everything”. Parallel spawning helps when sub-tasks are independent. Sequential dependencies (search, then synthesise) cannot be parallelised no matter what the option says.
• Treating the coordinator’s memory as shared. It is not. Anything a sub-agent needs must be in its prompt or in the structured data passed to it.
• Missing that resume and fork solve different problems. Resume continues a session with its context (cheap follow-ups); fork branches from a session to avoid anchoring bias in evaluation. See Resume Saves 85% Tokens and Fork Eliminates Anchoring Bias.
• Narrow decomposition. Splitting “review this PR” into “check function X” and “check function Y” misses cross-file issues. Narrow Decomposition Means Missing Coverage and Single-Pass Reviews Produce Contradictory Findings show the per-file plus cross-file pattern.
• Assuming a hook can call tools. Hooks return decisions; the model performs the alternative action. An option that has a hook “call escalate_to_human directly” is describing something hooks do not do.
• Choosing PostToolUse when PreToolUse is needed, or vice versa. Pre blocks or modifies inputs; Post normalises or audits outputs. PostToolUse Normalization: 12% → 0.3% Date Errors shows the output-side use case.

Next step

Read the seven anchor articles linked in the table above, then drill Domain 1 practice questions until you can name the mechanism before reading the options. When your per-domain accuracy is steady, sit the free CCA-F mock exam, which samples questions by official weight so Domain 1 shows up in proportion. The full article list is on the Domain 1 study guide page, and the study-order version of this post is CCA Study Tips for Domain 1.