Claude Certified Architect Foundations Exam Prep 2026: Complete Blueprint, Domains, and Practice Questions

Independent, unofficial exam prep guide. Not affiliated with, endorsed by, or reviewed by Anthropic. Always confirm current exam policies on Anthropic’s official certification page before registering.

Sixty questions. One hundred twenty minutes. A scaled passing score of 720 out of 1,000. That’s the Claude Certified Architect – Foundations (CCA-F) exam in one sentence, and if those numbers make your stomach drop a little, good. This is not a trivia quiz about model names. It’s a scenario-based test of whether you can actually architect production systems with Claude.

In 2026, Claude Certified Architect Foundations Exam Prep matters because Anthropic built this credential around real deployment decisions: agent versus workflow, tool boundaries, context reliability, and safe autonomy, the exact things hiring managers now ask about.

This is the only guide that covers The 5 Exam Domains Explained, Must-Know Agentic AI Systems & MCP Concepts, Hands-On Labs & Tool Integration, Free & Paid Practice Tests, and Sample Questions & Detailed Explanations, in one place, written for busy professionals who need results, not filler.

What You’ll Get

• A domain-by-domain breakdown with official exam weights, so you study the right things first
• Scenario-style practice questions modeled on real CCA-F item formats
• Five copy-paste-ready labs covering agents, MCP, Claude Code, and Artifacts
• A free 30-question open-book practice test (plus a downloadable PDF)
• A 60-question paid-style mock exam preview with a full answer key
• 20 fully explained sample questions to pressure-test your readiness
• Download the free CCA-F practice PDF and mini-simulator to reinforce what you’ve studied and get extra practice before exam day.

For a complete overview of the certification itself, including registration steps, exam format, passing score, and official domain weights, start with this full Claude Certified Architect Foundations exam guide. It covers everything you need before diving into domain-level preparation.

The 5 Exam Domains Explained

The official blueprint splits CCA-F into five weighted domains. Ignore the small ones at your own risk, CCA-F tests whether you can combine skills across domains inside one scenario, not just recite definitions.

1. Agentic Architecture & Orchestration (27%)

Key topics: workflows vs. model-directed agents; orchestrator-worker and hub-and-spoke patterns; the “gather context → act → verify” loop; iteration limits; state across turns; human review checkpoints.

Scenario question: A support system needs to categorize tickets, look up account data, and occasionally issue refunds under $50. Refunds over $50 need a human. What’s the best architecture? Answer approach: Use a single agent with a bounded tool loop and a host-enforced business rule that blocks any refund tool call above the threshold; don’t rely on the model to self-police high-risk actions.

Anti-pattern: Giving an agent unlimited tool calls “to be safe,” which increases cost, latency, and the chance of runaway loops without improving reliability.

Exam Tip: When two answers both “work,” pick the one that enforces safety and limits outside the model, not through a politely worded instruction.

2. Claude Code Configuration & Workflows (20%)

Key topics: project vs. user-level instruction scope, CLAUDE.md structure, custom commands, hooks, permissions, skills, headless/CI-CD operation.

Scenario question: A team wants coding conventions to apply to every engineer on a repo, but personal shortcuts shouldn’t leak into shared context. Where do the conventions belong? Answer approach: Project-level configuration (checked into the repo) for shared conventions; user-level settings for personal preferences, the narrowest scope that reliably reaches the right audience.

Anti-pattern: Cramming every possible instruction into a single global file “just in case,” which bloats context and dilutes the guidance that actually matters.

Exam Tip: CCA-F rewards the narrowest effective scope; memorize that phrase.

3. Prompt Engineering & Structured Output (20%)

Key topics: system prompt design, few-shot examples, XML-tag organization, output schemas, validation loops, retry strategies, and explicitly defined ambiguous cases.

Scenario question: Claude occasionally returns valid JSON that references a product ID that doesn’t exist. What’s missing? Answer approach: Syntactic validity (valid JSON) isn’t semantic validity. You need application-side validation against real data plus explicit instructions for the “not found” case, not just a schema.

