Claude Certified Architect: Complete Exam Guide

The Claude Certified Architect, Foundations (CCA-F) is Anthropic's first professional certification, launched 12 March 2026. If you are preparing for the exam, this guide covers every domain, the exact format, the anti-patterns the exam emphasises, and a study strategy grounded in the official weighting. We keep the advice concrete because the exam rewards concrete thinking.

What is the exact format of the CCA-F exam?

The exam consists of 60 scenario-based multiple-choice questions. Each question has one correct answer and three plausible distractors. There are no free-response or drag-and-drop items. The score scale runs from 100 to 1000, and the passing score is 720. Anthropic does not publish the raw-to-scaled conversion formula, so we do not state an exact question count as the pass mark. The exam is delivered online-proctored or at a test centre, and a single attempt costs $99. Tiered Anthropic partners receive a discounted first attempt.

As of 3 June 2026, more than 10,000 individuals have earned the certification, and over 40,000 firms have applied to the Claude Partner Network, the $100M programme that houses the credential.

How are the five exam domains weighted?

The exam blueprint divides 60 questions across five domains. Understanding the weights tells you where to invest study time.

Domain 1 alone accounts for more than a quarter of the exam. Combined with Domain 3 and Domain 4, those three domains represent 67% of the total score. That does not mean you can ignore Domains 2 and 5; the exam is scenario-based, and a single question can draw on multiple domains simultaneously.

Our Claude Certification Concepts library maps 174 atomic concepts to these five domains and 30 task statements, so you can study at the granularity the exam actually tests.

How should architects choose between agentic loops, subagents, and multi-agent orchestration?

Choose the simplest topology that satisfies the reliability and latency requirements of the task. A single agentic loop is appropriate when the task is sequential and the state fits comfortably in one context window. Subagents become necessary when subtasks are independent enough to run in parallel or when context isolation is required to prevent one subtask's noise from corrupting another's reasoning. Multi-agent orchestration with a coordinator is warranted when tasks are heterogeneous, require specialised models, or exceed what any single context window can hold reliably.

The exam consistently rewards deterministic solutions over probabilistic ones when stakes are high. If a question asks how to enforce a compliance rule, a programmatic hook beats a prompt instruction every time. If a question asks how to detect loop termination, inspecting the stop_reason field beats parsing the model's natural-language output.

The Agentic Architecture & Orchestration domain covers the full decision tree: when to use a hub-and-spoke architecture, how to handle parallel subagent spawning, and how to design prerequisite gates that prevent downstream failures.

What agentic anti-patterns does the exam emphasise?

The exam is explicit about several failure modes:

1. Parsing natural language for loop termination. Always inspect stop_reason; never rely on the model saying "I am done."
2. Same-session self-review. A model reviewing its own output in the same context window cannot catch its own blind spots. The exam expects an independent review instance.
3. Narrow decomposition failure. Splitting a task into subtasks that are too granular causes the coordinator to lose the broader goal. The narrow decomposition failure concept explains the boundary.
4. Attention dilution. Providing too many tools or too much irrelevant context degrades reasoning quality. The attention dilution problem is a tested concept.
5. Stale context. Long-running sessions accumulate outdated facts. The fix is structured summarisation, not simply extending the context window.

What are the best practices for MCP tool design?

Good tool design starts with the tool description, not the tool implementation. Claude selects tools based on their descriptions, so an ambiguous description causes misrouting before any code runs. The exam tests this directly: given a symptom (wrong tool called), identify the root cause (description too broad) and the proportionate fix (split or rewrite the description, not restructure the whole system).

Key principles the exam rewards:

• Tool splitting for specificity. One tool that does two things will be called for the wrong one. Split it.
• Structured error metadata. When a tool fails, return a structured error object with an isError flag and a category. Do not return a natural-language apology string.
• Scoped tool distribution. Give each agent only the tools it needs. A research subagent does not need write access to a production database.
• MCP scoping hierarchy. Understand which configuration level (user, project, workspace) governs which tools, and why environment variable expansion matters for secrets.

{
  "isError": true,
  "errorCategory": "access_failure",
  "message": "Read permission denied on /data/reports/q1.csv",
  "retryable": false
}

The Tool Design & MCP Integration domain covers all of these patterns. Pay particular attention to the distinction between an access failure and a valid empty result; the exam uses that distinction to test whether you understand what the model should do next.

How should Claude Code be configured in practice?

