Anthropic · certification prep

Claude Certified Architect

Foundations Certification

Practice for Anthropic's Claude Certified Architect – Foundations exam. Mock tests mirror official domain weights, scenarios, and multiple-choice format.Study hub mapped to Anthropic's Foundations Exam Guide — official proctored registration stays with Anthropic.
60 official Q · 120 minPass 720/1000540 practice Qs$5 lifetime

MOCK TESTS

8

QUESTION BANK

540

ACCESS

$5

lifetime

EXAM SIM

60 Q

120 min

PRACTICE ACCESS

Unlock every Claude Certified Architect mock on explainx.

  • All 8 mock tests — Foundations, domain drills, scenario marathon, full 60Q simulation
  • Fresh shuffle from 540+ practice questions every attempt
  • Instant score + explanations after each submit
  • Unlimited retakes — lifetime access, one payment

Independent practice — not Anthropic's proctored certification.

ONE-TIME

$5

lifetime · all mocks

Secure checkout via Stripe

Mock tests

Eight timed drills on explainx — unlock all for $5 lifetime.

Exam domains

Official weightings for the Foundations exam.

  • Agentic Architecture & Orchestration27%
  • Tool Design & MCP Integration18%
  • Claude Code Configuration & Workflows20%
  • Prompt Engineering & Structured Output20%
  • Context Management & Reliability15%

Production scenarios

Four scenarios per sitting (from six).

  • Customer Support Resolution Agent

    MCP tools for returns, billing, refunds, escalation.

  • Code Generation with Claude Code

    Slash commands, CLAUDE.md, plan mode vs direct execution.

  • Multi-Agent Research System

    Coordinator with search, analysis, synthesis, report subagents.

  • Developer Productivity with Claude

    Codebase exploration with built-in tools and MCP.

  • Claude Code for Continuous Integration

    Automated PR review and test generation in CI/CD.

  • Structured Data Extraction

    JSON schema validation and downstream integration.

Who this certification is for

Anthropic positions Claude Certified Architect – Foundations as a credential for solution architects who design and ship production Claude applications. The exam tests practical judgment about architecture, configuration, and tradeoffs — not trivia about model internals.

  • Building agentic apps with the Claude Agent SDK — multi-agent orchestration, subagent delegation, tool integration, lifecycle hooks
  • Configuring Claude Code for teams — CLAUDE.md, Agent Skills, MCP servers, plan mode vs direct execution
  • Designing MCP tool and resource interfaces for backend integration
  • Engineering prompts for reliable structured output — JSON schemas, few-shot, extraction patterns
  • Managing context across long documents, multi-turn chats, and multi-agent handoffs
  • Integrating Claude into CI/CD for automated review, test generation, and PR feedback
  • Escalation and reliability — error handling, human-in-the-loop, self-evaluation patterns
  • Typically 6+ months hands-on with Claude APIs, Agent SDK, Claude Code, and MCP in production

Official exam format

Summarized from Anthropic's public Foundations Exam Guide — confirm on Academy before you register.

Level
~301 — applied production judgment, not entry-level literacy
Format
60 multiple-choice questions · one correct answer · three distractors · no penalty for guessing
Duration
120 minutes · single proctored session
Pass score
720 / 1000 scaled (minimum passing standard set by SMEs)
Official price
$99 per attempt (partner discounts may apply)
Scenarios
4 of 6 per sitting
Partner-network examNo external resourcesNo breaks in session

Task statements by domain

The official guide lists weighted domains and granular task statements. explainx practice questions target these competencies — use this map to plan study time and pick focused mock tests.

Agentic Architecture & Orchestration (27%)

  • 1.1 Implement and control agentic loops

    • · stop_reason handling (tool_use vs end_turn)
    • · tool result handling
    • · loop termination — not heuristics or arbitrary caps
  • 1.2 Design multi-agent orchestration patterns

    • · Coordinator–subagent hub-and-spoke
    • · Task tool spawning
    • · Explicit context passing — subagents do not auto-inherit parent memory
  • 1.3 Delegate work to subagents

    • · allowedTools must include "Task"
    • · Structured handoffs: claim, excerpt, URL, date for synthesis
  • 1.4 Enforce business rules in agent workflows

    • · PostToolUse / tool interception hooks
    • · Programmatic gates vs prompt-only ordering for refunds and policy
  • 1.5 Normalize heterogeneous tool outputs

    • · Consistent date formats, status codes, field naming before agent reasoning
  • 1.6 Task decomposition strategies

    • · Prompt chaining for predictable reviews
    • · Dynamic decomposition for open-ended investigation
    • · Per-file passes + cross-file integration pass
  • 1.7 Session state, resumption, and forking

    • · --resume named sessions
    • · fork_session for parallel exploration branches
    • · Fresh session + summary when tool results are stale

