The Claude Certified Architect Foundations (CCA-001) is Anthropic's first official technical certification. Launched March 12, 2026, it tests whether you can actually build production AI systems with Claude — not whether you can answer trivia about API parameters.
This is the study guide I wish existed when I started preparing for it.
It covers the exact exam structure, all five domains with their weightings, the six production scenarios, the concepts that trip most candidates, and the hands-on preparation path that actually works.
What the CCA-001 exam tests
The exam is 60 questions, 120 minutes, proctored. Passing score is 720 on a scaled 100–1,000 range. Cost: $99, available through the Anthropic Claude Partner Network.
The most important thing to understand upfront: every question is anchored to a production scenario. You are not asked "what is an agentic loop?" — you are placed in a specific system design situation and asked which architectural decision is correct, which failure mode you're facing, or which implementation pattern will hold in production.
Candidates who have only read documentation fail because the distractors are genuinely tempting if you have surface-level knowledge. The correct answers consistently point toward real engineering judgment — the kind that only develops from having actually built and broken agentic systems.
The five exam domains
The exam is weighted across five domains. Know these ratios — they tell you where to spend study time.
Domain 1 — Agentic Architecture and Orchestration (27%)
The heaviest domain. Tests multi-agent system design, task decomposition, hub-and-spoke orchestration models, and the failure modes that emerge when agents interact.
Key concepts you must understand at depth:
- Coordinator-subagent architecture: when a central coordinator delegates to specialist subagents vs when a single agent handles the full task
- Agentic loop design: how agents reason, act, observe, and re-reason — and where loops break in production
- Context isolation for subagents: why you isolate context per subagent to prevent context leakage and token bloat
- Token economics in multi-agent systems: how coordinator overhead compounds when subagents don't have focused context
The most common mistake candidates make in this domain: treating orchestration as a purely logical problem. The exam tests whether you understand the operational reality — latency, cost, failure propagation, partial completion handling.
Domain 2 — Tool Design and MCP Integration (18%)
Tests how you design tools that agents use reliably, and how Model Context Protocol servers connect agents to external systems.
Key concepts:
- Tool schema design: why description quality determines whether Claude calls the tool correctly, not the implementation
- MCP server architecture: transport types (stdio vs HTTP), session management, tool registration patterns
- Tool boundary design: how to prevent reasoning overload from too many tools or overlapping tool responsibilities
- Error handling in tool execution: what the agent receives when a tool fails and how that shapes recovery behavior
The most common mistake: thinking MCP is just "an API wrapper." MCP introduces specific session lifecycle and discovery patterns that the exam tests at depth.
Domain 3 — Claude Code Configuration and Workflows (20%)
Tests CLAUDE.md hierarchy, custom slash commands, the -p flag for CI/CD, and the context:fork pattern for skill isolation.
Key concepts:
- CLAUDE.md hierarchy: global (
~/.claude/CLAUDE.md) vs project-level vs directory-level, and how they compose - Slash commands: how to define them, when to use
context:forkto isolate skill execution from the main session - CI/CD integration: the
--print/-pflag for non-interactive mode,--output-format jsonfor structured output in pipelines - Skills architecture:
context:forkin frontmatter runs the skill in a sub-agent, keeping verbose output out of the main session context
Domain 3 catches people who have only used Claude as a chat tool but haven't used Claude Code in production pipelines. The exam gets specific about flag combinations and config file locations.
Domain 4 — Prompt Engineering and Structured Output (20%)
Tests how to make production prompts reliable and how to enforce structured output at scale.
Key concepts:
- JSON schema enforcement: constraining model output to a schema through system prompts and validation retry loops
- Few-shot techniques for complex formats: when examples are necessary vs when zero-shot is sufficient
- Self-evaluation patterns: implementing retry loops where the model receives its own error logs and corrects them without human intervention
- System prompt architecture for complex applications: modular prompt composition, how to structure prompts that are maintainable across a team
The exam distinguishes between prompt engineering for demos (optimise for the impressive case) and for production (optimise for failure rate and consistency). Nearly every question in this domain has a "looks right" distractor that would work for a demo but fail at scale.
Domain 5 — Context Management and Reliability (15%)
Tests how to handle long-context tasks, agent handoff patterns, and confidence calibration.
Key concepts:
- Context window management: strategies for tasks that exceed context limits — summarisation, chunking, external memory
- Handoff patterns: how one agent passes state to another agent cleanly, what must be preserved vs what can be reconstructed
- Confidence calibration: how agents should signal uncertainty and when to escalate vs retry vs fail gracefully
- Session continuity: how AgentCore Memory supports cross-session persistence for long-running workflows
The six production scenarios
The exam presents four of these six scenarios randomly. Every question in your exam is anchored to those four scenarios. Study all six — they overlap significantly in the skills they test.
Scenario 1 — Customer Support Resolution Agent
An agent that handles customer support queries end-to-end. Tests: multi-turn conversation management, tool use for account lookups, escalation patterns, confidence calibration for edge cases.
Scenario 2 — Code Generation with Claude Code
Using Claude Code in a development workflow. Tests: CLAUDE.md configuration, slash command design, CI/CD integration with the -p flag, context management for large codebases.
Scenario 3 — Multi-Agent Research System
A coordinator agent that delegates research subtasks to specialist subagents. Tests: task decomposition, context isolation per subagent, result synthesis, failure handling when a subagent returns an error.
Scenario 4 — Developer Productivity with Claude
Claude integrated into an engineering team's daily workflow. Tests: Claude Code configuration, memory and context persistence across sessions, CLAUDE.md hierarchy for team-wide settings vs individual developer settings.
Scenario 5 — Claude Code for CI/CD
Claude Code embedded in a continuous integration pipeline. Tests: non-interactive mode (-p flag), structured JSON output, schema-enforced PR comments, failure modes when Claude Code encounters ambiguity in automated context.
Scenario 6 — Structured Data Extraction
An agent that extracts structured data from unstructured documents. Tests: JSON schema design, validation retry loops, few-shot examples for format consistency, handling documents that don't match expected patterns.
The concepts that trip most candidates
Context leakage in multi-agent systems
When a coordinator passes its full context to a subagent, the subagent inherits reasoning, instructions, and conversation history that are irrelevant to its task. This bloats token usage and degrades subagent performance. The correct pattern: isolate context per subagent, passing only the task specification and the minimum necessary context.
Tool description vs tool implementation
Most candidates focus on the implementation of tool functions. The exam tests whether you understand that Claude's tool-calling behaviour is determined almost entirely by the description field in the tool schema — not the code. A perfectly implemented tool with a vague description will be called incorrectly or not at all.
The context:fork pattern
Skills defined in CLAUDE.md with context: fork in frontmatter run in an isolated sub-agent. This prevents verbose skill output from polluting the main conversation context. Understanding when to use context:fork vs running inline is a Domain 3 question type.
Non-interactive Claude Code
In CI/CD pipelines, Claude Code runs in non-interactive mode using the -p flag (or --print). Combined with --output-format json and --json-schema, it produces structured output that can be parsed by pipeline tooling. The exam tests specific flag combinations and failure modes when the agent encounters ambiguity it cannot resolve without human input.
Pigouvian retry loops
The self-evaluation pattern: the model generates output, a validation function checks it against a schema, and if validation fails, the error message is fed back to the model for correction — without human intervention. Understanding when this pattern is appropriate (deterministic validation criteria) vs when it creates loops (ambiguous validation criteria) is a Domain 4 question type.
How to prepare
Official resources first
Complete the Anthropic Academy courses on Skilljar before anything else. The flagship course is 8+ hours and covers the foundational architecture concepts the exam assumes. These are not optional — the exam references specific Anthropic design patterns that appear in the official curriculum.
Then build, not just read
The exam rewards candidates who have built real Claude systems. The scenarios are grounded in production problems — partial completions, tool failures, context limits, schema validation errors. Reading about these doesn't build the intuition the exam tests.
What to build before the exam:
- A multi-agent system where a coordinator delegates to at least two specialist subagents
- A Claude Code workflow with custom slash commands and a CLAUDE.md that sets project-wide context
- A CI/CD integration using
-pflag with JSON schema output - A tool schema where you've deliberately written a poor description and observed the resulting tool-calling behaviour
The official practice exam
After registering, Anthropic provides access to a 60-question official practice exam in the same scenario format as the real exam. Complete it before booking your real exam slot. The explanations for incorrect answers are specifically useful — they clarify exactly why the distractor is wrong, which is harder to learn from any other source.
Hands-on lab preparation
The gap the exam is designed to close: most AI certification study involves reading documentation and answering multiple-choice questions. The CCA-001 tests production architecture judgment that only develops from actually building systems.
The CCA-001 track on Cloud Edventures provides 22 hands-on lab missions in isolated real AWS Bedrock sandboxes — covering all five exam domains:
- Navigator's Compass (Domain 3): CLAUDE.md configuration, slash commands, plan-execute pipelines, CI/CD integration
- Tool Architect (Domain 2): Custom tool schema design, MCP server builds, function calling patterns, tool boundary design
- Prompt Engineering (Domain 4): JSON schema enforcement, few-shot techniques, validation retry loops, system prompt architecture
- Multi-Agent Systems (Domain 1): Coordinator-subagent architecture, context isolation, task decomposition, failure handling
- Production Reliability (Domain 5): Context window management, handoff patterns, confidence calibration, AgentCore Memory integration
Each mission runs in a real AWS Bedrock environment with automated step validation. You get immediate feedback on whether your architecture decision is correct — the same kind of feedback loop the exam demands.
No AWS account needed. No billing risk.
👉 cloudedventures.com/labs/track/claude-certified-architect-cca-001
Frequently asked questions
Who should take the CCA-001?
Backend and full-stack engineers adding AI architecture skills, cloud engineers specialising in AI infrastructure, AI/ML engineers wanting formal validation of agentic system skills, solutions architects designing Claude-powered systems for enterprise clients. The exam assumes at least 6 months of hands-on experience with the Claude API and Claude Code.
What does the exam cost?
$99 USD. Available through the Anthropic Claude Partner Network.
How long is the certification valid?
Anthropic has not published an expiry date for the Foundations certification, consistent with how it was launched as the entry point to a multi-level credential stack.
What comes after CCA-001?
Anthropic has confirmed additional certifications targeting advanced architects are planned for later in 2026. The Foundations certification is explicitly positioned as the entry point.
What's the passing score?
720 on a scaled score of 100–1,000.
Is it multiple choice?
Yes, 60 multiple-choice questions. But unlike typical multiple-choice exams, the distractors are carefully constructed to be plausible if you have partial knowledge. Candidates who have studied documentation but not built real systems routinely find the exam harder than expected.
Have a specific CCA-001 preparation question? Drop it in the comments.
Top comments (0)