Claude Code uses a three-level configuration hierarchy: workspace-level CLAUDE.md, project-level CLAUDE.md, and user-level personal configuration. Rules at a lower level can override or extend rules at a higher level. The exam tests whether you know which level to use for which concern.

Practical configuration principles:

1. Put shared conventions (coding style, test framework, branch naming) in the workspace-level CLAUDE.md so every contributor inherits them.
2. Put path-specific rules (for example, "never modify files under /legacy") in a project-level CLAUDE.md with YAML frontmatter scoping.
3. Put personal preferences (verbosity, preferred editor commands) in user-level configuration, which is not committed to version control.
4. Use plan mode for high-risk operations. Plan mode surfaces the intended changes before execution, which is the correct answer whenever the exam asks how to reduce irreversible mistakes.
5. In CI/CD pipelines, use the -p flag for non-interactive mode and emit structured JSON output so downstream steps can parse results deterministically.

# Run Claude Code non-interactively in CI, emit structured output
claude --non-interactive -p "Run tests and return a JSON summary" \
  --output-format json > test-summary.json

The Claude Code Configuration & Workflows domain includes the three-level hierarchy and version control implications in detail.

What prompt patterns work best for structured output and reliable decision-making?

Structured output reliability depends on three layered techniques, applied in order of leverage:

1. Schema definition. Provide an explicit JSON schema in the system prompt. This is the highest-leverage single change for extraction and classification tasks.
2. Few-shot examples. For ambiguous edge cases, two or three worked examples outperform additional instruction prose. The exam treats few-shot as the correct answer when a schema alone is insufficient.
3. Validation-retry loops. When output must be machine-consumed, validate against the schema programmatically and retry with the error fed back into the prompt. Do not silently suppress validation failures.

import anthropic, json, jsonschema

schema = {
    "type": "object",
    "properties": {
        "intent": {"type": "string", "enum": ["refund", "escalate", "resolve"]},
        "confidence": {"type": "number", "minimum": 0, "maximum": 1}
    },
    "required": ["intent", "confidence"]
}

client = anthropic.Anthropic()

def classify_with_retry(text: str, max_attempts: int = 2) -> dict:
    for attempt in range(max_attempts):
        response = client.messages.create(
            model="claude-opus-4-5",
            max_tokens=256,
            messages=[{"role": "user", "content": text}]
        )
        try:
            parsed = json.loads(response.content[0].text)
            jsonschema.validate(parsed, schema)
            return parsed
        except (json.JSONDecodeError, jsonschema.ValidationError) as e:
            if attempt == max_attempts - 1:
                raise
            text = f"Previous output was invalid: {e}\n\nOriginal request: {text}"
    return {}

The Prompt Engineering & Structured Output domain covers schema design, few-shot construction, and the validation-retry pattern in depth.

How do you manage context and reliability in long-running workflows?

Context degradation is one of the most tested reliability concerns. In extended sessions, early facts get pushed toward the edges of the context window, where attention is weaker. The exam calls this the lost-in-the-middle effect, and it expects you to address it architecturally rather than by simply increasing max_tokens.

Effective strategies:

• Summary injection. At session boundaries, compress prior context into a structured summary and inject it at the top of the new session. This is preferable to resuming a stale session for tasks that span hours or days.
• Subagent context isolation. Each subagent receives only the context relevant to its subtask. The coordinator passes structured handoffs, not raw conversation history.
• Persistent scratchpad files. For large-codebase tasks, write intermediate findings to files rather than accumulating them in the context window.

The Context Management & Reliability domain covers session management options, the stale context problem, and when to resume versus fork versus start fresh.

What scenario types appear most often on the exam?

The exam uses five recurring scenario archetypes. Recognising the archetype quickly narrows the answer space.

For each archetype, the exam rewards root-cause tracing (identify the actual failure point) and proportionate fixes (the smallest change that resolves the problem). A question that describes a misrouted tool call is answered by fixing the tool description, not by redesigning the agent topology.

How should you structure your study plan?

Given the domain weights, we recommend the following allocation for a four-week preparation period:

Our practice exams at AI Skill Certs are 60 questions, scored on the same 100 to 1000 scale with 720 as the passing bar, matching the real exam format exactly. The adaptive engine uses Bayesian Knowledge Tracing with a 0.90 mastery threshold, so it surfaces the concepts you have not yet consolidated rather than repeating ones you already know. Archie, our Socratic tutor, guides you through the reasoning behind each answer without simply giving it away.

AI Skill Certs is an independent prep platform and is not affiliated with, endorsed by, or approved by Anthropic.