In March 2026, Anthropic launched its highly anticipated official technical certification: the Claude Certified Architect — Foundations (CCA-F). Designed for technical practitioners—including software engineers, solutions architects, and AI developers—this exam verifies your ability to build, optimize, and deploy scalable, reliable, and secure applications powered by Claude models.
Unlike early-stage AI certifications that test basic prompt engineering, the CCA-F is a highly practical, scenario-based exam. It focuses on the architectural decisions, operational safety, and system-level orchestrations necessary to run large-scale AI applications in production.
CCA-F Exam Overview
The exam evaluates how you translate architectural challenges into concrete code structures and configurations using the Claude ecosystem. Here are the core specifications of the CCA-F exam:
| Metric | Details |
|---|---|
| Exam Format | 60 Multiple-Choice & Scenario-Based Questions |
| Duration | 120 Minutes |
| Passing Score | 720 / 1,000 (Scaled Score) |
| Cost | $99 USD per attempt |
| Eligibility | Open (with early promo for Claude Partner Network members) |
| Delivery Method | Online proctored exam |
Exam Syllabus: Core Domains
The exam questions map to five distinct domains. Below is a breakdown of what each domain covers and their respective weights:
1. Agentic Architecture & Orchestration
27%Agentic loops, multi-agent networks (hub-and-spoke), task decomposition, subagent spawning, and tool-use lifecycle management.
2. Claude Code Workflows
20%`CLAUDE.md` structures, prompt configuration, plan mode vs. execute mode, and integrating agent actions within CI/CD pipelines.
3. Prompt Engineering & Structured Output
20%Context placement, XML tags, few-shot prompting, JSON schemas, parsing strategies, and validator/retry loops.
4. Tool Design & MCP Integration
18%Model Context Protocol (MCP) server design, resource and prompt schemas, tool validation, and preventing tool misrouting.
5. Context Management & Reliability
15%Long-context window optimization, error propagation, escalation loops, token economy (prompt caching), and managing session state.
Domain 1: Agentic Architecture & Orchestration (27%)
This is the heaviest domain on the exam. Anthropic wants to ensure architects understand how to build systems where Claude interacts with environment hooks, loops, and other models.
Key Architecture Patterns
- Single Agentic Loop: An agent that receives a prompt, uses a tool, observes the outcome, and repeats until the task is complete. Be prepared to choose the right
stop_reason(e.g.,tool_use,stop_sequence, orend_turn) to control the flow. - Hub-and-Spoke Pattern: A supervisor model orchestrating multiple specialized subagents. You must know when to delegate a task to a subagent and how to aggregate their results to avoid bloated context windows.
- Sequential Processing vs. Parallel Execution: Choosing whether tasks must run step-by-step or can run concurrently. Candidates must resolve latency vs. cost tradeoffs here.
Questions will present scenarios where an agent becomes stuck in an infinite tool-use loop. You will be asked to identify the best mitigation strategy (e.g., passing a counter in the system prompt, enforcing a hard iteration limit in the runner script, or optimizing the tool output schemas).
Domain 2: Claude Code Configuration & Workflows (20%)
Claude Code is Anthropic's agentic CLI tool. This domain assesses your ability to configure developer projects so that agents operate efficiently and safely.
Understanding CLAUDE.md
You must understand the role of the CLAUDE.md guide. It serves as the project instruction manual. You should know:
- Hierarchy: How user-level config (e.g.,
~/.claude.json) relates to workspace-specificCLAUDE.mdinstructions. - Sections: Standard parts of a
CLAUDE.mdfile, including **Build Commands**, **Formatting Guidelines**, and **Project Rules**.
# CLAUDE.md Example Structure
## Build & Test Commands
- Run tests: `npm test`
- Build app: `npm run build`
## Code Style Guidelines
- Use TypeScript for all modern utilities
- Always handle API exceptions with try/catch blocks
- Prefix helper functions with a descriptive comment
You will also face scenarios about **Plan Mode vs. Direct Execution**. You must determine when it is appropriate for Claude Code to write an implementation plan to get user approval before writing code, and how to set up CI/CD workflows so that agent scripts do not hang waiting for keyboard inputs.
Domain 3: Prompt Engineering & Structured Output (20%)
While this covers prompting, it is tailored for system designers. You must know how to guarantee that Claude returns structured, deterministic responses suitable for programmatic parsing.
XML Tags & Context Placement
Anthropic models are pre-trained to respond well to XML tags (e.g., <rules>, <context>, <examples>). You will be quizzed on where to place context. For instance, the **system prompt** should contain instructions and schemas, whereas the **user message** should contain the immediate task data.
JSON Schema Enforcement
You must know how to force Claude to return valid JSON. This involves:
- Describing the JSON schema in the tool definitions or system prompt.
- Instructing Claude to skip conversational preambles and output only raw JSON.
- Implementing parsing validation on the client side with a retry loop that feeds the error trace back to Claude.
Domain 4: Tool Design & MCP Integration (18%)
The Model Context Protocol (MCP) is an open-source standard for connecting LLMs to data and tools. The exam tests your practical understanding of MCP architecture.
Model Context Protocol Core Concepts
- MCP Host: The client application (like Claude Desktop or Claude Code) that runs the agent loop.
- MCP Server: The microservice that exposes resources (files/data), prompts (templates), and tools (executable actions).
- Preventing Tool Misrouting: Writing clear, non-overlapping tool descriptions. If you have two tools like
get_db_recordsandquery_database, you must provide distinct description fields so the model understands exactly when to invoke each one.
Here is a basic JSON representation of an MCP tool configuration schema that you might see on the exam:
{
"name": "fetch_incident_log",
"description": "Retrieves incident details from the database. Use this tool only when you have a specific incident ID.",
"input_schema": {
"type": "object",
"properties": {
"incident_id": {
"type": "string",
"description": "The unique ID of the incident to fetch (e.g., INC-404)"
}
},
"required": ["incident_id"]
}
}
Domain 5: Context Management & Reliability (15%)
Designing production-grade AI systems requires managing model errors, latency, and tokens.
Optimizing for Long Context & Caching
Claude 3.5 Sonnet supports a 200,000-token context window. However, sending large amounts of data repeatedly is expensive and slow. You must know:
- Prompt Caching: How to mark static blocks of prompt data (like system guidelines or large documents) with
cache_controltags so that subsequent calls are faster and cost up to 90% less. - Error Propagation & Escalation: Setting up deterministic thresholds. If Claude fails a tool validation 3 times, the system must trigger an escalation hook for human-in-the-loop (HITL) intervention.
CCA-F Study Checklist
If you are preparing for the Claude Certified Architect — Foundations exam, here is your recommended study roadmap:
1. Foundations
Read the official Anthropic API docs. Practice building tool-use workflows using the Claude Python/TypeScript SDKs.
2. MCP & Systems
Build a custom MCP server. Connect Claude Desktop or Claude Code to a local database or filesystem using MCP schemas.
3. Scenarios
Study system failure loops. Learn to diagnose why an agent failed, how to manage prompt cache, and how to write custom CLAUDE.md files.
Next Steps for Your Preparation
For official courses, check out the Anthropic Academy and review the Claude Cookbook repository for production-grade architectural patterns.
Was this guide helpful?
Thank you for your feedback!