Anti-pattern: Assuming a passing JSON schema check means the output is trustworthy.

Exam Tip: Structured output questions almost always hinge on the difference between syntax and semantics.

4. Tool Design & MCP Integration (18%)

Key topics: clear tool names/descriptions/input schemas, MCP tools vs. resources vs. prompts, server boundaries, transport choices, and predictable failure responses.

Scenario question: One “mega-tool” with ten optional parameters is causing Claude to misuse arguments. What should the architect do? Answer approach: Split it into several purpose-specific tools with narrow, well-described inputs. Clear boundaries beat flexible ambiguity almost every time on this exam.

Anti-pattern: Building one all-purpose tool to “reduce tool count,” which increases misuse and unpredictable behavior.

Exam Tip: If a question describes tool confusion, the fix is almost always decomposition, not better prompting.

5. Context Management & Reliability (15%)

Key topics: context-window compaction, retrieval strategies, prompt caching, durable state separate from conversation history, escalation paths, and confidence handling.

Scenario question: A long-running agent’s context is nearly full. What should it preserve first? Answer approach: Durable facts, citations, and unresolved action items, structured and explicit, rather than an unverified prose summary of the whole conversation.

Anti-pattern: Auto-summarizing everything and discarding the original source facts.

Exam Tip: This domain is small in weight but often decides borderline scores because it appears embedded in Domain 1 and Domain 3 scenarios too.

Must-Know Agentic AI Systems & MCP Concepts

Domain 1 and Domain 4 together make up 45% of your score, so agentic systems and MCP are the highest-leverage topics you can study. Here’s what actually shows up.

Agentic workflows vs. agents. A workflow follows a predetermined sequence; an agent decides its own next action using model reasoning. Predictable, auditable processes (invoice matching, form parsing) favor workflows. Open-ended problems (research, multi-step troubleshooting) favor agents; CCA-F consistently tests which one fits a given scenario.

The agentic loop. Production agents cycle through gather context → take action → verify → decide next step. Exam questions often hide “verify” as the missing piece in a broken scenario; an agent that acts without checking its own tool output is a classic wrong-answer trap.

Tool calling. Claude decides when to call a tool based on its name, description, and input schema, not hidden backend knowledge. Vague descriptions produce vague tool use; this connects directly to Domain 4.

Memory and state. Agents need durable state (facts, decisions, unresolved items) independent of the raw transcript. Confusing “memory” with “keep the whole chat history” is a common trap in Domain 5.

Planning. Multi-step tasks benefit from an explicit, revisable plan, especially in orchestrator-worker patterns, where a lead agent delegates subtasks to workers and reconciles their outputs.

Model Context Protocol (MCP). MCP standardizes how Claude connects to external tools, data sources, and prompts through three primitives:

• Tools, actions Claude can invoke (e.g., “create_ticket”)
• Resources, read-only data Claude can reference (e.g., a knowledge base article)
• Prompts, reusable prompt templates a server exposes to clients

The exam tests whether you can pick the right primitive for the job; using a tool when you actually needed a read-only resource is a classic wrong answer.

Real production example: An internal DevOps assistant exposes an MCP server with a deploy_service tool (guarded by host-side approval), a logs resource (read-only), and a postmortem_template prompt. Each primitive matches its actual function; that alignment is exactly what CCA-F scenario questions are checking for.

Hands-On Labs & Tool Integration

Reading about agents won’t get you to 720. Building small systems will. Each lab below takes 20–40 minutes and maps directly to exam domains.

Lab 1: Build a Bounded Tool-Calling Agent (Domain 1, Domain 4)

1. Define two tools: search_orders(customer_id) and issue_refund(order_id, amount), each with a clear, specific description and JSON schema.
2. Add a host-side rule (outside the prompt) that rejects any issue_refund call above $50.
3. Set a hard tool-call limit of 6 turns per conversation.
4. Test with a request that should trigger escalation instead of a tool call.

