examOS.
Exam CatalogueStudy PlansRoadmapsBlogs
Login

ExamOS

Credits PolicyReferral PolicyQuality StandardsPricingPrivacy PolicyTerms of UseContact UsReport a Bug

Follow us

Disclaimer: ExamOS is an independent platform, not affiliated with any certification provider, and does not use or distribute exam dumps.

Share your feedback

Checking sign-in status...

examOS.Study Plan
Disclaimer: ExamOS is an independent platform, not affiliated with any certification provider, and does not use or distribute exam dumps.
← Back to Exam Details
examOS.Study Plan · examos.io

Study Plan

Claude Certified Architect Foundations (CCAR-F) Study Plan for 2026

Study plan for CCAR-F covering agentic architecture, MCP integration, Claude Code workflows, prompt engineering, and context management.

AnthropicCCAR-FPassing score: 720 / 1000Machine learning engineers, software engineers, and architects with approximately 6 months hands-on experience building production systems with the Claude API and Claude Code18-Jul-202611 views
Start date: _______________Target exam date: _______________

Your personalized plan

A focused route built around your experience and daily study commitment.

Timeline

8 weeks

Personalized calendar

Daily commitment

1h

5 study & practice hrs/week

Progress

0/6

milestones completed

Saved on this device

Your week-by-week breakdown


Your week 1

Milestone 1: Agentic Architecture and Orchestration, Part 1 (Domain 1)

This first half of the largest domain covers the fundamentals of agentic systems: what an agent loop looks like, when to use an agent versus a simpler pattern, and how to decompose complex tasks effectively.

Topics

  • • Agentic loop mechanics and stop_reason
  • • Agents vs workflows vs conversations
  • • Task decomposition and planning
  • • Recognizing decomposition anti-patterns
  • • When agentic architecture adds value

Activities

  • • Build a minimal agent loop using the Claude Agent SDK. Log every stop_reason across a real run and document what triggers each one.
  • • Take a task you would normally hardcode as a script and design it two ways: as a fixed workflow and as an agent. Write down which one you would ship and the specific trade-off that decides it.
  • • Decompose one complex, ambiguous request into subtasks. Identify where a naive decomposition would fail and document the failure mode.
  • • Take the ExamOS Daily Sprint in Rookie mode on Agentic Architecture. Flag any topic below 60%.

Your week 2

Milestone 2: Agentic Architecture and Orchestration, Part 2 (Domain 1)

Building on Week 1's foundation, this half covers multi-agent systems: how to coordinate subagents, when to dispatch in parallel versus serial, and when to escalate to a human.

Topics

  • • Hub-and-spoke coordinator patterns
  • • Subagent context isolation
  • • Parallel vs serial dispatch trade-offs
  • • Escalation loops and human handoff
  • • Model confidence limitations for routing

Activities

  • • Build a coordinator that dispatches 2-3 subagents in parallel for independent subtasks. Measure the token cost difference versus serial execution in a single agent.
  • • Design an escalation rule for a scenario where the agent should not trust its own confidence score to decide when to hand off. Document the rule and the reasoning.
  • • Take the ExamOS Mock Exam in Challenger mode on Agentic Architecture. Repeat until you pass 2 consecutive attempts.

Your week 3

Milestone 3: Tool Design and MCP Integration (Domain 4)

Tools are how agents interact with the outside world. This week covers how to write tool descriptions that produce reliable selection, how to scope toolsets to avoid degradation, and how the Model Context Protocol (MCP) standardizes tool integration.

Topics

  • • Tool description best practices
  • • Structured error responses from tools
  • • Scoping tools per agent role
  • • Tool search and deferred schemas
  • • MCP: servers, primitives, and transports

Activities

  • • Write two versions of the same tool description: one vague ("handles deployments"), one specific. Confirm the model routes to the specific one more reliably in at least 5 test runs.
  • • Stand up a minimal MCP server using stdio transport and connect Claude to it. Verify the server exposes at least one tool that Claude can invoke.
  • • Build a toolset of 15+ tools to trigger selection degradation, then apply tool search or scoping to fix it. Document the before-and-after selection accuracy.
  • • Take the ExamOS Mock Exam in Challenger mode on Tool Design and MCP. Repeat until you pass 2 consecutive attempts.

Your week 4

Milestone 4: Claude Code Configuration and Workflows (Domain 2)

Claude Code is built on the Agent SDK's agentic loop, but it adds its own configuration layer: CLAUDE.md hierarchy, Agent Skills, hooks, and a permissions model that governs what the agent can and cannot do. This week gets those details right.

Topics

  • • Claude Code architecture and execution
  • • CLAUDE.md hierarchy and precedence
  • • Agent Skills: SKILL.md and triggers
  • • Hooks, permissions, and deny-wins rule
  • • Agent SDK and CI/CD integration

