Claude Certified Architect (CCA) — Complete Documentation

Last compiled: 2026-03-26 Primary source: Anthropic Partner Network + Anthropic Academy + docs.anthropic.com

1. What the CCA Is

Claude Certified Architect, Foundations is Anthropic's official technical certification, launched on March 12, 2026 as part of the Claude Partner Network.

Audience: Solution architects building production applications with Claude.

Access: Currently restricted to Claude Partner Network members — network membership is free.

Official source: https://www.anthropic.com/news/claude-partner-network

1b. The Claude Certification Family (Exam Guides v1.0, July 2026)

As of July 2026 the Claude Certification Program spans four credentials, all proctored by Pearson VUE, all scored on the 100–1,000 scale with a 720 cut score, all valid 12 months:

Shared mechanics across all four (v1.0 guides):

• Item format: multiple-choice and multiple-response — each item states how many responses to select.
• Registration: through the Anthropic Partner Academy; checkout reflects partner-tier discounts; scheduling and delivery via Pearson VUE (online proctored or test center). Cancel/reschedule up to 24 hours before your appointment, or the fee is forfeited.
• Retake policy: waiting periods grow per failed attempt — 14 days after the 1st, 30 days after the 2nd, 90 days after the 3rd; max 4 attempts per rolling 12 months, per exam. The fee applies to each attempt.
• Renewal: on-time renewal is a free, non-proctored assessment on the Partner Academy. If the credential lapses, you retake the full exam at full fee. Anthropic may require a full retake when content changes significantly.
• NDA: before starting you must accept a confidentiality agreement; declining ends the session with no refund.
• No prerequisites for any exam — the credential is awarded on exam performance alone.

1c. Architect Professional (CCAR-P) at a Glance

The Professional exam validates the full lifecycle of a Claude-powered system: design → integration → evaluation → governance → stakeholder communication. Recommended experience: 3+ years systems architecture, 6+ months of Claude (or comparable LLM) systems in production.

Notable differences vs the Foundations blueprint: RAG pipeline design (chunking, indexing, retrieval strategy), regulated-industry compliance (GDPR, HIPAA, FedRAMP), ethical AI (bias, fairness, transparency), formal evaluation programs (A/B tests, eval datasets), and an entire domain on stakeholder practice (discovery, trade-off communication, SLAs, ADRs, handoff). Anthropic's out-of-scope list still excludes fine-tuning, model internals, cloud-provider specifics, and pricing arithmetic.

This app's Architect Professional track mirrors the 63-item form, the official domain weights, and the multiple-response item format.

1d. Associate (CCAO-F) at a Glance

The Associate exam targets non-developer professionals who use Claude's consumer/workplace apps (Projects, Artifacts, connectors) rather than the API. It is the entry point into the Claude Certification Program: 60 items, $99, 120 minutes, cut score 720/1000.

This app's Associate track mirrors the 60-item form and the official domain weights.

1e. Developer (CCDV-F) at a Glance

The Developer exam targets developers building with the Claude API and SDKs — client SDKs, the Agent SDK, streaming, prompt caching, batch processing, and MCP tool integration. It sits alongside Associate as an entry-level credential: 53 items, $125, 120 minutes, cut score 720/1000.

This app's Developer track mirrors the 53-item form and the official domain weights.

2. Exam Structure

2b. Exam Details — CCAR-F (Official Exam Guide v1.0)

