Optivise AI OptiviseAI
Optivise AI Academy · Certification Prep

The Definitive Guide to the
Claude Certified Architect

Master the foundational architecture and agentic protocols needed to pass the Claude Certified Architect (Foundations) exam — agentic systems, tools & MCP, Claude Code, prompt engineering and context management. Five domains, exam overview and a four-step prep path, curated by Optivise AI Academy.

Take the mock exam → Explore the 5 domains

Independent study guide — not affiliated with, endorsed by, or sponsored by Anthropic. Content is based on Anthropic's official documentation and published exam guide.

2025
Version · Foundations
5
Exam domains
8→4
Scenarios · 4 drawn
720/1000
To pass · MCQ 1-of-4
15–20h
Suggested prep time
Exam blueprint

The Five Domains

The exam spans five technical domains, weighted as below. Work through each and you cover the full blueprint.

01 27%7 modules

Agentic Architecture & Orchestration

Design and run agentic systems on Claude's API — the agent loop, orchestration patterns, guardrails and the Claude Agent SDK.

  • Agent loop: gather · act · verify
  • Orchestrator–worker · routing · chaining
  • Subagents & parallelisation
  • Claude Agent SDK
  • Guardrails & human-in-the-loop
  • State, memory & long-running agents
02 20%6 modules

Claude Code Configuration & Workflows

Configure Claude Code for real development — settings, hooks, permissions, subagents and CI/CD.

  • Project memory & CLAUDE.md
  • Settings & permission allowlists
  • Hooks (Pre/PostToolUse)
  • Slash commands & subagents
  • MCP servers in Claude Code
  • Headless mode & CI/CD
03 20%6 modules

Prompt Engineering & Structured Output

Craft production-grade prompts and reliable structured output for Claude applications.

  • Clear, direct & system prompts
  • Few-shot examples & XML tags
  • Extended thinking & CoT
  • Structured / JSON / tool output
  • Prefill & stop sequences
  • Evaluating & iterating prompts
04 18%5 modules

Tool Design & MCP Integration

Design effective tool schemas, build MCP servers and clients, and wire external services into Claude apps.

  • Tool schemas & JSON Schema
  • Clear tool descriptions
  • Tool-use / function calling
  • MCP: servers, clients, transports
  • Integrating external APIs
05 15%6 modules

Context Management & Reliability

Manage context windows, caching and long conversations to build reliable production systems.

  • Context windows & token budget
  • Prompt caching strategies
  • Long conversations & compaction
  • Streaming & latency
  • Retries, idempotency & monitoring
  • Cost & performance tuning
Exam scenarios

The Eight Exam Scenarios

Each real sitting draws 4 of these 8 industry scenarios at random, and every question is scenario-based. Know the scenarios and you can anticipate the questions.

01

Customer Support Agent

Handle returns, billing and account issues with the Agent SDK and MCP tools — high first-contact resolution with the right escalation.

02

Code Generation with Claude Code

Accelerate generation, refactoring, debugging and docs with custom slash commands and CLAUDE.md — and know when to use planning mode.

03

Multi-Agent Research System

A coordinator delegates to research, analysis, synthesis and report subagents to produce complete, cited reports.

04

Developer Productivity Tools

Explore unfamiliar codebases, generate boilerplate and automate routine work with built-in tools (Read/Write/Bash/Grep/Glob) and MCP servers.

05

Claude Code for CI

Wire Claude Code into CI/CD for automated review, test generation and PR feedback — prompts tuned to minimise false positives.

06

Structured Data Extraction

Extract from unstructured documents, validate against JSON schemas, keep accuracy high and handle edge cases correctly.

07

Conversational AI Patterns

Multi-turn systems: context-window management, instruction persistence, memory strategies, safe tool design and handling ambiguous or conflicting inputs.

08

Agentic AI Tools

Advanced tooling and execution patterns for agentic systems — a newer exam scenario whose coverage is still expanding.

Core reference

Core-Concept Cheat Sheet

The most-tested facts distilled into six reference cards — from the agent loop to context and reliability.

Agent loop & SDK

  • stop_reason drives the loop: tool_use → run the tool and continue, end_turn → done.
  • The only reliable completion signal is end_turn — never parse text or use a fixed iteration cap.
  • Orchestrator–worker: subagents have isolated context, don't inherit parent history, and must be given it explicitly.
  • AgentDefinition: name, description, system_prompt, allowed_tools (least privilege).
  • The Task tool spawns subagents and can run several in parallel in one turn.

Tools & structured output

  • The tool description is the primary selection mechanism; overlapping descriptions cause misrouting.
  • tool_choice: auto (decide), any (must call a tool), tool (force a specific one).
  • Use tool_use + JSON Schema for syntactically valid structured output.
  • Schemas eliminate syntax errors but not semantic ones — values can still be wrong.
  • Nullable fields ([string,null]) let the model return null instead of fabricating; add other / unclear enums.

