What the Claude Certified Architect Exam Actually Tests
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.
Summary
- Core Idea: CCA Foundations is a 60-question, closed-book, no-AI-assistance proctored exam that tests whether a candidate can architect production Claude applications, not just call the API.
- Why It Matters: It gives hiring managers and teams a credential that signals real architectural judgment about agents, tools, and context, distinct from having read the docs once.
- Key Concepts: the five weighted exam domains, the no-AI-assistance constraint, proctored delivery, and the gap between API fluency and architectural judgment.
- When to Use: study this mental model before you touch practice questions, so you know which domains deserve the most study hours and why the format itself is part of what's being tested.
- Limitations / Trade-offs: a closed-book exam cannot test your ability to read documentation under pressure, which is a real production skill; it trades that for testing what you have actually internalized.
- Related Topics: exam domain weighting, Anthropic Academy prep courses, agentic orchestration patterns, tool and MCP design.
Foundations
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.
Mechanics & Interactions
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.
Advanced Considerations & Applications
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.
Common Misconceptions
- "It's mostly API syntax questions." - The exam is scenario- and trade-off-driven; knowing the shape of a
messages.createcall matters far less than knowing when a multi-agent topology is the wrong choice for a given problem. - "I can cram the week before since it's closed-book." - Closed-book format actually raises the bar for internalized understanding compared to an open-book test, since there is no fallback to looking something up mid-exam.
- "All five domains are worth the same study time." - They are explicitly weighted unevenly; treating them as equal wastes study hours that would be better spent on the 27% domain.
- "This only tests Claude Code." - Claude Code Configuration & Workflows is one of five domains at 20%; the exam also covers API-level agentic design, tool/MCP integration, and context reliability well outside the CLI.
- "No AI assistance means no code at all." - The exam still tests whether you can read and reason about code and architecture; it only removes the assistant that would normally help you produce or debug it live.
FAQs
Is CCA Foundations a coding exam or a conceptual exam?
Both, in different proportions:
- It includes architecture and design-judgment questions that don't require writing code.
- It also includes questions that require reading or reasoning about Python-style pseudocode or configuration snippets.
- It is not primarily a "write working code from scratch" exam the way a live coding interview is.
Why is the exam proctored?
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.
What does "no AI assistance" specifically rule out?
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.
Which domain should I study first?
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.
Do the five domains ever overlap on a single question?
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.
Is this exam only for people who already work at Anthropic or a partner company?
No. It is a general proctored technical certification aimed at practitioners who design and ship Claude-based systems, regardless of employer.
How does this exam differ from just reading the Claude API docs?
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.
Are Anthropic Academy courses required to pass?
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.
Does the exam test a specific Claude model version?
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.
What's the single biggest mistake candidates make preparing for this exam?
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.
Is 60 questions a lot for a certification exam?
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.
Should I study the smallest domain, Context Management & Reliability, last?
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.
Related
- CCA Foundations Exam Domains at a Glance - the quick-reference breakdown of all five domain weights this page introduces conceptually.
- Studying Agentic Architecture and Orchestration: the CCA Exam's Largest Domain - a deeper look at the 27% domain referenced throughout this page.
- Tool Design, MCP Integration, and Context Management: CCA Domain Checklist - checklist coverage of the remaining domains this page summarizes.
- CCA Foundations Best Practices - practical study and application guidance drawing on all five domains.
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.