CCA-F Study Guide 2026: How to Pass the Claude Certified Architect Foundations Exam

CCA-F isn't a credential about prompt engineering or "AI literacy." It's a credential about architecting production systems on Claude — the way an AWS Solutions Architect Associate certifies you can architect on AWS. The exam assumes you've actually built things, and the case-study questions reward candidates who can defend trade-offs rather than recite vocabulary.

If you're studying for CCA-F, you're probably already coding against the Claude API. This guide helps you focus the rest of your prep where the exam actually weights it.

CCA-F at a glance

The five exam domains and their published weights:

• Claude API fundamentals (20%)
• Tool use, MCP, and external integration (25%)
• Claude Agent SDK and agent architecture (25%)
• Claude Code and developer workflows (15%)
• Production patterns: caching, safety, cost, evaluation (15%)

Notice the weight distribution. Tool use + Agent SDK together are 50% of the exam. If your prep time isn't half on those two domains, you're under-prepared.

Domain 1: Claude API fundamentals (20%)

This is the foundation domain. You can't reason about agent architecture if you don't understand the underlying API model. Key topics:

• The Messages API — request/response structure, the role system (user, assistant, system), conversation turns, and how Claude maintains context within a single API call.
• System prompts — placement, format, and what belongs in a system prompt vs. a user message. The exam tests the architectural distinction, not the prose.
• The current Claude model family — Opus, Sonnet, Haiku, Fable. Each has a current generation (4.x family) and a model ID format (claude-opus-4-8, claude-sonnet-4-6, claude-haiku-4-5-20251001, claude-fable-5). Know which model fits which workload — Opus for hard reasoning, Sonnet for general intelligence, Haiku for fast/cheap, Fable for specialized tasks.
• Streaming — when to use streaming responses, how Server-Sent Events work, and how to handle partial outputs in a UI.
• Token economics — input vs. output token pricing, the cost asymmetry (output tokens are typically more expensive), and why this matters for architecture decisions.
• Rate limits and retries — token-per-minute and request-per-minute limits, exponential backoff, and how to architect for graceful degradation.

Common mistake: Memorizing exact prices. Anthropic adjusts pricing over time; the exam tests which model class is more expensive than which, not the absolute numbers.

Domain 2: Tool use, MCP, and external integration (25%)

This is the heaviest single domain after Agent SDK. Tool use is what turns Claude from "smart chat" into "production system."

Tool use basics

• How to define a tool (name, description, input schema)
• The tool-call → tool-result loop and how to wire it
• When Claude refuses to use a tool, and how to design tools that get used reliably
• Parallel tool calls vs. sequential tool calls
• Error handling — what to do when a tool returns an error

Model Context Protocol (MCP)

MCP is a heavy topic on the exam. You need to know:

• What MCP is — an open protocol for connecting AI applications to external data and tools, decoupled from any one model provider.
• The three primitives — Resources (data the model can read), Tools (actions the model can take), and Prompts (reusable templates).
• Server vs. client architecture and how the JSON-RPC handshake works.
• When to recommend MCP over a custom tool integration — typically when multiple applications need to share the same external integration, or when you want vendor portability.
• Security implications — MCP servers can do anything within their scope; authorization design matters.

Common tool integration patterns

• Read-only context tools (search, retrieval, documentation lookup)
• Write tools (creating tickets, sending messages, updating records)
• Reflection tools (the model calling tools to verify its own work)
• Decomposition tools (breaking a task into sub-tasks routed to specialists)

Domain 3: Claude Agent SDK and agent architecture (25%)

Claude Agent SDK is Anthropic's official library for building production agents. The SDK exposes the same primitives Claude Code uses internally — subagents, tool calling, hooks, sessions, MCP integration, and policy controls.

Key concepts to internalize:

• The agentic loop — perceive (read context), reason (call the model), act (use tools), observe (process results), repeat. The exam will test whether you can identify which step fails when an agent produces bad output.
• Subagents — when a parent agent delegates to a child agent with its own system prompt, tools, and context window. Useful for isolation, parallelization, and specialization.
• Hooks — lifecycle callbacks that fire at specific points (before tool call, after tool call, before message, after message). Used for logging, observability, validation, policy enforcement.
• Session management — persisting agent state across user requests. Compare to chat-style conversations and identify when long-lived sessions make sense.
• Policy controls — allowedTools and disallowedTools at the SDK level. Critical for safety in production deployments.
• Memory tool — Claude's built-in tool for persisting facts across sessions in a structured way.

For a deeper conceptual primer, see our Claude Agent SDK introductory post.

Domain 4: Claude Code and developer workflows (15%)

Claude Code is Anthropic's official CLI for software engineering. CCA-F tests architectural understanding of Claude Code, not power-user keyboard shortcuts.

Topics:

• How Claude Code structures sessions, tasks, and outputs
• The slash-command system and skill mechanism
• MCP integration in Claude Code (the same MCP from Domain 2)
• Permission modes and how they affect tool execution
• Settings hierarchy — global, project, local — and what overrides what
• Hooks in Claude Code (PreToolUse, PostToolUse, SessionStart, etc.)
• How to integrate Claude Code into a CI pipeline or developer workflow

You don't need to memorize every slash command. You do need to understand the design — Claude Code is an opinionated agent SDK with a CLI front-end, and the exam tests whether you can reason about that design.

Domain 5: Production patterns (15%)

