AnthropicFoundational

Claude Certified Architect: Foundations

CCAR-F

Validates that a solution architect can make informed tradeoff decisions building production applications with Claude Code, the Claude Agent SDK, the Claude API and MCP. Scenario-based: each exam presents 4 scenarios drawn at random from a published bank of 6 (customer support agent, Claude Code adoption, multi-agent research, developer productivity, CI/CD integration, structured data extraction). Open only to employees of Claude Partner Network organisations, registering with a company email address.

Duration
120 min
Exam questions
60
Passing score
720 / 1000
Exam fee
$125
Question formats:Multiple choiceMultiple response
Free plan
3 free papers
Free account
Mocks locked
Pro only
Upgrade to Pro
Every paper and mock exam.
Sign in to upgrade

Start with free papers Free

You get 3 free practice papers with your plan.

Free
Mixed paper 1
Domain 1 · 25 questions
Free
Mixed paper 2
Domain 1 · 25 questions
Free
Mixed paper 3
Domain 1 · 25 questions

Domain papers 1982 questions

Free
Mixed paper 1
25 questions · 60 min
Free
Mixed paper 2
25 questions · 60 min
Free
Mixed paper 3
25 questions · 60 min
Pro
Mixed paper 4
25 questions · 60 min
Pro
Mixed paper 5
25 questions · 60 min
Pro
Mixed paper 6
25 questions · 60 min
Pro
Mixed paper 7
25 questions · 60 min
Pro
Mixed paper 8
25 questions · 60 min
Pro
Mixed paper 9
25 questions · 60 min
Pro
Mixed paper 10
25 questions · 60 min
Pro
Mixed paper 11
25 questions · 60 min
Pro
Mixed paper 12
25 questions · 60 min
Pro
Mixed paper 13
25 questions · 60 min
Pro
Mixed paper 14
25 questions · 60 min
Pro
Mixed paper 15
25 questions · 60 min
Pro
Mixed paper 16
16 questions · 39 min

Mock exams Pro

Full-length, exam-like practice tests. Available with Pro.

Mock exam 1
60 questions · 120 min
Mock exam 2
60 questions · 120 min
Mock exam 3
60 questions · 120 min

Try a sample question

All 10 sample questions →
Question 1Agentic Architecture & Orchestration

A platform team rewrites the instructions its agent appends to the system prompt, ships the change, and asks users to resume their existing investigations so the new wording takes effect. Sessions started after the deploy behave as intended; resumed ones keep following the old wording for hours, then abruptly start following the new one. What accounts for both halves of that?

  1. A.

    Resumed sessions read the appended text lazily on the first turn that actually needs it, so the change lands whenever the conversation next touches a topic the instructions cover, which is why the switchover looks abrupt and unrelated to elapsed time.

  2. B.

    Appended instructions are cached by the API for a fixed period keyed on their text, so a resumed session reads the previous cached block until the entry expires; the switchover time is the cache lifetime rather than anything about the session itself.

  3. C.

    The system prompt is recorded on a session's first request and that record is reused until the session is compacted, so the new text reaches a resumed session only after compaction, or in a new session.

  4. D.

    Resumed sessions load the appended text from the transcript rather than from the deploy, and the transcript is rewritten whenever the session is renamed, so the sessions that switched over are the ones whose users happened to rename them.

Show answer

Answer: C

A session records its system prompt on the first request and keeps using that record until it is compacted.

  • A. System prompt text is not loaded lazily per topic; it is fixed for the request.
  • B. Prompt caching affects cost and latency, not which system prompt text a session uses.
  • C. Matches the documented recording behaviour and explains the post-compaction switchover.
  • D. Renaming a session changes a label and does not rebuild its recorded system prompt.

What's on the exam