Target candidate (Anthropic's official wording): hands-on experience with the Agent SDK (multi-agent, tool integration, lifecycle hooks), Claude Code (CLAUDE.md, Skills, MCP, plan mode), MCP tool/resource interface design, prompt engineering for reliable structured output, context window management, CI/CD integration, escalation and reliability decisions.

The typical candidate has 6+ months of hands-on experience with Claude APIs, the Agent SDK, Claude Code, and MCP.

2c. Exam-Day Rules & Policies (from the Official Exam Policy)

These are Anthropic's actual rules for the real, proctored exam — not this practice app's rules.

Before the exam:

• Accommodation requests (e.g. for a disability) must be submitted and approved before you schedule the exam — you cannot request one after booking.
• If asked, you must present a valid, unexpired government-issued photo ID matching your registration name exactly.

During the exam:

• No AI tools or services of any kind may be used to assist you — this includes Claude itself.
• Only one monitor, no notes, no extra devices, no other documentation.
• No unscheduled breaks unless requested and approved in advance.
• The exam is monitored via audiovisual recording; a proctor may act immediately on any rule violation.

After the exam:

• You may appeal a final decision (suspension, forced retake, invalidated results, removal from the program, certification denial/suspension/revocation) within 14 calendar days of being notified. Late appeals may not be granted.
• Misconduct findings can lead to suspension, forced retake, invalidated results, or certification denial/revocation — with no obligation for Anthropic to refund exam fees.

This is a plain-language summary, not the legal text. The authoritative source is Anthropic's own Certification Exam Policy and Certification Terms and Conditions.

Scenario System (how the random selection works)

The exam presents 4 of 6 scenarios, selected at random. Each question is anchored to a specific scenario.

Strategy: study all 6 — each scenario covers multiple domains. Don't bet on which 4 will show up.

How Questions Are Built — The Distractor Mechanism

From the Exam Guide: "Distractors are response options that a candidate with incomplete knowledge or experience might choose."

Distractors are NOT obviously wrong answers — they are real anti-patterns that someone with partial knowledge would pick.

3. The Five Exam Domains

Domain 1 — Agentic Architecture & Orchestration (27%)

The heaviest domain. It tests your understanding of agent-based architectures in production.

Topics covered:

• Agent loop mechanics
• Hub-and-spoke pattern for multi-agent orchestration
• Task decomposition
• Session resumption
• Handling agentic failures (subagent context not passed explicitly, vague tool descriptions, false-positive confidence)
• Multi-agent synthesis

Failure patterns to know:

• Subagent context not passed explicitly to the child agent
• Vague tool descriptions that cause misrouting
• Team standards configured only at the user level (not project/org level)
• Imprecise confidence instructions that trigger false positives
• Progressive summarization that destroys transactional facts

Domain 2 — Tool Design & MCP Integration (18%)

Often underrated, but with a very high impact on production reliability.

Topics covered:

• Precision of tool descriptions (naming, input schema, output contract)
• MCP (Model Context Protocol) server design and configuration
• Managing tool boundaries
• When to use tools vs disallowedTools in subagents
• Scoping MCP servers to specific subagents
• Transport mechanisms: stdio vs StreamableHTTP/SSE
• Production: stateless HTTP for horizontal scaling, load balancer compatibility

Key MCP concepts:

• Three primitives: tools (model-controlled), resources (app-controlled), prompts (user-controlled)
• Server Inspector for testing/debugging
• strict: true for guaranteed schema conformance in production agents
• MCP Advanced: sampling, progress/logging notifications, roots-based file access, JSON message architecture

Domain 3 — Claude Code Configuration (20%)

Configuration for production and team deployments.

Topics covered:

• CLAUDE.md — structure, scope, hierarchy, best practices
• Auto memory — how it works, storage location, limits (200-line MEMORY.md)
• .claude/rules/ — path-specific rules with YAML frontmatter
• Subagent configuration — frontmatter fields, tool scoping, permission modes
• Hooks — PreToolUse, PostToolUse, SubagentStart, SubagentStop
• Skills — packages of reusable workflows, trigger matching, distribution via plugin
• CI/CD integration (GitHub Actions, GitLab CI/CD)
• Managed policy CLAUDE.md (org-wide deployment via MDM)

CLAUDE.md hierarchy (highest to lowest priority):

CLI --append-system-prompt
Managed policy: /Library/Application Support/ClaudeCode/CLAUDE.md
Project: ./CLAUDE.md or ./.claude/CLAUDE.md
User: ~/.claude/CLAUDE.md

CLAUDE.md best practices:

• Target < 200 lines per file
• Concrete, verifiable instructions ("Use 2-space indentation", not "Format code properly")
• Use @path/to/import for file imports
• Use claudeMdExcludes in a monorepo to exclude irrelevant CLAUDE.md files

Domain 4 — Prompt Engineering & Structured Output (20%)

Designing effective prompts and reliable structured output in production.

Topics covered:

• Few-shot examples for reliability
• JSON schemas for structured output
• strict: true tool use to guarantee schema conformance
• Retry loops on validation failure
• Confidence calibration (avoiding false positives/negatives)
• Patterns for long-context management

Key concepts:

• Structured Outputs vs Strict Tool Use: knowing when to use one over the other
• Specific prompts produce more reliable behavior than generic prompts
• Output schema design that eliminates type mismatches in production

Domain 5 — Context Management & Reliability (15%)

The smallest domain by weight, but a fundamental foundation.

Topics covered:

• Long-context patterns (large context windows, what degrades)
• Handoff patterns between agents
• Escalation triggers
• Error propagation in multi-agent systems
• Auto-compaction (~95% capacity trigger)
• Progressive summarization — risks and when to avoid it
• Subagent context isolation vs sharing

4. Anthropic Academy Courses (CCA Preparation)

All courses are free at https://anthropic.skilljar.com

Courses relevant to the CCA (in recommended order):

Key course details:

Claude Code in Action

• Tool use architecture and context management
• Custom automation (slash commands/skills)
• MCP server integration
• GitHub Actions integration
• Reasoning modes for different complexity levels

Introduction to Model Context Protocol

• Three primitives: tools, resources, prompts
• Python SDK with decorators
• MCP Server Inspector
• Complete request-response flow

Model Context Protocol: Advanced Topics

• Sampling for language model integration
• Progress/logging notifications
• Roots-based file access
• stdio vs StreamableHTTP/SSE
• Stateless HTTP for horizontal scaling

Introduction to Agent Skills

• SKILL.md frontmatter structure
• Trigger matching and effective descriptions
• Context window management
• Distribution via plugin and enterprise settings

Introduction to Subagents

• Context isolation (separate context window)
• Custom subagent creation with /agents
• Structured output and obstacle reporting
• Tool access limitations
• When to delegate and when not to

5. Technical Reference Documentation

Claude Code — CLAUDE.md and Memory

URL: https://code.claude.com/docs/en/memory

Key points:

• CLAUDE.md vs Auto Memory: CLAUDE.md is written by the user, Auto Memory is written by Claude
• Auto Memory: the first 200 lines of MEMORY.md are loaded at the start of every session
• Storage: ~/.claude/projects/<project>/memory/
• Topic files (e.g. debugging.md) are not loaded at startup — Claude reads them on demand
• Path-specific rules: YAML frontmatter with a paths field in .claude/rules/
• @path/to/import for recursive file imports (max 5 hops)
• HTML block comments in CLAUDE.md are stripped from the context (use them for maintainer notes without consuming tokens)

Claude Code — Subagents

URL: https://code.claude.com/docs/en/sub-agents

Subagent frontmatter fields:

Subagent priority override (highest first):

1. --agents CLI flag (current session only)
2. .claude/agents/ (project scope)
3. ~/.claude/agents/ (user scope, all projects)
4. Plugin agents/ directory

Built-in subagents:

• Explore: Haiku, read-only, for codebase exploration
• Plan: Inherited, read-only, for plan mode research
• General-purpose: Inherited, all tools, for complex tasks

Delegation patterns:

• Natural language: Claude decides whether to delegate
• @-mention: guarantees that subagent is used for the task
• --agent <name>: the entire session uses the subagent as the main thread
• agent in .claude/settings.json: default for every session in the project

Tool Use — Overview

URL: https://platform.claude.com/docs/en/docs/build-with-claude/tool-use/overview

Key points:

• Tool access is the highest-leverage primitive for agents
• Each tool defines a contract: you specify the available operations, Claude decides when/how to call them
• strict: true for guaranteed schema validation in production
• On the LAB-Bench and SWE-bench benchmarks, even simple tools produce significant capability gains

5b. Complete Task Statements by Domain

D1 — Agentic Architecture & Orchestration (27%)

• 1.1 Agentic loops: stop_reason == 'tool_use' → continue; 'end_turn' → terminate. Tool results are ALWAYS appended to the history before the next iteration
• 1.2 Hub-and-spoke multi-agent: the coordinator manages all inter-subagent communication. Subagents have isolated context. Task decomposition that covers all subtopics (common error: decomposition that is too narrow)
• 1.3 Task tool for spawning subagents. allowedTools MUST include 'Task'. Subagent context is provided explicitly in the prompt — no auto-inheritance. Parallel spawning = multiple Task calls in a single response
• 1.4 Programmatic prerequisites for critical workflow ordering. Structured handoff (customer ID, root cause, recommended action) for escalation to a human
• 1.5 PostToolUse hooks for data normalization. Tool call interception to block policy-violating actions. Hooks = deterministic compliance; prompts = probabilistic guidance
• 1.6 Prompt chaining for predictable multi-aspect reviews. Dynamic decomposition for open-ended investigation. Split into per-file + cross-file integration pass
• 1.7 --resume <session-name> to resume sessions. fork_session for independent branches from a shared baseline

D2 — Tool Design & MCP Integration (18%)

• 2.1 Tool descriptions = the primary routing mechanism. Include: input formats, example queries, edge cases, boundaries relative to similar tools. FIRST action on misrouting: expand the descriptions
• 2.2 Structured error response: isError, errorCategory (transient/validation/business/permission), isRetryable. isError=False + data=None ≠ isError=True
• 2.3 Max 4-5 tools per agent. tool_choice: 'auto' (can return text), 'any' (must call a tool), {type:'tool', name:'...'} (a specific tool is required)
• 2.4 .mcp.json project-level for teams. ~/.claude.json user-level for personal use. ${VAR} for environment variable expansion. MCP resources for content catalogs
• 2.5 Grep = content search. Glob = file path patterns. Read/Write for full files. Edit for targeted modifications. NEVER Bash('cat file') when Read exists

D3 — Claude Code Configuration (20%)

• 3.1 Hierarchy: user-level (that user only), project-level (version-controlled, team), directory-level. @import for modularization. .claude/rules/ for topic-specific files
• 3.2 .claude/commands/ for team-wide slash commands. .claude/skills/ with context: fork to isolate verbose output. allowed-tools and argument-hint in the frontmatter
• 3.3 .claude/rules/ with paths: YAML frontmatter for conditional loading based on glob patterns
• 3.4 Plan mode for: complex tasks, large-scale changes, architectural decisions. Direct execution for well-scoped changes
• 3.5 Few-shot examples when prose descriptions produce inconsistent results. Test-driven iteration. Interview pattern for design considerations
• 3.6 -p / --print required in CI. --output-format json + --json-schema for machine-parseable structured findings

D4 — Prompt Engineering & Structured Output (20%)

• 4.1 Explicit criteria ("flag only when X contradicts Y") > vague instructions ("be conservative"). Disable high-FP categories to restore trust
• 4.2 2-4 few-shot examples for ambiguous scenarios. They demonstrate edge case handling, not just output format
• 4.3 tool_use + JSON schema = the only approach for guaranteed schema-compliant output. nullable for absent fields. 'other' + detail for extensibility
• 4.4 Retry with the SPECIFIC error in the prompt, not "try again". Retrying is ineffective for information absent from the document (not just format errors)
• 4.5 Message Batches API: 50% savings, 24h max, no SLA, no multi-turn tool calling. custom_id for correlation. Only for non-blocking workflows
• 4.6 Independent review with a separate instance (no prior reasoning context). Multi-pass: per-file local analysis + a separate cross-file integration pass

D5 — Context Management & Reliability (15%)

• 5.1 Progressive summarization loses transactional values. Extract critical facts into an immutable "case facts block". Trim verbose tool outputs to only the relevant fields. Put key findings AT THE START of aggregated inputs
• 5.2 Escalation triggers: customer requests a human (honor immediately), policy gap, inability to make progress. Sentiment ≠ case complexity
• 5.3 Structured error context: failure type, attempted query, partial results, alternative approaches. Silent failure = anti-pattern
• 5.4 Scratchpad files to persist findings across context boundaries. /compact in extended sessions. Structured state export for crash recovery
• 5.5 Stratified random sampling to measure the error rate in high-confidence extractions. Field-level confidence scores calibrated on labeled validation sets
• 5.6 Claim-source mappings preserved in synthesis. Conflicting statistics annotated with source attribution (not an arbitrary choice). Publication dates to distinguish temporal differences from contradictions

6. Failure Patterns to Know (for the Exam)

These are the 5 most common failure patterns in production Claude systems:

1. Subagent context not passed explicitly — the child agent doesn't receive the context it needs from the parent
2. Vague tool descriptions — they cause misrouting; Claude doesn't know when to call which tool
3. Team standards only at the user level — they must be in a project or managed policy CLAUDE.md to be shared
4. Imprecise confidence instructions — they trigger false positives on escalation, or false negatives that skip important checks
5. Progressive summarization that destroys transactional facts — loss of critical details in long-context sessions

6b. The 12 Most Common Traps

These are the distractors the exam is built around. For each trap: why it looks right → why it's wrong.

1. Few-shot for compliance-critical tool ordering → probabilistic, fails 1-12% of the time. You need a programmatic prerequisite gate
2. The LLM's self-reported confidence score for routing → poorly calibrated, confidently wrong on hard cases. Use explicit criteria
3. Batch API for all workflows to save 50% → 24h max with no SLA. It blocks anyone waiting on the results
4. A larger context window for attention dilution → context size ≠ attention quality. Fix: split into focused passes
5. Returning empty results when a subagent fails → masking the error as success prevents any recovery. You need structured error context
6. Giving every agent access to every tool → with 18+ tools, selection degrades. Target: 4-5 tools per agent
7. "Don't do X" in the system prompt for business-critical rules → non-zero failure rate. You need a programmatic hook
8. Detecting the end of the loop from natural text → never parse "done", "completed". The only reliable signal is stop_reason
9. Escalation based on sentiment analysis → sentiment ≠ complexity. A calm customer can have the most complex case
10. Reviewing code in the same session as the generation → the reviewer keeps the generator's reasoning context. You need an independent instance
11. A separate routing classifier to pre-select tools → over-engineering. The low-cost fix is to expand the tool descriptions
12. Consolidating similar tools into a single generic tool → loses disambiguation. Consolidate only when there is real functional overlap

6c. The 5 Mental Models for Solving the Exam by Reasoning

If you're unsure about an answer, run it through these 5 filters:

1. Programmatic Enforcement > Prompt-Based Guidance "If this fails 1 time in 100, is that acceptable?" If not → programmatic hook, not a prompt.

2. Tool Description = the Primary Routing Mechanism Not the system prompt, not the function name. The DESCRIPTION. First action on misrouting: expand the descriptions.

3. Subagents Never Inherit Context — Pass Everything Explicitly The subagent only has what you give it in its prompt. If the synthesis agent needs the web search agent's findings, you pass them directly.

4. Lost in the Middle = a Real Design Constraint A larger context window does NOT solve attention quality. Fix: key summaries at the start, split into focused passes.

5. Batch API vs Real-Time = a Latency Decision, Not a Cost One "Is someone waiting on this result to proceed?" Yes → real-time. No → batch.

6d. 12 Sample Questions with Answers

Q1 (Scenario 1): The agent skips get_customer in 12% of cases and calls lookup_order directly → A A programmatic prerequisite that blocks lookup_order until get_customer has returned a verified ID

Q2 (Scenario 1): The agent always calls get_customer when the user mentions an order number. Both tools have minimal descriptions. First step? → B Expand the descriptions with input formats, example queries, edge cases, boundaries

Q3 (Scenario 1): The agent reaches 55% first-contact resolution (target 80%). It escalates standard cases and handles complex cases on its own. How do you improve it? → A Add explicit escalation criteria with few-shot examples to the system prompt

Q4 (Scenario 2): You want a /review command available to every developer when they clone the repo. Where do you create it? → A .claude/commands/ in the project repository

Q5 (Scenario 2): Restructure a monolith into microservices — changes across dozens of files, decisions about service boundaries. Approach? → A Plan mode to explore the codebase and design before making changes

Q6 (Scenario 2): A convention for test files scattered throughout the codebase (Button.test.tsx next to Button.tsx). How do you enforce it automatically? → A .claude/rules/ with YAML frontmatter and glob patterns (**/*.test.tsx)

Q7 (Scenario 3): The report covers only visual arts, missing music, writing, film. The coordinator decomposed the work into 3 visual arts subtasks. Root cause? → B The coordinator's task decomposition was too narrow

Q8 (Scenario 3): The web search subagent times out. How do you make the error flow up to the coordinator? → A Structured error context: failure type, attempted query, partial results, alternative approaches

Q9 (Scenario 3): The synthesis agent has to verify facts — 3 round trips per task, +40% latency. 85% of the checks are simple. Solution? → A Give the synthesis agent a verify_fact tool scoped to the simple cases; complex verification continues via the coordinator

Q10 (Scenario 5): claude 'Analyze this PR' in CI hangs waiting for interactive input. Fix? → A Add the -p flag: claude -p "Analyze this PR"

Q11 (Scenario 5): A manager proposes the Batch API for both workflows: a blocking pre-merge check + an overnight report. Assessment? → A Batch only for the overnight report; real-time for the pre-merge check

Q12 (Scenario 5): A review of 14 files produces inconsistent results — variable detail, obvious bugs missed, contradictory feedback. Restructuring? → A Split: a per-file pass for local issues + a separate pass for cross-file data flow

6e. Out-of-Scope Topics (Don't Study)

Fine-tuning, authentication/billing, MCP server infrastructure deployment, Claude's internal architecture, Constitutional AI/RLHF, embedding models/vector databases, computer use, vision/image analysis, streaming API (SSE), rate limiting/quotas, OAuth/API key rotation, cloud provider specifics (AWS/GCP/Azure), performance benchmarking, prompt caching implementation details, token counting algorithms.

7. Study Resources

Official (free)

• Anthropic Academy: https://anthropic.skilljar.com (13+ courses)
• Claude Code Docs: https://code.claude.com/docs
• API Docs: https://platform.claude.com/docs
• Partner Network (free signup): https://www.anthropic.com/partner-network

Third-party (paywall caveat)

• The AI Corner — curriculum breakdown: https://www.the-ai-corner.com/p/claude-certified-architect-curriculum-2026 (premium)
• Linas Substack — unofficial production guide: https://linas.substack.com/p/claudearchitect (partially free)

7b. Cheatsheet of Numeric and Technical Values

8. Strategic Study Notes

Priority by exam weight:

1. Agentic Architecture (27%) → study sub-agents, orchestration, failure patterns
2. Claude Code + Prompt Engineering (20% each) → CLAUDE.md, structured outputs
3. Tool/MCP (18%) → MCP primitives, tool design precision
4. Context/Reliability (15%) → compaction, long-context, handoff patterns

The most underrated field is Tool Design & MCP — its impact on reliability is disproportionate to its weight (18%).

Exam format: closed-book (no lookup) — memorize the technical specifics (frontmatter fields, permission modes, CLAUDE.md hierarchy, MCP primitives).