Expected output: The agent looks up the order, successfully attempts a refund under $50, and is blocked (not just discouraged) from issuing a refund over $50. Common mistake: Relying on a prompt instruction (“never refund more than $50”) instead of enforcing it in code. Exam Relevance: Directly tests Domain 1’s host-controlled safety concept.

Lab 2: Structure a Claude Project with CLAUDE.md (Domain 2)

1. Create a project-level CLAUDE.md with coding conventions, testing requirements, and forbidden patterns.
2. Add a custom command that runs your test suite and a hook that blocks commits when linting fails.
3. Confirm personal preferences live in user-level settings, not the shared file.

Expected output: A teammate opening the same repo inherits the shared conventions automatically, without your personal shortcuts leaking in. Common mistake: Putting personal formatting preferences in the project-level file, polluting shared context for the whole team. Exam Relevance: Domain 2’s “narrowest effective scope” principle, tested almost every exam sitting.

Lab 3: Design an MCP Server with Clear Boundaries (Domain 4)

1. Stand up a minimal MCP server exposing three tools: get_invoice, flag_invoice, list_vendors, each with a single, obvious responsibility.
2. Define explicit failure responses (e.g., invoice not found) instead of letting errors pass through unhandled.
3. Connect the server to a Claude client and run a task requiring all three tools in sequence.

Expected output: Claude selects the correct tool on the first try in the majority of test runs, with clean error handling on invalid input. Common mistake: One oversized tool with ten optional parameters, causing Claude to guess at usage. Exam Relevance: Domain 4’s tool decomposition principle.

Lab 4: Structured Output with Validation and Retry (Domain 3)

1. Ask Claude to extract structured order data as JSON against a defined schema.
2. Add application-side validation checking referenced product IDs against a real database, with a retry loop that sends specific errors back to Claude for correction.
3. Test with an intentionally ambiguous input to confirm Claude flags uncertainty instead of guessing.

Expected output: Invalid outputs are caught and corrected automatically, and ambiguous inputs produce an explicit “unresolved” field rather than a fabricated value. Common mistake: Trusting schema validity as proof the data is factually correct. Exam Relevance: Domain 3’s syntax-vs-semantics distinction.

Lab 5: Context Compaction with Durable State (Domain 5)

1. Run a long multi-turn agent conversation until context approaches its limit.
2. Instead of a single prose summary, extract structured durable state, confirmed facts, open questions, citations, and discard verbose intermediate outputs once captured.
3. Resume from the compacted state and verify no critical fact was lost.

Expected output: The agent continues working accurately after compaction, with unresolved items still visible instead of silently dropped. Common mistake: Replacing the entire history with an unverified prose summary that quietly loses provenance. Exam Relevance: Domain 5’s structured-over-prose compaction principle.

Reading theory is not enough for a scenario-based exam. The highest-leverage preparation is building real systems. Work through these practical Claude Architect labs that cover multi-agent systems, MCP integration, Claude Code workflows, and production-style projects mapped directly to the five exam domains.

Free & Paid Practice Tests

Timed, full-length simulation is what separates “I understand the concepts” from “I can pass in 120 minutes.” Below is a free open-book set to start, plus a preview of a longer, official-style mock exam.

If you prefer structured training over pure self-study, this comparison of the best Claude Certified Architect Foundations course options covers official Anthropic training, instructor-led programs, and practice platforms so you can pick the path that matches your timeline and budget.

Free 30-Question Open-Book Practice Test (Sample)

Below are 10 representative questions from the full 30-question set. Download the complete free 30-question CCA-F PDF with answer key 

1. A workflow requires the exact same five steps every time with no exceptions. What architecture fits best?
2. An agent’s tool loop has no iteration cap. What risk does this introduce?
3. Where should personal coding shortcuts live in Claude Code, project or user scope?
4. What’s the difference between an MCP tool and an MCP resource?
5. A JSON response passes schema validation but references a nonexistent customer ID. What failed?
6. What should a context-compaction strategy preserve first when nearing the token limit?
7. Why might splitting one large tool into three smaller tools reduce misuse?
8. What signals that a task should escalate to a human instead of continuing autonomously?
9. What’s the risk of relying only on a prompt instruction to enforce a spending limit?
10. In an orchestrator-worker pattern, what is the orchestrator’s core responsibility?

