Claude Certified Architect (CCA) Practice Questions: Prepare for Anthropic's Certification

What Is the Claude Certified Architect (CCA) Certification?

The CCA is Anthropic's official certification for developers and architects who build with Claude. The Foundations exam (CCA-F) launched in March 2026. It is a 60-question, 120-minute exam delivered online with proctoring (or at a testing centre), and you need a scaled score of 720 out of 1000 to pass. The questions are multiple-choice and scenario-based, grounded in a handful of realistic production situations rather than trivia.

On pricing: the exam lists at USD 125, paid through Anthropic Partner Academy before Pearson scheduling. Access is open to anyone whose employer is in the (free) Claude Partner Network - you join the Partner Network, work through the free preparation courses on Anthropic Academy (anthropic.skilljar.com), then request exam access. The preparation courses are free for everyone regardless of partner status. Anthropic has signposted broader public, self-service registration but has not given a date.

The certification validates five domains, and the weighting tells you exactly where to spend your study time: Agentic Architecture and Orchestration (27%), Claude Code Configuration and Workflows (20%), Prompt Engineering and Structured Output (20%), Tool Design and MCP Integration (18%), and Context Management and Reliability (15%). Agentic architecture plus Claude Code alone account for nearly half the exam, so if you only have time to go deep on two domains, those are the two.

Unlike vendor certifications that test memorization of service names and pricing tiers, the CCA is scenario-based. You will not see "What does MCP stand for?" but rather "Your agent calls a tool that returns a structured error marked retryable - should it retry, escalate to a human, or abort?" This practical focus makes it both harder and more valuable than typical AI certifications, and it assumes roughly six months of hands-on experience building with Claude.

Domain 1: Agentic Architecture and Orchestration (27%)

This is the single heaviest domain and the centre of gravity for the whole exam. It covers designing agentic loops, multi-agent patterns, session and state management, and the Claude Agent SDK. You need to reason about when to use a single agent versus subagents, orchestrator-worker versus delegation patterns, and how to keep parallel work bounded so you do not exhaust resources.

Expect scenario questions about agentic loops driven by stop_reason, coordinator-subagent delegation, how to fan work out to a controlled number of subagents and aggregate their results, and how to keep subagent context isolated via the Task tool. The Claude Agent SDK is explicitly in scope here, so understand how it structures agentic loops and hooks rather than treating it as a black box.

Study tip: build a real multi-step agent before the exam. Wire up a small orchestrator that spawns a few workers, persists intermediate results with a memory tool, and aggregates their output. The questions reward people who have felt these failure modes in practice rather than just read about them.

Domain 2: Claude Code Configuration and Workflows (20%)

Claude Code is Anthropic's CLI for using Claude in software development. This domain covers the CLAUDE.md memory hierarchy (global, project, and folder level), custom slash commands, hooks and permissions, plan mode, and CI/CD integration. It tests whether you can configure Claude Code to behave consistently across a team and a pipeline, not just on your own laptop.

Expect questions about where context belongs (CLAUDE.md across the hierarchy versus IDE extensions versus environment variables), how plan mode helps with complex multi-file changes, and how hooks enforce compliance and security checks in agentic workflows. Enterprise patterns - running Claude Code in CI/CD, managing costs across teams - show up here too.

Study tip: set up a project CLAUDE.md, add a custom slash command and a hook, and run Claude Code non-interactively in a CI job. That covers most of what this domain asks.

Domain 3: Prompt Engineering and Structured Output (20%)

This domain covers prompt structure, clear instruction design, controlling output format, and getting reliable structured data out of Claude. A recurring theme is producing strictly valid JSON or schema-conformant output that a downstream system can parse without choking on prose or markdown fences.

You should understand when to use tool use to enforce an output schema versus prompting for JSON directly, how few-shot examples and explicit success criteria improve consistency across many calls, and how a validation-retry-feedback loop recovers when a response fails your schema. Expect questions that contrast a brittle approach (regex-stripping a free-form response) with a robust one (defining the shape as a tool).

Study tip: practise turning a vague "give me JSON" prompt into a schema enforced through tool use, and notice how much more reliable it becomes.

Domain 4: Tool Design and MCP Integration (18%)

MCP is the open protocol that lets Claude interact with external systems: databases, APIs, file systems, and more. This domain covers MCP architecture (servers and clients), the three core primitives - tools (actions Claude can take), resources (data Claude can read), and prompts (templates) - choosing the right primitive for the job, and how to design tools and their error responses well.

