Skip to content
7×7AI7x7
FoundationsArchitect trackCCAR-F

Claude Certified Architect – Foundations

Architect – Foundations tests whether you can design and build production agentic systems with Claude: multi-agent orchestration, tool and MCP design, Claude Code configuration for teams, structured extraction pipelines and the context and reliability patterns that keep them honest. It is scenario-based — each sitting draws four of six published scenarios — so the questions read like design reviews, not trivia.

Intended audience: Solution architects who design and implement production applications with Claude.

Exam code
CCAR-F
Level
Foundations
Official fee
$125
Paid to Anthropic, not AI7x7
Duration
120 minutes
Questions
60 items
4 scenarios drawn at random from a bank of 6
Format
Multiple choice & multiple response
Passing score
720 scaled
Scale 100–1,000
Validity
12 months

Verified against official exam guide version 1.0 (effective July 2026) on 4 November 2026.

Eligibility, prerequisites and registration

Official exam registration is through the Anthropic Partner Academy and is described by Anthropic as available to members of the Claude Partner Network (membership is free; firms join at claude.com/partners). AI7x7 resources may be used by anyone for learning and preparation.

Prerequisites: No formal prerequisites listed.

Delivery: Proctored, online (Pearson OnVUE) or at a Pearson VUE test centre. Waiting periods of 14 days after the first failed attempt, 30 days after the second, 90 days after the third. Maximum four attempts per exam in any rolling 12-month period. Fee applies to each attempt.

Who should take this

Built for people who do this work

  • Solution architects designing Claude-based applications and agent systems
  • Senior engineers who own the Agent SDK, MCP and Claude Code setup for a team
  • Technical leads responsible for extraction, review or research pipelines built on Claude
  • Developers who passed Developer – Foundations (or have equivalent experience) and now design rather than only implement

Recommended experience

  • — 6+ months of practical experience with the Claude APIs, Agent SDK, Claude Code and MCP

What it validates

A pass shows that

  • You can design an agentic loop and a coordinator–subagent system with sensible task decomposition and handoffs
  • You can design tools and MCP integrations with clear boundaries, structured errors and the right distribution across agents
  • You can configure Claude Code for a team: CLAUDE.md hierarchy, custom commands and skills, path-specific rules, plan mode, CI/CD integration
  • You can enforce structured output with tool use and JSON schemas, and design validation, retry and multi-pass review architectures
  • You can preserve context, escalate ambiguity, propagate errors across agents and build human-review workflows with calibrated confidence

Exam blueprint

Official domains and weights

5 domains, reproduced from the official exam guide 1.0 (effective July 2026). 4 scenarios drawn at random from a bank of 6.

1.Agentic Architecture & Orchestration

27%
  • 1.1 Design and implement agentic loops for autonomous task execution
  • 1.2 Orchestrate multi-agent systems with coordinator-subagent patterns
  • 1.3 Configure subagent invocation, context passing and spawning
  • 1.4 Implement multi-step workflows with enforcement and handoff patterns
  • 1.5 Apply Agent SDK hooks for tool call interception and data normalisation
  • 1.6 Design task decomposition strategies for complex workflows
  • 1.7 Manage session state, resumption and forking

2.Tool Design & MCP Integration

18%
  • 2.1 Design effective tool interfaces with clear descriptions and boundaries
  • 2.2 Implement structured error responses for MCP tools
  • 2.3 Distribute tools appropriately across agents and configure tool choice
  • 2.4 Integrate MCP servers into Claude Code and agent workflows
  • 2.5 Select and apply built-in tools (Read, Write, Edit, Bash, Grep, Glob) effectively

3.Claude Code Configuration & Workflows

20%
  • 3.1 Configure CLAUDE.md files with appropriate hierarchy, scoping and modular organisation
  • 3.2 Create and configure custom slash commands and skills
  • 3.3 Apply path-specific rules for conditional convention loading
  • 3.4 Determine when to use plan mode vs direct execution
  • 3.5 Apply iterative refinement techniques for progressive improvement
  • 3.6 Integrate Claude Code into CI/CD pipelines

4.Prompt Engineering & Structured Output

20%
  • 4.1 Design prompts with explicit criteria to improve precision and reduce false positives
  • 4.2 Apply few-shot prompting to improve output consistency and quality
  • 4.3 Enforce structured output using tool use and JSON schemas
  • 4.4 Implement validation, retry and feedback loops for extraction quality
  • 4.5 Design efficient batch processing strategies
  • 4.6 Design multi-instance and multi-pass review architectures

5.Context Management & Reliability

15%
  • 5.1 Manage conversation context to preserve critical information across long interactions
  • 5.2 Design effective escalation and ambiguity resolution patterns
  • 5.3 Implement error propagation strategies across multi-agent systems
  • 5.4 Manage context effectively in large codebase exploration
  • 5.5 Design human review workflows and confidence calibration
  • 5.6 Preserve information provenance and handle uncertainty in multi-source synthesis

Weights are reproduced from the official exam guide. Domain percentages are reported on the official score report but do not individually determine pass/fail.