MCP

  • Three resource types: tools (actions), resources (readable context), prompts (templates).
  • Servers expose capabilities; clients (hosts) connect and auto-discover all tools on connection.
  • Project .mcp.json (team, in VCS) vs user ~/.claude.json (personal).
  • Inject secrets via environment variables (e.g. GITHUB_TOKEN); never commit them.
  • Return errors as isError + errorCategory + isRetryable, not a generic Operation failed.

Claude Code config

  • CLAUDE.md hierarchy: user (~/.claude), project (.claude), directory-level; user-level isn't shared via VCS.
  • @path imports split standards (max depth 5); .claude/rules/ loads conditionally by paths glob.
  • Skills (SKILL.md): context: fork to isolate, allowed-tools to restrict, argument-hint.
  • Planning mode (investigate & propose) vs direct execution; use planning for large or architectural changes.
  • CI: -p / --print headless + --output-format json --json-schema; manage sessions with --resume / fork_session.

Prompt engineering

  • Explicit criteria beat vague instructions (e.g. flag a comment only if it contradicts the code).
  • Few-shot (2–4 examples) unifies format, demonstrates ambiguity handling and reduces extraction hallucination.
  • Prompt chaining breaks complex tasks into focused steps, avoiding attention dilution.
  • The interview pattern: ask clarifying questions about non-obvious design points before building.
  • Validate → retry-with-feedback: return the specific error to guide correction; useless when the info is absent.

Context & reliability

  • Lost-in-the-middle: place key information at the start / end and add section headings.
  • Extract key facts into a standalone block; trim tool results to only the relevant fields.
  • Prompt caching reuses a stable prefix; /compact compresses history; scratchpad files persist findings.
  • Error classes: transient (retry), validation (fix input), business (explain / alternative), permission (escalate).
  • Message Batches: 50% cheaper, up to 24h, no multi-turn tool calling, correlate with custom_id.
⚠ Three traps to avoid
  • 01When a rule has financial, legal or safety consequences, enforce it with a hook (deterministic, 100%) — not a prompt (probabilistic, >90% but not 100%).
  • 02Reliable escalation triggers are an explicit request, a policy gap, or no progress; customer sentiment and model self-rated confidence are unreliable (the model can be confidently wrong).
  • 03Task completion is signalled only by stop_reason == end_turn; parsing done from the assistant text or using a fixed iteration cap are anti-patterns.
Prep path

A Four-Step Prep Path

From diagnostic to hands-on build — one clear, executable route to exam-ready.

01

Diagnose

Start with a diagnostic to pinpoint your weakest domains fast.

02

Learn by domain

Work through lessons domain by domain, mastering all 30 task statements.

03

Mock exam

Simulate real exam conditions with a full mock to surface gaps.

04

Build

Lock in the patterns with hands-on build exercises.

Ready? Take the mock exam

32 original questions, weighted across all five domains, on a 60-minute timer. Get your score, a per-domain breakdown and a full answer review — on its own dedicated exam page.

Start the mock exam → Review the 5 domains
FAQ

About the Certification

What is the Claude Certified Architect (Foundations) exam?+
It is Anthropic's official certification for developers who build with Claude. It covers five domains: Agentic Architecture, Tool Design & MCP, Claude Code Configuration, Prompt Engineering, and Context Management. You need 720 out of 1,000 points to pass.
How do I prepare for the exam?+
Start with the diagnostic to identify weak areas, then work through the lessons for each of the five domains. Use the mock exam to simulate real conditions, and practise with build exercises for hands-on experience. The diagnostic helps you focus where you need the most work.
How long does preparation take?+
Most developers with Claude experience need 15–20 hours of study. If you are new to Claude, allow 30–40 hours. The diagnostic helps you focus on the domains where you need the most work.
Is this guide affiliated with Anthropic?+
No. This is an independent learning resource compiled by Optivise AI Academy. It is not affiliated with, endorsed by, or sponsored by Anthropic. The content is based on Anthropic's official documentation and published exam guide.
What format is the exam?+
Multiple choice with one correct answer of four, scored on a 100–1,000 scale with 720 to pass and no guessing penalty — so answer every question. Each sitting randomly draws 4 of the 8 industry scenarios, and every question is scenario-based.
What background do I need?+
It targets solution architects who design and ship production applications with Claude. Plan on at least 6 months of hands-on experience across the Claude Agent SDK (multi-agent orchestration, subagents, tool integration, lifecycle hooks), Claude Code, the Model Context Protocol (MCP), and prompt engineering with structured output.
How can Optivise AI help?+
Optivise AI Academy runs practical AI training and hands-on enablement for individuals and teams — from prompt engineering, agents and MCP to putting Claude to work in real business workflows. If you want structured exam prep or AI onboarding for your team, get in touch.

Prepare with Optivise AI Academy

Turn certification knowledge into team capability — practical AI training, agent & MCP workshops, and enterprise enablement for individuals and teams.

Book a consult → Explore the AI Academy