Questions will test whether you can choose the right primitive for a scenario, when to use stdio versus SSE transport, how to handle authentication in an MCP server, and how to structure servers for scalability and caching. The line between Claude API tool use (tool_use and tool_result content blocks) and an MCP-exposed tool is fair game, so be clear on both.

Study tip: build one MCP server that exposes a tool and a resource, and run it over both stdio and SSE. The four sample MCP questions below are the most-missed on this topic.

Domain 5: Context Management and Reliability (15%)

This domain covers working within the context window, using memory tools to persist state across turns, and making agentic systems reliable: retries, error handling, and graceful degradation. It is where long-horizon reasoning meets production realities like cost and latency.

Expect questions about serializing analysis state to a memory tool when a conversation approaches the context limit, monitoring the stop_reason field to detect when max_tokens truncated a response, and balancing cost control against response completeness. The exam rewards explicit state tracking over relying on Claude's implicit summarization.

Study tip: instrument a real workload - log stop_reason, persist state to a memory tool at a token threshold, and prove you can continue in a fresh context window without losing the audit trail.

Study Strategy: How to Pass the CCA on Your First Attempt

1. Work through the free preparation courses on Anthropic Academy first (anthropic.skilljar.com). They are the primary source material and remain free for everyone, partner or not. Do not skip a course just because you think you know the content.

2. Go deep on Agentic Architecture and Claude Code (47% of the exam combined). These two domains reward hands-on practice: build at least one multi-agent workflow and configure a real Claude Code project before you sit the exam.

3. Use ReadRoost's free practice pack to pressure-test your knowledge. Our 525 questions are scenario-based, matching the exam format. Focus on the ones you get wrong and read the explanations carefully.

4. Read the official documentation at docs.claude.com and docs.anthropic.com, including the Claude Agent SDK reference. The exam references specific implementation details that live in the docs, not in the course videos.

5. Practice with real code. The CCA is a practical certification. If you have not actually built something with the Claude API, MCP, the Agent SDK, and Claude Code, you will struggle with the scenario questions.

Why the CCA Matters for Your Career

AI engineering roles are exploding in 2026, and employers are struggling to evaluate candidates. Anyone can claim "experience with LLMs" on a resume. The CCA provides a verifiable signal that you can actually design and ship production systems with Claude.

Anthropic is the maker of Claude, the model that powers an increasing number of enterprise AI applications. Being certified by the model provider carries weight that third-party AI certifications cannot match, similar to how an AWS certification from Amazon carries more weight than a generic cloud certification.

Updated July 2026: 12 Practice Questions (Mapped to the Current Exam Blueprint)

Updated July 2026: refreshed price (USD 99 → USD 125) and removed the stale "5,000 free Partner Network" claim that has not been on the Skilljar access page since at least June 2026. The 12 questions below are mapped to the five live domains, with the heaviest coverage on Agentic Architecture and Orchestration and Tool Design and MCP Integration - two of the areas that reward hands-on practice the most. They are pulled from the ReadRoost CCA Foundations question bank (525 scenario-based questions, 100% free) and match the difficulty and format of the real assessment. Read each question, pick your answer, then check the explanation. The full free pack is at readroo.st/marketplace/claude-certified-architect-cca-foundations.

Quick answer key (try the questions first, this is here for scanning afterwards): 1-A, 2-A, 3-B, 4-A, 5-B, 6-B, 7-A, 8-A, 9-A, 10-D, 11-B, 12-B. The two that most often catch people out are the MCP subscription pattern (Q3) and the multi-agent orchestration with bounded parallelism (Q6) - if you got both of those right, you have a solid grip on the heaviest domains.

Questions 1-4: Tool Design and MCP Integration

Domain: Tool Design & MCP Integration | Difficulty: Challenging 1. Your MCP server is experiencing intermittent connection drops with clients. You've confirmed that the network is stable. The server logs show that clients sometimes send requests but the server never sends responses. What diagnostic step should you take first? A) Check if the server's event loop is blocking; long-running request handlers can prevent the server from processing subsequent messages B) Increase the TCP keep-alive timeout on both client and server C) Verify that all JSON-RPC 2.0 responses include the same 'id' value as the corresponding request D) Check if the transport layer buffer is full and implement flow control

