Reference

About the CCA-F exam

The Claude Certified Architect, Foundationsis Anthropic's first technical certification, launched in March 2026 as part of the Claude Partner Network. It validates that you can make sound tradeoff decisions when building real solutions across Claude Code, the Claude Agent SDK, the Claude API, and MCP.

Format & scoring

Questions: 60
Duration: 120 minutes
Style: Scenario-based multiple choice — one correct response, three distractors
Scenarios: 4 of 6 per attempt (random)
Scoring: Scaled 100–1000; 720 to pass · Pass / Fail
Guessing: Unanswered = incorrect; no penalty for guessing
Platform: Anthropic Partner Academy (Skilljar)

Who it's for

The ideal candidate is a solution architect who designs and implements production applications with Claude. They have hands-on experience building agentic applications using the Claude Agent SDK (multi-agent orchestration, subagent delegation, tool integration, lifecycle hooks); configuring and customizing Claude Code for team workflows using CLAUDE.md files, Agent Skills, MCP server integrations, and plan mode; designing Model Context Protocol (MCP) tool and resource interfaces for backend system integration; engineering prompts that produce 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 for automated code review, test generation, and PR feedback; and making sound escalation and reliability decisions (error handling, human-in-the-loop workflows, self-evaluation patterns). They understand both the capabilities and limitations of large language models in production environments.

The candidate typically has 6+ months of practical experience building with Claude APIs, Agent SDK, Claude Code, and MCP.

Domain weightings

1. Agentic Architecture & Orchestration27%

2. Tool Design & MCP Integration18%

3. Claude Code Configuration & Workflows20%

4. Prompt Engineering & Structured Output20%

5. Context Management & Reliability15%

The 6 scenarios

Each attempt frames its questions inside 4of these six. You can't pick which four — prepare all of them.

Customer Support Resolution Agent

You are building a customer support resolution agent using the Claude Agent SDK. The agent handles high-ambiguity requests like returns, billing disputes, and account issues. It has access to your backend systems through custom Model Context Protocol (MCP) tools (get_customer, lookup_order, process_refund, escalate_to_human). Your target is 80%+ first-contact resolution while knowing when to escalate.

Code Generation with Claude Code

You are using Claude Code to accelerate software development. Your team uses it for code generation, refactoring, debugging, and documentation. You need to integrate it into your development workflow with custom slash commands, CLAUDE.md configurations, and understand when to use plan mode vs direct execution.

Multi-Agent Research System

You are building a multi-agent research system using the Claude Agent SDK. A coordinator agent delegates to specialized subagents: one searches the web, one analyzes documents, one synthesizes findings, and one generates reports. The system researches topics and produces comprehensive, cited reports.

Developer Productivity with Claude

You are building developer productivity tools using the Claude Agent SDK. The agent helps engineers explore unfamiliar codebases, understand legacy systems, generate boilerplate code, and automate repetitive tasks. It uses the built-in tools (Read, Write, Bash, Grep, Glob) and integrates with Model Context Protocol (MCP) servers.

Claude Code for Continuous Integration

You are integrating Claude Code into your Continuous Integration/Continuous Deployment (CI/CD) pipeline. The system runs automated code reviews, generates test cases, and provides feedback on pull requests. You need to design prompts that provide actionable feedback and minimize false positives.

Structured Data Extraction

You are building a structured data extraction system using Claude. The system extracts information from unstructured documents, validates the output using JavaScript Object Notation (JSON) schemas, and maintains high accuracy. It must handle edge cases gracefully and integrate with downstream systems.

In scope

+Agentic loop implementation: Control flow based on stop_reason, tool result handling, loop termination conditions
+Multi-agent orchestration: Coordinator-subagent patterns, task decomposition, parallel subagent execution, iterative refinement loops
+Subagent context management: Explicit context passing, structured state persistence, crash recovery using manifests
+Tool interface design: Writing effective tool descriptions, splitting vs consolidating tools, tool naming to reduce ambiguity
+MCP tool and resource design: Resources for content catalogs, tools for actions, description quality for adoption
+MCP server configuration: Project vs user scope, environment variable expansion, multi-server simultaneous access
+Error handling and propagation: Structured error responses, transient vs business vs permission errors, local recovery before escalation
+Escalation decision-making: Explicit criteria, honoring customer preferences, policy gap identification
+CLAUDE.md configuration: Hierarchy (user/project/directory), @import patterns, .claude/rules/ with glob patterns
+Custom commands and skills: Project vs user scope, context: fork, allowed-tools, argument-hint frontmatter
+Plan mode vs direct execution: Complexity assessment, architectural decisions, single-file changes
+Iterative refinement: Input/output examples, test-driven iteration, interview pattern, sequential vs parallel issue resolution
+Structured output via tool_use: Schema design, tool_choice configuration, nullable fields to prevent hallucination
+Few-shot prompting: Ambiguous scenario targeting, format consistency, false positive reduction
+Batch processing: Message Batches API appropriateness, latency tolerance assessment, failure handling by custom_id
+Context window optimization: Trimming verbose tool outputs, structured fact extraction, position-aware input ordering
+Human review workflows: Confidence calibration, stratified sampling, accuracy segmentation by document type and field
+Information provenance: Claim-source mappings, temporal data handling, conflict annotation, coverage gap reporting

