Exam Overview & Blueprint

Everything the Claude Certified Architect - Foundations (CCA-F) exam tests, mapped to the official content outline — domains, task statements, tested scenarios, and scope.

Content Domains & Task Statements

The full syllabus. Percentages are the share of scored content per domain — select a card to start studying that domain.

Domain 1: Agentic Architecture & Orchestration

Weight: 27% — the largest domain.

Task statements:
- 1.1 Design and implement agentic loops for autonomous task execution
- 1.2 Orchestrate multi-agent systems with coordinator-subagent patterns
- 1.3 Configure subagent invocation, context passing, and spawning
- 1.4 Implement multi-step workflows with enforcement and handoff patterns
- 1.5 Apply Agent SDK hooks for tool call interception and data normalization
- 1.6 Design task decomposition strategies for complex workflows
- 1.7 Manage session state, resumption, and forking
Explore Domain 1 →
Domain 2: Tool Design & MCP Integration

Weight: 18%

Task statements:
- 2.1 Design effective tool interfaces with clear descriptions and boundaries
- 2.2 Implement structured error responses for MCP tools
- 2.3 Distribute tools across agents and configure tool choice
- 2.4 Integrate MCP servers into Claude Code and agent workflows
- 2.5 Select and apply built-in tools (Read, Write, Edit, Bash, Grep, Glob)
Explore Domain 2 →
Domain 3: Claude Code Configuration & Workflows

Weight: 20%

Task statements:
- 3.1 Configure CLAUDE.md files with hierarchy, scoping, and modular organization
- 3.2 Create and configure custom slash commands and skills
- 3.3 Apply path-specific rules for conditional convention loading
- 3.4 Determine when to use plan mode vs direct execution
- 3.5 Apply iterative refinement techniques for progressive improvement
- 3.6 Integrate Claude Code into CI/CD pipelines
Explore Domain 3 →
Domain 4: Prompt Engineering & Structured Output

Weight: 20%

Task statements:
- 4.1 Design prompts with explicit criteria to reduce false positives
- 4.2 Apply few-shot prompting to improve output consistency and quality
- 4.3 Enforce structured output using tool use and JSON schemas
- 4.4 Implement validation, retry, and feedback loops for extraction quality
- 4.5 Design efficient batch processing strategies
- 4.6 Design multi-instance and multi-pass review architectures
Explore Domain 4 →
Domain 5: Context Management & Reliability

Weight: 15%

Task statements:
- 5.1 Preserve critical information across long interactions
- 5.2 Design effective escalation and ambiguity resolution patterns
- 5.3 Implement error propagation strategies across multi-agent systems
- 5.4 Manage context effectively in large codebase exploration
- 5.5 Design human review workflows and confidence calibration
- 5.6 Preserve information provenance and handle uncertainty in synthesis
Explore Domain 5 →

Practice

Ready to test yourself?

Sit a timed mock exam scored just like the real thing, or work the full question bank at your own pace — every answer links back to the exact notes it tests.

275Questions

90 minTimed Mock

720To Pass

Open the Exam Simulator

Exam at a Glance

Candidate profile, question format, and how the exam is scored.

Target Candidate

A solution architect with 6+ months of hands-on experience building with the Claude API, Agent SDK, Claude Code, and MCP — comfortable with multi-agent orchestration, tool integration, prompt engineering for structured output, and context management, and aware of both the capabilities and limitations of LLMs in production.
Question Format

Multiple choice, single correct answer with three distractors. All questions are scenario-based — 4 scenarios are drawn at random from the 6 below. Unanswered questions count as incorrect, so there is no penalty for guessing.
Scoring & Passing

Pass / fail result, reported as a scaled score of 100–1000. The minimum passing score is 720. Scaled scoring equates results across exam forms of slightly different difficulty.

Tested Production Scenarios

Every question sits inside one of these six production contexts. On exam day, 4 of the 6 are selected at random.

1. Customer Support Resolution Agent

An Agent SDK agent handling high-ambiguity requests (returns, billing disputes, account issues) via custom MCP tools — get_customer, lookup_order, process_refund, escalate_to_human — targeting 80%+ first-contact resolution while knowing when to escalate.

Primary domains: 1, 2, 5
2. Code Generation with Claude Code

