Claude Certified Architect Foundations CCAR-F Exam Questions

Claude Certified Architect – Foundations (CCAR-F) Exam Preparation Guide

The Claude Certified Architect – Foundations certification is an industry-recognized credential that validates a professional’s ability to architect, configure, and deploy production-grade solutions using Anthropic’s Claude ecosystem. This guide provides a comprehensive breakdown of the exam structure, content domains, core technical concepts, and preparation strategies necessary to achieve passing results on the official CCAR-F examination.

Overview of the Certification & Exam Specifications

The CCAR-F certification focuses on evaluating practical trade-off analysis, system design decisions, and architectural execution rather than simple rote memorization. Candidates are evaluated on their ability to design and implement real-world solutions built around four core technological pillars:

• Claude Code: CLI-based workflows, local and project-level configuration management, custom tooling, and automated software development environments.

• Claude Agent SDK: Multi-agent orchestration frameworks, programmatic lifecycle hooks, autonomous task loops, and subagent delegation patterns.

• Claude API: System prompt design, parameter tuning, context window optimization, and structured output formatting.

• Model Context Protocol (MCP): Standardized integration of custom tools, dynamic enterprise resource catalogs, and multi-server system architectures.

Questions are delivered using scenario-based items drawn from production use cases, including multi-agent research tools, automated customer service routing, enterprise data extraction pipelines, and CI/CD development automation.

Key Exam Details

Target Audience & Required Background

The CCAR-F exam is engineered for solution architects, senior software engineers, and AI technical leads who design and implement production software with Claude.

Prerequisites and Practical Experience

Candidates typically possess 6 or more months of hands-on experience developing with the Claude API, Claude Agent SDK, Model Context Protocol, and Claude Code. The ideal candidate routinely manages:

• Agentic Orchestration: Constructing complex multi-agent workflows with specialized subagents, task delegation rules, explicit lifecycle hooks, and contextual boundary enforcement.

• Tool Integration & MCP: Creating secure custom tools and resources using Model Context Protocol (MCP) standards for backend infrastructure integration.

• Claude Code Customization: Engineering team-level development environments using CLAUDE.md files, project-scoped slash commands, skills with isolated execution contexts, and custom MCP connections.

• Prompt Engineering & Data Formatting: Generating precise, validated structured outputs (e.g., JSON) using schemas, detailed extraction logic, and multi-shot examples.

• Context & Reliability Management: Building resilient applications with structured error reporting, human-in-the-loop escalation workflows, context-window optimization, and effective session state management.

Exam Content Outline & Domain Weighting

The examination content is divided across five key technical domains. Domain weights reflect the proportion of scoring items allocated to each core area.

                    CCAR-F Domain Weighting
┌─────────────────────────────────────────────────────────────┐
│ [Domain 1] Agentic Architecture & Orchestration     (27%)   │
├─────────────────────────────────────────────────────────────┤
│ [Domain 2] Tool Design & MCP Integration            (18%)   │
├─────────────────────────────────────────────────────────────┤
│ [Domain 3] Claude Code Configuration & Workflows    (20%)   │
├─────────────────────────────────────────────────────────────┤
│ [Domain 4] Prompt Engineering & Structured Output   (20%)   │
├─────────────────────────────────────────────────────────────┤
│ [Domain 5] Context Management & Reliability         (15%)   │
└─────────────────────────────────────────────────────────────┘

Detailed Core Domain Breakdown

Domain 1: Agentic Architecture & Orchestration (27%)

Domain 1 focuses on designing autonomous loops, managing multi-agent networks, and establishing deterministic control boundaries over model behavior.

Autonomous Loops and Control Flow

The core foundation of agentic systems is the agentic execution loop. A standard loop operates by sending user prompts and conversation state to the model, parsing the model's response, and checking the returned stop_reason:

• stop_reason: "tool_use": Indicates the model wants to call an external tool. The runtime must execute the requested tool using the provided input parameters, append the execution output to the conversation history as a tool result, and send the updated thread back to the model for the next reasoning step.

• stop_reason: "end_turn": Signals that the model has completed its processing loop and is returning its final response to the user.

Anti-Pattern Warning: Avoid using natural-language markers in response text, arbitrary loop-count limits, or assistant-text parsing as the primary mechanism for determining when an agentic task is complete. Instead, rely on the explicit structural signal provided by stop_reason.

Multi-Agent Topology: Hub-and-Spoke Coordinator Patterns

For multi-step, multi-domain tasks, a Hub-and-Spoke (Coordinator-Subagent) topology isolates concerns and limits context bloat.

                  ┌──────────────────────┐
                  │  Coordinator Agent   │
                  │ (Main Loop / Router) │
                  └──────────┬───────────┘
                             │ (Spawns via Task Tool)
       ┌─────────────────────┼─────────────────────┐
       ▼                     ▼                     ▼
┌──────────────┐      ┌──────────────┐      ┌──────────────┐
│  Subagent A  │      │  Subagent B  │      │  Subagent C  │
│ (Search Web) │      │ (Analyze Doc)│      │ (Synthesis)  │
└──────────────┘      └──────────────┘      └──────────────┘

• Context Isolation: Subagents do not automatically inherit the history or system state of the coordinator. Required prior findings (e.g., search outputs or document content) must be explicitly passed into the subagent's initialization prompt using clear schema markers to differentiate source data from metadata (such as URLs or IDs).

• Subagent Spawning: Coordinators spawn subagents by issuing a Task tool call. For a coordinator to invoke subagents, the Task tool must be explicitly included in its allowed tool array (allowedTools). Multiple Task tool calls can be issued within a single turn to run subagent execution paths in parallel.

• Communication Isolation: All subagent outputs must route directly back to the central coordinator. Subagents do not communicate peer-to-peer. This guarantees complete audit visibility, structured aggregation, and unified error handling.

Deterministic vs. Probabilistic Enforcement

When business rules require zero-defect compliance—such as verifying user identity before processing a financial refund—relying exclusively on prompt instructions introduces non-zero risk. High-stakes workflows require programmatic enforcement:

• Prerequisite Gates: Hardcoded application logic or programmatic hooks that intercept tool invocation attempts and block downstream operations until prerequisite state conditions are verified.

• SDK Lifecycle Hooks: Use SDK hooks like PostToolUse to inspect, alter, or validate tool call payloads programmatically before they reach external APIs or the model context.

• Human-in-the-Loop Escalation: When programmatic checks fail or ambiguity thresholds are breached, agents should build structured handoff payloads (containing verified customer details, action items, and clear error conditions) to pass context smoothly to a human operator.

Domain 2: Tool Design & MCP Integration (18%)

Domain 2 evaluates how to construct clean tool interfaces, expose external systems via Model Context Protocol (MCP), and optimize tool routing efficiency.

Tool Description Engineering

Because Claude relies primarily on tool descriptions to decide which tool to call, minimal or ambiguous tool descriptions lead directly to tool misrouting.

• Eliminate Overlap: Distinct tools must have clearly separated functional boundaries. For example, generic names like analyze_content and analyze_document cause misrouting; renaming them to extract_web_results and parse_pdf_text eliminates ambiguity.

• Provide Full Specifications: Descriptions should explicitly detail expected parameter formats, operational boundaries, edge case handling, and structural outputs.

• Avoid Keyword Sensitivities: Avoid system prompts containing repetitive keyword imperatives that accidentally trigger specific tool names out of context.

Scoped Tool Scopes and tool_choice Controls

Providing an agent with access to too many tools simultaneously (e.g., 18 tools instead of 4–5 specialized tools) increases decision space complexity and degrades tool choice precision.

• Role-Based Tool Scoping: Restrict each subagent's tool access strictly to its direct operational scope. A synthesis agent should not possess web search tools; rather, it can be provided a focused verification tool like verify_fact.