Answer key summary: 1) Deterministic workflow; 2) Runaway cost/latency/loops; 3) User scope; 4) Tools act, resources are read-only; 5) Semantic validation, not syntax; 6) Durable facts, citations, open items; 7) Clearer boundaries reduce argument guessing; 8) Risk threshold or repeated failure; 9) Model compliance isn’t guaranteed, enforce host-side; 10) Delegating subtasks and reconciling worker output.

60-Question Official-Style Mock Exam (Preview)

The full paid-style mock exam mirrors the real blueprint: 60 questions, 120-minute timer, weighted 27/20/20/18/15 across the five domains, mixing single-answer and multiple-response items exactly like the live CCA-F exam. Below is a five-question preview with full explanations; the complete set includes a full answer key and domain-by-domain scoring breakdown.

• Q1. A team wants Claude to autonomously resolve tickets but escalate anything involving a refund over $50. Which control should enforce the escalation?

Answer: A host-side rule outside the model. Prompts express intent; only code guarantees enforcement.

• Q2. Which MCP primitive should expose a static company policy document to Claude? A

Answer: A resource. Resources are for read-only reference data, not actions.

• Q3. A structured-output pipeline keeps producing valid JSON with fabricated field values. What’s the most likely gap?

Answer: Missing semantic validation. Schema checks confirm shape, not truth.

• Q4. What is the main tradeoff of giving an agent unlimited autonomy on a well-defined, repeatable task?

Answer: Unnecessary cost, latency, and nondeterminism. Deterministic tasks are usually cheaper and safer as workflows.

• Q5. In Claude Code, where should a CI/CD pipeline’s shared linting rules be defined?

Answer: Project-level configuration. It needs to reach every contributor, not just one user’s environment.

Bonus: 10-Question Mini-Simulator

A short, timed 10-question drill (roughly 20 minutes) pulled proportionally from all five domains, perfect for a quick readiness check the night before your exam. Included in the free downloadable PDF.

Sample Questions & Detailed Explanations

Twenty questions mixing recall and scenario-based formats, each with a full explanation.

1. What distinguishes an agent from a workflow?

An agent decides its own next action using model reasoning; a workflow follows a fixed sequence. Use workflows for predictable tasks, agents for open-ended ones.

2. Why does CCA-F favor host-side enforcement over prompt instructions for safety limits?

Prompts are requests, not guarantees. Spending caps and permission boundaries must be enforced in code the model can’t override.

3. What’s the purpose of an MCP resource?

It exposes read-only reference data, distinct from tools (actions) and prompts (reusable templates).

4. A tool has ten optional parameters and Claude keeps misusing it. What’s the fix?

Split it into narrowly scoped tools with clear descriptions, ambiguous flexibility increases misuse.

5. Why isn’t “valid JSON” the same as “correct JSON”?

Schema validation checks structure, not truth. A referenced ID can be nonexistent and still pass validation.

6. What should context compaction avoid?

Replacing full history with an unverified prose summary, risking silently dropped facts or unresolved items.

7. In an orchestrator-worker pattern, what does the orchestrator do?

It delegates subtasks to worker agents and reconciles their results into one output.

8. When does a workflow outperform an agent?

When the task follows a known, repeatable sequence, workflows are cheaper and more predictable.

9. What’s often missing when an agent fails silently?

The “verify” step, acting on tool output without checking results invites compounding errors.

10. Why does CCA-F favor “narrowest effective scope” in Claude Code configuration?

Broad catch-all files dilute guidance and bloat context; scoped instructions keep behavior predictable.

11. What’s a key risk of unlimited tool-call loops?

Runaway cost, latency, and nondeterministic behavior with no upper bound.

12. How should ambiguous input be handled in structured output tasks?

Flag it explicitly (an “unresolved” field) rather than letting the model guess a plausible value.

