1. The agentic loop and stop_reason
Every agent you build on the Messages API is the same four-step loop, and one response field drives it.
Free · No Sign-Up · Fully Sourced
Claude Certified Architect
Study Guide & Mock Exams
A 54-lesson curriculum and 240 practice questions covering all five CCAR‑F domains — every claim traced back to Anthropic’s own documentation.
54
Lessons
240
Questions
108
Quick checks
25
Primary sources
Independent study aid. AITraining2U is not affiliated with, authorised by, or endorsed by Anthropic. “Claude” and “Anthropic” are trademarks of Anthropic PBC. These are original lessons and practice questions, not real exam content. Exam logistics change — confirm current format and eligibility before you book.
The path
Three steps, in this order
1
15 minDiagnose cold
Take the diagnostic before reading anything. The breakdown shows where your gaps actually are.
Start diagnostic2
~249 minStudy weak domains
54 lessons with diagrams, reference tables and the exam trap called out. Weakest domain first, not front to back.
Open curriculum3
120 minSit the full mock
60 questions scored out of 1000. Repeat until you clear 800, then book the real thing.
Start full mock
The exam
What you’re preparing for
60
Questions
120
Minutes
720
To pass / 1000
4 of 6
Scenarios
Pearson VUE
Proctor
Domain weighting
Agentic Architecture & Orchestration27%
16 of 60 exam questions · 12 lessons · 64 practice questions
Claude Code Configuration & Workflows20%
12 of 60 exam questions · 11 lessons · 48 practice questions
Prompt Engineering & Structured Output20%
12 of 60 exam questions · 12 lessons · 48 practice questions
Tool Design & MCP Integration18%
11 of 60 exam questions · 10 lessons · 44 practice questions
Context Management & Reliability15%
9 of 60 exam questions · 9 lessons · 36 practice questions
The seven anti-patterns
Most wrong answers are one of these. Learn to spot them and the distractors become obvious.
01 Enforcing a hard rule in the prompt instead of in backend code
02 Routing on the model’s self-reported confidence
03 Using the Batch API for a blocking, user-facing path
04 Reaching for a bigger context window to fix an attention problem
05 Subagents that fail silently instead of returning error context
06 Giving every agent the full tool set instead of role-scoping it
07 Flat all-to-all agent topology instead of a coordinator
Check eligibility first. Registration requires a company email on a domain tied to an organisation in the Claude Partner Network — personal addresses are rejected at signup. See the for all four exams.
Full contents
Complete curriculum outline
All 54 lessons and what each covers. Open any one in the study app to read it in full, with its diagrams, worked example and comprehension checks.
Domain 1: Agentic Architecture & Orchestration
27% of the exam · 12 lessons · ~54 min · 64 practice questions
2. pause_turn and server-side tools
Server-side tools run their own sampling loop. When it hits its limit you get a pause, not an error.
3. Parallel tool use and result pairing
One assistant message can request several tools. How you return the results decides whether it ever does so again.
4. Workflow patterns: chaining, routing, parallelisation
Three of the five canonical patterns. The exam tests which one fits a described workload.
5. Orchestrator-workers and evaluator-optimizer
The two patterns for work you cannot fully specify up front.
6. Coordinator and subagent architecture
The single most-tested idea in the heaviest domain: subagents do not inherit context.
7. Subagent prompting and tool scoping
How you brief a subagent, and what you let it touch.
8. Session state, resume and crash recovery
What to do when a long pipeline dies halfway.
9. Agent or workflow? Surfaces, tiers and effort
When an agent is justified at all, which surface to build it on, and how to tune spend.
10. Error classification and propagation
Not all failures are the same kind, and the kind decides who handles them.
11. Fallback, retry and graceful degradation
What the system does when the happy path is unavailable.
12. State: in-context versus external memory
Where an agent keeps what it knows, and why the choice matters.
Domain 2: Claude Code Configuration & Workflows
20% of the exam · 11 lessons · ~53 min · 48 practice questions
1. Settings files and precedence
Five scopes, one order, and one important exception.
2. Permissions: enforcement vs guidance
The distinction the exam returns to again and again.
3. The CLAUDE.md hierarchy and load order
Where memory files live, in what order they load, and why nested files behave differently.
4. Path-scoped rules with .claude/rules/
How to keep instructions out of context until they are relevant.
5. Imports, AGENTS.md and exclusions
Composing memory files across repos and tools.
6. Hooks: events, exit codes and decisions
The enforcement layer. Exit codes are near-guaranteed exam content.
7. MCP config and CI/CD workflows
Sharing servers with a team, and running Claude Code without a human.
8. Skills and custom slash commands
The two used to be separate features. They have merged, and the exam-relevant details are the frontmatter and the precedence.
9. Claude Code architecture and the execution model
What actually runs where, and why that determines what you can enforce.
10. Excluding files and controlling project scope
How to keep Claude away from files it should not read, and what actually enforces it.
11. The Agent SDK and headless automation
Running the same harness programmatically, and in CI where nobody can answer a prompt.
Domain 3: Prompt Engineering & Structured Output
20% of the exam · 12 lessons · ~53 min · 48 practice questions
1. Structured outputs: two distinct features
Constraining the response body and constraining tool parameters are separate knobs.
2. JSON Schema support and limits
What the schema engine will and will not enforce.
3. Syntax errors vs semantic errors
The highest-value idea in this domain: schemas guarantee shape, never truth.
4. Prefill removal and its replacements
A migration detail that shows up as a scenario.
5. Prompt construction for production
Where each kind of content belongs, and why placement is a caching decision too.
6. Message Batches: economics and limits
Numbers worth memorising, and the one workload Batches must never serve.
7. Batch recovery and accuracy measurement
Handling partial failure, and the statistics trap before you automate.
8. Structuring complex prompts with XML tags
When a prompt carries several kinds of content, delimiters stop them bleeding into each other.
9. Generation parameters and what replaced them
temperature, top_p and top_k are gone on current models. Knowing what to use instead is the exam-relevant part.
10. Multi-turn design and context accumulation
Conversations grow, and how you let them grow determines both cost and coherence.
11. Evaluating prompts: datasets, grading and regression
How you know a prompt change was an improvement rather than a vibe.
12. Chain-of-thought and extended thinking
Getting the model to reason before answering, and how that is configured now.
Domain 4: Tool Design & MCP Integration
18% of the exam · 10 lessons · ~46 min · 44 practice questions
1. MCP architecture: host, client, server
The participant model and the two layers, which the exam states precisely.
2. MCP primitives and transports
Three server primitives, and knowing which one a scenario actually calls for.
3. Tool descriptions are the primary lever
When the model picks the wrong tool, the description is almost always the fix.
4. Designing tool inputs and outputs
The cluster of design rules the exam tests most heavily.
5. Tool errors and trust boundaries
Who fixes which failure, and what you are allowed to believe.
6. Scaling the tool surface
What to do when there are too many tools to put in context.
7. Building an MCP server
What you actually implement, and the decisions that shape the surface you expose.
8. MCP clients and multi-server routing
What the host does when several servers are connected at once.
9. Idempotency, partial success and safe retries
The property that decides whether retrying a tool is safe at all.
10. MCP security and production hardening
A server is an interface a model drives. Scope it accordingly.
Domain 5: Context Management & Reliability
15% of the exam · 9 lessons · ~43 min · 36 practice questions
1. Prompt caching mechanics
One invariant explains every caching question on the exam.
2. Cache economics and verification
The numbers, and how to prove caching is actually working.
3. Invalidation hierarchy and silent invalidators
Not every change invalidates everything — and the ones that do are predictable.
4. Context editing, compaction and memory
Three mechanisms, three different jobs. Expect a "which one" question.
5. Long-context effects
Two distinct failure modes with two distinct signatures.
6. Provenance, conflict and escalation
Reliability practices that keep multi-agent output trustworthy.
7. RAG architecture: chunking, embedding, retrieval
The pipeline that puts the right context in front of the model instead of all of it.
8. Semantic, keyword and hybrid retrieval
Two retrieval methods with complementary blind spots, and why production uses both.
9. Production RAG: multi-index, citation and grounding
What separates a demo pipeline from one you can put in front of users.
Beyond the reading
Build it, then look it up
This is a hands-on exam. Reading gets you recognition; building gets you recall. Two free companions to the curriculum — both also inside the study app.
30 build exercises
Thirty things to actually ship, weighted to the blueprint — a bare agentic loop, a blocking hook, an MCP server with all three primitives, a cache breakpoint you can verify. Each one comes with build steps, acceptance criteria you can check yourself, and the trap it inoculates you against.
~22 hours
All 5 domains
Free
168-term glossary
Every term the exam turns on — pause_turn, prefix matching, evaluator-optimizer, hook exit code 2 — with a definition and a note on how it is actually tested. Grouped by domain, each entry linked to the lesson that covers it, and searchable inside the app.
168 terms
Exam context
Searchable
Primary sources
Study the source, not the summary
Every lesson and answer links back to one of these. Third-party guides for this exam contain real factual errors — when in doubt, check the docs.
Claude API documentation
Tool use, structured outputs, batches, caching, stop reasons.
Claude Code documentation
Settings precedence, hooks, memory hierarchy, permissions, skills.
Claude Agent SDK
The agent loop, subagents, sessions and permissions as a library.
MCP specification
Primitives, transports, JSON-RPC, host/client/server architecture.
Building effective agents
Chaining, routing, parallelisation, orchestrator-workers, evaluator-optimizer.
Anthropic Academy
The official prep courses, exam guide and practice exam.
FAQ
Common questions
720 on a scaled range of 100–1000. Because scoring is scaled rather than a raw percentage, 720 does not mean exactly 72% of items correct. Our mocks use a linear scale, so treat the number as a comparable signal rather than a prediction.
60 scenario-based questions in 120 minutes — about two minutes each. Questions are drawn from four scenarios selected from a pool of six, spanning customer support, multi-agent research, Claude Code team configuration, CI/CD automation, developer tooling with MCP, and structured data extraction.
No. Registration goes through Pearson VUE and requires a company email on a domain tied to an organisation in the Claude Partner Network; personal addresses are rejected at signup. Check this before planning around a sitting date.
The curriculum here is about 249 minutes of reading across 54 lessons. Most candidates with real hands-on Claude experience need roughly 15–20 hours in total including practice; if you are new to the Agent SDK, Claude Code or MCP, allow considerably more and build something first.
No, and be wary of anyone claiming otherwise. These are original questions and lessons written against the published domain blueprint and the official documentation. They train the same decision-making the exam tests without reproducing protected content.
Because several popular third-party guides contain factual errors — for example claiming user-scope CLAUDE.md lives at ~/.claude.json (it is ~/.claude/CLAUDE.md; the JSON file holds OAuth and MCP state), or listing temperature and top_p as live tuning knobs when they return a 400 on current models. Every lesson and answer here cites its source so you can verify rather than trust.
Yes, in your browser’s local storage only. Lessons you mark as read, an in-progress exam attempt, and your per-domain mastery all persist in the study app. Nothing is uploaded and there is no account to create.
Want the hands-on version?
Certification proves you know the patterns. Our instructor-led Claude training gets your team building agents, MCP servers and Claude Code workflows on your own codebase — HRDC claimable for Malaysian employers.
Related reading: · Claude vs ChatGPT vs Gemini · AI Engineering programme · All articles