Activities

  • • Configure a project-level CLAUDE.md and a nested subdirectory CLAUDE.md. Verify which one wins for a file in the subdirectory by testing a real command.
  • • Write one Agent Skill (SKILL.md with frontmatter) for a repeated task and trigger it successfully.
  • • Configure a permission rule set and test what happens when a user-level deny meets a project-level allow. Confirm deny wins.
  • • Integrate Claude Code into a CI/CD pipeline using non-interactive mode. Run a test commit through the pipeline.
  • • Take the ExamOS Mock Exam in Challenger mode on Claude Code Configuration. Repeat until you pass 2 consecutive attempts.

Your week 5

Milestone 5: Prompt Engineering, Structured Output, Context Management, and Reliability (Domains 3 and 5)

This week covers two closely related domains: how to structure prompts and outputs for reliability, and how to manage the context window over long-running sessions. These are the same discipline in practice: getting consistent, accurate responses from Claude at scale.

Topics

  • • Prompt structuring with XML tags
  • • Extended thinking and effort parameter
  • • Structured output: constrained sampling vs tools
  • • Context rot and management strategies
  • • Prompt caching: breakpoints and invalidation

Activities

  • • Implement native structured output (JSON schema) for one task and strict tool use for another. Write down when you would pick each approach and why.
  • • Build a validator-and-retry loop that catches a schema violation and retries with corrective instructions. Test it with at least 3 malformed inputs.
  • • Deliberately let a long-running agent's context grow past a reasonable size, observe the quality drop, then fix it with compaction. Document the quality difference.
  • • Set up prompt caching on a stable system prompt and tool set. Confirm what a mid-session edit does or does not invalidate.
  • • Take the ExamOS Mock Exam in Challenger mode on Prompt Engineering and Context Management. Repeat until you pass 2 consecutive attempts.

Your week 6

Milestone 6: Exam Simulation and Booking

Your final push. Full exam simulation mode: filling in remaining gaps and building the confidence to book the exam.

Topics

  • • Full syllabus review across all five domains
  • • Time management (120 minutes for 60 questions)
  • • Scenario reasoning under time pressure
  • • All 6 official production scenarios

Activities

  • • Take at least 3 ExamOS Mock Exams in Legend mode. Review every missed question and write one sentence naming the architectural principle behind the correct answer.
  • • Simulate real exam conditions at least once: no notes, no breaks, 120 minutes, same time of day you plan to sit the exam.
  • • Review all 6 official production scenarios. Only 4 appear per sitting, but you will not know which 4 in advance.
  • • Identify your weakest domain from Mock Exam results and take 2 Bonus Quests on that domain.

Your weeks 7–8

Use this practice and review phase for mock exams, weak-topic revision, and reworking missed questions before exam day.

Stay consistent by setting a target date for this certification.

Set target

Week-by-Week Breakdown


W1

Week 1

Agentic Architecture and Orchestration, Part 1 (Domain 1)

This first half of the largest domain covers the fundamentals of agentic systems: what an agent loop looks like, when to use an agent versus a simpler pattern, and how to decompose complex tasks effectively.

Topics

  • Agentic loop mechanics and stop_reason
  • Agents vs workflows vs conversations
  • Task decomposition and planning
  • Recognizing decomposition anti-patterns
  • When agentic architecture adds value

Activities

Daily Study Routine

Suggested 2–3 Hour Day

TimeActivity
15 minReview yesterday's missed questions. Identify the architectural principle behind each correct answer.
30 minRead Anthropic documentation for this week's topic
30 minHands-on coding with Claude API, Agent SDK, or Claude Code
30 minTake an ExamOS quiz (Daily Sprint or Mock Exam, depending on the week)
  • Build a minimal agent loop using the Claude Agent SDK. Log every stop_reason across a real run and document what triggers each one.
  • Take a task you would normally hardcode as a script and design it two ways: as a fixed workflow and as an agent. Write down which one you would ship and the specific trade-off that decides it.
  • Decompose one complex, ambiguous request into subtasks. Identify where a naive decomposition would fail and document the failure mode.
  • Take the ExamOS Daily Sprint in Rookie mode on Agentic Architecture. Flag any topic below 60%.
W2

Week 2

Agentic Architecture and Orchestration, Part 2 (Domain 1)

Building on Week 1's foundation, this half covers multi-agent systems: how to coordinate subagents, when to dispatch in parallel versus serial, and when to escalate to a human.

Topics

  • Hub-and-spoke coordinator patterns
  • Subagent context isolation
  • Parallel vs serial dispatch trade-offs
  • Escalation loops and human handoff
  • Model confidence limitations for routing