• tool_choice Configurations:

  • "auto": Default behavior; model decides whether to call a tool or return conversational text.

  • "any": Ensures that the model invokes at least one tool during the turn, preventing it from falling back to conversational text.

  • {"type": "tool", "name": "extract_metadata"}: Forces the model to execute the named tool on the current turn, establishing a deterministic initial step before processing follow-up actions.

Model Context Protocol (MCP) System Architecture

MCP simplifies system integration by standardizing how tools, data resources, and prompt templates are exposed to Claude.

┌──────────────────────────────────────────────────────────┐
│                      Claude Client                       │
└──────────────┬────────────────────────────┬──────────────┘
               │                            │
               ▼                            ▼
┌──────────────────────────┐    ┌──────────────────────────┐
│     Project-Scoped       │    │       User-Scoped        │
│        MCP Server        │    │        MCP Server        │
│     (.mcp.json file)     │    │    (~/.claude.json file) │
├──────────────────────────┤    ├──────────────────────────┤
│ Shared Team Workflows    │    │ Personal Utilities       │
│ Database Integrations    │    │ Experimental Tools       │
└──────────────────────────┘    └──────────────────────────┘

• Configuring Project vs. User Scopes: Project-level implementations belong in .mcp.json at the repository root, allowing team-wide sharing via version control. Personal or experimental tools reside in ~/.claude.json.

• Secret Management: Never check credentials directly into .mcp.json. Use environment variable expansion syntax (e.g., "${GITHUB_TOKEN}") to pull environment secrets at launch.

• MCP Resources: Expose structured data catalogs (such as database schemas, documentation indexes, or project issue hierarchies) as MCP Resources rather than tools. Resources allow the agent to read context upfront without spending execution turns issuing repetitive exploratory tool calls.

Structuring Failure Responses (isError)

When an MCP tool encounters an error, returning a uniform generic message (e.g., "Operation failed") deprives the model of the information it needs to attempt recovery.

{
  "isError": true,
  "content": [
    {
      "type": "text",
      "text": "Database query timed out after 5000ms."
    }
  ],
  "meta": {
    "errorCategory": "transient",
    "isRetryable": true,
    "suggestedAction": "Retry request with an increased timeout value or narrower filter range."
  }
}

By providing structured metadata such as errorCategory and isRetryable, the model can distinguish between temporary system failures that are worth retrying and permanent permission or business-rule violations that require immediate escalation or user notification.

Domain 3: Claude Code Configuration & Workflows (20%)

Domain 3 covers configuring local workspace environments, managing execution context hierarchy, writing custom execution rules, and operating automation tasks.

The CLAUDE.md Architectural Hierarchy

CLAUDE.md files provide system guidelines, architectural rules, testing standards, and style guides to Claude Code sessions.

       ┌─────────────────────────────────────────────────┐
       │     User Global (~/.claude/CLAUDE.md)           │
       │    (Applies strictly to local user setup)       │
       └────────────────────────┬────────────────────────┘
                                │
                                ▼
       ┌─────────────────────────────────────────────────┐
       │     Project Level (.claude/CLAUDE.md)           │
       │     (Shared across team via repository)         │
       └────────────────────────┬────────────────────────┘
                                │
                                ▼
       ┌─────────────────────────────────────────────────┐
       │     Directory Sub-Scope (src/api/CLAUDE.md)     │
       │    (Overrides/applies to sub-tree only)         │
       └─────────────────────────────────────────────────┘

To maintain clean modular configurations:

• Use the @import directive inside project files to conditionally import targeted sub-documents (e.g., @import .claude/standards/database.md).

• Break large, monolithic CLAUDE.md configurations into dedicated, single-purpose rule sets within the .claude/rules/ directory.

• Run the /memory command inside a session to inspect currently active rule files and debug unexpected context or rule evaluation issues.

