Exam Overview & Study Strategy
What to expect on the Claude Certified Architect exam, how it's scored, the five weighted domains, the six scenario types, and a concrete study plan to pass on your first attempt.
Quick Reference
- →Multiple-choice format: 1 correct answer + 3 distractors per question
- →Scoring range: 100-1000 scaled score, 720 minimum to pass
- →No penalty for guessing — always answer every question
- →Domain 1 (Agentic Architecture & Orchestration) carries the highest weight at 27%
- →Domain 3 (Claude Code) and Domain 4 (Prompt Engineering) each carry 20%
- →6 exam scenarios exist; you get 4 randomly selected per sitting
- →Scenarios test practical judgment: architecture tradeoffs, not memorized facts
- →Target candidate: 6+ months hands-on experience with Claude APIs, Agent SDK, Claude Code, and MCP
- →All questions are scenario-based — expect real-world system design situations
- →Study all 6 scenarios even though only 4 appear — you cannot predict which 4
In this article
What This Certification Validates
The Claude Certified Architect exam validates that you can design, build, and operate production-grade applications using the Anthropic technology stack. It targets solution architects, senior developers, and technical leads who have spent at least 6 months working hands-on with Claude APIs, the Agent SDK, Claude Code, and MCP.
This is not a theory exam. Every question is rooted in a realistic scenario — a customer support agent that needs to handle escalations, a CI pipeline powered by Claude Code, a multi-agent research system coordinating subagents. The exam measures your ability to make sound architectural decisions under constraints: choosing the right orchestration pattern, designing tool interfaces that Claude can reliably call, structuring prompts that produce consistent output, and managing context windows so your agent stays on track across long conversations.
Passing the exam signals to employers and clients that you understand not just how individual Anthropic APIs work, but how they compose into reliable production systems. You know when to use a single agent versus a multi-agent supervisor, when to reach for MCP versus direct tool_use, and how to structure CLAUDE.md files so Claude Code behaves predictably in your repository.
Exam Format & Scoring
The exam uses a straightforward multiple-choice format. Each question presents a scenario and four answer choices. Exactly one choice is correct; the other three are plausible distractors designed to test whether you truly understand the tradeoffs versus having a surface-level familiarity.
| Aspect | Detail |
|---|---|
| Question format | Multiple choice — 1 correct + 3 distractors |
| Scoring range | 100 to 1000 (scaled) |
| Passing score | 720 / 1000 |
| Guessing penalty | None — always answer every question |
| Question style | Scenario-based — real-world system design situations |
| Scenarios per exam | 4 of 6 scenarios randomly selected |
| Target experience | 6+ months hands-on with Claude APIs, Agent SDK, Claude Code, MCP |
There is zero penalty for incorrect answers. If you are unsure, eliminate what you can and guess. Leaving a question blank guarantees zero points; guessing gives you at least a 25% chance even with no elimination.
The scaled scoring model means raw question counts do not map linearly to your score. Questions that more candidates answer correctly may be weighted slightly less, while harder questions carry more weight. The 720 threshold is deliberately set to require solid competence across all five domains — you cannot ace two domains and ignore three.
The Five Domains
The exam content is organized into five domains, each with a specific weight that determines how many questions come from that area. The weights are not equal — Agentic Architecture carries the most at 27%, while Context Management carries the least at 15%. However, 'least' still means roughly 1 in 7 questions, which is enough to make or break your score near the 720 threshold.
| Domain | Weight | Key Topics |
|---|---|---|
| 1. Agentic Architecture & Orchestration | 27% | Agent loops, orchestration patterns (single agent, supervisor, swarm), Claude Agent SDK, subagent spawning, human-in-the-loop, error handling |
| 2. Tool Design & MCP Integration | 18% | MCP servers & clients, tool schemas, tool_use vs MCP, designing reliable tool interfaces, permission models |
| 3. Claude Code Configuration & Workflows | 20% | CLAUDE.md files, project vs user settings, slash commands, hooks, Claude Code in CI/CD, repository conventions |
| 4. Prompt Engineering & Structured Output | 20% | System prompts, prefilling, JSON Schema output, Pydantic models, prompt chaining, few-shot examples, structured extraction |
| 5. Context Management & Reliability | 15% | Context window budgeting, summarization strategies, Message Batches API, error propagation, retry patterns, guardrails |
A common mistake is to focus only on Domain 1 because it has the highest weight. At 15%, Domain 5 still contributes roughly 150 points of the 1000-point scale. If you score poorly on any single domain, even the lowest-weighted one, it can pull you below the 720 passing threshold.
Each domain in this course maps to a dedicated topic with multiple articles. Domain 1 maps to our Agentic Architecture topic, Domain 2 to Tool Design & MCP, Domain 3 to Claude Code, Domain 4 to Prompt Engineering & Structured Output, and Domain 5 to Context Management & Reliability. Work through every topic systematically.
The Six Exam Scenarios
Every exam question is anchored to one of six predefined scenarios. Each scenario describes a realistic system — the kind of application a Claude architect would actually design and ship. On any given exam sitting, you receive four of these six scenarios randomly. You cannot predict which four will appear, so you must prepare for all six.
- ▸Customer Support Resolution Agent — An agent that handles customer tickets end-to-end: classifying intent, looking up order data via tools, composing responses, and escalating to humans when confidence is low. Tests orchestration, tool design, and human-in-the-loop patterns.
- ▸Code Generation with Claude Code — Using Claude Code to generate, refactor, and test code within a repository. Tests CLAUDE.md configuration, slash commands, hooks, and how Claude Code interacts with your development workflow.
- ▸Multi-Agent Research System — A supervisor agent coordinating multiple specialized subagents (e.g., a searcher, a summarizer, a fact-checker) to produce a research report. Tests multi-agent orchestration, subagent spawning, context sharing, and result aggregation.
- ▸Developer Productivity with Claude — Integrating Claude into developer tools and workflows: code review, documentation generation, debugging assistance. Tests prompt engineering, structured output, and how to design reliable developer-facing AI features.
- ▸Claude Code for Continuous Integration — Running Claude Code as part of a CI/CD pipeline: automated code review on PRs, test generation, lint fixing. Tests Claude Code configuration, non-interactive mode, hooks, and reliability in automated environments.
- ▸Structured Data Extraction — Extracting structured data (JSON, tables, typed objects) from unstructured text: invoices, contracts, medical records. Tests JSON Schema, Pydantic validation, prompt engineering for extraction, and error handling when extraction fails.
For each of the six scenarios, you should be able to sketch: (1) the orchestration pattern you would use, (2) the tools the agent needs, (3) how you would structure the system prompt, (4) how you would handle failures, and (5) how context is managed across turns. If you can do this for all six, you are ready.
Technologies on the Exam
The exam covers a specific set of Anthropic technologies and complementary standards. Knowing exactly what is in scope helps you focus your study time and avoid rabbit holes.
| Technology | What to Know |
|---|---|
| Claude API (Messages API) | Request/response format, system prompts, multi-turn conversations, stop reasons |
| Claude Agent SDK | Agent loops, tool registration, handoffs, guardrails, hooks, lifecycle events |
| MCP (Model Context Protocol) | Server/client architecture, tool schemas, resource types, transport layers |
| Claude Code | CLAUDE.md files, settings hierarchy, slash commands, hooks, CI mode |
| Message Batches API | Batch processing patterns, when to use batches vs single requests |
| JSON Schema | Defining output schemas, required fields, nested objects, enums |
| Pydantic | Model validation, field types, custom validators, integration with Claude output |
The following topics are explicitly out of scope: fine-tuning, billing and pricing, cloud provider configurations (AWS/GCP/Azure), embeddings, computer use (beta), vision capabilities, streaming implementation details, rate limiting, and OAuth/authentication. Do not spend study time on these areas.
Study Strategy
Passing on the first attempt requires a deliberate study plan. The exam rewards practical understanding — the kind you only get from building real systems. Here is a seven-step preparation approach.
Complete the Anthropic Skilljar courses
Start with Claude 101, then work through Building with Claude API, Intro to MCP, Agent Skills, and Subagents. These free courses from Anthropic cover the foundational concepts tested on the exam. They take roughly 15-20 hours total.
Build at least one agent end-to-end
Use the Claude Agent SDK to build a working agent with tool_use, human-in-the-loop, and error handling. A customer support bot or a code review assistant are ideal practice projects. The act of building will surface gaps in your understanding that reading alone will not.
Configure Claude Code in a real repository
Set up CLAUDE.md files, define custom slash commands, configure hooks, and run Claude Code in non-interactive mode. Practice the difference between project-level and user-level settings. This directly prepares you for Domain 3 (20% of the exam).
Design and implement MCP tools
Build an MCP server with at least 3-4 tools. Practice defining tool schemas, handling errors in tool responses, and configuring MCP clients. Understand when MCP is the right choice versus direct tool_use.
Practice prompt engineering with structured output
Write system prompts that produce JSON matching a predefined schema. Use Pydantic for validation. Practice techniques: prefilling, few-shot examples, chain-of-thought, and output format enforcement. This covers Domain 4 (20%).
Work through the Claude Cookbooks
The github.com/anthropics/claude-cookbooks repository contains working examples for tool use, agents, structured output, and more. Run the notebooks. Modify them. Break them and fix them. Cookbook examples frequently mirror exam scenario patterns.
Scenario drill: sketch all six architectures
For each of the six exam scenarios, draw the architecture on paper: orchestration pattern, tools needed, prompt structure, error handling, context management. Then compare your design against what you have learned in this course. Repeat until you can sketch each scenario confidently in under 5 minutes.
Allocate your study time roughly proportional to domain weights: 27% on agentic architecture, 20% each on Claude Code and prompt engineering, 18% on MCP/tools, and 15% on context management. Adjust based on your existing strengths — spend more time on domains where you have less hands-on experience.
Exam Day Tips
- ▸Read each scenario carefully before looking at the answer choices — form your own answer first, then find the closest match
- ▸Watch for distractors that mention out-of-scope technologies (fine-tuning, embeddings, computer use) — these are never the correct answer
- ▸When two answers seem correct, look for the one that addresses the specific constraint in the scenario (cost, latency, reliability, context limits)
- ▸Flag uncertain questions and revisit them after completing the rest — fresh eyes often catch what you missed
- ▸Manage your time across all four scenarios — do not spend 60% of your time on the first scenario
For every question, start by eliminating answers that reference out-of-scope topics or use deprecated patterns. This immediately removes 1-2 distractors on most questions, improving your odds even when you are unsure about the remaining choices.
Best Practices
Do
- ✓Focus on hands-on building — the exam tests practical judgment, not memorization
- ✓Study all 5 domains even if some carry lower weight
- ✓Prepare for all 6 scenarios since you cannot predict which 4 will appear
- ✓Use the Anthropic Skilljar courses as your foundational study material
- ✓Build at least one complete agent with tools, error handling, and human-in-the-loop
- ✓Practice sketching architectures for each scenario on paper
Don’t
- ✗Don't memorize API signatures without understanding the tradeoffs they encode
- ✗Don't skip low-weight domains — Domain 5 at 15% can still cost you a passing score
- ✗Don't study out-of-scope topics (fine-tuning, embeddings, computer use, billing)
- ✗Don't ignore scenario practice — every question is tied to a real-world scenario
- ✗Don't assume your strongest domain will carry you — the 720 threshold requires breadth
Key Takeaways
- ✓The exam uses multiple-choice questions with scenario-based framing — 720/1000 to pass, no guessing penalty.
- ✓Domain 1 (Agentic Architecture & Orchestration) carries the highest weight at 27% — master agent loops, orchestration patterns, and the Agent SDK.
- ✓Every question is tied to one of six realistic scenarios — you get 4 of 6 randomly, so prepare for all of them.
- ✓The exam tests practical architectural judgment, not memorization — expect tradeoff questions, not trivia.
- ✓Technologies in scope: Claude API, Agent SDK, MCP, Claude Code, Message Batches API, JSON Schema, Pydantic.
- ✓Out of scope: fine-tuning, embeddings, computer use, billing, cloud configs, streaming details, rate limiting.
- ✓Study proportionally to domain weights but do not skip any domain — the 720 threshold requires competence across all five.
- ✓The single most effective preparation strategy is building real systems: agents, MCP tools, Claude Code configurations, and structured output pipelines.
Video on this topic
Claude Architect Exam: What You Need to Know in 60 Seconds
tiktok