Correct Answer: A If the server receives requests but doesn't send responses, the most likely cause is that the server's event loop is blocked by a long-running handler. This prevents the server from processing and responding to messages. Debugging the server's request handling code (looking for blocking I/O, synchronous operations, or infinite loops) should be the first step. TCP keep-alive and buffer management are valid concerns but would not explain the specific pattern of requests arriving but responses not being sent.

Domain: Tool Design & MCP Integration | Difficulty: Moderate 2. Your document processing pipeline needs to handle images, text, and tool calls in a single request to analyze a complex report. You're constructing a user message that includes a scanned PDF image, a text question about it, and need to call a tool to verify facts. How should you organize the content blocks, and in what order? A) Place the image content block first, followed by the text content block with the question; tools are invoked by Claude's response, not included in the user message B) Mix image and text blocks freely in any order; include tool_use blocks in the user message to specify which tools might be needed C) Put all text content in a single block, then the image block, then a tool_use block specifying the analysis task D) Separate image and text into different messages; tool_use blocks cannot coexist with image content in the same request

Correct Answer: A In a user message, you can include both image and text content blocks in any logical order (typically image first for context, then text with the question). Tool_use blocks are generated by Claude in the assistant response, not included in user messages. When Claude generates a tool_use block, your application executes the tool and returns results in a subsequent user message with a tool_result block. This separation maintains the proper message flow and lets Claude decide which tools to invoke based on content.

Domain: Tool Design & MCP Integration | Difficulty: Moderate 3. Your MCP server publishes a 'resource_updated' notification whenever a monitored resource changes. A client connects and immediately starts receiving notifications for resources it hasn't requested yet. Is this a problem, and how should you handle it? A) This is expected behavior; notifications are broadcast to all connected clients regardless of their resource subscriptions B) This is a problem; implement subscription-based notifications where clients explicitly request updates for specific resources C) This is expected; the client should implement filtering logic to ignore notifications for resources it doesn't care about D) This is a protocol violation; the server should only send notifications after the client has initialized

Correct Answer: B While MCP supports server-initiated notifications, best practice is to implement subscription-based notifications where clients explicitly subscribe to updates for specific resources or topics. This reduces unnecessary message traffic and allows clients to control which notifications they receive. Broadcasting all notifications to all clients is inefficient and can overwhelm clients with irrelevant information. Client-side filtering is possible but less efficient than server-side subscription management.

Domain: Tool Design & MCP Integration | Difficulty: Moderate 4. Your MCP server provides resources that represent database query results. These results are large (10+ MB) and expensive to compute. A client requests the same resource multiple times within a 5-minute window. How should you optimize this scenario? A) Implement server-side caching with a 5-minute TTL; return the same resource data for repeated requests within the cache window B) Implement client-side caching hints in the resource metadata (e.g., 'cache-control' headers) so Claude can cache results locally C) Implement streaming resource responses using chunked transfer encoding to reduce memory overhead D) Request that the client implement request deduplication logic to avoid duplicate queries

Correct Answer: A Server-side caching with appropriate TTLs is the most efficient approach for expensive, frequently-accessed resources. The server can transparently cache results and serve them to multiple clients without recomputation. Client-side caching hints might help in some scenarios, but the server is best positioned to manage cache lifecycle for expensive operations. Streaming helps with memory but doesn't address the core optimization problem. Client-side deduplication is not a reliable optimization strategy.

Questions 5-7: Agentic Architecture and Orchestration

Domain: Agentic Architecture & Orchestration | Difficulty: Moderate 5. You are building a multi-step document processing agent that must: (1) extract text from PDFs, (2) analyze sentiment, and (3) generate a summary. You want to implement hooks to log execution time and validate outputs between each step. Which approach best implements this requirement? A) Create a single prompt that chains all three tasks together and use Claude's native tool_use feature to call external APIs sequentially B) Implement pre/post execution hooks in your agent loop that wrap tool calls, allowing you to inject logging and validation logic before and after each step C) Use three separate Claude API calls with no hooks, storing intermediate results in a database and manually validating between calls D) Create a CLAUDE.md configuration file that lists all three tasks and rely on Claude to automatically execute them in the correct order

Correct Answer: B Pre/post execution hooks are the standard pattern for injecting cross-cutting concerns like logging, validation, and monitoring into tool execution workflows. This allows clean separation of concerns while controlling execution flow. Option A conflates prompt engineering with execution control, Option C bypasses agent architecture benefits, and Option D misuses CLAUDE.md which is for static project configuration, not dynamic execution control.