Path-Specific Rules with YAML Frontmatter

Rather than loading all development standards into memory at once, use path-scoped rules in .claude/rules/. Adding YAML frontmatter containing glob patterns ensures that contextual rules load only when files matching those paths are being inspected or edited:

---
paths:
  - "src/api/**/*.ts"
  - "tests/api/**/*.test.ts"
---
# API Development Standards
- All endpoints must enforce strict input schema validation via Zod.
- Standardized error handlers must wrap all async route implementations.

Custom Slash Commands and Isolated Skills

Extend developer workflows using project-scoped automation tools:

• Slash Commands: Stored in .claude/commands/, these commands allow developers to run reusable team workflows from the CLI.

• Skills Framework: Defined in .claude/skills/SKILL_NAME/SKILL.md, skills support frontmatter configuration options including allowed-tools, argument-hint, and context: fork.

Key Architectural Pattern: Setting context: fork inside a skill's frontmatter forces the skill to run inside an isolated sub-agent context. This prevents verbose file searches, long stack traces, or exploratory analysis from cluttering the primary development thread's context window.

Choosing Plan Mode vs. Direct Execution

• Plan Mode: Ideal for complex modifications, multi-file architectural refactoring, technology migrations, or high-ambiguity tasks. Plan mode uses the Explore subagent to inspect code bases cleanly, returning structured proposal summaries without exhausting context memory.

• Direct Execution: Best suited for well-scoped, localized tasks with predictable edits (e.g., adding a single conditional check to a function or fixing a localized syntax error).

Domain 4: Prompt Engineering & Structured Output (20%)

Domain 4 focuses on designing reliable prompts, extracting structured data from unstructured inputs, and validating JSON output consistency.

Guarantees for Structured Output Generation

Extracting reliable JSON or schema-conforming structural data from unstructured inputs requires a multi-layered design strategy:

1. JSON Schema Enforcement: Pass formal JSON schemas alongside extraction requests to establish unambiguous typing, mandatory field lists, and formatting rules.

2. Few-Shot Demonstration Examples: Provide 2–3 concrete input/output examples inside system prompts. Showing real transformation targets resolves edge-case ambiguities far more effectively than descriptive prose alone.

3. Syntactic Isolation Markers: Use clear XML tags (e.g., <source_document>, <extraction_rules>, <output_format>) to isolate user inputs from systemic instructions, guarding against prompt injection and context confusion.

Effective Iterative Refinement Patterns

• Test-Driven Iteration: Write validation test suites first. Share specific test outputs and failure messages directly with Claude to guide precise, code-level adjustments.

• The Interview Pattern: Before initiating large-scale task execution, instruct Claude to ask clarifying questions about unspecified edge cases, caching behavior, or unexpected failure modes.

• Interacting vs. Independent Bug Fixes: When fixing independent bugs, present items sequentially across separate turns. However, when addressing tightly coupled, interacting issues, present all error details together in a single prompt so the model can reason about overall system balance.

Domain 5: Context Management & Reliability (15%)

Domain 5 examines strategies for context compression, state recovery, and automated continuous integration pipeline engineering.

Optimizing Context Window Usage

Context window bloat slows generation speed, increases operational costs, and risks degradation of attention across long context spaces.

           Context Management Trade-off Matrix
┌──────────────────────┬──────────────────────────────────────────┐
│ Management Approach  │ Key Characteristics & Architectural Use  │
├──────────────────────┼──────────────────────────────────────────┤
│ Named Resumption     │ Reconnects to an existing thread via     │
│ (--resume <name>)    │ --resume. Preserves historical flow when │
│                      │ prior state remains fully valid.         │
├──────────────────────┼──────────────────────────────────────────┤
│ Session Forking      │ Clones historical context into new       │
│ (fork_session)       │ branch; ideal for testing alternative    │
│                      │ implementations from a shared baseline.  │
├──────────────────────┼──────────────────────────────────────────┤
│ Clean Session +      │ Clears stale tool results and bloated    │
│ Context Summaries    │ execution logs; re-injects a concise     │
│                      │ structured summary into a fresh session. │
└──────────────────────┴──────────────────────────────────────────┘