Published scenario bank

  • — Customer Support Resolution Agent
  • — Code Generation with Claude Code
  • — Multi-Agent Research System
  • — Developer Productivity with Claude
  • — Claude Code for Continuous Integration
  • — Structured Data Extraction

Skills and practical examples

What each domain looks like at work

1.Agentic Architecture & Orchestration

27%

Skills

  • — Design agentic loops for autonomous execution
  • — Orchestrate coordinator–subagent systems and configure spawning and context passing
  • — Enforce multi-step workflows with handoff patterns
  • — Use Agent SDK hooks to intercept tool calls and normalise data
  • — Manage session state, resumption and forking

In practice

  • A research system where a coordinator plans, three subagents search in isolation, and a synthesiser writes the report keeps each context small and lets the coordinator retry one branch without restarting the whole job.
  • A hook that rewrites every date a tool returns into ISO format before it enters context removes a class of downstream parsing failures.

2.Tool Design & MCP Integration

18%

Skills

  • — Write tool interfaces with clear descriptions and boundaries
  • — Return structured errors from MCP tools
  • — Distribute tools across agents and configure tool choice
  • — Integrate MCP servers into Claude Code and agent workflows
  • — Use Read, Write, Edit, Bash, Grep and Glob appropriately

In practice

  • A support agent with 40 tools uses them worse than one with 8 scoped tools; giving the refund tool only to the escalation subagent is both a quality and a safety decision.
  • An MCP tool that returns `{error: 'RATE_LIMITED', retry_after: 30}` lets the agent wait; one that returns a 500 string makes it guess.

3.Claude Code Configuration & Workflows

20%

Skills

  • — Structure CLAUDE.md with hierarchy, scoping and modular organisation
  • — Create custom slash commands and skills
  • — Apply path-specific rules
  • — Decide when to use plan mode
  • — Integrate Claude Code into CI/CD pipelines

In practice

  • A `/release-notes` command that reads the changelog and opens a PR encodes a team process once instead of relying on each engineer's prompt.
  • Running Claude Code headless in CI to review every PR against a repository's conventions file is a Domain 3 pattern; deciding what it may and may not change is a Domain 5 one.

4.Prompt Engineering & Structured Output

20%

Skills

  • — Design prompts with explicit criteria to cut false positives
  • — Use few-shot examples for consistency
  • — Enforce structured output with tool use and JSON schemas
  • — Build validation, retry and feedback loops
  • — Design batch strategies and multi-instance, multi-pass review

In practice

  • An extraction pipeline that runs two independent passes and flags disagreements for human review catches errors a single confident pass never surfaces.
  • Defining 'high-risk clause' with five explicit criteria and three labelled examples halves the false-positive rate compared with 'flag anything risky'.

5.Context Management & Reliability

15%

Skills

  • — Preserve critical information across long interactions
  • — Design escalation and ambiguity-resolution patterns
  • — Propagate errors across multi-agent systems
  • — Manage context in large-codebase exploration
  • — Design human review with confidence calibration
  • — Preserve provenance and handle uncertainty in multi-source synthesis

In practice

  • A subagent that fails should return a typed failure the coordinator can reason about, not an empty string that looks like 'nothing found'.
  • A synthesis report that attributes every claim to a source and marks conflicts between sources is what a reviewer can actually check.

Example scenario

Structured extraction from 50,000 supplier contracts

A procurement team needs twelve fields extracted from 50,000 historical contracts (PDFs of varying quality), plus a flag for any clause that allows automatic renewal. Legal will review flagged contracts but cannot review all 50,000. The first prototype, a single prompt per contract, extracts well on clean documents but invents renewal terms on scanned ones and produces inconsistent date formats.

Your task: Design the pipeline: how output is structured and validated, how batches are processed, how the renewal flag is made precise, how uncertain extractions are routed to legal, and how a reviewer can trace each field back to the contract text.

An original AI7x7 scenario illustrating the type of professional problem the exam tests. It is not an official exam item.

What this scenario tests

  • Structured output via tool use and JSON schema, with validation and retry (Domain 4)
  • Batch processing and multi-pass review design (Domain 4)
  • Human review workflows and confidence calibration (Domain 5)
  • Provenance: tying each extracted field to its source span (Domain 5)
  • Agent SDK hooks for normalising dates and tool interception (Domain 1)

How to prepare

A 14-day study plan