13. What differentiates a Claude Code hook from a command?

A command is invoked by name; a hook runs automatically on an event, like blocking a commit when linting fails.

14. Why might independent review passes catch more than self-review?

A model retains its own reasoning context during self-review, making it less likely to question its own decisions.

15. What’s the tradeoff of large “mega-tools”?

They reduce tool count but increase ambiguity, causing Claude to guess at parameter usage.

16. When should an agent escalate to a human?

When risk exceeds a defined threshold, confidence is low, or failures repeat, escalation should be explicit, not implicit.

17. What’s the difference between prompt caching and context compaction?

Caching reuses unchanged prefix content to cut cost and latency; compaction reduces active context size by restructuring older content.

18. Why does multi-pass review outperform single-pass on large codebases?

Per-file local passes plus cross-file integration passes avoid attention dilution and contradictory findings.

19. What should durable agent state contain that raw history often lacks?

Structured facts, decisions, citations, and open items organized for retrieval.

20. Why does MCP server-boundary design matter beyond individual tool schemas?

Poor boundaries, too many unrelated tools on one server, or fragmented related tools across many, create discoverability and operational problems even with well-written schemas.

Once you pass the Foundations exam, many candidates immediately ask whether they should continue to the Professional level. This side-by-side comparison of Claude Certified Architect Foundations vs Professional helps you decide the right next step based on your experience and career goals.

Frequently Asked Questions FAQ’s

Is the CCA-F exam proctored?

Yes. The exam is delivered online, proctored, or at a Pearson VUE test center.

How many questions are on the Claude Certified Architect Foundations exam?

Sixty questions, a mix of single-answer multiple-choice and multiple-response items, in 120 minutes.

What is the passing score?

A scaled score of 720 out of 1,000. That’s not a direct percentage of correct answers; difficulty is factored into scoring.

How much does the exam cost?

$125 USD, before any eligible partner-tier discount.

Who can register for the exam?

Registration currently requires a recognized company email address tied to an organization in the Claude Partner Network.

How long is the certification valid?

12 months from your pass date.

Can I retake the exam if I fail?

Retake policies and any waiting period are set by Anthropic’s official certification terms, check the current policy before your first attempt.

Is there a prerequisite certification?

No. Claude Certified Developer Foundations is not required, though hands-on experience helps.

How long should I study?

Most developers with existing Claude experience need 15–20 hours across 2–4 weeks, weighted toward Domains 1 and 2.

Does the exam test coding syntax directly?

No, it tests architectural judgment and tradeoffs, not memorized syntax.

Is MCP heavily tested?

Yes. MCP appears directly in Domain 4 (18%) and indirectly inside Domain 1 and 5 scenarios.

What’s the difference between CCA-F and CCDV-F?

CCA-F (Architect) focuses on end-to-end design tradeoffs; CCDV-F (Developer) focuses on implementation.

Can I use notes during the exam?

No, the official exam is closed-book. Use open-book practice only for early learning, then switch to timed simulations.

Where do I register?

Through Anthropic’s official Claude certification page, delivered via Pearson VUE. Verify current details there before booking.

Beyond passing the exam, understanding the real career impact is important. This breakdown of Claude Certified Architect Foundations career paths, salary ranges, and job opportunities shows what the credential actually unlocks in 2026.

Conclusion

Claude Certified Architect Foundations Exam Prep isn’t about memorizing feature lists, it’s about proving you can make the same tradeoffs a production architect makes every day: agent versus workflow, tool boundaries, context reliability, and where humans belong in the loop. Study the five domains in proportion to their weight, build the five labs with your own hands, and stop guessing your readiness, measure it with timed, scenario-based practice.

You now have the blueprint, the concepts, the labs, and 20 fully explained sample questions. The only thing left is repetition under real exam conditions.

Download the free 30-question PDF + 10-question mini-simulator now and start your final push toward a passing score. Grab it, and if you want weekly domain-specific drills sent straight to your inbox, sign up for the study list, it’s the fastest way to walk into exam day ready.