What the Claude Certified Architect Exam Actually Tests
The Claude Certified Architect (CCA) - Foundations exam is Anthropic's first proctored technical certification.
//
Search across all documentation pages
The Claude Certified Architect (CCA) - Foundations exam is Anthropic's first proctored technical certification.
It launched on 2026-03-12, and it exists to answer one question about a candidate: can this person design and ship a production-grade Claude application at enterprise scale, not just write a prompt that works in a demo.
That distinction shapes everything about the exam's format and content.
If you have shipped a single-agent chatbot behind a Flask endpoint, you have touched maybe a third of what this exam covers.
The rest is orchestration, tool design, context discipline, and the operational judgment that separates a weekend project from something a company can run in production.
A certification exam is, at its core, a sampling problem.
Anthropic cannot ask every possible question about building with Claude, so CCA Foundations samples from five domains, each weighted by how often that kind of decision actually determines whether a production system succeeds or fails.
Agentic Architecture & Orchestration carries the most weight at 27%, covering multi-agent design and orchestration patterns: when to use a single agent versus a supervisor-worker topology, how to hand off context between agents, and how to keep a long-running agent loop from drifting or looping forever.
Claude Code Configuration & Workflows is 20%, covering how teams configure Claude Code itself: hooks, subagents, custom commands, and the workflows that make an engineering team's use of Claude Code repeatable rather than ad hoc.
Prompt Engineering & Structured Output is also 20%, covering how to get reliable, parseable output from Claude at scale, not just a single well-crafted prompt that works once in a playground.
Tool Design & MCP Integration is 18%, covering how to design tools an agent can use correctly, and how to integrate external systems through the Model Context Protocol (MCP) without exposing agents to more surface area than they need.
Context Management & Reliability is 15%, the smallest domain by weight but arguably the one most production incidents trace back to: token budgets, context window discipline, and the failure modes that show up only after a system has been running for a while.
These five domains do not map cleanly onto "the API," "the SDK," or "one library."
They map onto architectural decisions a person makes when designing a system, which is why the exam is structured around scenarios and trade-offs rather than syntax recall.
The most distinctive mechanic of CCA Foundations is not its content but its format: it is closed-book and prohibits AI assistance during the exam itself.
This is a genuine departure from how most Claude practitioners work day to day, where reaching for Claude Code, an MCP-connected assistant, or even a quick doc search is normal and expected.
The exam deliberately removes that scaffolding to test something else: whether the concepts underlying agentic architecture, tool design, and context management have become part of a candidate's own reasoning, rather than something they can reconstruct on demand with an assistant's help.
Think of it as the difference between being able to solve a problem with a search engine open, versus being able to explain to a teammate on a whiteboard why one orchestration pattern will fail under load and another won't.
Both skills matter in a real job.
The exam is built to measure only the second one, on the theory that the first is easier to develop once the underlying judgment exists, and much harder to fake without it.
A second mechanic worth understanding is domain weighting itself.
A 60-question exam with a 27% domain does not mean exactly 16 questions come from Agentic Architecture & Orchestration on every sitting, but it does mean that domain is proportionally the largest pool a question can be drawn from, and it should receive proportionally the largest share of study time.
# A rough way to think about study-time allocation, not an official formula.
domain_weights = {
"agentic_architecture_orchestration": 0.27,
"claude_code_configuration_workflows": 0.20,
"prompt_engineering_structured_output": 0.20,
"tool_design_mcp_integration": 0.18,
"context_management_reliability": 0.15,
}
study_hours_total = 40
plan = {d: round(w * study_hours_total, 1) for d, w in domain_weights.items()}That snippet is not a formula Anthropic publishes; it is a way of making the weighting concrete enough to plan around, which matters more than memorizing the percentages themselves.
Where this gets interesting is in how the domains interact rather than stand alone.
A question framed as being about "tool design" often also tests context management, because a badly designed tool is frequently the thing that blows a token budget or returns unbounded output that floods an agent's context window.
Similarly, "agentic architecture" questions frequently fold in prompt engineering, because how you structure the system prompt for a supervisor agent is itself an orchestration decision, not a separate skill practiced in isolation.
Candidates who study the five domains as five disconnected buckets tend to underperform relative to candidates who study them as five lenses on the same underlying set of production systems.
Anthropic Academy's free Skilljar-hosted courses, launched 2026-03-02, are built with this interconnection in mind: courses like Building with the Claude API, Introduction to MCP, and Claude Code in Action each touch multiple exam domains rather than mapping one-to-one onto a single domain.
| Preparation Approach | Strength | Weakness | Best Fit |
|---|---|---|---|
| Domain-by-domain study guides | Efficient coverage tracking against exact weights | Can miss cross-domain questions | Early-stage studying, building baseline vocabulary |
| Anthropic Academy courses | Matches Anthropic's own framing and terminology | Free courses move slower than a condensed guide | Building conceptual grounding before practice questions |
| Building real production-shaped systems | Tests judgment the exam actually rewards | Time-intensive, no guaranteed question overlap | Candidates with some hands-on Claude experience already |
| Practice question banks | Fast feedback on weak spots | Risk of pattern-matching without real understanding | Late-stage review, closer to exam day |
The honest limitation of a closed-book, no-AI-assistance format is that it does not test a skill that matters enormously in real production work: reading documentation quickly and correctly under time pressure when an API surface has changed.
Anthropic's own model lineup and SDKs move fast, and a working architect leans on current docs constantly.
The exam trades that realism for a cleaner signal: it wants to know what you actually understand well enough to reason about without a reference open, on the assumption that this underlying judgment is what transfers across model versions and SDK releases, even as the specific syntax changes.
messages.create call matters far less than knowing when a multi-agent topology is the wrong choice for a given problem.Both, in different proportions:
Proctoring exists to make the credential mean something consistent across every candidate who earns it, by ensuring the closed-book, no-AI-assistance conditions are actually enforced rather than self-reported.
It rules out using Claude, Claude Code, any other AI assistant, or AI-powered search during the exam itself, so that the score reflects the candidate's own internalized understanding rather than a live collaboration with a model.
Start with Agentic Architecture & Orchestration, since it is the largest domain at 27% and its concepts (orchestration patterns, multi-agent handoffs) recur inside questions nominally about other domains too.
Yes, frequently. A question about a badly designed tool call, for example, can simultaneously test Tool Design & MCP Integration and Context Management & Reliability, since an unbounded tool response is a common source of both problems.
No. It is a general proctored technical certification aimed at practitioners who design and ship Claude-based systems, regardless of employer.
The docs describe what each parameter and endpoint does; the exam tests whether you can combine that knowledge into sound architectural decisions under realistic production constraints, which is a different and harder skill.
They are not stated as a hard requirement, but the free Skilljar-hosted courses launched 2026-03-02 are built to map onto the exam domains and are a reasonable primary study path, especially for candidates newer to agentic system design.
The exam tests architectural and design principles that are meant to generalize across the current model lineup rather than quizzing model-specific trivia that would go stale the next time a model ships.
Treating it like an API reference quiz and cramming syntax, instead of practicing the judgment calls the domains are actually built around, such as when to add a second agent versus when that just adds coordination overhead.
It's a moderate length designed to sample meaningfully across five unevenly weighted domains without making the exam so long that fatigue starts affecting later answers more than knowledge does.
Not necessarily by weight alone. It's the smallest domain at 15%, but its failure modes (context overflow, token budget mismanagement) show up as root causes inside questions framed around other domains, so under-studying it can cost points indirectly too.
Stack versions: Written against the Claude model lineup current as of ~June 2026 - Claude Fable 5, Claude Opus 4.8, Claude Sonnet 5 (the default), and Claude Haiku 4.5 - and the official
anthropicPython SDK (latest 0.x release). Model names, pricing, exam format, and SDK versions move quickly - verify current specifics at platform.claude.com/docs and the official CCA exam guide before relying on them.
Reviewed by Chris St. John·Last updated Jul 15, 2026