Best Practice: When resuming a session after files have been edited locally, explicitly supply Claude with a summary of modified paths. This avoids forcing the model to perform broad re-exploration of the repository using tool searches.

Continuous Integration Pipeline Execution

Integrating Claude Code into headless CI/CD automation pipelines requires non-interactive execution flags:

--p / --print: Runs Claude Code in non-interactive batch mode, returning output directly to stdout.

--output-format json: Formats execution results as structured JSON suitable for downstream parsing by automated pipeline stages.

--json-schema: Enforces explicit schema compliance on response payloads, ensuring reliability when parsing test results or automated code review feedback.

Scenario Mapping & Practical Applications

The CCAR-F examination tests conceptual knowledge through scenario-driven items based on realistic enterprise architectures. The table below outlines the core scenarios evaluated during the exam:

Strategic Preparation & Practical Study Plan

To maximize your performance on the CCAR-F exam, follow this practical, multi-week study approach:

               CCAR-F Preparation Roadmap
┌─────────────────────────────────────────────────────────┐
│ Week 1: Core Fundamentals & API Architecture            │
│ ├─ Study stop_reason mechanics & loop control flow       │
│ └─ Practice structured JSON output & schema validation  │
├─────────────────────────────────────────────────────────┤
│ Week 2: Agentic Orchestration & SDK Implementation    │
│ ├─ Build Hub-and-Spoke multi-agent research tools       │
│ └─ Implement SDK lifecycle hooks & prerequisite gates   │
├─────────────────────────────────────────────────────────┤
│ Week 3: Tool Design & Model Context Protocol (MCP)      │
│ ├─ Design scoped tools & write clear descriptions       │
│ └─ Build custom MCP servers with resources & isError    │
├─────────────────────────────────────────────────────────┤
│ Week 4: Claude Code Environment & CI/CD Pipelines       │
│ ├─ Configure CLAUDE.md hierarchy & .claude/rules/ paths │
│ └─ Implement headless CI/CD execution (-p, --json-schema)│
└─────────────────────────────────────────────────────────┘

Essential Exam Checklist

Before scheduling your examination, ensure you can independently execute the following hands-on tasks:

[ ] Construct a complete, non-terminating agentic execution loop that evaluates stop_reason signals correctly.

[ ] Implement a Hub-and-Spoke multi-agent system using the Task tool with explicitly scoped context payloads.

[ ] Write unambiguous tool descriptions and apply tool_choice settings to guide tool invocation.

[ ] Construct a custom MCP server featuring structured error handling (isError) and dynamic resource endpoints.

[ ] Organize a multi-tier CLAUDE.md setup utilizing @import directives, .claude/rules/ path scoping, and custom skills using context: fork.

[ ] Configure a headless Claude Code script for automated CI/CD pipeline execution using the -p and --json-schema flags.

Frequently Asked Questions (FAQs)

What is the validity period of the CCAR-F credential?

The Claude Certified Architect – Foundations credential remains valid for 12 months from the date it is awarded. Candidates must recertify annually to maintain active status.

What is the passing score for the CCAR-F examination?

The passing score is a scaled score of 720 on a scale ranging from 100 to 1,000. Candidates receive an official pass/fail result along with domain-by-domain percentage breakdowns upon completion.

How is the exam structured?

The exam consists of 60 multiple-choice and multiple-response items delivered over a 120-minute testing window. Questions are contextualized around 4 scenario blocks drawn randomly from a master bank of 6 production scenarios.

Can I use external documentation or reference guides during the exam?

No. The CCAR-F exam is a fully proctored examination (delivered online or at testing centers). Access to external websites, documentation, personal notes, or AI assistants is strictly prohibited during the test session.