Activities

  • Build a coordinator that dispatches 2-3 subagents in parallel for independent subtasks. Measure the token cost difference versus serial execution in a single agent.
  • Design an escalation rule for a scenario where the agent should not trust its own confidence score to decide when to hand off. Document the rule and the reasoning.
  • Take the ExamOS Mock Exam in Challenger mode on Agentic Architecture. Repeat until you pass 2 consecutive attempts.
W3

Week 3

Tool Design and MCP Integration (Domain 4)

Tools are how agents interact with the outside world. This week covers how to write tool descriptions that produce reliable selection, how to scope toolsets to avoid degradation, and how the Model Context Protocol (MCP) standardizes tool integration.

Topics

  • Tool description best practices
  • Structured error responses from tools
  • Scoping tools per agent role
  • Tool search and deferred schemas
  • MCP: servers, primitives, and transports

Activities

  • Write two versions of the same tool description: one vague ("handles deployments"), one specific. Confirm the model routes to the specific one more reliably in at least 5 test runs.
  • Stand up a minimal MCP server using stdio transport and connect Claude to it. Verify the server exposes at least one tool that Claude can invoke.
  • Build a toolset of 15+ tools to trigger selection degradation, then apply tool search or scoping to fix it. Document the before-and-after selection accuracy.
  • Take the ExamOS Mock Exam in Challenger mode on Tool Design and MCP. Repeat until you pass 2 consecutive attempts.
W4

Week 4

Claude Code Configuration and Workflows (Domain 2)

Claude Code is built on the Agent SDK's agentic loop, but it adds its own configuration layer: CLAUDE.md hierarchy, Agent Skills, hooks, and a permissions model that governs what the agent can and cannot do. This week gets those details right.

Topics

  • Claude Code architecture and execution
  • CLAUDE.md hierarchy and precedence
  • Agent Skills: SKILL.md and triggers
  • Hooks, permissions, and deny-wins rule
  • Agent SDK and CI/CD integration

Activities

  • Configure a project-level CLAUDE.md and a nested subdirectory CLAUDE.md. Verify which one wins for a file in the subdirectory by testing a real command.
  • Write one Agent Skill (SKILL.md with frontmatter) for a repeated task and trigger it successfully.
  • Configure a permission rule set and test what happens when a user-level deny meets a project-level allow. Confirm deny wins.
  • Integrate Claude Code into a CI/CD pipeline using non-interactive mode. Run a test commit through the pipeline.
  • Take the ExamOS Mock Exam in Challenger mode on Claude Code Configuration. Repeat until you pass 2 consecutive attempts.
W5

Week 5

Prompt Engineering, Structured Output, Context Management, and Reliability (Domains 3 and 5)

This week covers two closely related domains: how to structure prompts and outputs for reliability, and how to manage the context window over long-running sessions. These are the same discipline in practice: getting consistent, accurate responses from Claude at scale.

Topics

  • Prompt structuring with XML tags
  • Extended thinking and effort parameter
  • Structured output: constrained sampling vs tools
  • Context rot and management strategies
  • Prompt caching: breakpoints and invalidation

Activities

  • Implement native structured output (JSON schema) for one task and strict tool use for another. Write down when you would pick each approach and why.
  • Build a validator-and-retry loop that catches a schema violation and retries with corrective instructions. Test it with at least 3 malformed inputs.
  • Deliberately let a long-running agent's context grow past a reasonable size, observe the quality drop, then fix it with compaction. Document the quality difference.
  • Set up prompt caching on a stable system prompt and tool set. Confirm what a mid-session edit does or does not invalidate.
  • Take the ExamOS Mock Exam in Challenger mode on Prompt Engineering and Context Management. Repeat until you pass 2 consecutive attempts.
W6

Week 6

Exam Simulation and Booking

Your final push. Full exam simulation mode: filling in remaining gaps and building the confidence to book the exam.

Topics

  • Full syllabus review across all five domains
  • Time management (120 minutes for 60 questions)
  • Scenario reasoning under time pressure
  • All 6 official production scenarios

Activities

  • Take at least 3 ExamOS Mock Exams in Legend mode. Review every missed question and write one sentence naming the architectural principle behind the correct answer.
  • Simulate real exam conditions at least once: no notes, no breaks, 120 minutes, same time of day you plan to sit the exam.
  • Review all 6 official production scenarios. Only 4 appear per sitting, but you will not know which 4 in advance.
  • Identify your weakest domain from Mock Exam results and take 2 Bonus Quests on that domain.

Overview

The CCAR-F validates your ability to design and deploy production-grade Claude integrations. It tests architectural judgment in real-world scenarios, not definition recall. Questions are anchored in system design problems where you must choose the right approach, justify trade-offs, and reason about reliability, cost, and safety.