Tool Design & MCP Integration (18%)

  • 2.1 Design effective tool interfaces

    • · Rich descriptions: inputs, outputs, edge cases, when to use vs similar tools
    • · Split overlapping tools (e.g. analyze_content → extract_web_results)
  • 2.2 Structured MCP error responses

    • · isError flag
    • · errorCategory: transient / validation / business / permission
    • · isRetryable — avoid wasted retries on policy violations
  • 2.3 Distribute tools across agents

    • · 4–5 tools per agent vs 18-tool overload
    • · Scoped verify_fact for synthesis
    • · tool_choice: auto, any, forced tool
  • 2.4 Integrate MCP into Claude Code

    • · Project .mcp.json vs user ~/.claude.json
    • · ${ENV} expansion
    • · MCP resources for catalogs vs exploratory Grep
  • 2.5 Built-in tools: Read, Write, Edit, Bash, Grep, Glob

    • · Grep for content search
    • · Glob for path patterns
    • · Read + Write when Edit lacks unique anchors

Claude Code Configuration & Workflows (20%)

  • 3.1 CLAUDE.md hierarchy and modular rules

    • · User vs project vs directory scope
    • · @import modular standards
    • · .claude/rules/ topic files
    • · /memory diagnostics
  • 3.2 Slash commands and skills

    • · .claude/commands/ project vs ~/.claude/commands/
    • · SKILL.md frontmatter: context: fork, allowed-tools, argument-hint
  • 3.3 Path-specific rules

    • · YAML frontmatter paths globs — e.g. **/*.test.tsx regardless of directory
  • 3.4 Plan mode vs direct execution

    • · Plan mode for multi-file architecture, monolith→microservices
    • · Direct execution for bounded single-file fixes
  • 3.5 Claude Code in CI/CD

    • · claude -p for non-interactive runs
    • · --output-format json
    • · --json-schema for structured CI output

Prompt Engineering & Structured Output (20%)

  • 4.1 JSON schemas and tool_use

    • · Nullable optional fields to prevent hallucination
    • · tool_choice configuration
    • · strict schema mode
  • 4.2 Few-shot and review criteria

    • · Ambiguous scenario examples
    • · Explicit criteria to cut false positives in PR review
    • · Multi-pass review architecture
  • 4.3 Validation-retry loops

    • · Pydantic / JSON schema failures fed back with document + error
    • · Resolvable vs absent-information errors
  • 4.4 Message Batches API tradeoffs

    • · 50% cost savings vs latency
    • · Blocking pre-merge vs overnight reports
    • · custom_id failure handling

Context Management & Reliability (15%)

  • 5.1 Context window optimization

    • · Trim verbose tool outputs
    • · Structured fact extraction
    • · Lost-in-the-middle — position-aware ordering
  • 5.2 Escalation and human-in-the-loop

    • · Policy gaps vs customer-requested escalation
    • · Explicit criteria + few-shot — not uncalibrated self-confidence scores
  • 5.3 Multi-agent error propagation

    • · Structured failure context to coordinator
    • · Partial results + coverage gap annotation
  • 5.4 Information provenance

    • · Claim–source mappings
    • · Conflicting sources preserved with attribution
    • · Temporal data in synthesis
  • 5.5 Human review routing

    • · Field-level confidence
    • · Stratified sampling
    • · Accuracy by document type and field

Six production scenarios (four per exam)

Questions are scenario-framed. Each official sitting draws four scenarios at random from this pool.

Customer Support Resolution Agent

Build a support agent with the Claude Agent SDK for high-ambiguity returns, billing, and account issues. MCP tools: get_customer, lookup_order, process_refund, escalate_to_human. Target 80%+ first-contact resolution with safe escalation when policy or ambiguity requires a human.

Domains: Agentic Architecture · MCP Integration · Context & Reliability

Code Generation with Claude Code

Accelerate generation, refactoring, debugging, and docs. Integrate slash commands, CLAUDE.md hierarchies, and decide when plan mode beats direct execution for team workflows.

Domains: Claude Code · Context & Reliability

Multi-Agent Research System

Coordinator delegates to web search, document analysis, synthesis, and report subagents. Produce comprehensive, cited research — test decomposition breadth, parallel Task calls, and provenance in synthesis.

Domains: Agentic Architecture · MCP Integration · Context & Reliability

Developer Productivity with Claude

Explore unfamiliar codebases and legacy systems, generate boilerplate, automate repetitive work using Read, Write, Bash, Grep, Glob plus MCP integrations.

Domains: MCP Integration · Claude Code · Agentic Architecture

Claude Code for Continuous Integration

Automated code review, test generation, and PR feedback in CI/CD. Design prompts for actionable output and minimal false positives; non-interactive claude -p runs.

Domains: Claude Code · Prompt Engineering

Structured Data Extraction

Extract fields from unstructured documents, validate with JSON schemas, handle absent fields with nullables, batch via Message Batches API, route low-confidence rows to human review.

Domains: Prompt Engineering · Context & Reliability

In scope on the exam

  • Agentic loop control flow and termination
  • Multi-agent orchestration and parallel subagent execution
  • Explicit subagent context passing and crash recovery manifests
  • Tool descriptions, splitting vs consolidating tools
  • MCP tool/resource design and multi-server configuration
  • Structured errors, escalation criteria, human-in-the-loop
  • CLAUDE.md hierarchy, path-scoped rules, skills frontmatter
  • Plan mode vs direct execution, iterative refinement
  • Structured output via tool_use, few-shot, batch processing tradeoffs
  • Context trimming, provenance, confidence-based human review

Explicitly out of scope

  • Fine-tuning, training, or model weights
  • API billing, OAuth, key rotation
  • Hosting MCP servers (infra, containers, networking)
  • Embeddings, vector DB implementation
  • Computer use, vision, streaming SSE
  • Rate limits, tokenization algorithms, prompt caching internals
  • Cloud provider IaC (AWS/GCP/Azure)

Technologies you should know

  • Claude Agent SDK — agentic loops, hooks, Task tool, allowedTools
  • MCP — servers, tools, resources, isError, .mcp.json, env expansion
  • Claude Code — CLAUDE.md hierarchy, .claude/rules/, skills, plan mode, /compact, --resume, fork_session
  • Claude API — tool_use, tool_choice, stop_reason, max_tokens
  • Message Batches API — cost vs latency, custom_id, no multi-turn tool calling in batch
  • JSON Schema & Pydantic — nullable fields, validation-retry loops
  • Built-in tools — Read, Write, Edit, Bash, Grep, Glob

Practice on explainx — live now

Independent mock exams aligned to the Foundations Exam Guide — not affiliated with Anthropic's proctored certification. 540 multiple-choice questions in the bank, shuffled every attempt, instant explanations after submit.

Recommended study path

  1. Build a complete Agent SDK loop with tools, errors, and subagent delegation
  2. Configure Claude Code on a real repo — CLAUDE.md, .claude/rules/, skills, MCP
  3. Design MCP tools with differentiated descriptions and structured errors
  4. Build a structured extraction pipeline with schemas and validation-retry
  5. Practice few-shot for ambiguous scenarios and multi-pass code review
  6. Study context trimming, scratchpads, and subagent delegation for limits
  7. Review escalation vs autonomous resolution patterns
  8. Run explainx mock tests for scenario-style MCQ practice before the proctored sitting

FAQ

Quick answers for candidates preparing with explainx mock exams (not Anthropic support).

What is the Claude Certified Architect Foundations exam?
Anthropic's ~301-level proctored certification for solution architects building production apps with Claude Code, the Claude Agent SDK, MCP, and structured output. The official exam has 60 multiple-choice questions in 120 minutes, four scenario frames per sitting, and a scaled pass score of 720/1000.
What domains are on the Claude Certified Architect exam?
Five weighted areas: Agentic Architecture & Orchestration (27%), Tool Design & MCP Integration (18%), Claude Code Configuration & Workflows (20%), Prompt Engineering & Structured Output (20%), and Context Management & Reliability (15%).
Are explainx mock tests the official Anthropic exam?
No. explainx.ai offers independent practice mock tests aligned to the public Foundations Exam Guide domains, task statements, and scenarios. Official registration and proctoring are through Anthropic Academy / Skilljar.
How much does lifetime practice access cost on explainx?
Lifetime access to all Claude Certified Architect mock tests on explainx.ai is $5 USD (one-time). Each attempt draws a shuffled subset from a bank of 1,000+ practice questions with explanations after submit.
Do I need to sign in to run mock tests?
You can browse certification and test pages without an account. Starting a timed mock test requires signing in and purchasing lifetime practice access for that program.
How many practice questions and mock tests are available?
Eight mock tests including a 60-question full exam simulation, plus 1,000+ banked multiple-choice items across agentic architecture, MCP, Claude Code, prompt engineering, and context management.
What scenarios do explainx practice questions use?
Questions mirror the six official production scenarios: customer support agents, Claude Code development, multi-agent research, developer productivity, CI/CD with Claude Code, and structured data extraction.
How do I prepare for the official exam vs explainx mocks?
Use Anthropic's Foundations Exam Guide and Academy courses for the proctored exam. Use explainx mock tests for timed MCQ practice, domain drills, and instant feedback — especially scenario-framed items and tradeoff questions.