This domain bundles four critical operational topics. Smallest weight in the curriculum, but the highest density of "this is what working in production teaches you" knowledge.

Prompt caching

• How prompt caching works — repeated portions of input are cached and re-billed at a discount
• Cache control — cache_control: { "type": "ephemeral" } markers, the 5-minute TTL, the 1-hour extended option
• When caching pays back — long system prompts, RAG context, multi-turn conversations with stable preamble
• Cost savings math — roughly 90% on cached input tokens after the first call

Safety and policy

• Anthropic's policy framework and how it interacts with your own product policies
• Designing for refusals — Claude will sometimes refuse; how to handle gracefully
• Prompt injection defense — input sanitization, output validation, separation of trusted vs. untrusted content
• Constitutional AI's role in Claude's training, at the conceptual level

Cost engineering

• Picking the right model for the workload (Opus for hard, Sonnet for general, Haiku for cheap/fast)
• Trimming context — RAG vs. full-document, recent N turns vs. summarized history
• Batching where possible
• Using prompt caching aggressively for repeated context

Evaluation

• Building eval sets for agentic systems
• LLM-as-judge patterns and their limitations
• Regression testing when you change models or prompts
• Production telemetry — what to log, what to alert on

An 8-week study plan

This assumes 10–15 hours per week and existing developer experience (Python or TypeScript).

Weeks 1–2: Claude API fundamentals

Build something small with the raw Messages API. A CLI tool, a small Slack bot, a structured-output extractor. Read the official Messages API documentation end-to-end. Get fluent with streaming, system prompts, and the model-selection trade-offs.

Weeks 3–4: Tool use and MCP

Add tool use to your week-1 project. Then build an MCP server (the official MCP docs include quick-starts in TypeScript and Python). Wire your MCP server to Claude Code as a smoke test. You should be able to explain MCP's three primitives without referring to docs.

Weeks 5–6: Claude Agent SDK

Read through the Agent SDK documentation, then build a small two-agent system — a parent agent that delegates to a subagent. Wire hooks for logging. Use allowedTools to restrict the subagent's capabilities. This is the prep that pays back hardest on the exam.

Week 7: Claude Code + production patterns

Spend a week actively using Claude Code — install it, configure permissions, build a custom skill or slash command, integrate with at least one MCP server. Read about prompt caching and refactor your week-1 project to use cache markers. Estimate the cost savings.

Week 8: Practice tests and gap filling

Take practice tests under exam conditions. Note every question you miss. Return to the relevant domain documentation. Re-test. Most candidates who fail CCA-F under-prepare in Tool Use + MCP or in Agent SDK; if your weak spots are there, address them before sitting the real exam.

Pitfalls

• Treating CCA-F as a prompt-engineering exam. It's not. The questions test architecture and operations.
• Skipping the SDK domain. Twenty-five percent of the exam is Agent SDK. Hands-on time with the SDK is non-negotiable.
• Memorizing prices. Anthropic's pricing evolves. Know relative costs (Opus > Sonnet > Haiku) and the structural facts (input vs. output asymmetry, cache discount).
• Confusing MCP with custom HTTP integrations. They have different design properties. The exam will test whether you can choose between them in scenarios.
• Ignoring evals. Production patterns are 15% of the exam, and evals show up in multiple case studies.

Related reading

• What is the Claude Agent SDK? A beginner's primer
• The 30-day CCA-F study plan
• 10 free CCA-F sample questions to test your readiness
• CCA-F vs. other AI architect certs (AB-100, AIF-C01, Databricks)

FAQ

How does CCA-F compare to AWS, Microsoft, or Databricks AI certs?

CCA-F is the only certification specifically focused on the Claude ecosystem. AWS AIF-C01 covers general AI literacy on AWS; Microsoft AB-100 covers agentic architecture on the Microsoft stack; Databricks DEA covers data engineering with ML components. They're complementary, not competitive. See our comparison post for the full breakdown.

Do I need to know Constitutional AI in detail?

At a conceptual level only — what it is, why Anthropic uses it, how it shapes Claude's training. You don't need to recite the original paper.

How many tool-use questions appear on the exam?

Tool use + MCP is 25% of the exam, so expect roughly 15 questions out of 60. Several will be embedded in case studies.

Are there any prerequisites?

Officially none. Practically, you need developer fluency in Python or TypeScript and at least 40 hours of hands-on Claude API time before the exam will feel reasonable.

Is the exam updated regularly?

Anthropic has indicated annual updates. The first content refresh is expected in early 2027 to incorporate any major API or SDK changes from late 2026.

What happens if I fail?

You can retake after 14 days. Anthropic offers a retake at a reduced fee for the first retake within 60 days of the original attempt.

What about CCA-A (the Advanced exam)?

Anthropic has not yet announced a CCA-A. CCA-F is the only Anthropic credential available as of mid-2026. An Advanced-tier credential is rumored for 2027 — but treat that as speculation, not roadmap.

The bottom line

CCA-F is a real architectural exam — not a vocabulary test, not a prompt-engineering quiz. It rewards candidates who've built something with the Claude API, used the Agent SDK in anger, integrated MCP into a real workflow, and engineered for cost and safety in production.

Eight weeks of focused study works for someone with prior developer experience. Lighter prep usually shows up as gaps in Tool Use, MCP, or Agent SDK — the heavy-weighted domains. Build something with each of those three before the exam, and the rest of the prep follows naturally.