Out of scope

−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

Hands-on prep exercises

Anthropic recommends building these before sitting the exam — judgment comes from hands-on reps, not memorization.

Exercise 1

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

Practice designing an agentic loop with tool integration, structured error handling, and escalation patterns.

1Define 3-4 MCP tools with detailed descriptions that clearly differentiate each tool's purpose, expected inputs, and boundary conditions. Include at least two tools with similar functionality that require careful description to avoid selection confusion.
2Implement an agentic loop that checks stop_reason to determine whether to continue tool execution or present the final response. Handle both "tool_use" and "end_turn" stop reasons correctly.
3Add structured error responses to your tools: include errorCategory (transient/validation/permission), isRetryable boolean, and human-readable descriptions. Test that the agent handles each error type appropriately (retrying transient errors, explaining business errors to the user).
4Implement a programmatic hook that intercepts tool calls to enforce a business rule (e.g., blocking operations above a threshold amount), redirecting to an escalation workflow when triggered.
5Test with multi-concern messages (e.g., requests involving multiple issues) and verify the agent decomposes the request, handles each concern, and synthesizes a unified response.

Exercise 2

Exercise 2: Configure Claude Code for a Team Development Workflow

Practice configuring CLAUDE.md hierarchies, custom slash commands, path-specific rules, and MCP server integration for a multi-developer project.

1Create a project-level CLAUDE.md with universal coding standards and testing conventions. Verify that instructions placed at the project level are consistently applied across all team members.
2Create .claude/rules/ files with YAML frontmatter glob patterns for different code areas (e.g., paths: ["src/api/**/*"] for API conventions, paths: ["**/*.test.*"] for testing conventions). Test that rules load only when editing matching files.
3Create a project-scoped skill in .claude/skills/ with context: fork and allowed-tools restrictions. Verify the skill runs in isolation without polluting the main conversation context.
4Configure an MCP server in .mcp.json with environment variable expansion for credentials. Add a personal experimental MCP server in ~/.claude.json and verify both are available simultaneously.
5Test plan mode versus direct execution on tasks of varying complexity: a single-file bug fix, a multi-file library migration, and a new feature with multiple valid implementation approaches. Observe when plan mode provides value.

Exercise 3

Exercise 3: Build a Structured Data Extraction Pipeline

Practice designing JSON schemas, using tool_use for structured output, implementing validation-retry loops, and designing batch processing strategies.

1Define an extraction tool with a JSON schema containing required and optional fields, an enum with an "other" + detail string pattern, and nullable fields for information that may not exist in source documents. Process documents where some fields are absent and verify the model returns null rather than fabricating values.
2Implement a validation-retry loop: when Pydantic or JSON schema validation fails, send a follow-up request including the document, the failed extraction, and the specific validation error. Track which errors are resolvable via retry (format mismatches) versus which are not (information absent from source).
3Add few-shot examples demonstrating extraction from documents with varied formats (e.g., inline citations vs bibliographies, narrative descriptions vs structured tables) and verify improved handling of structural variety.
4Design a batch processing strategy: submit a batch of 100 documents using the Message Batches API, handle failures by custom_id, resubmit failed documents with modifications (e.g., chunking oversized documents), and calculate total processing time relative to SLA constraints.
5Implement a human review routing strategy: have the model output field-level confidence scores, route low-confidence extractions to human review, and analyze accuracy by document type and field to verify consistent performance.

Exercise 4

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

Practice orchestrating subagents, managing context passing, implementing error propagation, and handling synthesis with provenance tracking.

1Build a coordinator agent that delegates to at least two subagents (e.g., web search and document analysis). Ensure the coordinator's allowedTools includes "Task" and that each subagent receives its research findings directly in its prompt rather than relying on automatic context inheritance.
2Implement parallel subagent execution by having the coordinator emit multiple Task tool calls in a single response. Measure the latency improvement compared to sequential execution.
3Design structured output for subagents that separates content from metadata: each finding should include a claim, evidence excerpt, source URL/document name, and publication date. Verify that the synthesis subagent preserves source attribution when combining findings.
4Implement error propagation: simulate a subagent timeout and verify the coordinator receives structured error context (failure type, attempted query, partial results). Test that the coordinator can proceed with partial results and annotate the final output with coverage gaps.
5Test with conflicting source data (e.g., two credible sources with different statistics) and verify the synthesis output preserves both values with source attribution rather than arbitrarily selecting one, and structures the report to distinguish well-established from contested findings.

A note on sourcing

The exam facts, domain weightings, scenarios, task statements, sample questions, and scope lists on this site are taken from Anthropic's official Claude Certified Architect – Foundations Certification Exam Guide (Version 0.1).

Teaching content and the practice question bank (beyond the official samples) are independently written and mapped to the official task statements, then fact-checked against current Anthropic and MCP documentation. This site is an independent study aid and is not affiliated with or endorsed by Anthropic.