Study guide for the Claude Certified Architect – Professional exam
Anthropic · October 2026 exam blueprint · 218 curriculum items
Start guide
0.1 Separate model capacity from reliable knowledge
About this guide
Each bite isolates one concept or one architecture decision. Read them in order to prepare for the exam, or come back to a single bite later as a reference — the shape is the same either way, so you always know where in a lesson an answer will be.
Lessons are made to fit into the gaps between real engineering work, including the time while your coding agent is running. There is no reading-time promise attached to that, only a deliberate scope: one decision per bite.
A Lab completes when you open its official exercise — and, if it ends with a knowledge check, once you have answered that too. Anything else that carries a knowledge check — a bite, a checkpoint, a mock exam — completes when you answer every question of it; a bite without one completes when you say so. Completion only accumulates — nothing here takes it back.
Prerequisites
Outside the exam blueprint0 of 8 items completed
- 0.1 Separate model capacity from reliable knowledgeDistinguish context capacity, sampling variability, and training cutoffs when defending a production model's limits.
- 0.2 Make Messages an explicit service contractAssign ownership of request assembly, typed response handling, completion decisions, and token accounting.
- 0.3 Tell augmented calls, workflows, loops, and delegation apartClassify augmented calls, workflows, agent loops, and delegation by control ownership and operational cost.
- 0.4 Connect evidence and actions through interfacesSeparate tools, retrieval, and durable memory by the external state they expose and the responsibilities your application retains.
- 0.5 Trace authority across the data flowIdentify where content crosses a trust boundary and where application code must retain authority.
- 0.6 Separate identity from permission to actDistinguish user and service identities, authentication, authorization, and least privilege before choosing access controls.
- 0.7 Define what each performance number measuresInterpret quality, latency, throughput, cost, and reliability metrics with explicit units and denominators.
- 0.8 Turn business intent into owned requirementsSeparate outcomes, functions, constraints, and service objectives and assign the stakeholders who accept them.
Solution Design & Architecture
17% of the exam0 of 34 items completed
Translate business problems into Claude-based AI solutions
- 1.1.1 Assign Claude the right workflow jobsPartition a business workflow into Claude-owned outputs, deterministic decisions, and human responsibilities.
- 1.1.2 Define acceptance before designing the solutionTurn a business goal into testable capability, error, data, human-review, and boundary requirements.
- 1.1.3 Choose a surface your team can operateSelect Claude apps, developer tooling, API integration, or an agent runtime by user needs and operational responsibility.
- 1.1.4 Test the assumption that can stop deliveryFrame a falsifiable proof-of-value hypothesis and scope a proof of concept around the riskiest production assumption.
- LABRequirements and designHave Claude turn an approved intent.md into a requirements and design spec constrained by the organization's skills, with flagged areas of concern.
- LABClassification with Claude: Insurance Support Ticket ClassifierBuild an insurance support ticket classifier and measure how retrieved examples and chain-of-thought reasoning change its accuracy.
Design end-to-end architectures (input → processing → output → feedback loops)
- 1.2.1 Trace each request through accepted actionMap input, context, inference, output checks, and downstream delivery as explicit stage contracts.
- 1.2.2 Keep business writes behind deterministic ownersAssign inference, execution, authorization, and transaction recovery to distinct owners that prevent duplicate side effects.
- 1.2.3 Match structured interfaces to acceptance gatesCombine final JSON and strict tool contracts while enforcing semantic checks, calibrated review, and explicit failure outcomes.
- 1.2.4 Turn verified feedback into tested releasesConnect corrections, review decisions, and production evidence to targeted prompt, retrieval, and evaluation changes.
- LABContent policy enforcement with ClaudeBuild a moderation pipeline in which Claude compiles a written policy into rules and extracts typed fields, while a deterministic engine decides each verdict.
Select appropriate architectural patterns (workflow, agentic, augmented LLM)
- 1.3.1 Locate control before naming the architectureClassify augmented LLMs, workflows, and agents by the decisions they delegate and the execution path their host retains.
- 1.3.2 Match workflow shape to task dependenciesChoose and combine the five workflow patterns according to dependencies, category separability, dynamic scope, and useful feedback.
- 1.3.3 Require evidence before granting agent autonomyJustify autonomous investigation or a bounded agent step using path uncertainty, measured quality gains, and enforceable operating limits.
- 1.3.4 Defend the simplest acceptable production patternCompare candidate patterns across six operational dimensions and record the evidence, accepted costs, and fallback owner behind the choice.
- LABBasic Multi-LLM WorkflowsImplement prompt chaining, parallelization and routing as small Python functions and run each on a worked example.
- LABEvaluator-Optimizer WorkflowBuild a loop in which one Claude call generates code and another evaluates it and returns feedback until the result passes.
Design multi-agent systems and orchestration strategies
- 1.4.1 Justify the cost of splitting workDefend single-agent or multi-agent execution using measured parallelism, context isolation, coordination effort, and accepted-result cost.
- 1.4.2 Choose who controls the agent graphCompare four orchestration topologies by decision authority, traceability, dependencies, and the scope of a failed branch.
- 1.4.3 Make delegation contracts preserve decision evidenceDesign portable agent contracts that connect roles, capabilities, evidence, provenance, uncertainty, and accountable acceptance.
- 1.4.4 Recover failed branches without corrupting completionDesign bounded recovery and escalation that retain verified partial results while preventing unresolved agent failures from becoming accepted conclusions.
- LABMulti-Agent Research SystemRun a Claude Agent SDK research system in which a lead agent delegates to researcher, analyst and report-writer subagents, and trace each subagent's tool calls with hooks.
- LABAsync Multi-Agent Orchestration with ClaudeBuild a fixed agent team and a lead that spawns async subagents, both coordinating through a shared message hub on the Anthropic SDK and asyncio.
Apply decomposition techniques for complex problem solving
- 1.5.1 Size subtasks around verifiable completionDefine independently testable subtask results and choose a scope that preserves evidence within context and attention limits.
- 1.5.2 Choose when findings may reshape the planDefend a fixed, adaptive, or hybrid decomposition using discovery needs, operational limits, and evidence of useful outcomes.
- 1.5.3 Partition corpora without breaking evidence dependenciesDesign map-reduce over large document sets while preserving shared inputs, cross-document relationships, and required execution order.
- 1.5.4 Verify the whole after recombining partsDesign integration gates that expose missing obligations, duplicate evidence, and contradictory conclusions before accepting a decomposed result.
- LABOrchestrator-Workers WorkflowBuild an orchestrator that decides at runtime which subtasks a request needs and hands each one to a worker call.
- LABOrchestrate subagents at scale with dynamic workflowsLaunch a Claude Code dynamic workflow from the Agent SDK to fact-check a document claim by claim, then read the orchestration script Claude wrote.
Align solutions to business value pillars (efficiency, transformation, productivity, cost, performance SLAs)
- 1.6.1 Prove each value pillar with its own metricMap the five business value pillars to distinct outcome metrics, comparable baselines, and accountable owners.
- 1.6.2 Price the whole accepted workflow outcomeBuild a workflow cost ledger that includes all attempts, supporting services, evaluation, human work, and lifecycle costs.
- 1.6.3 Derive service targets from user journeysTranslate a user-facing performance agreement into measurable latency, availability, throughput, and quality targets for the complete workflow.
- 1.6.4 Rank use cases for production fundingPrioritize Claude investments using comparable baselines, explicit adoption assumptions, delivery feasibility, risk gates, and time to production.
- LABOrchestrator pattern: big models for planning, small models for executionRun a frontier orchestrator with cheaper web-reading workers in Claude Managed Agents, then compare its bill with a single frontier agent held to the same verification standard.
Claude Models, Prompting & Context Engineering
13% of the exam0 of 27 items completed
Select appropriate Claude models based on trade-offs
- 2.1.1 Choose tiers with workload measurementsCompare Claude tiers across capabilities, limits, latency, and cost, then defend a model choice with task-specific evaluations.
- 2.1.2 Route hard cases to stronger model tiersDesign tiered model routing whose escalation signals, quality gains, and total costs outperform a single-model baseline.
- 2.1.3 Tune reasoning with supported model controlsSelect adaptive thinking and effort or a supported manual thinking budget, and measure the resulting quality, latency, and cost.
- 2.1.4 Plan model changes within deployment constraintsKeep model pinning, migration deadlines, platform capabilities, and residency controls aligned in a deployable model decision.
- LABAdvisor: let a working agent consult a stronger model mid-turnGive a mid-tier Claude Managed Agents agent a stronger advisor model, then watch when it consults and price each consultation.
Design system prompts, templates, and guardrails
- 2.2.1 Separate standing policy from request contentDesign a system prompt whose role, context, rules, format, and examples remain distinct from each request.
- 2.2.2 Keep template variables inside data slotsBuild parameterized prompts that label request variables and isolate third-party content from instructions.
- 2.2.3 Define useful responses at scope limitsDesign prompt guardrails for scope, refusal, escalation, and missing information while preserving execution controls.
- 2.2.4 Answer only what supplied sources supportDesign source-grounded free-form answers with native citations and useful abstention when support is insufficient.
- 2.2.5 Release prompts against adversarial regression casesVersion prompt releases and compare regression results for conflicting instructions, injected content, and legitimate requests.
- LABMetapromptUse Anthropic's metaprompt to have Claude draft a prompt template for a task, then fill its variables and test it on a smaller model.
Apply prompt engineering techniques (zero-shot, few-shot, chain-of-thought)
- 2.3.1 Establish a reproducible zero-shot starting pointDefine and evaluate a zero-shot prompt that separates instruction defects from missing context and the need for examples or reasoning.
- 2.3.2 Curate examples for production decision coverageGovern a compact few-shot example set that covers consequential boundaries and transfers to unseen cases without reinforcing incidental patterns.
- 2.3.3 Choose reasoning without exposing private deliberationSelect prompt guidance, explicit decomposition, or native thinking while keeping application decisions and audit records independent of reasoning text.
- 2.3.4 Justify prompting complexity with measured gainsCompare zero-shot, few-shot, and reasoning candidates using held-out quality, actual token usage, and latency before selecting a production configuration.
- LABText to SQL with ClaudeTurn natural-language questions into SQL with Claude, adding examples, reasoning, schema retrieval and an execute-and-retry loop step by step.
Optimize context windows and manage token usage
- 2.4.1 Allocate tokens before admitting each requestAllocate a model-specific request budget across input components and output, then reconcile token forecasts with measured usage.
- 2.4.2 Select context for the next decisionDefend a system-wide context selection policy that limits noise, refreshes stale sources, and tests whether ordering preserves decisive evidence.
- 2.4.3 Choose what a long conversation losesChoose API compaction, selective tool-result clearing, or an application summarizer while preserving critical facts and source provenance.
- 2.4.4 Own memory beyond the active windowDesign durable agent memory with explicit storage scope, retrieval, expiration, and validation rather than treating a saved note as authoritative state.
- LABContext Engineering for AI Agents: Memory vs. Compaction vs. Tool ClearingRun one long research agent under tool-result clearing, server-side compaction and the memory tool, and compare what each keeps and loses.
Implement prompt reuse strategies (caching, modular prompts, Skills)
- 2.5.1 Price and preserve reusable prompt prefixesDesign cacheable request prefixes, calculate their break-even reuse, and diagnose misses with measured token usage.
- 2.5.2 Release shared prompts as versioned componentsSeparate stable instructions from request variables and release shared prompt components without silently changing dependent use cases.
- 2.5.3 Deliver Skills across controlled runtime surfacesPackage domain procedures for on-demand use while controlling API versions, runtime dependencies, distribution, and release approval.
- 2.5.4 Choose between caching, components, Skills, and system promptsCombine caching, modular prompts, Skills, and always-loaded instructions according to relevance, change cadence, context cost, and governance.
- LABPrompt caching in actionAdd cache breakpoints to tool schemas and a system prompt, then read cache writes and reads in the response usage.
- LABBuilding Custom Skills for ClaudePackage three custom Skills, upload and version them through the Skills API, and attach them to Messages requests.
Integration
19% of the exam0 of 44 items completed
Evaluate tool/agent configuration for capability bloat
- 3.1.1 Audit every reachable capability by roleBuild a role-level capability inventory that exposes selection errors, unnecessary context, and excess authority.
- 3.1.2 Remove privilege without breaking the workflowRemove unnecessary capabilities and choose specialist scopes that preserve complete business workflows.
- 3.1.3 Measure discovery before deferring the catalogConfigure on-demand tool search and distinguish discovery recall, tool selection, and context savings.
- 3.1.4 Validate the complete redesigned tool pathBuild representative selection, denial, and recovery evaluations that reveal regressions in redesigned tool sets.
- LABTool EvaluationRun an evaluation harness over a tool set and read accuracy, tool-call counts and the agent's feedback on each tool.
- LABTool Search with Embeddings: Scaling Claude to Thousands of ToolsBuild a client-side tool_search tool that ranks a tool library by embedding similarity and returns tool_reference blocks.
Analyze authentication and authorization requirements to identify security gaps
- 3.2.1 Choose whose authority each tool spendsTrace user, workload, agent, and downstream identities to defend delegated access or a narrowly scoped service identity.
- 3.2.2 Scope every read and write upstreamApply trusted authorization to tool handlers, retrieval queries, and memory stores before data enters an agent's context.
- 3.2.3 Keep credentials outside the agent runtimeChoose secret storage, per-user credential selection, and bounded token lifetimes without exposing credentials through prompts or configuration.
- 3.2.4 Review remote OAuth beyond successful sign-inAssess MCP token audiences, scope challenges, client consent, and connector responsibilities before approving remote access.
- 3.2.5 Block injected actions and trace accessTest authorization against untrusted instructions and connect proposed actions, policy decisions, and backend outcomes in an access trail.
- LABOperate: running Managed Agents in productionGive a Managed Agents session a per-user vault credential for an MCP toolset, then drive it with webhooks and lifecycle calls.
Evaluate accuracy-latency trade-offs and justify configuration decisions
- 3.3.1 Match configuration levers to measured errorsIdentify which configuration change addresses a measured error and what latency it adds.
- 3.3.2 Remove waits from the critical pathCombine streaming, cache reuse, and fewer round trips while measuring accepted-answer completion.
- 3.3.3 Bound thoroughness by the task deadlineAllocate an agentic task deadline and combine time-aware instructions with runtime cancellation.
- 3.3.4 Require verification to earn its delayCompare configurations on identical cases and quantify the accuracy gained by an extra verification call.
- LABMulti-agent teams under latency pressure and budgetsShow a lead agent and its helpers one shared running clock, then compare latency pressure with a latency budget.
Analyze observability challenges and select monitoring strategies at scale
- 3.4.1 Diagnose outcomes beyond successful model callsRecognize the observation gaps that nondeterministic, multi-step, and multi-agent execution creates in production.
- 3.4.2 Connect agent work to downstream resultsDesign request traces that preserve prompt and model provenance through tool execution, subagent activity, and external effects.
- 3.4.3 Measure service health and answer qualitySelect latency, error, usage, cache, termination, cost, and quality signals with explicit denominators.
- 3.4.4 Assign review methods and alert ownersCombine human review, automated evaluation, and anomaly alerts into an owned production monitoring strategy.
- 3.4.5 Limit telemetry to its diagnostic purposeChoose content controls, metric dimensions, sampling, access, and retention that preserve useful diagnosis within a data budget.
- LABMultiagent: watch a curriculum team work in real timeStream every subagent thread of a Managed Agents coordinator live, and reconcile each preview with the buffered record.
Design a RAG pipeline with appropriate chunking and indexing strategies
- 3.5.1 Choose retrieval, full context, or live toolsDecide whether a question needs retrieval, complete documents, or an authorized live-system query.
- 3.5.2 Preserve meaning and permissions during ingestionDesign document ingestion that keeps structure, provenance, and access labels correct through normalization and publication.
- 3.5.3 Cut passages without losing their meaningChoose chunk boundaries and surrounding context that preserve answerable passages without unnecessary duplication.
- 3.5.4 Design hybrid indexes that track source changesDesign filtered dense and lexical retrieval while keeping revisions, deletions, and embedding migrations consistent.
- 3.5.5 Measure retrieval before judging the answerSeparate passage selection from answer quality using precision, recall, reciprocal rank, and end-to-end accuracy.
- LABRetrieval Augmented GenerationBuild a RAG pipeline over Claude's documentation, evaluate retrieval and answers separately, then add summary indexing and reranking.
Apply retrieval strategies matched to data shape and query pattern
- 3.6.1 Classify sources and questions before retrievalCharacterize source structure and answer requirements so each query reaches a retrieval path that can support it.
- 3.6.2 Select retrieval that preserves answer correctnessChoose exact, semantic, SQL, and relationship retrieval while assigning execution controls and source ownership.
- 3.6.3 Tune relevance across the retrieval stagesCombine hybrid search, reranking, query transformations, freshness constraints, and retrieval depth under measurable quality and latency targets.
- 3.6.4 Budget autonomy for uncertain search pathsChoose fixed, iterative, or hybrid retrieval by path uncertainty, measured answer gains, and enforceable operating limits.
- LABEnhancing RAG with Contextual RetrievalAdd Claude-generated context to each chunk, then add BM25 hybrid search and a reranker, measuring Pass@k at each stage.
Evaluate connection protocols and select the appropriate integration mechanism (MCP, API/CLI, agent-to-agent)
- 3.7.1 Weigh four integration mechanisms per connectionCompare integration mechanisms by reuse, identity, observability, failure isolation, and execution control.
- 3.7.2 Justify MCP with reusable service capabilitiesChoose an MCP server and transport only when reusable capabilities justify authorization, compatibility, and operational costs.
- 3.7.3 Keep mediated calls in application codeChoose direct custom tools or established CLIs according to policy ownership, execution environment, and operational requirements.
- 3.7.4 Own acceptance across independent agent systemsDesign external agent delegation with authenticated identities, bounded tasks, verifiable artifacts, and observable completion.
- LABDefining tools with MCPDefine a read tool and an edit tool on an MCP server with the Python SDK's decorators instead of hand-written JSON schemas.
Evaluate progressive discovery vs. monolithic context strategy
- 3.8.1 Choose what every request must loadChoose an up-front, progressive, or hybrid context strategy from task coverage, change cadence, and operational constraints.
- 3.8.2 Connect the four disclosure pathsCombine Skills, deferred tools, file navigation, and resource catalogs without confusing their loading controls.
- 3.8.3 Measure what discovery actually savesCompare complete loading strategies using token categories, cache behavior, acquisition latency, freshness, and missed-context rates.
- 3.8.4 Govern capabilities after they are discoveredPreserve execution policy and reconstructable run records when tools, procedures, and source context load dynamically.
- LABTool Search: Alternate ApproachesList tool names in the system prompt, load a tool's definition on demand with describe_tool, and keep the prompt cache with defer_loading.
Evaluation, Testing & Optimization
16% of the exam0 of 32 items completed
Define evaluation metrics (accuracy, latency, cost, safety, security)
- 4.1.1 Assign business targets to metric ownersTranslate business outcomes into measurable acceptance thresholds, segment-specific decisions, and accountable metric ownership.
- 4.1.2 Measure useful answers and justified abstentionsDefine complementary quality measures that expose missed cases, unsupported claims, unnecessary abstentions, and incomplete tasks.
- 4.1.3 Price successful work on the user's clockSpecify latency, throughput, and total cost measures that retain retries, failed attempts, and human review.
- 4.1.4 Score harmful actions and unnecessary refusalsSpecify safety and security measures that distinguish policy violations, refusal errors, successful injection, and sensitive-data exposure.
- LABBuilding EvalsBuild three small evals and grade them by code, by a human, and by Claude against a rubric.
Design evaluation datasets and test frameworks using mixed methodologies
- 4.2.1 Build evaluation cases that mirror productionConstruct evaluation datasets that distinguish traffic performance from coverage of rare, expert, adversarial, and synthetic cases.
- 4.2.2 Resolve disagreements before trusting model gradersCombine deterministic checks, calibrated model judgments, and expert adjudication without letting one score hide a critical failure.
- 4.2.3 Locate failures across the evaluation layersOrganize unit, component, end-to-end, trajectory, and regression checks so each answers a distinct production-readiness question.
- 4.2.4 Keep evaluation sets useful across releasesVersion evaluation artifacts, protect held-out cases from tuning, and turn verified production failures into maintained regression coverage.
- LABCode based gradingAdd a code grader that checks the format and syntax of generated code, and combine its score with a model grader's.
- LABGenerate Synthetic Test Data for Your Prompt TemplateHave Claude generate realistic values for a prompt template's variables, and steer the cases it plans.
Conduct A/B testing and iterative improvements
- 4.3.1 Isolate the change before comparing variantsCompare prompt, model, and configuration changes on fixed cases while preserving attribution and reproducible evaluation conditions.
- 4.3.2 Assign comparable traffic before measuring liftDesign concurrent online experiments with stable randomization, explicit outcome metrics, and controls for selection and time effects.
- 4.3.3 Read uncertain results before declaring improvementInterpret sample size, significance, effect intervals, and repeated trials without confusing random output variation with a reliable improvement.
- 4.3.4 Stage releases and roll back regressionsSet evaluation pass criteria, stage candidate exposure, and restore a validated baseline when quality or operational signals regress.
- LABPrompt Versioning and RollbackVersion a Claude Managed Agents triage agent's system prompt, score each version on labelled tickets, and roll back a regression by pinning.
- LABContinuous evals in CIRun an eval suite of real tasks through Claude Code in CI, and gate changes to CLAUDE.md, skills and hooks on its results.
Diagnose system issues (prompt failure, hallucinations, model mismatch)
- 4.4.1 Isolate the layer behind a failureUse recorded runs, repeated trials, and controlled substitutions to locate failures before changing a production system.
- 4.4.2 Prove which instruction causes the defectDistinguish ambiguous instructions, conflicting rules, and defective examples through controlled prompt comparisons.
- 4.4.3 Separate retrieval faults from unfaithful answersLocate missing, stale, and irrelevant context separately from unsupported generation using claim-level comparisons.
- 4.4.4 Prove when the model should changeIdentify capability shortfalls and unnecessary model spend through controlled comparisons of quality, latency, and accepted-result cost.
- 4.4.5 Locate the first broken agent transitionDiagnose selection, argument, execution, error-delivery, and loop failures from correlated tool and agent transcripts.
Optimize token usage, latency, and cost-performance trade-offs
- 4.5.1 Baseline spending before choosing an optimizationBuild a task-level token and latency baseline that exposes optimization gains without hiding quality losses or repeated work.
- 4.5.2 Cut input without losing decisive contextCombine cache reuse, context trimming, retrieval tuning, and tool-result pruning under a measured input-reduction policy.
- 4.5.3 Tune generated work before capping outputChoose concise response formats, safe output ceilings, and measured effort levels without confusing brevity with completed work.
- 4.5.4 Cut agent-loop turns and defer batchable stagesChoose fewer turns, parallel calls, programmatic orchestration, and deferred batches according to dependencies, quality, and complete task cost.
- LABCost Optimization on the Claude APIBaseline an agent's pass rate and cost per task, then apply each cost lever in turn and keep the ones that hold the quality bar.
Monitor system performance using logging and observability tools
- 4.6.1 Specify records that explain each callDefine structured production records that preserve call provenance, measured usage, termination, and verified tool outcomes.
- 4.6.2 Reconcile spend before charging product teamsCombine organization usage and cost reports with application attribution to explain workspace, model, and feature spending trends.
- 4.6.3 Alert when healthy traffic hides deteriorationDesign owned alerts that separate service failures, cost changes, retrieval staleness, and task-mix drift against explicit baselines and SLOs.
- 4.6.4 Turn incident findings into release checksInvestigate production failures through correlated records, verify mitigation, and convert confirmed causes into evaluation and release requirements.
- LABUsage & Cost Admin API CookbookQuery the organization's usage and cost reports with an Admin API key, group and paginate them, and export them for chargeback.
Governance, Safety & Risk Management
14% of the exam0 of 31 items completed
Implement guardrails and safety controls
- 5.1.1 Place controls before each harmful effectAssign input screening, output screening, and tool authorization to the trust boundaries where they can prevent harm.
- 5.1.2 Price classifier errors before choosing controlsCombine deterministic enforcement with semantic classifiers and evaluate bypasses, legitimate blocks, and their operational costs.
- 5.1.3 Require approval and fail closed before risky callsDesign tool approvals that preserve business authorization and block execution when policy checks or reviewers are unavailable.
- 5.1.4 Deny injected instructions any authorityMitigate direct and indirect prompt injection by isolating content, reducing accessible privileges, and constraining tool effects.
- 5.1.5 Contain execution with centrally enforced settingsChoose sandbox boundaries, restrict network access, and verify managed runtime policy across developer and automated environments.
- LABHooks as approval gatesExpress a release approval as a Claude Code PreToolUse hook that allows, asks or denies, and lock it in with managed settings.
- LABBuilding a moderation filter with ClaudeBuild a prompt-defined moderation classifier that sorts user text into ALLOW and BLOCK, then improve it with reasoning and examples.
Identify risks, limitations, and failure modes of LLM systems
- 5.2.1 Separate six sources of model failureIdentify model limitations and assign the checks that prevent plausible answers from becoming unsupported business decisions.
- 5.2.2 Trace failures across the agent workflowIdentify how local agent mistakes, dependency failures, stale inputs, and drift propagate into system-wide operational harm.
- 5.2.3 Trace attacks from content to capabilityIdentify prompt-injection, exfiltration, disclosure, and excess-access risks by following untrusted content through data and action paths.
- 5.2.4 Rank risks by harm and recoverabilityPrioritize risks using likelihood, impact, detectability, and reversibility while making uncertainty and decision authority explicit.
- 5.2.5 Assign treatment and authorize residual riskCreate owned risk-treatment plans with verified fallbacks, execution budgets, shutdown authority, and explicit residual-risk acceptance.
- LABDesign and Debug a Multi-Agent Research PipelineBuild a coordinator with parallel subagents, then inject a subagent timeout and conflicting sources and check how the failure reaches the final report.
Apply human-in-the-loop validation strategies
- 5.3.1 Choose when people intervene in agent actionsChoose approval, retrospective review, or exception handling from reversibility, validated uncertainty, and the cost of an error.
- 5.3.2 Give each reviewer an actionable decisionDesign owned review queues, escalation paths, and compact review packages that preserve the evidence needed to decide.
- 5.3.3 Let policy outrank calibrated confidenceCombine validated confidence signals, mandatory policy triggers, and risk tiers into an inspectable review-routing policy.
- 5.3.4 Budget reviewer time before promising turnaroundCalculate review and audit demand, reserve specialist capacity, and set sampling plans that preserve risk coverage under turnaround constraints.
- 5.3.5 Test whether reviewers catch consequential mistakesMeasure adjudicated overrides, errors that survive review, and automation bias, then turn verified decisions into evaluation cases.
- LABGate: human-in-the-loop with custom toolsBuild a Managed Agents expense approver whose decide and escalate custom tools pause the session until your application returns a result.
- LABBuild a Structured Data Extraction PipelineBuild a schema-driven extraction pipeline with validation retries and batch processing, then route low-confidence fields to human review.
Ensure compliance with regulations (e.g., GDPR, HIPAA, FedRAMP)
- 5.4.1 Trace each obligation to control and evidenceTranslate regulatory obligations into testable architectural requirements, named controls, accountable owners, and proportionate audit records.
- 5.4.2 Carry GDPR obligations through every copyApply GDPR purpose, lawful-basis, minimization, retention, deletion, and rights requirements across prompts, logs, memory, and outputs.
- 5.4.3 Match PHI flows to covered servicesSelect contractually covered services and eligible Claude API configurations for every protected-health-information flow.
- 5.4.4 Separate cloud assurance from system authorizationSelect an appropriate FedRAMP service boundary and distinguish inherited provider capabilities from controls your system must operate.
- 5.4.5 Choose geography across the processing chainAlign inference routing, storage, deployment platforms, and subprocessor review with residency and international-transfer requirements.
- LABData residency: pin an agent's inference geographyPin a managed agent's model requests to US inference with model.inference_geo, and see how the workspace policy, updates and per-session overrides treat the pin.
- LABVisibility: what you can measureDecide how a Claude Enterprise rollout records content, exports telemetry and sets retention, and name who reviews each record.
Address ethical AI considerations (bias, fairness, transparency)
- 5.5.1 Trace bias before comparing group outcomesIdentify bias sources and measure group outcomes without treating aggregate accuracy or equal selection rates as proof of fairness.
- 5.5.2 Layer bias mitigations from criteria to reviewCombine prompt changes, curated inputs, enforceable decision constraints, and human oversight into a measured bias-mitigation plan.
- 5.5.3 Explain AI assistance where people rely on itDesign AI notices, contextual explanations, limitations, and verifiable citations that help people understand and question an outcome.
- 5.5.4 Assign authority to correct AI-assisted decisionsDefine decision ownership, usable appeals, corrective action, and incident reporting across an AI-assisted service.
Stakeholder Communication & Lifecycle Management
14% of the exam0 of 23 items completed
Conduct structured discovery and requirement gathering
- 6.1.1 Plan discovery around journeys and decision ownersPlan discovery that exposes real workflows, stakeholder conflicts, and the owners who can accept or block delivery.
- 6.1.2 Ask what each workflow must doElicit business functions, required data, and accepted failure outcomes from stakeholder walkthroughs and real cases.
- 6.1.3 Find constraints that can stop deliveryElicit measurable operating limits and verify data and system readiness before treating a Claude workflow as feasible.
- 6.1.4 Turn findings into a bounded problemWrite a problem statement with prioritized acceptance criteria, explicit constraints, and owned assumptions and decisions.
- LABCapture as intent.mdTurn an originator's idea into a reviewed, version-controlled intent.md proto-spec that the product owner accepts or closes.
- LABOwners and intakeName an owner for each of the five Claude Enterprise rollout decisions and run an intake that flags the ones needing extra attention.
Communicate architectural decisions and trade-offs
- 6.2.1 Recommend an option with explicit consequencesPresent comparable architecture options, separate mandatory criteria from preferences, and recommend a bounded decision with an accountable owner.
- 6.2.2 Brief each audience for its decisionTailor architecture briefings to executive, security, legal, and engineering decisions while preserving shared facts about cost, risk, delivery, and quality.
- 6.2.3 State uncertainty before promising production outcomesExplain variable model behavior, bounded evaluation claims, and remaining business risk in language stakeholders can use to authorize a scoped deployment.
- 6.2.4 Defend the choice against credible alternativesAnswer architecture challenges with comparable evaluation results, bounded prototype claims, and explicit conditions for changing the recommendation.
Manage stakeholder feedback loops and expectation alignment (including SLAs)
- 6.3.1 Give stakeholder feedback an owned cadenceEstablish phase-specific feedback channels, decision owners, and response cadences that keep stakeholder expectations aligned.
- 6.3.2 Negotiate SLAs around provider and human limitsNegotiate measurable service commitments with explicit exclusions, provider dependencies, human handoffs, fallback behavior, and support ownership.
- 6.3.3 Require pilot value before funding scaleRun a bounded pilot whose predefined exit criteria test business value, operating costs, risk, and readiness for expansion.
- 6.3.4 Resolve scope demands against agreed outcomesUse owned change decisions, explicit priorities, and outcome-based progress reports to resolve conflicting stakeholder demands.
Document architectures and provide implementation guidance
- 6.4.1 Describe the system behind each releaseDocument system boundaries and versioned behavioral configuration so builders and operators can identify what a deployed Claude system actually does.
- 6.4.2 Write ADRs that say when to reopen themWrite architecture decision records that preserve rejected alternatives, testable assumptions, and explicit reasons to reopen a decision.
- 6.4.3 Specify outcomes builders can verifyTurn an approved architecture into implementation guidance with owned interfaces, explicit failure behavior, and measurable acceptance criteria.
- 6.4.4 Give operators procedures and decision authorityWrite runbooks and responsibility matrices that let operators deploy, monitor, respond, and roll back without relying on the original architect.
Support lifecycle phases (discovery, design, handoff, monitoring, iteration)
- 6.5.1 Define phase exits and production readinessDefine owned entry and exit criteria that distinguish a successful prototype from a secure, hardened, scalable production service.
- 6.5.2 Transfer service ownership through operational rehearsalPlan an operational handoff with accepted responsibilities, actionable alerts, funded support, and training demonstrated without the architect.
- 6.5.3 Coordinate changes across the whole releaseManage model, prompt, index, and tool changes as owned releases with regression results, staged exposure, and executable rollback.
- 6.5.4 Prioritize useful iterations and retire responsiblyCombine operational signals with stakeholder outcomes to choose bounded improvements, reopen discovery, or retire a Claude service safely.
- LABClosing the loop on metricsWire a deterministic control-band script to log a breach, start Claude read-only to diagnose it, or let it propose a gated fix, and route the finding back as intent.md.
Developer Productivity & Operational Enablement
7% of the exam0 of 19 items completed
Configure Claude tools and environments for teams (e.g., Claude Code)
- 7.1.1 Release the team's configuration togetherStandardize a reviewable Claude Code setup whose instructions, permissions, hooks, integrations, and skills work together on a clean clone.
- 7.1.2 Put mandatory policy in managed settingsAssign configuration ownership by scope and verify which managed source enforces organizational restrictions.
- 7.1.3 Set team permission modes and sandbox limitsSelect permission modes and narrow tool approvals while keeping secrets and shell execution inside explicit access boundaries.
- 7.1.4 Review capabilities before distributing them broadlyChoose skill, plugin, and connector distribution routes with source review, bounded updates, and checks on the actual consumer surface.
- 7.1.5 Verify onboarding before expanding team accessPlan access cohorts, route-specific spending controls, usage reporting, and reproducibility checks that expose configuration drift.
- LABConfigure Claude Code for a Team Development WorkflowConfigure a shared Claude Code setup — instructions, path rules, a forked skill and MCP servers — and test when plan mode pays off.
- LABGoverning customizationsChoose an organization's posture for creating and spreading skills, plugins, projects and organization instructions in Claude Enterprise.
Improve developer workflows using AI-assisted tooling
- 7.2.1 Target assistance at the delivery bottleneckSelect AI-assisted development stages by measurable delivery value, verification cost, and the risk of an incorrect change.
- 7.2.2 Spend planning effort where uncertainty mattersChoose a team planning policy that resolves consequential uncertainty before implementation while keeping understood changes direct.
- 7.2.3 Require checks before accepting generated changesCombine executable verification, independent review, and merge enforcement into owned completion criteria for AI-generated work.
- 7.2.4 Separate CI analysis from repository mutationsDesign Claude Code automation whose triggers, credentials, tools, and publication steps match an explicitly owned side-effect policy.
- 7.2.5 Integrate parallel sessions without losing ownershipChoose subagents or separate worktree sessions and coordinate their context, dependencies, verification, and cleanup.
- LABGive Claude a feedback loopGive a Claude Code session one-command tests, a build and visual checks so it verifies its own work, and protect those checks from the agent.
Support debugging and operational issue resolution
- 7.3.1 Locate configuration faults before relaxing controlsDiagnose instruction, permission, MCP, and hook failures from the configuration a Claude Code session actually loaded.
- 7.3.2 Match API recovery to the failureDiagnose Claude API integration failures and choose bounded retries, request repair, or an approved fallback within the caller's deadline.
- 7.3.3 Separate broken integrations from behavior regressionsUse correlated requests and controlled comparisons to locate failures in adapters, tools, prompts, or model behavior.
- 7.3.4 Keep investigation separate from production remediationDesign read-only Claude incident access and require explicit human approval and reliable pre-execution checks for remediation.
- 7.3.5 Rehearse runbooks against confirmed incident causesMaintain executable diagnostic procedures that connect verified causes to rollback, regression checks, and operator documentation.
- LABThe SRE Incident Response AgentBuild a Claude Agent SDK agent that diagnoses a simulated database pool exhaustion through MCP tools, then fixes it behind PreToolUse hooks.