Claude Certified Architect – Foundations — Study Guide

Agentic Architecture & Orchestration is the single largest domain on the Claude Certified Architect - Foundations (CCAR-F) exam, carrying **27%** of your score. That weighting is deliberate: nearly everything else in the certification assumes you can reason about how a Claude agent actually runs. Get this domain right and you have built the foundation the rest of the exam stands on. These seven lessons move from the mechanics of a single agentic loop up through multi-agent coordination. You will learn how `stop_reason` drives deterministic control flow, why the hub-and-spoke pattern is the only orchestration model the exam tests, how subagent context isolation forces explicit context passing, when to reach for programmatic enforcement instead of prompting, how PreToolUse and PostToolUse hooks inject determinism, how to decompose work without diluting the model's attention, and how to resume or fork sessions without poisoning them with stale context. Because this is the heaviest-weighted domain, invest your study time here first.

Domain 2 covers how Claude agents reach outside their context to act on the world through **tools** and the **Model Context Protocol (MCP)**. At 18% of the CCAR-F blueprint, it tests whether you can design tool schemas Claude selects correctly, return errors an agent can recover from, distribute the right tools to the right agent, wire up MCP servers securely, and choose between custom tools and Claude's built-in capabilities. The recurring theme is that tools are a *language interface* first and a code interface second. A tool succeeds or fails on how clearly it describes itself, how honestly it reports failure, and how narrowly it is scoped. Get those right and Claude routes work accurately; get them wrong and no amount of downstream infrastructure fully compensates.

Domain 3 covers how you shape Claude Code's behavior through configuration and disciplined workflows. It carries **20% of the CCAR-F blueprint**, so expect several scored items here. You will learn how memory files layer from user to project to directory scope, why concatenation (not override) governs conflicts, and when a hard rule belongs in `settings.json` or a hook instead of `CLAUDE.md`. The domain then moves from static configuration to active workflow: authoring reusable slash commands and skills, scoping conventions to file paths with glob-based rules, choosing plan mode versus direct execution, refining output through examples and tests, and running Claude Code non-interactively inside CI/CD pipelines. These are the everyday levers a Claude-certified architect uses to make an agent reliable across a team.

Prompt engineering is where architectural intent becomes reliable model behaviour. This domain — 20% of the CCAR-F blueprint — covers the techniques that turn Claude from a capable chat model into a dependable component in a production pipeline: writing **system prompts with explicit criteria**, teaching format and judgement with **few-shot examples**, guaranteeing schema-compliant **structured output** via tool use, and wrapping it all in **validation-retry loops**. Beyond single calls, you will learn to scale and harden extraction workflows: when to trade latency for cost with the **Message Batches API**, and how **multi-pass, multi-instance review** overcomes attention dilution and self-confirmation bias. The exam tests judgement — knowing which technique fixes which failure mode — so every lesson pairs the concept with the traps that distinguish a correct answer from a plausible distractor.

Domain 5 is where architecture meets reliability. As Claude agents run longer and coordinate more subagents, the biggest risks stop being model capability and start being **context hygiene**: facts that vanish under summarisation, errors that get silently swallowed, and citations that dissolve during synthesis. This 15% slice of the CCAR-F blueprint tests whether you can keep a stateless API coherent across long conversations, decide when an agent should hand off to a human, and make failures visible instead of invisible. The six lessons move from single-conversation context windows to multi-agent pipelines. You will learn structural fixes (case-facts blocks, prompt caching, scratchpad files, structured error objects) that beat prompt-level pleading every time. Expect scenario questions that reward the smallest proportionate change — usually a system-prompt or data-layout fix — over expensive architectural rewrites.