CCAR-F Exam Guide 2026: Claude Certified Architect – Foundations

What is the CCAR-F, and is it worth it?

The Claude Certified Architect – Foundations credential uses the current exam code CCAR-F (formerly CCA-F) and is Anthropic's first official technical certification, launched March 12, 2026 through the Claude Partner Network. It validates that you can design, deploy, and maintain production-grade applications across the Claude ecosystem — the Claude API, the Claude Agent SDK, Claude Code, and the Model Context Protocol (MCP).

The one-line answer to "is it worth it": if you build real systems with Claude — agents, MCP integrations, structured-output pipelines, retrieval — CCAR-F is intended to assess architectural judgment rather than tutorial completion. It is a proctored, scenario-based exam aimed at solution architects, not casual chat users. Its value depends on whether the credential is relevant to the Claude systems you build and the roles you pursue.

The exam is 60 scenario-based multiple-choice and multiple-response questions in 120 minutes, scored on a 100–1000 scale with 720 required to pass, and costs $125 per attempt; any applicable partner-tier discount is shown during checkout. Questions are organized around four real-world scenarios drawn from a published pool of six — customer-support agents, multi-agent research, Claude Code in CI/CD, structured data extraction, and more — so you architect inside a realistic problem rather than answer trivia. This guide breaks down every domain, the six scenarios, the scoring math, eligibility, how it differs from "knowing how to use Claude," and a concrete week-by-week prep path. You can start free CCAR-F practice questions alongside it.

Why Anthropic created the CCAR-F

Anthropic committed an initial $100 million to the Claude Partner Network for 2026, with a significant share going directly to partners for training, sales enablement, and market development. The certification is designed to assess production architecture decisions across Claude APIs, agents, Claude Code, MCP, structured output, and reliability—not merely prompt vocabulary.

The CCAR-F now sits in a four-exam program. Pearson VUE's Anthropic program page lists Claude Certified Associate – Foundations (CCAO-F), Developer – Foundations (CCDV-F), Architect – Foundations (CCAR-F), and Architect – Professional (CCAR-P), and certification is open only to organizations in the Claude Partner Network. Treat the credential as evidence of architecture judgment, not a guaranteed career outcome.

Who should take the CCAR-F?

This is an architecture-level exam. There are no formal prerequisites, but certification is open only to people at Claude Partner Network organizations, who register with a partner company email address. Anthropic's exam guide describes the typical candidate as having 6+ months of practical experience building with the Claude API, Claude Agent SDK, Claude Code, and MCP, and the Partner Academy lists free prep courses for the exam. It is the right exam if you are a:

• Solution architect or AI engineer designing multi-agent systems and tool integrations on Claude.
• Technical consultant or partner-network engineer deploying Claude for enterprise clients.
• Backend/platform developer who already ships Claude features and wants to formalize the architecture skill set.

It is the wrong exam if you have only used claude.ai for chat. The questions assume you have wired up an MCP server, written a system prompt with structured output, configured Claude Code with a CLAUDE.md, and debugged a flaky agent loop in production.

CCAR-F exam format, scoring, cost, and eligibility

A few details worth internalizing. Scoring is scaled, not raw percentage — a 720/1000 does not mean exactly 72% of items correct, because harder items can be weighted. Anthropic does not publish a raw-score conversion, so use practice results to locate weak domains rather than to claim a guaranteed cutoff. The exam is scenario-driven: questions place you in the role of an architect at a company deploying Claude in production ("the chatbot is hallucinating confidently — what is the architectural fix?"), not a vocabulary quiz. Registration begins in Anthropic Partner Academy. After checkout, candidates continue to Pearson VUE to schedule either online-proctored delivery or a test-center appointment.

The six exam scenarios (and how questions hang off them)

CCAR-F questions are not free-floating. The exam draws four scenarios at random from a pool of six, but it does not publish a fixed question count for each scenario. Knowing the pool lets you rehearse the exact architectural decisions each one forces:

1. Customer support resolution agent — returns, billing, and account issues with 80%+ first-contact resolution. Tests the agent loop, tool design, enforcement, and escalation.
2. Code generation with Claude Code — team configuration, CLAUDE.md, slash commands, and plan mode vs direct execution. Tests the Claude Code workflow domain head-on.
3. Multi-agent research system — a coordinator delegating to specialized subagents. Tests coordinator-subagent design, explicit context passing, and source provenance.
4. Developer productivity with Claude — helping engineers explore codebases and automate tasks with the built-in tools and MCP servers. Tests tool selection, MCP integration, and delegation.
5. Claude Code for continuous integration — automated reviews, test generation, and PR feedback. Tests non-interactive runs, structured findings, and explicit review criteria.
6. Structured data extraction — pulling fields from unstructured documents with validation. Tests tool-based JSON schemas, validation-retry loops, and edge-case handling.

Notice every scenario spans multiple domains. That is by design: the exam rewards architects who can move between agent orchestration, prompting, tools, and reliability inside one business problem. Build a small version of at least three of these before exam day.

The five CCAR-F domains and weights, explained

The blueprint has five domains. The weights tell you exactly where to spend study hours.

1. Agentic Architecture & Orchestration — 27%

The single biggest domain and the most underestimated. You design agentic loops and multi-agent systems with the Claude Agent SDK: a loop that continues while stop_reason is tool_use and ends on end_turn (not on parsed text or an arbitrary iteration cap), coordinator-subagent orchestration where each subagent receives its context explicitly in the prompt, parallel subagents spawned from one coordinator response, programmatic prerequisites and hooks for rules that must hold every time, structured handoffs to humans, prompt chaining versus adaptive decomposition, and session resumption and forking. Expect to defend trade-offs: when is a prompt instruction enough, and when does a business rule need a hook?

2. Tool Design & MCP Integration — 18%

Designing the interfaces Claude chooses between. Tool descriptions are the main signal for tool selection, so you write them with inputs, examples, edge cases, and boundaries, and split or rename overlapping tools. You return structured MCP errors (isError, an error category, a retryable flag) instead of a generic failure, give each agent only the tools its role needs, and configure tool_choice. You also configure MCP servers for a team: project-scoped .mcp.json for shared servers with environment variable expansion for secrets, user-scoped ~/.claude.json for personal ones, and MCP resources for content catalogs. Choosing among the built-in tools (Read, Write, Edit, Bash, Grep, Glob) sits here too. A favorite "gotcha" archetype: why would you NOT give one agent all 18 tools? The right answer is about role-scoped access and tool-selection reliability.

3. Claude Code Configuration & Workflows — 20%

Configuring Claude Code for a team: the CLAUDE.md hierarchy (user, project, directory), @import and .claude/rules/ files, path-specific rules with glob patterns, custom slash commands and skills (with context: fork, allowed-tools, and argument-hint frontmatter), and when to use plan mode versus direct execution. It also covers iterative refinement (concrete examples, test-driven iteration, the interview pattern) and CI/CD: running Claude Code non-interactively with -p, plus --output-format json and --json-schema for machine-readable findings.

4. Prompt Engineering & Structured Output — 20%

Production prompting, not casual prompting. Explicit criteria instead of "be conservative", targeted few-shot examples for ambiguous cases, and structured output through tool use and JSON schemas, including tool_choice and nullable fields so the model does not invent missing values. The recurring theme is reliability: validation-retry loops that feed specific errors back, knowing that a schema removes syntax errors but not semantic ones, using the Message Batches API only for latency-tolerant work, and preferring independent or multi-pass reviews to self-review.

5. Context Management & Reliability — 15%

The smallest domain by weight, but its ideas bleed into every other domain. You keep critical facts through long interactions (a persistent case-facts block, trimmed tool outputs, key findings placed first because of the lost-in-the-middle effect), set escalation triggers (an explicit request for a human, a policy gap, no meaningful progress — not sentiment), propagate structured errors across agents, manage context while exploring large codebases, calibrate human review with confidence scores and stratified sampling, and keep information provenance when sources disagree.

