CCAR-F Course Overview

Exam code CCAR-F 60 items · 120 min $125 Pass 720/1000

What the credential validates

That you can design agentic systems on Claude that are correct, reliable and cost-aware – choosing between workflows and agents, orchestrating coordinator/subagent hierarchies, configuring Claude Code for teams, engineering prompts and structured output, designing tools and MCP integrations, and managing the context window and failure modes that make or break production systems.

The Architect – Foundations exam is scenario-driven. Items are drawn from 4 of 6 reference scenarios, so you must be able to reason about a described system, not just recall a definition. Every question is really asking: given these constraints, what is the correct architectural decision, and which tempting options are the anti-patterns?

Intended for: solutions architects, technical leads and senior engineers who design Claude-based agentic systems and set standards for teams building with the API, the Agent SDK, Claude Code and MCP.

Not intended for: non-technical business users (see CCAO-F Associate) or those who only write application code without designing the system (much of CCDV-F Developer overlaps but is implementation-first).

Blueprint (Exam Guide v1.0, July 2026)

#	Domain	Weight	Items (approx.)	Course page
1	Agentic Architecture and Orchestration	27%	~16	Domain 1
2	Claude Code Configuration and Workflows	20%	~12	Domain 2
3	Prompt Engineering and Structured Output	20%	~12	Domain 3
4	Tool Design and MCP Integration	18%	~11	Domain 4
5	Context Management and Reliability	15%	~9	Domain 5

The six exam scenarios

Items are drawn from 4 of the 6 scenarios below. You will not know in advance which four, so prepare all six. Each maps to a cluster of domains.

#	Scenario	Primary domains	Signature decisions
1	Customer Support Resolution Agent	D1, D4, D5	Agent SDK, MCP tools, capability-based escalation
2	Code Generation with Claude Code	D2, D3	CLAUDE.md hierarchy, plan mode, slash commands, hooks
3	Multi-Agent Research System	D1, D5	Coordinator/subagent, explicit context passing, partial-failure handling
4	Developer Productivity	D2, D4	Built-in tools, MCP servers, codebase exploration
5	Claude Code for CI/CD	D2, D3	Headless mode, structured output, Batch API, multi-pass review
6	Structured Data Extraction	D3, D4	JSON schemas, tool_use-as-schema, validation-retry

Full write-ups, reference architectures and 18 practice questions are on the Scenarios page.

The Architect’s mindset

The exam rewards one posture repeatedly: determinism where correctness matters, the model where judgment matters, and explicit contracts everywhere between them. Correct answers tend to:

• Prefer the simplest solution that meets the requirement – a single prompt or workflow before a multi-agent system.
• Drive control flow from stop_reason, not from parsing the model’s prose or capping iterations.
• Enforce critical business rules with programmatic hooks, never with prompt instructions.
• Escalate on explicit request (immediately) or capability (after attempting resolution) – never on sentiment or self-reported confidence.
• Pass context to subagents explicitly; never rely on auto-inheritance.
• Surface structured errors (category, retryable, partial results) rather than generic messages or silent empty results.
• Give each agent 4–5 focused tools; use tool search and defer_loading beyond ~10.
• Protect the main context window with subagent isolation, context editing and compaction, and put anything that must survive in the memory tool or external state.

Wrong answers tend to: over-engineer (multi-agent where a workflow suffices), trust the model’s self-report, enforce rules by prompt, hide errors, overload agents with tools, and let the context window fill until quality degrades.

Suggested time allocation (30-hour plan)

Domain	Weight	Hours
Agentic Architecture and Orchestration	27%	9
Claude Code Configuration and Workflows	20%	6
Prompt Engineering and Structured Output	20%	6
Tool Design and MCP Integration	18%	5
Context Management and Reliability	15%	4

Hands-on preparation checklist

• Build a two-tier coordinator/subagent system and pass context to a subagent explicitly; observe what breaks if you rely on inheritance.
• Implement an agentic loop that terminates on stop_reason and handles tool_use, end_turn, max_tokens, pause_turn and refusal.
• Write a Claude Code PreToolUse hook that blocks rm -rf and a PostToolUse hook that runs a linter; confirm exit code 2 blocks the action.
• Configure a project CLAUDE.md hierarchy with an @import and a .claude/agents/ subagent with its own tool allowlist and model.
• Get structured output three ways – output_config.format JSON schema, tool-use-as-schema, and strict tools – and note when each is correct.
• Stand up a minimal MCP server (stdio) exposing one tool and one resource; connect it from Claude Code and via the Messages API MCP connector.
• Force a validation-retry loop: return a schema error to the model and confirm it self-corrects.
• Trigger compaction and context editing on a long session; verify what survives via the memory tool.

Course pages