Knowing what a feature does is table stakes. Knowing when to use it and when to reach for an alternative is what the exam measures. If you already work with the Claude API and Claude Code, you have the hands-on foundation this plan assumes. It shifts your focus from "how do I use this feature?" to "when and why is this the right architectural choice?"

Domain Weight
Agentic architecture and orchestration 27%
Claude Code configuration and workflows 20%
Prompt engineering and structured output 20%
Tool design and MCP integration 18%
Context management and reliability 15%

Agentic architecture is the single largest domain and the one most candidates underestimate. It is also the conceptual foundation for how questions in other domains are framed. This plan dedicates two weeks to it.

Recommended experience: Approximately 6 months of hands-on experience with the Claude API and Claude Code. Understanding of LLM APIs, prompting fundamentals, and message roles.

Frequently Asked Questions (FAQ)

Do I need prior LLM experience?

Basic understanding of LLM APIs is helpful but not required. The certification covers Claude-specific concepts. Approximately 6 months of hands-on experience with the Claude API and Claude Code is a realistic baseline. Motivated candidates with less experience have passed with focused preparation.

Why does this plan dedicate two weeks to agentic architecture?

Because it is 27% of the exam and the conceptual foundation for every other domain. Tool design, context management, and Claude Code configuration all assume you understand agentic patterns. Candidates who skim this domain consistently underperform across the entire exam.

What if I have only 4 weeks to study instead of 6 weeks?

  • Week 1: Merge current Weeks 1-2 (all of Agentic Architecture). This is the biggest domain. Do not shortcut it, just move faster.
  • Week 2: Merge current Weeks 3-4 (Tool Design/MCP + Claude Code Configuration). These overlap conceptually (MCP servers show up inside Claude Code), so studying them back-to-back reinforces rather than fragments.
  • Week 3: Current Week 5 unchanged (Prompt Engineering + Context Management).
  • Week 4: Current Week 6 unchanged (Mock Exams + booking). Do not compress this. It is the gate that tells you whether you are ready.

How many practice questions should I do?

Aim for at least 600 unique questions across all domains, prioritizing quality over quantity. ExamOS provides scenario-based practice questions across every domain, designed to explain the rationale behind both correct and incorrect answers.

When should I book the exam?

Book when your readiness score is stable and above 80, and you have covered every domain at least once. Trust your preparation.

How long is the exam?

120 minutes for 60 questions. That averages to 2 minutes per question, but scenario-heavy questions with long context may take 3-4 minutes. Budget your time accordingly.

What are the core technologies tested?

Claude Code, Claude Agent SDK, Claude API, and Model Context Protocol (MCP).

How is this different from other AI certifications?

CCAR-F focuses on decision-making in production contexts, not definition recall. Every question is anchored in a scenario where you must choose the right architectural approach. Knowing what a feature does is table stakes. Knowing when to use it and when not to is what the exam measures.

What is the most important domain to study?

Agentic architecture and orchestration (27%) is the single largest domain and the conceptual foundation for how questions in other domains are framed. Tool design, context management, and Claude Code configuration all build on agentic patterns. Get this domain right first.

Can I use reference materials during the exam?

No. The CCAR-F exam is closed-book. You cannot access external documentation, websites, or AI assistants during the test. All questions are designed to be answerable from your knowledge of Claude architecture, the Claude API, Claude Code, and MCP.

What are the most common ways people fail?

  • Confusing agents with workflows. Knowing when agentic architecture adds value versus when a deterministic pattern is simpler and more reliable is tested constantly.
  • Ignoring token cost trade-offs in multi-agent systems. Parallel subagent dispatch is powerful but expensive. The exam tests whether you understand when the cost is justified.
  • Poor tool descriptions. Vague descriptions cause the model to misroute or fail to select the right tool. This is one of the most common failure scenarios.
  • Not understanding context rot. Assuming more context is always better is a trap. Long-running sessions degrade accuracy, and the exam tests whether you know how to fix it.
  • Studying features in isolation. The exam tests combined scenarios where multiple domains interact: an agent with MCP tools, structured output, and context management all in one question.

What are the three biggest preparation mistakes?

  1. Studying documentation without building. CCAR-F is a practical, scenario-based exam. If you have not built an agent loop, stood up an MCP server, or configured CLAUDE.md precedence, you will struggle with scenario questions.
  2. Skipping agentic architecture depth. It is 27% of the exam and the foundation for every other domain. Candidates who skim this domain consistently underperform.
  3. Not practicing under time pressure. 60 questions in 120 minutes means you cannot afford to deliberate on every question. Practice timed Mock Exams to build decision-making speed.