Quick math: domains 1, 3, and 4 alone are 67% of the exam. If you are short on time, weight your hours there — but skip nothing, because reliability concepts (domain 5) recur inside the other four.

How CCAR-F differs from "knowing how to use Claude"

This is the distinction that trips up experienced Claude users. The CCAR-F does not ask "what is a hallucination?" It asks "your customer's agent hallucinates confidently in production — what is the architectural fix?" The earlier version 0.1 exam guide warned that distractors are written to look reasonable to candidates with incomplete knowledge — every wrong answer sounds plausible. You cannot pattern-match your way through it.

Day-to-day Claude usage teaches you features. The CCAR-F tests trade-offs: when a fixed prompt chain beats adaptive decomposition, when a hook must enforce a rule that a prompt only suggests, when to escalate to a human, and how to scope each agent's tools to its role. Internalizing Anthropic's design philosophy beats memorizing API parameters.

A domain-weighted preparation path

Map your study order to the weights and to how the platform actually layers.

Phase 1 — Claude API and Agent SDK foundations. Master the Messages API tool-use cycle (stop_reason, tool results, tool_choice, max_tokens), system prompts, and the Agent SDK basics. Everything above sits on this.

Phase 2 — Prompt engineering & structured output. Practice explicit review criteria, few-shot examples for ambiguous cases, tool-based JSON schemas with nullable fields, and validation-retry loops until you can reliably parse output in code. Covers domain 4 (20%).

Phase 3 — Tool design & MCP. Actually build an MCP server. Write differentiated tool descriptions, return structured errors with a retryable flag, configure it in a project .mcp.json with environment variable expansion, and expose a resource. Reading about MCP is not enough — the exam tests design decisions you only understand by building. Covers domain 2 (18%).

Phase 4 — Agentic architecture & Claude Code. The heaviest phase for the heaviest domain (27%) plus Claude Code (20%). Build a coordinator with subagents in the Agent SDK, pass context explicitly, and add a hook that blocks a policy-violating tool call; configure Claude Code with a CLAUDE.md hierarchy, .claude/rules/, a skill, plan mode, and a -p CI run.

Phase 5 — Context, reliability & timed mocks. Case-facts blocks, trimmed tool outputs, escalation triggers, error propagation, confidence calibration, and provenance — then timed full-length practice to build exam stamina and pacing (you have ~2 minutes per question).

The Anthropic Partner Academy lists free prep courses for this exam: Building with the Claude API, Claude Code in Action, Introduction to Model Context Protocol, AI Fluency: Framework & Foundations, Claude 101, and the Amazon Bedrock and Google Cloud courses. The Claude API, Claude Code, and MCP docs are all free as well. Pair the courses with free CCAR-F practice questions across all five domains, and review every miss until you can explain the architecture principle behind the right answer.

Common CCAR-F pitfalls

• Under-weighting domain 1. Agentic architecture is 27% and the section people most often underprepare. Know each pattern and its trade-offs, not just the names.
• Treating MCP as theory. You will be tested on server scoping (.mcp.json vs ~/.claude.json), tool descriptions, and structured error handling — build a server, do not just read about one.
• Casual prompting habits. The exam wants production-grade structured output and validation, not vibes-based prompting.
• Ignoring reliability because it is "only 15%." Context management, escalation, and provenance appear inside other domains' scenarios too.
• Skipping timed practice. 60 scenario questions in 120 minutes punishes slow readers; rehearse pacing.

Your next step

Confirm current logistics against the official CCAR-F exam guide and Pearson VUE before paying. Then work through the Partner Academy prep courses, build something real with the Agent SDK and an MCP server, then pressure-test your readiness with free CCAR-F practice questions that mirror all five exam domains and the six scenarios. Drill terminology fast with free CCAR-F flashcards. Use consistent timed results across every domain as one readiness signal before you schedule.