Last verified: September 1, 2026
CCAR-F, or Claude Certified Architect – Foundations, is the Foundations certification in Anthropic’s Architect track. It tests production architecture decisions across Claude Code, the Claude Agent SDK, the Claude API, agentic systems, Model Context Protocol (MCP), prompt engineering, structured output, context management, and reliability.
The exam has 60 multiple-choice and multiple-response questions, lasts 120 minutes, and costs $125. Pearson VUE delivers it online or at a test centre. Anthropic currently limits access to people at organizations in the Claude Partner Network.
My first tip: before you open a mock exam, check whether you are eligible.
Can anyone take the CCAR-F exam?
No, not right now. You cannot register with a personal email; your email domain must match an organization in the Claude Partner Network.
Can an individual or freelancer join the network?
Not automatically. A freelancer can apply through a business, and Anthropic says Partner Network membership is free. But forming a company does not guarantee exam access. Anthropic’s current Services Track update says new applicants enter at Registered with a minimum commitment to ten certified practitioners. If you are solo, confirm your eligibility with Anthropic before building a study plan around the exam.
Hey, I’m Karo Zieminski 🤗.
AI PM and builder. I write Product with Attitude, an AI newsletter for tens of thousands of readers across 146 countries, helping them develop critical AI literacy the only way it sticks: through practice.
I studied for the CCAR-F exam for several weeks before discovering I was not eligible to take it. An impressively efficient system, if the goal was personal growth.
Today, I’m sharing what I learned along the way.
CCAR-F Exam Quick Overview
These details come from the current certification page, official FAQ, Pearson VUE programme page, and July 2026 exam guide.
Last verified: 1 September 2026.
Where to Find the Official CCAR-F Exam Guide
Open the CCAR-F page in Anthropic Partner Academy. Eligible candidates register and pay there, then receive instructions for scheduling through Pearson VUE.
You can also:
Check whether your account has access to the CCAR-F exam.
Download the official PDF exam guide.
Review exam policies and testing requirements.
See the six core production scenarios used in the exam.
Your exam will include questions based on four of these six scenarios.
Where the Exam Guide Differs from Current Claude Documentation
Here are some differences I noticed while studying:
July 2026 exam-guide language:
Taskspawns subagents.Current Agent SDK subagent docs: Tool-use blocks use
Agent; older SDK versions and thesystem:inittool list may still reportTask.
July 2026 exam-guide language:
allowed-toolslimits a skill’s tool access.Current skills docs: It pre-approves matching tools. Use
disallowed-toolsto remove access.
July 2026 exam-guide language: Use
@importto include another instruction file.Current memory docs: The syntax is
@path/to/file; use/contextto inspect what loaded.
July 2026 exam-guide language: Tool use plus JSON Schema is the structured-output pattern.
Current structured-output docs: APIs also provide
strict: truefor tool inputs andoutput_config.formatfor a schema-conformant final response.
July 2026 exam-guide language: A batch request cannot run a multi-turn tool workflow.
Current batch docs: A batch can contain multi-turn history and run Anthropic server tools. It still cannot complete a client-side tool loop inside one request.
Know a freelancer, or AI architect considering CCAR-F? Send them this guide.
What CCAR-F tests
Scroll down for a plain-English map of the July 2026 CCAR-F exam blueprint: every domain, subdomain, skill, tool, and concept it names.
Where to Find Free CCAR-F Practice Questions
The July 2026 official guide includes 12 sample questions, but Anthropic does not offer a full-length official practice bank.
Several community resources are free:
Szymon Paluch’s practice exam gives you a full 60-question mock exam based on the official blueprint.
The AI Booklet offers free CCAR-F study questions and mock exams by domain.
CertSafari also provides free CCAR-F practice questions and exam-preparation material.
You can also use this GitHub study guide, which includes six full mock exams with 360 questions.
These resources are unofficial. If they disagree with the official Anthropic exam guide, Anthropic wins.
How Long Does It Take to Prepare for the CCAR-F Exam?
Self-reported candidate experiences vary wildly:
Matthew Purcell reported about six hours of preparation on top of daily Claude use and scored 811.
Akshay Kokane studied for almost two weeks, built a small Agent SDK project, and raised his practice-exam score from 677 to 910 before passing the real exam.
Prasad Rao studied for two weeks with an architecture background and advised beginners to allow much longer.
One experienced cloud architect reported failing with 598 after three weeks and high mock scores.
One YouTuber says he passed after two days of study.
Yeah. I know. That’s not the benchmark I would plan around.
CCAR-F Exam Experiences: What Passed Candidates Are Saying
Here is what professionals who have passed the CCAR-F exam have shared about their testing experience and study strategies:
On the scenario-based difficulty:
Each [question] was well-constructed and based on real production concerns rather than theoretical edge cases. [...] Hands-on experience with the Agent SDK, MCP tools, and Claude Code is not optional — it is how you develop the judgment the exam tests.
On learning “the Anthropic way”:
In the end the exam expects you to answer the questions how Anthropic wants you to. There are some things which are always wrong - like choosing the bigger model.
On exam strategy and structure:
The official exam guide names all six scenarios, and your exam form draws four of them at random with fifteen questions hanging off each one. That makes your study plan obvious: build real projects against all six, not four.
On the pressure of the retake policy:
The review process: I used the full 105 minutes, including a deliberate review pass. [...] The 6-month retake window adds real pressure — you know going in that there is no casual attempt.
CCAR-F Misconceptions
Use the right name
CCAF and CCA-F are common community shorthand, but Anthropic’s current official code is CCAR-F: Claude Certified Architect – Foundations. Do not confuse it with CCAO-F, Anthropic’s separate Associate – Foundations certification.
Pay the right price and take the right exam
Anthropic launched the certification in March 2026. Exam delivery moved to Pearson VUE on 30 June 2026. That date made several older guides stale at once: the listed price changed from $99 to $125, the old official practice exam was retired and replaced by sample questions in the guide, and earlier six-month credentials were extended to 12 months.
If a guide still tells you to use ProctorFree, pay $99, or take the old practice exam, ignore it.
Understand the score
One detail is easy to misread. A scaled score of 720 does not mean you need 72% of the questions correct. Anthropic does not publish the raw-score conversion.
Is CCAR-F Worth It?
The CCAF exam is worth it when you already work with Claude and the credential can affect a decision within its 12-month validity period. The strongest cases are partner-tier requirements, project staffing, client bids, and jobs that name CCAR-F.
Its learning value is also credible because the blueprint covers production architecture decisions.
It is a weaker choice for beginners or job seekers expecting a guaranteed salary return. Anthropic publishes no pass rate, hiring effect, or salary data.
Take it if you already build production systems with Claude and the badge can change a specific work decision within the next 12 months. It can help your employer reach a partner tier. It can support staffing for a Claude project. A few current jobs also list it as preferred.
Skip it if you want a first AI certificate, a job guarantee, or proof that you can ship. Anthropic has published no pass rate, salary effect, or hiring outcome. Its own partner tiers ask for certified people, production deployments, and customer references.
The CCAF exam is worth taking for:
consultants and architects whose company belongs to the Claude Partner Network
builders who already use Claude APIs, Claude Code, the Agent SDK, or MCP at work
people who need a named credential for an upcoming Claude project, bid, promotion, or staffing decision
It is a weaker purchase for:
beginners looking for their first AI course
job switchers hoping one badge will replace a portfolio
product managers who have not implemented agent systems
founders whose product must work across several model providers
How to prepare for the CCAR-F Exam?
Start with the official guide. Treat third-party mock exams as question-format practice. Do not treat their answer keys as scripture. Zawanah’s exam report warns that some mock answers are ambiguous or wrong. A candidate who passed on a second attempt also blamed conflicting and stale preparation material for wasted study.
Map each task statement to evidence from your own work. If you cannot point to code, a configuration file, a trace, or a design decision, build a small example.
Then work in this order:
Architecture: Build one agent loop with clear stopping rules, state, escalation, and human review.
Claude Code: Test CLAUDE.md scope, commands, skills, hooks, plan mode, and CI use.
Structured output: Add a schema, validation, retries, and a failure path.
MCP and tools: Design narrow tool interfaces. Trigger timeouts, bad arguments, and partial results.
Context: Practise selecting, summarizing, and tracing context instead of stuffing everything into one prompt.
Scenario review: For every answer, state why the other plausible choices are weaker.
Verify disputed answers against current Anthropic documentation. The product and the exam have already changed since launch.
If you take the exam online, run Pearson’s system test on the exact computer and network you will use. OnVUE requires one screen, a private room, a webcam, a microphone, speakers, and a stable connection. Pearson prohibits VPNs, corporate networks, and public or shared networks. Use a permitted private network or take the exam at a test centre.
CCAR-F Exam Domains
CCAR-F Exam Domains
The official exam guide divides CCAR-F into five domains:
Agentic Architecture & Orchestration
Tool Design & MCP Integration
Claude Code Configuration & Workflows
Prompt Engineering & Structured Output
Context Management & Reliability
For every domain, I separate what you need to know from what you need to be able to do.
Domain 1: Agentic Architecture & Orchestration
1.1 Design Agentic Loops
Know
An agentic loop sends a request to Claude and checks
stop_reason.tool_usemeans Claude wants to use a tool.end_turnmeans Claude has completed the task.After a tool runs, its result must be added to the conversation history.
Claude uses the updated context to decide the next action.
Model-driven tool selection is different from a fixed decision tree.
Be able to
Continue the loop when
stop_reasonistool_use.Stop the loop when
stop_reasonisend_turn.Add tool results to the conversation before the next model call.
Use
stop_reasonas the main completion signal.Do not depend on natural-language phrases such as “done.”
Do not use assistant text as the completion signal.
Do not use an arbitrary iteration limit as the main stopping rule.
If agentic loops are new to you, start with How to Build Your First Agent. One That Works. It turns the loop into a working beginner build.
1.2 Orchestrate Multi-Agent Systems
Know
A hub-and-spoke system uses one coordinator agent.
The coordinator receives the main request, divides the work, selects subagents, sends context to them, receives their results, handles errors, combines the final answer.
Subagents have isolated context.
They do not automatically receive the coordinator’s conversation history.
Overly narrow task decomposition can also cause problems. A coordinator can divide a broad research problem into tasks that are too small and miss important areas.
Be able to
Select subagents based on the task.
Do not run every subagent for every request.
Give different research areas to different subagents.
Reduce duplicate work between subagents.
Route communication through the coordinator.
Let the coordinator check the combined result for missing information.
Send targeted follow-up work to subagents when information is missing.
Repeat this process until the required coverage is sufficient.
1.3 Configure and Spawn Subagents
Know
The July 2026 exam guide calls the subagent-spawning tool
Task. Current tool-use blocks call itAgent; older SDK versions and thesystem:inittool list may still reportTask.Current Agent SDK examples include
Agentin the coordinator’sallowedTools. EachAgentDefinitionuses its owntoolsfield to define the subagent’s tool set anddisallowedToolsto remove tools.Ordinary subagents do not automatically inherit the parent’s context, previous agent results, or shared memory. Claude Code conversation forks are the exception.
You must give the required information to each subagent.
A current
AgentDefinitioncan specify the agent’s description, prompt, model, andtoolsallowlist.The exam guide uses
fork_sessionfor Agent SDK session branching. On the CLI, use--resume <name-or-id> --fork-session. This creates a new session from an existing one; it is separate from both Claude Code conversation forks and a skill’s isolatedcontext: fork.
Be able to
Include
Agentin the coordinator’sallowedToolswhen using the Agent SDK.Put all required context in the subagent prompt.
Pass previous findings directly to the next agent.
Keep content and source metadata separate.
Preserve URLs, document names, and page numbers.
Start multiple subagents in parallel with multiple
Agentcalls in one response.Give the coordinator goals and quality criteria.
Avoid unnecessary step-by-step instructions that reduce agent flexibility.
Why the names disagree: tool-use blocks changed from Task to Agent in Claude Code v2.1.63. Detection code should match both names. For the exam, recognise the blueprint’s Task terminology. For current implementations, use the live Agent SDK subagent documentation.
1.4 Enforce Multi-Step Workflows
Know
Prompt instructions are not deterministic.
Use programmatic controls when a rule must always apply.
Use structured handoffs when a human must continue the work.
Be able to
Block a tool until required earlier steps are complete.
Use prerequisite gates for important business rules.
Split requests with several concerns into separate work items.
Investigate independent items in parallel.
Combine the findings into one response.
Create a complete handoff for a human who cannot see the full conversation.
1.5 Use Agent SDK Hooks
Know
Hooks can intercept tool activity.
A
PreToolUsehook can inspect, modify, deny, defer, or request approval before a tool runs.A
PostToolUsehook can add context or replace the output after a tool runs.Use hooks for deterministic client-side enforcement. A hook is not, by itself, a blanket compliance guarantee.
Be able to
Use
PostToolUseto normalize tool output.Normalize Unix timestamps and ISO 8601 dates.
Normalize status codes.
Use
PreToolUseto inspect outgoing tool calls.Block actions that break policy before they execute.
Route blocked actions to another workflow.
Choose hooks instead of prompt-only rules when deterministic client-side enforcement is required.
1.6 Decompose Complex Tasks
Know
Use different decomposition methods for different tasks.
Use a fixed sequence when the workflow is predictable.
Use dynamic decomposition when later work depends on earlier findings.
Be able to
Select prompt chaining for predictable workflows.
Select dynamic decomposition for open-ended investigation.
Split large code reviews into local file reviews and cross-file reviews.
Map a system before making a large change.
Update the work plan when new dependencies appear.
1.7 Manage Sessions
Know
--resume <session-name>to continue a named session;fork_sessionto create an independent branch.A resumed session can contain stale information.
If files changed after the first analysis, tell Claude what changed.
Sometimes a new session with a fresh summary is safer than resuming an old session.
Be able to
Resume a named session.
Fork a session to compare different approaches.
Tell a resumed session which files changed.
Request targeted re-analysis of changed files.
Start a new session when old tool results are no longer reliable.
Give the new session a structured summary of the valid findings.
Domain 2: Tool Design & MCP Integration
2.1 Design Clear Tool Interfaces
Know
Claude uses tool descriptions to decide which tool to use.
Weak or overlapping descriptions can cause wrong tool selection.
Be able to
Give each tool a clear purpose.
Explain the difference between similar tools.
Rename tools when their names overlap.
Replace generic tools with more specific tools when this improves selection.
Define clear input and output contracts.
Check system prompts for instructions that can cause incorrect tool selection.
2.2 Return Structured MCP Errors
Know
MCP tools can use the
isErrorflag to report failures.Different failures need different responses.
Common error categories include transient errors, validation errors, permission errors, and business-rule violations.
A generic message such as
Operation faileddoes not give the agent enough information.The agent also needs to know if retry can help.
Be able to
Return
isError: true. Put application-defined fields such aserrorCategoryandisRetryableinstructuredContentor serialised result content, with a human-readable recovery explanation.Identify retryable errors.
Identify non-retryable errors.
Distinguish a failed request from a valid empty result.
Let subagents retry transient errors locally.
Send unresolved errors to the coordinator.
Include partial results when useful.
Explain what was already attempted.
MCP note: isError is the standard MCP result flag. errorCategory and isRetryable are useful conventions, not standard top-level MCP properties. The Claude API uses the separate tool-result field is_error.
2.3 Control Tool Access and Tool Choice
Know
Too many tools can reduce tool-selection accuracy.
An agent should usually receive only the tools that match its role.
On supported models and settings, Claude accepts these current
tool_choiceobjects:{"type":"auto"}: Claude can use a tool or answer with text.{"type":"any"}: Claude must call at least one tool.{"type":"tool","name":"tool_name"}: Claude must call the named tool.{"type":"none"}: Claude cannot call a tool.
Current restriction:
anyand namedtoolchoices are unavailable with manual extended thinking and on Fable 5.1 or Mythos 5.1;autoandnoneremain available.
Be able to
Give each agent only the tools it needs.
Remove tools that are outside the agent’s role.
Replace broad tools with constrained tools when useful.
Give limited cross-role tools when there is a clear need.
Use
{"type":"auto"}when tool use is optional.On a supported model and setting, use
{"type":"any"}when at least one tool call is required.On a supported model and setting, force a named tool when a specific first step is required. If exactly one call is required, also set
disable_parallel_tool_use: true.
2.4 Integrate MCP Servers
Know
Claude Code supports different MCP scopes.
Use project scope for shared team configuration:
.mcp.jsonUse user scope for personal or experimental configuration:
~/.claude.jsonYou can use environment variables in
.mcp.json.MCP resources can expose catalogs such as: issue indexes, documentation structures, database schemas.
Be able to
Configure a shared MCP server in
.mcp.json.Configure a personal MCP server in
~/.claude.json.Use environment variables for secrets.
Write detailed MCP tool descriptions.
Help Claude select an MCP tool instead of a weaker built-in tool.
Use an existing MCP server for standard integrations when possible.
Build a custom MCP server for team-specific workflows.
Use MCP resources to expose available data before the agent searches it.
2.5 Use Claude Code Built-In Tools
Know
Grepto search file contents;Globto find files by path or name pattern;Readto read files;Writeto write complete files;Editto make targeted changes;Bashto run shell commands.
Be able to
Use
Grepto find function names, imports, errors, and callers.Use
Globto find file patterns such as**/*.test.tsx.Use
Readbefore making changes when more context is required.Use
Writewhen targeted editing is not reliable.Start codebase exploration with search.
Read only the files that become relevant.
Trace exported functions across wrapper modules and callers.
Domain 3: Claude Code Configuration & Workflows
3.1 Configure CLAUDE.md
Know
Claude Code supports several instruction levels.
User level:
~/.claude/CLAUDE.mdUser-level instructions are personal. They are not automatically shared through version control.
Project level:
.claude/CLAUDE.mdor:CLAUDE.mdDirectory level:
a
CLAUDE.mdinside a subdirectory.Use
@importto include external instruction files.Use
.claude/rules/to split a large instruction file into smaller topic-specific files.
Be able to
Find configuration hierarchy problems.
Put team rules at project level.
Keep personal rules at user level.
Use
@importfor modular instructions.Split large instruction files into focused rule files.
Use
/memoryto check which memory and instruction files are loaded.
3.2 Create Commands and Skills
Know
Project commands:
.claude/commands/Personal commands: ~/.claude/commands/
Project skills:
.claude/skills/A skill uses a
SKILL.mdfile.Useful skill frontmatter includes:
context: fork,allowed-tools,argument-hint.context: forkruns the skill in isolated context.
Be able to
Create project slash commands for shared workflows.
Create personal commands for personal workflows.
Create skills with
SKILL.md.Use
context: forkwhen isolated context is useful.Limit skill tool access with
allowed-tools.Use
argument-hintto show required arguments.Use skills for task-specific workflows.
Use
CLAUDE.mdfor instructions that must always apply.
3.3 Apply Path-Specific Rules
Know
Files in
.claude/rules/can use YAML frontmatter with apathsfield.Claude loads the rule only when it works with matching files.
Path rules are useful when one convention applies to files in several directories.
Be able to
Create path-specific rule files.
Use glob patterns in
paths.Apply rules by file type.
Apply rules across multiple directories.
Use path rules instead of directory-level
CLAUDE.mdwhen the same convention applies in many locations.
3.4 Choose Plan Mode or Direct Execution
Know
Use plan mode for:
complex changes;
architectural decisions;
many-file changes;
tasks with several valid approaches;
migrations.
Use direct execution for:
small changes;
clear bug fixes;
one-file edits;
Be able to
Select plan mode for high-impact work.
Select direct execution for simple work.
Use Explore for large discovery tasks.
Keep the main context focused.
Plan first and execute after the approach is clear.
3.5 Use Iterative Refinement
Know
Concrete examples often communicate requirements better than long prose.
Tests can also define expected behavior.
The interview pattern lets Claude ask questions before implementation.
This can expose hidden requirements.
Be able to
Give two or three input/output examples.
Write tests before implementation when useful.
Include expected behavior and edge cases.
Give Claude test failures during iteration.
Ask Claude to interview you before a complex implementation.
Give interacting problems in one message when their fixes affect each other.
Fix independent problems one at a time when that is clearer.
3.6 Use Claude Code in CI/CD
Know
-p--print--output-format json--json-schemaUse
CLAUDE.mdto give CI runs project-specific rules.A separate Claude instance can review generated code more effectively than the same session that wrote it.
Be able to
Run Claude Code without interactive input.
Produce structured JSON output.
Enforce a JSON schema.
Add review criteria to
CLAUDE.md.Include earlier review findings in later runs.
Report only new or unresolved findings.
Give existing tests to Claude before asking it to create more tests.
Use a separate review instance for independent code review.
Domain 4: Prompt Engineering & Structured Output
4.1 Write Explicit Prompt Criteria
Know
Specific rules work better than vague instructions.
Be able to
Define exactly which problems Claude must report.
Define which problems Claude must ignore.
Separate bugs and security issues from minor style issues.
Define severity levels with clear criteria.
Add examples for each severity level.
Disable a noisy review category while you improve its prompt.
4.2 Use Few-Shot Examples
Know
Few-shot examples can improve:
output format;
tool selection;
classification;
extraction;
handling of ambiguous cases;
consistency.
Be able to
Provide two to four useful examples.
Show correct handling of ambiguous cases.
Show acceptable and unacceptable code patterns.
Demonstrate the required output format.
Include examples with different document structures.
Use examples to reduce false positives and extraction errors.
4.3 Enforce Structured Output
Know
The exam guide teaches schema-based tool use as a strong method for structured output.
In the current API,
strict: trueenforces a tool’s input schema. Useoutput_config.formatwhen the final response itself must match a JSON schema.Strict schema enforcement guarantees structural compliance and removes JSON syntax or shape errors; it does not guarantee that the values are semantically correct. A refusal or token truncation can also prevent a valid final structured response.
Be able to
Define a tool with JSON schema input.
Extract structured data from a
tool_useresponse.Use
tool_choice: {"type":"auto"}when Claude may answer with text instead of calling a tool.On a supported model and setting, use
tool_choice: {"type":"any"}when at least one tool call is required.On a supported model and setting, use
tool_choice: {"type":"tool","name":"extract_data"}when a named extraction tool must run first.Make fields optional when the source may not contain the value.
Use values such as
unclearwhen the source is ambiguous.Use
otherplus a detail field for open categories.Add normalization rules for inconsistent source formats.
4.4 Validate and Retry
Know
A retry is useful when the first result contains a correctable error.
Give Claude the exact validation error.
A retry will not help when the source does not contain the required information.
Schema validation and semantic validation are different.
Schema validation checks structure.
Semantic validation checks meaning and relationships between values.
Be able to
On retry, provide:
the source;
the failed result;
the validation error.
Also be able to:
identify errors that can be corrected by retry;
stop retrying when the source lacks the required data;
compare calculated totals with stated totals;
add fields such as
conflict_detected;record
detected_patternto study repeated false positives.
4.5 Use Batch Processing
Know
The Message Batches API gives a 50% cost reduction.
Processing can take up to 24 hours.
There is no guaranteed low-latency SLA.
Use batch processing for work such as:
overnight reports;
weekly audits;
nightly test generation.
Do not use it for blocking tasks such as pre-merge checks.
A single batch request cannot run a multi-turn tool workflow.
Use
custom_idto match each request with its result.
Be able to
Use the synchronous API for time-sensitive work.
Use batch processing for latency-tolerant work.
Set submission frequency based on the required SLA.
Identify failed requests by
custom_id.Resubmit only failed items.
Modify failed requests when required.
Test and refine prompts on a sample before processing a large batch.
4.6 Use Independent and Multi-Pass Reviews
Know
A model that reviews its own work in the same session still has the context that produced the original decision.
A separate review instance has less of this bias.
Large reviews also work better when divided into several passes.
Be able to
Use a second Claude instance for independent review.
Review each file separately for local issues.
Run a second pass for cross-file issues.
Check data flow and integration behavior separately.
Ask the reviewer to report confidence when this helps review routing.
Domain 5: Context Management & Reliability
5.1 Preserve Important Context
Know
Long conversations can lose important details.
Progressive summaries can remove:
exact amounts;
dates;
percentages;
order numbers;
user requirements.
Important information can also receive less attention when it is in the middle of a very long input.
Tool output can consume large amounts of context.
Be able to
Keep critical facts in a separate structured block.
Preserve exact amounts, dates, IDs, and statuses.
Keep issue state separate from summarized conversation history.
Remove irrelevant fields from large tool responses.
Put key findings near the start of a combined input.
Use clear section headings.
Require source metadata from subagents.
Ask upstream agents for structured facts instead of long reasoning output.
If you want the working version of this domain, read Context Engineering for Product Builders.
5.2 Handle Escalation and Ambiguity
Know
Useful escalation triggers include:
the customer explicitly requests a human;
policy does not cover the request;
the agent cannot make useful progress.
Customer frustration alone does not always require escalation.
Self-reported model confidence is also not a reliable measure of case complexity.
If a search returns several possible customer records, do not guess which one is correct.
Be able to
Define explicit escalation rules.
Add examples that show when to escalate.
Immediately honor a clear request for a human.
Offer to solve a normal issue when the user has not requested escalation.
Escalate when policy is missing or unclear.
Ask for another identifier when several records match.
Do not select a customer by heuristic guess.
5.3 Propagate Errors Across Agents
Know
A coordinator needs useful error information.
Good error context includes:
failure type;
attempted action;
partial result;
possible alternative.
A timeout is not the same as a successful search with zero results.
Do not hide errors by returning an empty result.
Do not stop the entire workflow because one subagent failed if useful work can continue.
Be able to
Return structured error information.
Distinguish access failures from empty results.
Retry transient failures locally.
Send unresolved errors to the coordinator.
Include partial results.
Explain what was attempted.
Mark report sections where source coverage is incomplete.
5.4 Manage Context in Large Codebases
Know
Very long exploration sessions can reduce answer quality.
The model can start to rely on general patterns instead of the specific code it inspected earlier.
Use:
subagents;
summaries;
scratchpad files;
structured state files;
/compact.
Be able to
Give specific exploration tasks to subagents.
Keep the main agent focused on coordination.
Save important findings in scratchpad files.
Summarize one investigation phase before the next phase begins.
Give new subagents the relevant summary.
Save agent state for recovery.
Load saved state after a crash or restart.
Use
/compactwhen verbose context starts to consume the context window.
5.5 Design Human Review and Confidence Workflows
Know
A high overall accuracy score can hide weak areas.
For example, 97% total accuracy does not prove that every:
document type;
field;
customer segment
also has 97% accuracy.
Use stratified sampling to test different segments.
Confidence scores also need calibration against labeled data.
Be able to
Sample high-confidence results.
Measure errors in different document types.
Measure errors by field.
Find new error patterns.
Ask the model for field-level confidence.
Calibrate confidence thresholds with labeled validation data.
Send low-confidence cases to human review.
Send ambiguous or contradictory cases to human review.
Use reviewer capacity on the cases with the highest risk.
5.6 Preserve Provenance and Uncertainty
Know
Source attribution can disappear during multi-step summarization.
Each important claim should remain connected to its source.
Useful source metadata includes:
source URL;
document name;
page or section;
publication date;
data collection date;
relevant excerpt or evidence.
Two credible sources can report different values.
Do not automatically select one value.
The difference can result from different dates, methods, or populations.
Be able to
Require structured claim-to-source mappings.
Preserve these mappings during synthesis.
Keep conflicting values when both are credible.
Label the conflict.
Preserve the original source context.
Include publication and collection dates.
Separate established findings from contested findings.
Present each type of information in a useful format.
Technologies and Techniques to Know
Agent Architecture
Claude Agent SDK
Agent definitions
Agentic loops
stop_reasonPostToolUseTool call interception
TaskSubagent spawning
allowedToolsPrompt chaining
Coordinator-subagent architecture
Model Context Protocol
Model Context Protocol (MCP)
MCP servers
MCP tools
MCP resources
isErrorTool descriptions
Tool distribution
.mcp.jsonEnvironment variable expansion
Claude Code
Claude Code
CLAUDE.md.claude/rules/.claude/commands/.claude/skills/SKILL.mdcontext: forkargument-hintPlan mode
Direct execution
Explore subagent
/memory/compact--resumefork_session
Claude Code CLI
-p--print--output-format json--json-schema
Claude API
Claude API
tool_useJSON Schema
tool_choiceautoanyforced tool selection
max_tokenssystem prompts
Batch Processing
Message Batches API
custom_id
Built-In Development Tools
Read
Write
Edit
Bash
Grep
Glob
Prompt Engineering
Few-shot prompting
Explicit criteria
Prompt chaining
Structured output
Retry with validation feedback
Multi-pass review
Independent review
Context and Reliability
Context window management
Token budgets
Progressive summarization
Lost-in-the-middle effects
Context extraction
Scratchpad files
Session management
Provenance
Confidence scoring
Field-level confidence
Stratified sampling
CCAR-F FAQ
Is the CCAR-F Exam Worth It?
CCAR-F is worth it when you already build with Claude and the credential can influence a specific decision before its 12-month expiry: a partner tier, client bid, project assignment, promotion, or staffing decision. The blueprint also has learning value because it covers production architecture decisions. It is weaker for beginners or anyone expecting a guaranteed hiring or salary return.
Is CCAF the Same as CCAR-F?
People often use CCAF and CCA-F for the certification now called Claude Certified Architect – Foundations, but Anthropic’s official code is CCAR-F. Do not confuse it with CCAO-F, the separate Associate – Foundations certification. Older study guides may use all three Architect labels, so check publication dates before following their advice.
How Much Does the CCAR-F Exam Cost?
CCAR-F has a $125 list price. As of 1 September 2026, eligible Select, Preferred, and Global Premier partners receive 50% off their first attempt, bringing the fee to $62.50. The amount shown at checkout is the one that applies. Each retake requires another fee at the applicable rate. Pearson VUE lists a 14-day wait after the first failed attempt, 30 days after the second, and 90 days after the third, with no more than four attempts per exam in a rolling 12-month period.
Is the CCAR-F Exam Hard?
CCAR-F can be hard even for experienced technical candidates because several options may look plausible. The exam asks you to choose the strongest production design for a detailed scenario. Preparation reports range from six hours for a daily Claude user to several weeks for other candidates. One experienced architect also reported failing after three weeks despite high mock scores. No credible average preparation time or official pass rate exists. Hands-on work with Claude Code, the Agent SDK, MCP, structured output, and failure handling is more useful than memorising isolated terms.
Can Anyone Take the CCAR-F Exam?
No. CCAR-F is limited to people at organizations in the Claude Partner Network. Registration requires a recognised company email; a personal email will not work, and candidates must be at least 18. Anthropic lists no formal degree, course, or prior certification requirement. It describes six or more months of practical Claude experience as the typical ideal-candidate profile, not a formal prerequisite. If you do not have partner access, you can still use its free courses and the official exam guide as a learning plan. A freelancer can apply through a business, but a company registration alone does not guarantee access.
How Many Questions Are on the CCAR-F Exam?
CCAR-F has 60 multiple-choice and multiple-response questions. The exam gives you 120 minutes, or an average of two minutes per question. Each multiple-response item states how many answers to select.
What Score Do You Need to Pass CCAR-F?
You need a scaled score of 720 on a 100–1,000 scale. That does not mean you need exactly 72% of the questions correct. Anthropic does not publish the raw-to-scaled-score conversion.
Is the CCAR-F Exam Open Book?
No. CCAR-F is closed book. You cannot use a browser, documentation, translator, AI assistant, notes, or a second screen during the exam.
Can You Take CCAR-F Online?
Yes. Pearson VUE offers online proctoring through OnVUE and appointments at test centres. If you test online, use one screen and a private room. VPNs and corporate or public networks are prohibited.
What Is the Difference Between CCAR-F, CCAR-P, CCDV-F, and CCAO-F?
Pearson VUE currently lists four Claude certifications: CCAR-F is Architect – Foundations, CCAR-P is Architect – Professional, CCDV-F is Developer – Foundations, and CCAO-F is Associate – Foundations. Choose the role track that matches the work you actually do.
How Long Is CCAR-F Valid?
CCAR-F is valid for 12 months. You can renew it through a free, non-proctored Partner Academy assessment if you complete the renewal before the credential expires. If you let it lapse, you must take the full proctored exam again and pay the applicable fee. Anthropic may change the recertification requirements after material updates instead of offering the standard renewal assessment. Treat it as a versioned credential that requires current product knowledge, not a permanent line on your CV.
Further Reading
Continue with my complete Claude Hub. Paid Product with Attitude subscribers get the reusable skills and implementation resources behind guides like this
I passed my CCAR-F exam successfully! EXAM4LEAD provided useful and up-to-date study material that helped me prepare effectively.