Using Claude Code for generation, refactoring, debugging, and documentation. Integrating it into the dev workflow with custom slash commands, CLAUDE.md configuration, and choosing plan mode vs direct execution.

Primary domains: 3, 5
3. Multi-Agent Research System

A coordinator delegates to specialized subagents (web search, document analysis, synthesis, report generation) to produce comprehensive, cited reports — passing context and preserving source attribution across handoffs.

Primary domains: 1, 2, 5
4. Developer Productivity with Claude

Agent SDK tools that help engineers explore unfamiliar codebases, understand legacy systems, and automate repetitive tasks using built-in tools (Read, Write, Bash, Grep, Glob) alongside MCP servers.

Primary domains: 1, 2, 3
5. Claude Code for Continuous Integration

Claude Code in a CI/CD pipeline running automated code reviews, generating test cases, and giving PR feedback — designing prompts that are actionable and minimize false positives.

Primary domains: 3, 4
6. Structured Data Extraction

Extracting information from unstructured documents, validating output against JSON schemas, and maintaining high accuracy — handling edge cases gracefully and integrating with downstream systems.

Primary domains: 4, 5

What the Certification Validates

A foundations-level exam for architects who build production applications with Claude.

The CCA-F certification validates that practitioners can make informed decisions about tradeoffs when implementing real-world solutions with Claude. It tests foundational knowledge across four core technologies used to build production-grade applications:

Claude Code — configuration, workflows, and CI/CD integration
Claude Agent SDK — agentic loops, multi-agent orchestration, and hooks
Claude API — tool use, structured output, and batch processing
Model Context Protocol (MCP) — tool and resource interfaces for backend integration

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, developer-productivity tooling, and structured data extraction. You are expected to demonstrate not just conceptual knowledge, but practical judgment about architecture, configuration, and production tradeoffs.

What Is (and Isn't) Tested

Focus your preparation — and avoid studying topics the exam explicitly excludes.

In scope

Agentic loop implementation: stop_reason control flow, tool-result handling, termination conditions
Multi-agent orchestration: coordinator-subagent patterns, task decomposition, parallel execution, iterative refinement
Subagent context: explicit context passing, structured state persistence, crash recovery with manifests
Tool interface design and MCP tool/resource design; server configuration (project vs user scope, env-var expansion)
Error handling and propagation: structured responses, transient/business/permission errors, local recovery before escalation
Escalation decisions, CLAUDE.md hierarchy and @import, .claude/rules/ glob patterns, commands and skills
Plan mode vs direct execution, iterative refinement, structured output via tool_use, few-shot prompting
Batch processing (Message Batches API), context-window optimization, human review and confidence calibration, information provenance

Out of scope

Fine-tuning or training custom models; Constitutional AI, RLHF, or safety-training methods
API authentication, billing, account management, rate limits, quotas, and pricing calculations
Deploying/hosting MCP servers (infrastructure, networking, containers) and specific cloud-provider configs
Claude's internal architecture, training process, or model weights
Embedding models / vector databases, computer use, vision/image analysis, streaming/SSE
Token-counting algorithms and tokenization specifics; prompt-caching implementation details (beyond knowing it exists)

How to Prepare

The exam rewards hands-on experience. Build these before you sit it.

Build an agent with the Agent SDK — a full agentic loop with tool calling, structured error handling, hooks, and session management, including spawning subagents and passing context between them.
Configure Claude Code for a real project — a CLAUDE.md hierarchy, path-specific rules in .claude/rules/, custom skills with frontmatter (context: fork, allowed-tools), and at least one MCP server.
Design and test MCP tools — write descriptions that differentiate similar tools, implement structured error responses with categories and retryable flags, and test selection reliability on ambiguous requests.
Build a structured-extraction pipeline — tool_use with JSON schemas, validation-retry loops, nullable fields to prevent fabrication, and batch processing with the Message Batches API.
Practice prompt engineering — few-shot examples for ambiguous cases, explicit review criteria to cut false positives, and multi-pass review architectures for large reviews.
Study context and reliability patterns — extract structured facts from verbose tool output, use scratchpad files for long sessions, and calibrate escalation and human-in-the-loop routing.

Then work through the practice quizzes at the end of each domain to test your judgment against scenario-based questions, and finish with the Exam Practice hub — a timed Mock Exam Simulator and an untimed Full Practice Exam scored 100–1000 like the real thing.