Claude Architect Certification — The Complete Field Guide

See the whole request: Full API-Spec · SDK implementation and full JSON. Read complete exchanges, every displayed field, and fixed versus changing parameters.

Written by a certified architect

Sam Muthu

Claude Certified Architect – Professional (17 Oct 2026) and Foundations (12 Oct 2026)

I built this guide as my own study system and kept improving it while I prepared for and sat both Anthropic exams. Most of it, including the Professional track, the practice banks and the mock exams, was written or rebuilt in the 3–4 intensive weeks around the two exams. Every lesson was tested against practice questions I could not yet answer, then rewritten until I could.

Verify both badges on Credly →

An independent practitioner's guide. Not affiliated with or endorsed by Anthropic. The practice questions and mock exams are original, written against the public exam guides; none reproduces a live exam item.

A free, deeply-indexed study guide for Anthropic's Claude Certified Architect exams — Foundations (CCAR-F) and Professional (CCAR-P) — written by a practitioner who builds production agentic systems daily, for people who want to understand the concepts, not memorize trivia.

⚠️ Read this first — the honest status of the exams (August 2026): Anthropic's proctored certification exams are currently open only to Claude Partner Network organizations — individuals with personal emails cannot register yet, and most "Anthropic certified" posts you've seen are the free Academy course completion certificates (open to everyone), not the proctored exams. This guide teaches the full blueprint anyway, because the knowledge is the point: if you're at a partner org, this prepares you to pass; if you're not, this prepares you to build — and to sit the exam the day the gate opens or your next employer's partner status unlocks it. The competence isn't gated. Details in the Exam Guide.

🎯 How this guide is different: every section teaches the architecture behind the answer — the agent loop, the harness, the trust boundaries — with diagrams, runnable snippets, real CLAUDE.md and skill samples, and "exam lens" callouts that tell you exactly how a concept gets tested. Where a topic has a trap, we name the trap.

Take a full timed mock exam

Eight full-length mock exams, free, in this guide. Each one runs with a real 120-minute timer, hides the answers until you submit, then shows a practice score with a per-domain breakdown and the full explanation for every question. Your answers and attempts are saved only in your browser: no account, nothing sent anywhere. Every question is original, written for this guide against the official exam guides; none is an official exam item, and none reproduces, reconstructs or recalls a live one.

Which mock should I take?

Why a certification at all?

If you learn from scattered blog posts, you get islands of knowledge with invisible gaps between them. A certification blueprint is a map of the whole territory — it tells you what a complete practitioner knows, so learning has a shape instead of a drift. Experienced builders get the complement: the blueprint finds the 30% you've never had to name, and the credential independently verifies that your experience speaks the industry's shared language. Either way the structure is the prize; the badge is a byproduct. The full argument — and the ladder from "I use Claude Code in a terminal" to "I architect agentic systems" — lives in Start Here.

💡 Reading tip: dotted-underlined terms everywhere in this guide are clickable — each opens a card with the definition, how it looks in code, and a use-case story. Collapsible 📖 story blocks on every domain explain why the topic exists before the reference begins, and 🔍 "See it run" blocks sit under every theory diagram, tracing one concrete use case through it — actual Claude API responses, tool results, and which branch fires — so you never have to hold the diagram in your head while hunting for an example. Beginners expand; veterans skip.

Start here

The exams at a glance

Two exams carry the Architect name, and it's worth knowing which one you're walking toward. Here they are side by side:

The five CCAR-F domains (weight-ordered study plan)

pie showData
  title CCAR-F blueprint weights
  "Agentic Architecture & Orchestration" : 27
  "Claude Code Config & Workflows" : 20
  "Prompt Engineering & Structured Output" : 20
  "Tool Design & MCP Integration" : 18
  "Context Management & Reliability" : 15

⚠️ The honest prerequisite: courses alone will not carry the architect exams. The blueprints test judgment calls from production work. This guide compresses that judgment — but build something real with Claude Code and MCP before exam day, even if small.

The Professional track (CCAR-P) — same KB, second exam

Every Professional page is built in the same fully-plugged pattern: plain meaning first, then the real artifact (request JSON, config, or the consulting document), glossary dialogs shared with Foundations, and question narratives. The sidebar tags them 🏛️.

The mental model that unifies everything

The cast — this guide always names its actors precisely. This guide uses five roles to describe a typical tool-using agentic system; some systems omit roles or split them further. Ambiguous words like "the API" or "the server" are banned here in favor of these names:

And there's a sixth actor the table can't contain: you, the architect. Everything above only works because someone brought the context, defined the objective, set the stage, wrote the goals, and made the rules — that someone is you. Claude is your thinking partner inside a world you constructed. Every domain in this guide is really teaching one slice of that construction job, and we'll point out your seat at the table in each one.

One picture explains 80% of the exam:

flowchart LR
  U[User / Trigger] --> H
  subgraph H[HARNESS — deterministic code]
    C[Assemble context] --> P[Build prompt + tool defs]
    P --> M
    M --> D{Decision as data}
    D -->|tool_use| T[Execute tool]
    T --> C
    D -->|end_turn| R[Respond]
    G[Gates · budgets · guardrails] -.- D
  end
  M[🧠 MODEL — Claude]
  R --> V[Verify / evals]

The model decides; the harness executes. Claude returns decisions as data (a tool_use block, a structured JSON object); your deterministic code runs the branch, applies guardrails, and loops. Every domain — agent orchestration, Claude Code, MCP, structured output, context reliability — is a view of this loop. Hold that picture and the scenario questions become readable.