CCAR-F PrepJoin the AI Sprint

Exam guide

Claude Certified Architect: Foundations

CCAR-F tests whether you make sound tradeoff decisions when building production systems on Claude — not whether you can recite an API surface. Almost every question is a symptom in a running system, and the right answer is the smallest change that addresses the cause. This page is the blueprint, the scenarios, and the reading list.

Exam format

Question type
Multiple choice — one correct of four
Questions
60
Time limit
120 minutes
Scoring
100–1000 scale, passing score 720
Guessing penalty
None — answer every question
Scenarios
4 of 8 possible, randomly selected per attempt
Validity
12 months

The five domains

Weights are the blueprint's. Allocate study hours roughly in proportion — Domain 1 alone is more than a quarter of the exam.

1. Agent Architecture & Orchestration

27%

The Agent SDK's agentic loop, stop_reason-driven control flow, coordinator/subagent orchestration, hooks, escalation design, and error propagation across multi-step systems.

2. Tool Design & MCP Integration

18%

Writing tool descriptions and schemas Claude can select correctly, MCP servers, tools vs. resources, and the boundary between what a tool does and what the model decides.

3. Claude Code Configuration & Workflows

20%

CLAUDE.md and memory, skills and slash commands, hooks, sub-agents, permissions, headless mode, and Claude Code in CI.

4. Prompt Engineering & Structured Output

20%

System prompt design, few-shot examples, extended thinking, JSON schema enforcement, and getting reliably parseable output from a probabilistic model.

5. Context Management & Reliability

15%

Context window budgeting, compaction and memory strategies, retries and idempotency, batching, and keeping long-running sessions coherent.

The eight scenarios

Each attempt draws 4 of these 8 at random, so you can sit the exam having never seen half of them. Prepare all eight.

  1. 1. Customer Support Resolution Agent

    Agent SDK plus MCP tools (get_customer, lookup_order, process_refund, escalate_to_human) targeting 80%+ first-contact resolution.

  2. 2. Code Generation with Claude Code

    Accelerating development with slash commands, CLAUDE.md, and planning mode.

  3. 3. Multi-Agent Research System

    A coordinator delegating to web-research, document-analysis, synthesis, and report-generation subagents.

  4. 4. Developer Productivity Tools

    Built-in tools (Read, Write, Bash, Grep, Glob) plus MCP servers for codebase exploration and boilerplate.

  5. 5. Claude Code for Continuous Integration

    Automated code review, test generation, and PR feedback with false positives kept low.

  6. 6. Structured Data Extraction

    Extracting from unstructured documents, validating against JSON schemas, and handling edge cases.

  7. 7. Conversational AI Architecture Patterns

    Context window management, instruction persistence, memory strategies, safe tool design, and ambiguity handling.

  8. 8. Agentic AI Tools

    Reported by candidates but not fully documented — treat as a gap area and apply the tool-design principles from the other scenarios.

The mental model

Most questions offer four things that would all help a little. These three rules pick the one that is actually being asked for.

R1Fix the root cause, not the symptom

When a tool is chosen wrongly, the first move is almost always a better tool description — not few-shot examples, not a routing classifier, not a bigger model.

R2Prefer deterministic over probabilistic

If a step must always happen, enforce it in code — a programmatic precondition or a hook — rather than instructing the model to remember.

R3Match the fix to the size of the problem

A 12% failure rate on one tool call does not justify re-architecting into a multi-agent system. The right answer is usually the smallest one that fully addresses the cause.

Distractors that keep coming back

Recognising these on sight removes one or two options before you start reasoning.

  • Parsing natural language for control flow instead of reading stop_reason
  • Adding few-shot examples where the real defect is an ambiguous tool description
  • Introducing a routing classifier or a second model to fix a prompt-level problem
  • Relying on model self-rated confidence instead of explicit, stated criteria
  • Capping iterations with a fixed number rather than a real termination signal
  • Reaching for fine-tuning or a larger model before exhausting prompt and tool design
  • Merging distinct tools instead of describing their boundaries clearly
  • Escalating on sentiment or difficulty rather than on a genuine policy gap

How to study this

  1. 1Diagnose

    Sit the free mock exam cold. The per-domain breakdown tells you where your hours should go far better than a syllabus does.

  2. 2Drill the weak domains

    Use untimed practice, one domain at a time. Read the documentation link on every question you miss, not just the explanation.

  3. 3Build something

    Write an agent loop that keys on stop_reason, an MCP server with two tools, and a CLAUDE.md that actually changes what Claude Code does. The exam asks about production tradeoffs; those are hard to fake.

Take the free mock exam →Browse the question bank

Documentation to read

Every practice question on this site links to one of these pages. If you have read all of them carefully, you have covered the examinable surface.

Claude API

Claude Agent SDK

Model Context Protocol

Claude Code

Original practice questions written by IntelliForge from the public exam blueprint and Claude documentation. These are not real exam questions, and this material is not affiliated with, sponsored by, or endorsed by Anthropic.