Two weeks, roughly 90 minutes a day, organised around the six published exam scenarios. By the end you will have built a small version of each scenario, which is the most reliable preparation for scenario-based items.

  1. 1

    Blueprint

    • — Read the exam guide; list the five domains, 30 task statements and six scenarios
    • — Note which task statements you have never done hands-on
  2. 2

    Agentic loops (1.1, 1.6)

    • — Build a single-agent loop with the Agent SDK for a bounded task
    • — Decompose a complex task into steps and encode the plan
  3. 3

    Multi-agent orchestration (1.2, 1.3, 1.4)

    • — Add a coordinator and two subagents with isolated context
    • — Implement a handoff with an explicit contract between agents
  4. 4

    Hooks and sessions (1.5, 1.7)

    • — Write a hook that intercepts a tool call and normalises its output
    • — Resume a session and fork it; observe what state carries over
  5. 5

    Tool design (2.1, 2.2, 2.3)

    • — Rewrite three tool descriptions until a fresh agent uses them correctly first time
    • — Return structured errors and watch the agent recover
  6. 6

    MCP and built-in tools (2.4, 2.5)

    • — Connect an MCP server to Claude Code and to an SDK agent
    • — Do a codebase task using only Grep/Glob/Read before any Edit
  7. 7

    Scenario: Customer Support Resolution Agent

    • — Design the tool set, escalation rule and session handling on paper
    • — Build the smallest working version
  8. 8

    Claude Code configuration (3.1, 3.2, 3.3)

    • — Create a layered CLAUDE.md for a two-package repo with path-specific rules
    • — Add a custom slash command and a skill
  9. 9

    Plan mode, refinement, CI (3.4, 3.5, 3.6)

    • — Run the same change with and without plan mode; compare
    • — Run Claude Code headless in a CI-like script against a PR diff
  10. 10

    Structured output (4.1, 4.2, 4.3, 4.4)

    • — Enforce a schema with tool use; add validation and a retry loop
    • — Add five labelled examples and measure the consistency gain
  11. 11

    Batch and multi-pass review (4.5, 4.6)

    • — Process 100 documents in batches; add a second independent pass and compare disagreements
    • — Route disagreements to a review queue
  12. 12

    Context and reliability (5.1–5.6)

    • — Build a long-running task that summarises its own context at checkpoints
    • — Make a subagent fail and propagate a typed error
    • — Attach provenance to every claim in a synthesised answer
  13. 13

    Scenario: Multi-Agent Research System

    • — Design and build the smallest version with provenance and conflict handling
    • — Review the other four scenarios against your builds
  14. 14

    Practice exam and review

    • — Sit the AI7x7 20-question practice exam under the timer
    • — For every missed item, identify the task statement and re-read it

Preparation tips

  • — Items are grouped under scenarios. Read the scenario once carefully, then answer each item in its light; a 'best' answer in one scenario can be wrong in another
  • — Domain 1 is 27%: orchestration, handoffs and hooks appear in most scenarios, not just the research one
  • — Build the six scenarios in miniature. Recognising a pattern you have implemented is faster and more reliable than reasoning from first principles under time pressure
  • — Know the built-in tools (Read, Write, Edit, Bash, Grep, Glob) well enough to say which one is wrong for a given step

Official documentation to read

Practice with AI7x7

Free practice exam, free guide, $19 full-length package

Practice percentages are not the official 720 scaled score and do not predict your result. They tell you which domains need work.

Free

20-question practice exam

Timed 40-minute session with a domain breakdown and full explanations on completion. AI7x7 practice timing, not the official 120-minute duration.

Free exam in editorial review. Ask to be notified.
Free

Preparation guide (PDF)

A 12–20 page study guide: blueprint, domain-by-domain notes, worked examples, common mistakes and a 7-day and 14-day plan. Delivered by email.

Guide in editorial review. Ask to be notified.
$19 one-time

5 full-length practice exams

5 distinct 60-question timed simulations matching the official format, explanations for every option, domain reports and score history. Unofficial AI7x7 simulation.

Premium exams coming soon. Ask to be notified.

FAQ

CCAR-F questions, answered

How is the Architect – Foundations exam structured?

It is scenario-based: each sitting draws four scenarios at random from a bank of six (for example a customer support resolution agent or a multi-agent research system), with 60 items in total across 120 minutes.

What is the difference between Architect – Foundations and Architect – Professional?

Foundations is a hands-on, implementation-focused exam about building agentic systems with the Agent SDK, Claude Code, MCP and structured output. Professional adds enterprise concerns: integration architecture, evaluation programmes, governance, stakeholder communication and lifecycle management.

How much experience is recommended?

The guide recommends six or more months of practical experience with the Claude APIs, Agent SDK, Claude Code and MCP. There are no formal prerequisites.

What is the biggest domain?

Agentic Architecture & Orchestration at 27%, followed by Claude Code Configuration & Workflows and Prompt Engineering & Structured Output at 20% each.

How much does the exam cost?

USD 125. This is the official fee paid to Anthropic; AI7x7 practice materials are priced separately.

Is this exam affected by the December 2026 content update?

Not according to Pearson VUE's current notice, which lists updates for the Associate, Developer and Architect – Professional exams only. AI7x7 monitors the official pages and will update this record if that changes.

Related certifications

Other Claude tracks

Official certification page: https://anthropic-partners.skilljar.com/claude-certified-architect-foundations-certification · Exam guide: PDF (1.0 (effective July 2026))

AI7x7 is an independent exam preparation platform and is not affiliated with, sponsored by, or endorsed by Anthropic. Claude and related trademarks belong to their respective owners. AI7x7 practice questions are original and are not official exam questions.