Official Exam Guide — Claude Certified Architect – Foundations

Summarized from the official Anthropic "Claude Certified Architect – Foundations Exam Guide", Version 1.0, effective July 2026.

About the exam

The Claude Certified Architect – Foundations certification validates that practitioners can make informed decisions about tradeoffs when implementing real-world solutions with Claude. It tests foundational knowledge across Claude Code, the Claude Agent SDK, the Claude API, and Model Context Protocol (MCP) — the core technologies used to build production-grade applications with Claude. Questions are grounded in realistic scenarios drawn from actual customer use cases: agentic customer support systems, multi-agent research pipelines, Claude Code in CI/CD workflows, developer productivity tools, and structured data extraction from unstructured documents.

The ideal candidate is a solution architect who designs and implements production applications with Claude, typically with 6+ months of practical experience building with the Claude APIs, Agent SDK, Claude Code, and MCP. Hands-on experience is expected in: building agentic applications with the Agent SDK (multi-agent orchestration, subagent delegation, tool integration, lifecycle hooks); configuring Claude Code for team workflows (CLAUDE.md files, Agent Skills, MCP server integrations, plan mode); designing MCP tool and resource interfaces; engineering prompts for reliable structured output (JSON schemas, few-shot examples, extraction patterns); managing context windows across long documents, multi-turn conversations, and multi-agent handoffs; integrating Claude into CI/CD pipelines; and making sound escalation and reliability decisions.

Exam at a glance

Domain blueprint

The 6 scenarios

The exam is scenario-based: each scenario presents a realistic production context framing a set of questions. During the exam, 4 scenarios are picked at random from the bank of 6 below.

1. Customer Support Resolution Agent

Building a customer support resolution agent with the Claude Agent SDK. It handles high-ambiguity requests (returns, billing disputes, account issues) via custom MCP tools (get_customer, lookup_order, process_refund, escalate_to_human). Target: 80%+ first-contact resolution while knowing when to escalate.

Primary domains: Agentic Architecture & Orchestration; Tool Design & MCP Integration; Context Management & Reliability

2. Code Generation with Claude Code

Using Claude Code to accelerate software development — code generation, refactoring, debugging, and documentation — integrated into the team workflow with custom slash commands, CLAUDE.md configurations, and knowing when to use plan mode vs direct execution.

Primary domains: Claude Code Configuration & Workflows; Context Management & Reliability

3. Multi-Agent Research System

Building a multi-agent research system with the Claude Agent SDK: a coordinator delegates to specialized subagents (web search, document analysis, synthesis, report generation) to produce comprehensive, cited reports.

Primary domains: Agentic Architecture & Orchestration; Tool Design & MCP Integration; Context Management & Reliability

4. Developer Productivity with Claude

Building developer productivity tools with the Claude Agent SDK: helping engineers explore unfamiliar codebases, understand legacy systems, generate boilerplate, and automate repetitive tasks — using built-in tools (Read, Write, Bash, Grep, Glob) and MCP server integrations.

Primary domains: Tool Design & MCP Integration; Claude Code Configuration & Workflows; Agentic Architecture & Orchestration

5. Claude Code for Continuous Integration

Integrating Claude Code into a CI/CD pipeline for automated code reviews, test case generation, and pull request feedback — designing prompts that provide actionable feedback and minimize false positives.

Primary domains: Claude Code Configuration & Workflows; Prompt Engineering & Structured Output

6. Structured Data Extraction

Building a structured data extraction system with Claude: extracting information from unstructured documents, validating output with JSON schemas, maintaining high accuracy, handling edge cases gracefully, and integrating with downstream systems.

Primary domains: Prompt Engineering & Structured Output; Context Management & Reliability

How to prepare

From Section 7 of the guide:

• Build an agent with the Claude Agent SDK: implement a complete agentic loop with tool calling, error handling, and session management. Practice spawning subagents and passing context between them.
• Configure Claude Code for a real project: set up CLAUDE.md with a configuration hierarchy, create path-specific rules in .claude/rules/, build custom skills with frontmatter options (context: fork, allowed-tools), and integrate at least one MCP server.
• Design and test MCP tools: write tool descriptions that clearly differentiate similar tools. Implement structured error responses with error categories and retryable flags. Test tool selection reliability with ambiguous requests.
• Build a structured data extraction pipeline: use tool_use with JSON schemas, implement validation-retry loops, design schemas with optional/nullable fields, and practice batch processing with the Message Batches API.
• Practice prompt engineering techniques: write few-shot examples for ambiguous scenarios. Define explicit review criteria to reduce false positives. Design multi-pass review architectures for large code reviews.
• Study context management patterns: practice extracting structured facts from verbose tool outputs, implementing scratchpad files for long sessions, and designing subagent delegation to manage context limits.
• Review escalation and human-in-the-loop patterns: understand when to escalate (policy gaps, customer requests, inability to progress) versus resolve autonomously. Practice designing human review workflows with confidence-based routing.

The 4 official preparation exercises

Condensed from Section 8 of the guide.

Exercise 1: Build a Multi-Tool Agent with Escalation Logic

Practice designing an agentic loop with tool integration, structured error handling, and escalation patterns. Define 3-4 MCP tools with detailed, differentiated descriptions (including two similar tools that require careful description). Implement an agentic loop that handles "tool_use" and "end_turn" stop reasons correctly. Add structured error responses (errorCategory, isRetryable, human-readable descriptions) and verify the agent retries transient errors and explains business errors. Implement a programmatic hook that blocks operations above a threshold and redirects to escalation. Test with multi-concern messages and verify decomposition and unified synthesis. Domains reinforced: 1, 2, 5.

Exercise 2: Configure Claude Code for a Team Development Workflow

Practice CLAUDE.md hierarchies, custom slash commands, path-specific rules, and MCP server integration for a multi-developer project. Create a project-level CLAUDE.md with universal standards; create .claude/rules/ files with YAML frontmatter glob patterns (e.g., paths: ["src/api//*"], paths: ["/.test."]) and verify conditional loading; create a project-scoped skill with context: fork and allowed-tools restrictions; configure an MCP server in .mcp.json with environment variable expansion plus a personal server in ~/.claude.json; and test plan mode vs direct execution on tasks of varying complexity. Domains reinforced: 3, 2.

Exercise 3: Build a Structured Data Extraction Pipeline

Practice JSON schema design, tool_use structured output, validation-retry loops, and batch processing. Define an extraction tool with required/optional fields, an enum with "other" + detail pattern, and nullable fields — verify the model returns null rather than fabricating values. Implement a validation-retry loop with error feedback and track which errors are retry-resolvable. Add few-shot examples for varied document formats. Design a batch strategy with the Message Batches API (100 documents, failure handling by custom_id, resubmission with modifications, SLA timing). Implement human review routing with field-level confidence scores and accuracy analysis by document type and field. Domains reinforced: 4, 5.

Exercise 4: Design and Debug a Multi-Agent Research Pipeline

Practice subagent orchestration, context passing, error propagation, and synthesis with provenance tracking. Build a coordinator delegating to at least two subagents, with "Task" in allowedTools and explicit context passing in prompts. Implement parallel subagent execution via multiple Task tool calls in a single response. Design structured subagent output separating content from metadata (claim, evidence excerpt, source, publication date) and verify attribution survives synthesis. Simulate a subagent timeout and verify structured error context reaches the coordinator, which proceeds with partial results and annotates coverage gaps. Test with conflicting source data and verify both values are preserved with attribution. Domains reinforced: 1, 2, 5.

In-scope technologies

From the Section 17 appendix, technologies and concepts that might appear on the exam:

• Claude Agent SDK — agent definitions, agentic loops, stop_reason handling, hooks (PostToolUse, tool call interception), subagent spawning via Task tool, allowedTools configuration
• Model Context Protocol (MCP) — MCP servers, MCP tools, MCP resources, isError flag, tool descriptions, tool distribution, .mcp.json configuration, environment variable expansion
• Claude Code — CLAUDE.md configuration hierarchy (user/project/directory), .claude/rules/ with YAML frontmatter path-scoping, .claude/commands/ for slash commands, .claude/skills/ with SKILL.md frontmatter (context: fork, allowed-tools, argument-hint), plan mode, direct execution, /memory command, /compact, --resume, fork_session, Explore subagent
• Claude Code CLI — -p / --print flag for non-interactive mode, --output-format json, --json-schema for structured CI output
• Claude API — tool_use with JSON schemas, tool_choice options ("auto", "any", forced tool selection), stop_reason values ("tool_use", "end_turn"), max_tokens, system prompts
• Message Batches API — 50% cost savings, up to 24-hour processing window, custom_id for request/response correlation, polling for completion, no multi-turn tool calling support
• JSON Schema — required vs optional fields, enum types, nullable fields, "other" + detail string patterns, strict mode for syntax error elimination
• Pydantic — schema validation, semantic validation errors, validation-retry loops
• Built-in tools — Read, Write, Edit, Bash, Grep, Glob — their purposes and selection criteria
• Few-shot prompting — targeted examples for ambiguous scenarios, format demonstration, generalization to novel patterns
• Prompt chaining — sequential task decomposition into focused passes
• Context window management — token budgets, progressive summarization, lost-in-the-middle effects, context extraction, scratchpad files
• Session management — session resumption, fork_session, named sessions, session context isolation
• Confidence scoring — field-level confidence, calibration with labeled validation sets, stratified sampling for error rate measurement

Out-of-scope topics

The guide states these related topics will not appear on the exam — deprioritize them in your study plan:

• Fine-tuning Claude models or training custom models
• Claude API authentication, billing, or account management
• Detailed implementation of specific programming languages or frameworks (beyond what's needed for tool and schema configuration)
• Deploying or hosting MCP servers (infrastructure, networking, container orchestration)
• Claude's internal architecture, training process, or model weights
• Constitutional AI, RLHF, or safety training methodologies
• Embedding models or vector database implementation details
• Computer use (browser automation, desktop interaction)
• Vision/image analysis capabilities
• Streaming API implementation or server-sent events
• Rate limiting, quotas, or API pricing calculations
• OAuth, API key rotation, or authentication protocol details
• Specific cloud provider configurations (AWS, GCP, Azure)
• Performance benchmarking or model comparison metrics
• Prompt caching implementation details (beyond knowing it exists)
• Token counting algorithms or tokenization specifics

Scoring & logistics

Criterion-referenced scoring. Each candidate is measured against a fixed performance standard, not against other candidates. The passing score was established through a formal standard-setting study by trained subject matter experts judging the level expected of a minimally qualified candidate. Scores are reported on a scaled range of 100–1,000 with a cut score of 720; scaled scoring equates scores across exam forms of slightly different difficulty. The score report shows pass/fail, your scaled score, and percent-correct by domain (domain percentages are informational only — pass/fail is based on the total scaled score).

Registration and scheduling. Handled through the Anthropic Partner Academy and Pearson VUE. Choose online proctoring or a Pearson test center. You may cancel or reschedule up to 24 hours before your appointment; changes within 24 hours forfeit the exam fee. No-shows and late arrivals forfeit the fee and must re-register.

Retake policy. Waiting periods increase with each failed attempt: 14 days after the first, 30 days after the second, and 90 days after the third. You may take an exam up to four times within a rolling twelve-month period (limits apply per exam). The exam fee applies to each attempt.

Credential maintenance. The credential is valid for 12 months. To renew on time, review what has changed since you certified and complete a free, non-proctored assessment on the Anthropic Partner Academy — no fee for on-time renewal. If the credential lapses, you must retake the full exam at the full fee. If exam content changes significantly, Anthropic may require a full retake instead of the renewal assessment.