Passing the Claude Certified Architect (CCA-F): The Complete Guide
On March 12, 2026, Anthropic launched its first official technical certification: the Claude Certified Architect — Foundations (CCA-F). It's neither an AI-literacy badge nor a "clever prompts" quiz. It's a 300-level, production-scenario-based exam that validates one thing: can you design and ship Claude systems that hold up in real conditions?
This guide gathers everything you need to pass on the first try: who it's for and what it's worth, how to register, the exact format, the five domains and their weights illustrated with schemas, the question types with worked examples, the traps that sink most candidates, a six-week study plan, the free official courses with links, and a full glossary. Whether you're aiming for the cert for yourself or to frame a team's upskilling, read this before you register.
What exactly is the CCA-F?
Here are the official specs to know before booking a slot:
- Format: multiple choice, each question with one correct answer and three distractors.
- Number of questions: 60.
- Scenarios: the exam draws 4 of 6 scenarios at random. The six: Customer Support Resolution Agent, Code Generation with Claude Code, Multi-Agent Research System, Developer Productivity with Claude, Claude Code for Continuous Integration, Structured Data Extraction.
- Duration: 120 minutes (~2 minutes per question).
- Score: scale of 100 to 1000, passing at 720. Weighted scoring: questions in heavier domains count more.
- Cost: $99 ($0 for the first 5,000 Claude Partner Network employees).
- Proctoring: online or test center. You cannot have Claude open in another window.
- Language: English only.
- Registration: via Anthropic Academy on Skilljar. Score report within ~2 business days.
Who is it for, and is it worth it?
The target: software engineers, solutions architects, and AI developers who actually build with Claude — the API, Claude Code, the Agent SDK, MCP. If you've never gone beyond chatting, it's not for you just yet: the exam assumes hands-on practice.
Why it matters, concretely: it's the first certification backed by the vendor itself, in an ecosystem seeing rapid enterprise adoption. Anthropic committed a $100M investment in 2026 to its partner network, and major consulting firms are training their workforces on Claude at massive scale. The result: for Claude-focused delivery roles, the credential is becoming a baseline expectation. "I know prompt engineering" is easy to claim; a vendor cert is proof.
How to register
The registration path, step by step:
- Create an Anthropic Academy account (Skilljar) — just an email, no Anthropic Console account needed.
- Follow the prep path and take the official practice exam available on the platform.
- Request exam access. Today, access mainly goes through the Claude Partner Network; whether it opens to the general public, and post-launch pricing, are not yet officially confirmed.
- Book your proctored slot (online or test center) and pay the $99 (or $0 if you're among the first 5,000 partner employees).
- Receive your score report within about 2 business days.
The five domains (and their weight)
This is THE strategic data point for your revision. Scoring is weighted, so your time should be too.
CCA-F domain weighting
Domain 1 — Agentic architecture & orchestration (27%)
The heaviest, and the one that fails the most people. Designing multi-agent systems, the agentic loop, task decomposition, subagent spawning, tool-use lifecycle, hooks, session state, failure handling in a pipeline. This is where real architecture decisions live, built on the Claude Agent SDK.
It all starts with the agentic loop. It hinges entirely on the stop_reason field the API returns — know it cold.
Beyond a single agent, the reference multi-agent pattern is the hub-and-spoke orchestrator: a central agent delegates to specialized subagents, each with an isolated context, then aggregates.
Domain 2 — Claude Code configuration & workflows (20%)
CLAUDE.md structures, prompt configuration, plan mode vs. execute mode, integrating agent actions into CI/CD pipelines. The exam checks that you can frame a coding agent: where to place persistent instructions, when to plan before acting, how to insert an agent into a continuous-integration chain without letting it execute anything.
Domain 3 — Prompt engineering & structured output (20%)
Context placement, XML tags, few-shot, JSON schemas, parsing strategies, validation/retry loops. This domain weighs less than orchestration: the exam assumes you can write a prompt. What it tests is robustness — and a recurring trap: a JSON schema guarantees syntax, never semantics.
Domain 4 — Tool design & MCP integration (18%)
Designing MCP (Model Context Protocol) servers, resource and prompt schemas, tool validation, preventing tool misrouting. MCP is the standard protocol by which Claude connects to external tools and data.
Domain 5 — Context management & reliability (15%)
The lightest, but don't skip it. Context window optimization, pruning, token budgeting, prompt caching (token economy), error propagation, escalation loops, Human-in-the-Loop (HITL) checkpoints, graceful degradation, session state.
The question types (and how to answer them)
Every question is a scenario: you're given a production system and asked for the best architecture decision. The trap is structural: the three wrong answers are realistic anti-patterns, exactly what someone with incomplete knowledge would pick.
The right method: don't look for "the right answer" in the abstract, look for the one that holds in production. Always ask: which handles failure? which avoids an unvalidated irreversible action? which relies on the native mechanism (the stop_reason, the schema, the cache) rather than a hack?
Spotting the distractor
| Anti-pattern (distractor) | Correct answer (production) | |
|---|---|---|
| Agentic loop termination | Parse text to guess the end | Rely on stop_reason (end_turn) |
| Structured output | Trust valid JSON | Validate semantics on top of syntax |
| Code review | The agent reviews its own code | Independent instance, no generation context |
| Irreversible action | Let the agent decide alone | HITL checkpoint before execution |
| Saturated context | Pile everything into the window | Prune + budget tokens + cache |
| Tool misrouting | Vague tool descriptions | Explicit schemas and descriptions |
Practice on realistic questions
Your agent calls a tool. The API response contains stop_reason: "tool_use". What should your loop do?
The classic traps that cause failure
stop_reason, never text parsing.
4. Having the agent self-review. Context isolation isn't a detail, it's an exam answer.
5. Forgetting HITL. The moment an action is irreversible, the right answer almost always goes through a human checkpoint.Study plan (~6 weeks)
Aligned with the weights. Adapt the pace, keep the order.
Preparation roadmap
Read the official exam guide
The official PDF works as a standalone course. Read it in full before touching the courses. Identify the 6 scenarios.
Domain 1 — Agentic (27%)
Claude Agent SDK, agentic loop, orchestrator/subagents, hooks, session state. Build a mini multi-agent system to anchor the theory.
Domains 2 & 3 (20% + 20%)
Claude Code & CLAUDE.md, plan vs. execute mode, CI/CD. Then prompt engineering: JSON schemas, XML tags, validation loops.
Domains 4 & 5 (18% + 15%)
MCP: design a server, validate tools, avoid misrouting. Reliability: prompt caching, token budgeting, HITL, graceful degradation.
Practice exam + strategy
Take the Anthropic Academy practice exam under timed conditions. Analyze every mistake, review the distractors, set your pace to 2 min/question.
The free official courses (with links)
Good news: the best prep is free and signed by Anthropic. Avoid sketchy paid "braindumps" — often outdated and risky. Focus on official sources.
The most useful Anthropic Academy courses for the CCA-F (all free, in English): Building with the Claude API, Claude Code in Action, Claude Code 101, Introduction to Subagents, Skills in Claude Code, Introduction to Claude Cowork, and the AI Fluency / AI Capabilities and Limitations foundation. The official technical docs remain the absolute reference: docs.claude.com (API, Agent SDK, MCP, prompt caching, Claude Code).
Exam day
- Pace: 60 questions in 120 minutes = 2 min/question. Don't get stuck; flag hard questions and come back.
- Environment: proctored exam. Quiet room, clear desk. Claude must be closed — no open window.
- Reading the scenario: read the full context before the options. The scenario often contains the clue that eliminates two distractors.
- Elimination method: first spot the two obvious anti-patterns, then decide between the two "plausible" answers using the production criterion (failure handled? action validated? native mechanism?).
- Don't overthink: the right answer follows Anthropic best practices, not the cleverest trick.
AI & Claude glossary to know
The terms that recur in the questions. Master them — they're the grammar of the exam.
📚Full glossary (expand)
Agentic loop — Cycle of request → model call → tool execution → result reinjection → loop back, until end_turn.
stop_reason — Field the API returns indicating why Claude stopped. tool_use = it's requesting a tool; end_turn = it's done.
Claude Agent SDK — Official kit for building autonomous agents: managing the loop, subagents, hooks, and session state.
Subagent — A secondary agent the orchestrator delegates an isolated task to, with its own context.
Orchestrator / hub-and-spoke — Pattern where a central agent coordinates several specialized subagents in a star shape.
Task decomposition — Breaking a complex task into delegable subtasks.
MCP (Model Context Protocol) — Standard protocol for connecting Claude to external tools and data sources via MCP servers.
MCP server — A service exposing resources, prompts, and tools to Claude per the MCP protocol.
Tool use — Mechanism by which Claude calls a tool defined by its schema, rather than replying in free text.
Tool misrouting — Error where the agent calls the wrong tool; prevented with clear schemas and descriptions.
JSON Schema — Specification describing the expected shape of an output; guarantees syntax, not semantics.
Pydantic — Python data-validation library, often used to type/validate structured outputs.
CLAUDE.md — Configuration and persistent-instruction file for Claude Code, read automatically.
Plan mode vs execute mode — In Claude Code, the separation between planning (without acting) and executing actions.
Hooks — Interception points letting you run code at key moments of the agent's cycle.
Prompt caching — Caching reused portions of a prompt to cut cost and latency (token economy).
Context window — The model's limited workspace; its short-term memory.
Context pruning — Removing what's no longer useful from the context to avoid saturation.
Token budgeting — Deliberately allocating tokens across instructions, context, and output.
HITL (Human-in-the-Loop) — A checkpoint where a human validates before a sensitive or irreversible action.
Few-shot prompting — Giving examples in the prompt to guide format and behavior.
XML tags — Tags structuring the prompt to clearly delimit context, instructions, and examples.
Structured output — Output constrained to a machine format (JSON via schema), to make parsing reliable.
Validator / retry loop — A loop that checks the output and re-requests on validation failure.
Message Batches API — Batch-processing API to run many requests asynchronously and economically.
Multi-pass review — Review in several passes (per file then cross-file) to avoid attention dilution.
Graceful degradation — Designing the system to degrade cleanly rather than fail abruptly.
Escalation loop — Mechanism that escalates a case to a higher agent or a human when the agent fails.
Distractor — In a multiple-choice question, a plausible wrong answer — here often a realistic anti-pattern.
In summary
The CCA-F rewards one thing: the ability to make architecture choices that hold in production. Three levers make the difference — revise by weight (agentic first), train to recognize anti-patterns rather than memorize answers, and lean on the free official resources rather than dumps. The rest is practice: build a small agentic system, break it, fix it. That's exactly what the exam will ask you to know how to do.
This article is part of nAIvigate's Learn module. To go deeper on two topics the certification tests directly, read AI Agent Drift and Persistent Memory.
Want to certify a whole team or move from theory to a genuinely deployed Claude system? That's what nAIvigate Studio does: from agentic architecture to production, supported end to end.
Official sources
- Anthropic Academy (free courses): anthropic.skilljar.com
- Claude technical documentation: docs.claude.com
- Partner program & certification: anthropic.com/news