Domain: Agentic Architecture & Orchestration | Difficulty: Moderate 6. You're building a document processing agent that needs to extract data from 50 PDFs in parallel, then aggregate results into a summary report. Each PDF extraction takes 2-3 seconds and requires separate API calls. Your context window is 200K tokens. Which orchestration pattern best balances efficiency and context management? A) Create a single parent agent that sequentially processes each PDF, storing intermediate results in a local SQLite database, then reads all results back into context for final aggregation B) Spawn 10 parallel subagents, each processing 5 PDFs independently, with each subagent persisting its results to disk via a memory tool, then have a coordinator agent read and aggregate the saved states C) Create 50 concurrent subagents processing one PDF each, collect all results in memory, then pass the complete array to a final aggregation agent D) Use a single agent with tool_use loops to process all PDFs sequentially within one conversation, relying on Claude's internal context management to handle token limits automatically

Correct Answer: B Option B implements proper subagent orchestration with bounded parallelism (10 workers) to avoid resource exhaustion while leveraging parallel execution. By persisting intermediate results to disk via a memory tool, it avoids context window overflow and enables long-horizon reasoning across state checkpoints. Option A is inefficient (sequential), C risks resource limits with 50 concurrent agents, and D ignores context window constraints entirely.

Domain: Agentic Architecture & Orchestration | Difficulty: Moderate 7. Your agent performs multi-step financial analysis spanning 15 reasoning steps. After step 8, the agent needs to transition to a different reasoning context (e.g., switching from technical analysis to regulatory compliance checks). The conversation is at 180K tokens. What's the best approach to maintain continuity while managing context? A) Use a memory tool to serialize the analysis state after step 8 (including all intermediate calculations, assumptions, and decisions), save it to a JSON file, then load it back when starting the compliance phase in a fresh conversation B) Continue the same conversation thread and rely on Claude to automatically summarize earlier steps to make room for new context C) Create a new agent instance for the compliance phase and pass only the final conclusion from step 8 as input, discarding all intermediate reasoning D) Implement a git-based checkpoint system where each step commits the full agent state, allowing rollback but continuing in the same conversation

Correct Answer: A Option A implements explicit state tracking with a memory tool, enabling clean context transitions while preserving all reasoning artifacts needed for compliance validation. This is the recommended pattern for long-horizon reasoning across context windows. Option B relies on implicit summarization (unreliable), C loses critical audit trail information, and D adds unnecessary version control overhead without solving the context window problem.

Questions 8-10: Claude Code, Context Reliability, and Prompt Engineering

Domain: Claude Code Configuration & Workflows | Difficulty: Moderate 8. A developer on your team is working on a feature branch and asks: 'I need Claude to understand our codebase structure, dependencies, and coding standards. Should I put all this in CLAUDE.md or rely on IDE extensions to provide context?' What's the best practice? A) Put all context in CLAUDE.md files (global, project, and folder-level) so Claude has access regardless of IDE, then let IDE extensions enhance with real-time features B) Rely solely on IDE extensions to provide context, since they have access to real-time project information that CLAUDE.md files cannot capture C) Put context only in project CLAUDE.md and avoid folder-level CLAUDE.md files to prevent duplication and maintenance overhead D) Use environment variables for context that changes frequently, and CLAUDE.md for static configuration

Correct Answer: A CLAUDE.md files (across the memory hierarchy) provide Claude with persistent context about codebase structure, dependencies, and standards, ensuring consistency across CLI usage, different IDEs, and team members. IDE extensions complement this by providing real-time features (syntax highlighting, navigation, debugging). This layered approach ensures Claude has context everywhere while extensions enhance the IDE experience. Option B ignores CLI usage, C misses the benefits of hierarchical configuration, and D conflates different configuration concerns.

Domain: Context Management & Reliability | Difficulty: Challenging 9. You're optimizing token usage in your application and want to understand how max_tokens affects both cost and response quality. You set max_tokens to 500 for a complex analysis task, but Claude's response is incomplete. What should you do to balance cost control with response completeness? A) Increase max_tokens incrementally and test; monitor the stop_reason to understand if 'max_tokens' is being hit; consider breaking complex tasks into multiple requests with intermediate summaries B) Remove the max_tokens limit entirely; the API will automatically optimize token usage C) Set max_tokens to match the model's context window size to ensure complete responses D) Use max_tokens only for streaming requests; non-streaming requests ignore this parameter