5 domains · 30 task statements, straight from the official exam guide (as of Version 1.0 · Effective July 2026).

  1. 1.1Design and implement agentic loops for autonomous task execution
    • Knowledge: The agentic loop lifecycle: sending requests to Claude, inspecting stop_reason ("tool_use" vs "end_turn"), executing requested tools, and returning results for the next iteration
    • Knowledge: How tool results are appended to conversation history so the model can reason about the next action
    • Knowledge: The distinction between model-driven decision-making (Claude reasons about which tool to call next based on context) and pre-configured decision trees or tool sequences
    • Skill: Implementing agentic loop control flow that continues when stop_reason is "tool_use" and terminates when stop_reason is "end_turn"
    • Skill: Adding tool results to conversation context between iterations so the model can incorporate new information into its reasoning
    • Skill: Avoiding anti-patterns such as parsing natural language signals to determine loop termination, setting arbitrary iteration caps as the primary stopping mechanism, or checking for assistant text content as a completion indicator
  2. 1.2Orchestrate multi-agent systems with coordinator-subagent patterns
    • Knowledge: Hub-and-spoke architecture where a coordinator agent manages all inter-subagent communication, error handling, and information routing
    • Knowledge: How subagents operate with isolated context—they do not inherit the coordinator's conversation history automatically
    • Knowledge: The role of the coordinator in task decomposition, delegation, result aggregation, and deciding which subagents to invoke based on query complexity
    • Knowledge: Risks of overly narrow task decomposition by the coordinator, leading to incomplete coverage of broad research topics
    • Skill: Designing coordinator agents that analyze query requirements and dynamically select which subagents to invoke rather than always routing through the full pipeline
    • Skill: Partitioning research scope across subagents to minimize duplication (e.g., assigning distinct subtopics or source types to each agent)
    • Skill: Implementing iterative refinement loops where the coordinator evaluates synthesis output for gaps, re-delegates to search and analysis subagents with targeted queries, and re-invokes synthesis until coverage is sufficient
    • Skill: Routing all subagent communication through the coordinator for observability, consistent error handling, and controlled information flow
  3. 1.3Configure subagent invocation, context passing, and spawning
    • Knowledge: The Task tool as the mechanism for spawning subagents, and the requirement that allowedTools must include "Task" for a coordinator to invoke subagents
    • Knowledge: That subagent context must be explicitly provided in the prompt—subagents do not automatically inherit parent context or share memory between invocations
    • Knowledge: The AgentDefinition configuration including descriptions, system prompts, and tool restrictions for each subagent type
    • Knowledge: Fork-based session management for exploring divergent approaches from a shared analysis baseline
    • Skill: Including complete findings from prior agents directly in the subagent's prompt (e.g., passing web search results and document analysis outputs to the synthesis subagent)
    • Skill: Using structured data formats to separate content from metadata (source URLs, document names, page numbers) when passing context between agents to preserve attribution
    • Skill: Spawning parallel subagents by emitting multiple Task tool calls in a single coordinator response rather than across separate turns
    • Skill: Designing coordinator prompts that specify research goals and quality criteria rather than step-by-step procedural instructions, to enable subagent adaptability
  4. 1.4Implement multi-step workflows with enforcement and handoff patterns
    • Knowledge: The difference between programmatic enforcement (hooks, prerequisite gates) and prompt-based guidance for workflow ordering
    • Knowledge: When deterministic compliance is required (e.g., identity verification before financial operations), prompt instructions alone have a non-zero failure rate
    • Knowledge: Structured handoff protocols for mid-process escalation that include customer details, root cause analysis, and recommended actions
    • Skill: Implementing programmatic prerequisites that block downstream tool calls until prerequisite steps have completed (e.g., blocking process_refund until get_customer has returned a verified customer ID)
    • Skill: Decomposing multi-concern customer requests into distinct items, then investigating each in parallel using shared context before synthesizing a unified resolution
    • Skill: Compiling structured handoff summaries (customer ID, root cause, refund amount, recommended action) when escalating to human agents who lack access to the conversation transcript
  5. 1.5Apply Agent SDK hooks for tool call interception and data normalization
    • Knowledge: Hook patterns (e.g., PostToolUse) that intercept tool results for transformation before the model processes them
    • Knowledge: Hook patterns that intercept outgoing tool calls to enforce compliance rules (e.g., blocking refunds above a threshold)
    • Knowledge: The distinction between using hooks for deterministic guarantees versus relying on prompt instructions for probabilistic compliance
    • Skill: Implementing PostToolUse hooks to normalize heterogeneous data formats (Unix timestamps, ISO 8601, numeric status codes) from different MCP tools before the agent processes them
    • Skill: Implementing tool call interception hooks that block policy-violating actions (e.g., refunds exceeding $500) and redirect to alternative workflows (e.g., human escalation)
    • Skill: Choosing hooks over prompt-based enforcement when business rules require guaranteed compliance
  6. 1.6Design task decomposition strategies for complex workflows
    • Knowledge: When to use fixed sequential pipelines (prompt chaining) versus dynamic adaptive decomposition based on intermediate findings
    • Knowledge: Prompt chaining patterns that break reviews into sequential steps (e.g., analyze each file individually, then run a cross-file integration pass)
    • Knowledge: The value of adaptive investigation plans that generate subtasks based on what is discovered at each step
    • Skill: Selecting task decomposition patterns appropriate to the workflow: prompt chaining for predictable multi-aspect reviews, dynamic decomposition for open-ended investigation tasks
    • Skill: Splitting large code reviews into per-file local analysis passes plus a separate cross-file integration pass to avoid attention dilution
    • Skill: Decomposing open-ended tasks (e.g., "add comprehensive tests to a legacy codebase") by first mapping structure, identifying high-impact areas, then creating a prioritized plan that adapts as dependencies are discovered
  7. 1.7Manage session state, resumption, and forking
    • Knowledge: Named session resumption using --resume <session-name> to continue a specific prior conversation
    • Knowledge: fork_session for creating independent branches from a shared analysis baseline to explore divergent approaches
    • Knowledge: The importance of informing the agent about changes to previously analyzed files when resuming sessions after code modifications
    • Knowledge: Why starting a new session with a structured summary is more reliable than resuming with stale tool results
    • Skill: Using --resume with session names to continue named investigation sessions across work sessions
    • Skill: Using fork_session to create parallel exploration branches (e.g., comparing two testing strategies or refactoring approaches from a shared codebase analysis)
    • Skill: Choosing between session resumption (when prior context is mostly valid) and starting fresh with injected summaries (when prior tool results are stale)
    • Skill: Informing a resumed session about specific file changes for targeted re-analysis rather than requiring full re-exploration

Outline reproduced from the vendor's public exam guide for study reference.Official guide

CCAR-F practice — frequently asked questions

Are these real CCAR-F exam questions?

No. Every question on CertifyAIx is original, written by us against Anthropic's publicly available CCAR-F exam guide to rehearse the skills it lists. None are actual exam questions, and CertifyAIx is not affiliated with or endorsed by Anthropic.

How many CCAR-F practice questions are there?

1,982 practice questions, including 3 full-length timed mock exams and 172 domain papers of up to 25 questions (mixed and by topic). Every question has a detailed explanation of why the right answer wins and why each distractor loses.

Is the content up to date with the current CCAR-F exam guide?

The questions are written against the CCAR-F exam guide dated Version 1.0 · Effective July 2026, and we revise them when Anthropic updates the guide.

What question formats are covered?

The same formats the real CCAR-F uses: Multiple choice, Multiple response. Each is rendered and graded the way the exam does it.

How long is the CCAR-F exam and how many questions does it have?

According to Anthropic's published exam details: 60 questions, 120 minutes, passing score 720 / 1000. Our mock exams use the same time limit and question count. Always confirm current details with Anthropic before booking.

Can I practise CCAR-F for free?

Yes. 3 papers are free, with up to 10 questions a day on the free plan and no card needed. Pro unlocks every paper and mock exam with no daily limit.

Does CertifyAIx guarantee that I will pass?

No practice material can guarantee a result. CertifyAIx helps you find and close your weak areas — accuracy by exam-guide domain and topic shows what to study next.