Correct Answer: A The max_tokens parameter is essential for cost control but can truncate responses if set too low. The proper approach is to test incrementally, monitor the stop_reason field to detect when 'max_tokens' is being hit, and adjust accordingly. For complex tasks, consider breaking them into multiple API calls with intermediate summaries or using a retrieval-augmented approach. This balances cost efficiency with response quality and helps you find the optimal max_tokens value for your specific use case.

Domain: Prompt Engineering & Structured Output | Difficulty: Challenging 10. Your extraction service asks Claude to return a JSON object of invoice fields, but occasionally a response fails your downstream schema validation (a required field is missing or a date is malformed). You need the highest success rate without human review. What is the most reliable pattern? A) Lower the temperature to 0 and resend the identical prompt repeatedly, assuming a deterministic setting will eventually emit a schema-valid response on its own B) On a validation failure, return the invalid output plus the validator errors to Claude and ask it to fix only those fields, with a small retry cap C) Accept the first response and add a rules engine that guesses the missing or malformed values from the surrounding invoice text D) Split every invoice into one field per request so that no single Claude response can ever fail the schema validation step

Correct Answer: B The reliable pattern is a validation-retry-feedback loop: when a response fails schema validation, return the invalid output and the specific validator errors to Claude and ask it to correct just those fields, bounded by a small retry limit. That targeted feedback is what lifts the success rate. Option A resends blindly with no new information, so it tends to repeat the same failure; Option C fabricates values outside the model's control; and Option D multiplies cost and latency while losing the cross-field context that makes extraction accurate.

Questions 11-12: Agentic Loops and Structured Output

Domain: Agentic Architecture & Orchestration | Difficulty: Challenging 11. You are writing the control loop for an agent that calls tools with the Claude API. After each model response you must decide whether to execute tools and continue, or stop and return the answer to the user. Which signal should drive that decision? A) Continue looping until Claude returns a completely empty text block, and treat that blank response as the definitive signal that the task has finished B) Check the response's stop_reason: on 'tool_use' run the requested tools, append the tool_result blocks, and call the model again; on 'end_turn' stop C) Set a fixed number of loop iterations up front and always run exactly that many tool rounds D) Parse the assistant's prose on each turn for natural-language phrases like 'I am done now' to decide when the task has finished

Correct Answer: B The agent loop is driven by the response's stop_reason. A 'tool_use' stop_reason means Claude is requesting tools: you execute them, append the tool_result blocks, and call the model again; an 'end_turn' stop_reason means the turn is complete and you return the result to the user. Option A misreads an empty block as completion, Option C ignores what the model actually asked for and runs a rigid number of rounds, and Option D relies on brittle prose-matching instead of the structured signal the API already provides.

Domain: Prompt Engineering & Structured Output | Difficulty: Moderate 12. Your service must return strictly valid JSON matching a fixed schema for every Claude response, because a downstream system parses it programmatically and cannot tolerate prose or markdown fences. Which approach is most reliable? A) Ask for JSON in the prompt and run a regex to strip any extra text before parsing B) Define the response shape as a tool and have Claude return it via tool use, so the output conforms to the tool's input schema C) Lower the temperature to 0 and rely on the model stopping before it adds explanations D) Post-process every response with a second Claude call that reformats it into JSON

Correct Answer: B Defining the target shape as a tool and having Claude respond through tool use is the most reliable way to get schema-conformant structured output: the model fills the tool's input schema rather than free-form text, so you avoid stray prose or markdown fences. Regex stripping (A) is brittle, temperature alone (C) does not guarantee structure, and a second reformatting call (D) doubles cost and latency while still not guaranteeing validity.

How Did You Score?

10-12 correct: You are exam-ready on the heaviest CCA domains. Drill edge cases on Context Management and Reliability and on the Agent SDK in the full ReadRoost pack at readroo.st/marketplace/claude-certified-architect-cca-foundations. 6-9 correct: Solid core, but tighten your Agentic Architecture and MCP knowledge. Review the orchestration, subscription, and memory-tool patterns above - they map to the heaviest-weighted domains on the current blueprint. 0-5 correct: Work through the free Anthropic Academy courses (anthropic.skilljar.com) for Agentic Architecture and MCP first, then come back and retake these questions. The CCA is scenario-based - memorization will not carry you.

If you found these useful, the full CCA Foundations pack (525 questions and 300 flashcards) is free at readroo.st/marketplace/claude-certified-architect-cca-foundations. It covers every domain with explanations that match the format above.