Free Claude Certified Architect practice exam

Answer: D. Read-heavy research where independent sources can be explored simultaneously and each subagent returns a condensed summary

Parallel subagents shine on parallelizable, self-contained, read-heavy work: each worker explores independently in its own context and returns compressed findings. Sequential dependencies eliminate the parallelism benefit, tasks requiring continuously shared state incur heavy coordination overhead, and quick targeted edits are better done in the main conversation because subagents start fresh and add latency.

Answer: A. The tool call is blocked, and the hook's stderr output is fed back to Claude as an error message

Exit code 2 from a PreToolUse hook is a blocking error: the tool call is prevented and the stderr text is returned to Claude so it understands why the action was rejected. Stdout, including any JSON, is ignored on exit code 2; JSON decisions like permissionDecision are only processed when the hook exits with code 0. There is no automatic retry behavior for hooks.

Answer: D. Gather context, take action, verify work, then repeat.

Anthropic describes the agent loop as gathering context, taking action, verifying work, and repeating until the task is done. Classify-and-route describes the routing workflow, not the agent loop, and generate-then-evaluate describes evaluator-optimizer. Planning everything upfront and terminating contradicts the iterative, feedback-driven nature of agents.

Answer: D. Sectioning, which breaks a task into independent subtasks run in parallel, and voting, which runs the same task multiple times to get diverse outputs.

Anthropic names exactly two parallelization variants: sectioning (independent subtasks in parallel) and voting (the same task run multiple times for diverse outputs). Routing is a separate workflow pattern and gates belong to prompt chaining, not parallelization. Sharding, batching, and map-reduce are general distributed computing terms that Anthropic does not use for this pattern.

Answer: A. It is a client-side tool: Claude requests operations such as view and create, and the developer's application executes them against storage the developer controls.

The memory tool operates client-side: Claude only emits tool_use requests, and your application executes each command against its own storage, returning results in tool_result blocks. The /memories path is just a prefix your handler maps onto real storage such as a per-user directory or database keys. Anthropic does not host the files, there is no managed vector database behind it, and it has no dependency on the code execution tool.

Answer: D. Failures are easier to trace and debug because there is one context and one decision-making loop instead of coordination across multiple agents.

With one agent there is a single trajectory to inspect, so debugging and tracing are simpler and cheaper than reconstructing interactions among an orchestrator and multiple subagents. Breadth-first research exceeding one context window is exactly where multi-agent systems excel, single agents remain non-deterministic across runs, and long-running single agents are still stateful systems where errors compound, so observability is still required.

Answer: D. In an isolated environment such as a container or VM where the agent cannot damage systems that matter

The docs warn that bypassPermissions skips permission prompts and should only be used in isolated environments like containers or VMs where Claude Code cannot cause damage. CLAUDE.md instructions shape model behavior but are not an enforced boundary, so they do not make the mode safe on a workstation. Monitoring a production session does not contain the blast radius of a mistaken action, and git does not protect files outside the repository or actions like network calls.

Answer: B. Agentic systems often trade higher latency and cost for better performance on complex tasks, so teams must evaluate when that tradeoff makes sense.

Anthropic states that agentic systems often trade latency and cost for better task performance, and developers should consider when this tradeoff makes sense. Splitting work across calls increases rather than decreases total tokens and wall-clock time, agents are used precisely because complex tasks demand correctness, and autonomous behavior increases (not removes) the need for evaluation and guardrails.

Answer: A. A clear objective, an expected output format, guidance on which tools and sources to use, and explicit task boundaries

Anthropic found that vague delegations cause duplicated work and gaps, and the remedy is detailed task descriptions: an objective, an output format, tool and source guidance, and clear boundaries for each subagent. Adding more workers amplifies the duplication rather than fixing it, peer negotiation is not the documented pattern (the orchestrator owns decomposition), and dumping the full reasoning trace bloats worker context without defining boundaries.

Answer: B. Resume the session with the fork session option enabled, which creates a new session ID seeded with a copy of the original history while leaving the original session unchanged.

Forking (resume plus forkSession in TypeScript or fork_session in Python) creates a new session that starts from a copy of the original's history and gets its own session ID, so the original thread remains intact and separately resumable. The continue option simply picks up the most recent session and does not snapshot anything. Renaming transcript files is not a supported branching mechanism, and resuming never reassigns or archives the original session's ID.

Answer: C. Let the agent resolve routine cases autonomously, but have it pause at checkpoints for human approval on high-risk actions, such as refunds above a threshold, or when it encounters blockers.

Anthropic describes agents that pause for human feedback at checkpoints or when encountering blockers, which lets teams gate high-risk actions like large refunds while preserving autonomy for routine resolutions. Approving every message forfeits the scaling benefit of an agent, Anthropic's own support example includes consequential tools like issuing refunds, and temperature is a sampling parameter, not a guardrail against financially risky tool calls.

Answer: C. It separates concerns by classifying each query and sending it to a specialized prompt, so optimizing one category no longer degrades performance on the others.

Anthropic recommends routing for complex tasks with distinct categories that are better handled separately, precisely because it allows separation of concerns and specialized prompts without one input type's optimization hurting others. Running all prompts in parallel describes parallelization and wastes cost here. Routing needs an accurate classifier, not fine-tuned models, and stuffing all instructions into one prompt is the failure mode the team is already experiencing.

Answer: C. A permission rule that denies Claude the ability to run a specific shell command

Permission rules like permissions.deny are technical enforcement applied by the Claude Code client regardless of what the model decides, so they belong in settings files. CLAUDE.md content is context that guides behavior but is not guaranteed to be obeyed. Build commands, naming conventions, and architecture overviews are exactly the kind of natural-language guidance CLAUDE.md is designed to carry.

Answer: A. Lists all CLAUDE.md, CLAUDE.local.md, and rules files loaded in the session and lets you open them in your editor, plus toggle auto memory

The /memory command is the inspection and editing entry point for memory: it shows every memory file loaded in the current session, opens any of them in your editor, and includes the auto memory toggle. Clearing context is handled by /clear or /compact, not /memory. It does not produce token usage reports, and it never writes the conversation itself into CLAUDE.md.

Answer: C. Holding personal, project-specific instructions (like sandbox URLs or preferred test data) that are added to .gitignore rather than committed

CLAUDE.local.md is for individual, per-project preferences: it loads alongside the project CLAUDE.md and should be gitignored so it stays private to you. It does not override or disable the shared CLAUDE.md; both files are combined into context. There is no --local launch flag gating it, and organization-wide policy belongs in the managed policy CLAUDE.md location, not in a per-developer local file.

Answer: B. name and description

Only name and description are required in subagent frontmatter; the Markdown body then becomes the subagent's system prompt. Fields like tools, model, and permissionMode are optional: omitting tools inherits all tools from the main conversation, and omitting model falls back to the session's model. The description is required because Claude uses it to decide when to delegate.

Answer: A. Analyzes the codebase and generates a starting CLAUDE.md with discovered build commands, test instructions, and conventions; if one already exists it suggests improvements instead of overwriting it

/init bootstraps project memory by exploring the codebase and writing a CLAUDE.md that captures build commands, test instructions, and project conventions, and when a CLAUDE.md already exists it proposes improvements rather than overwriting. It is a memory-generation command, not a settings or permissions generator. It never destroys an existing file, and it has nothing to do with Console registration.

Answer: D. An @ prefix followed by the path, for example @docs/git-instructions.md

CLAUDE.md supports @path/to/import syntax, so writing @docs/git-instructions.md anywhere in the file expands that file into context at launch. Both relative and absolute paths are allowed. The templating, #include, and markdown-link forms are plausible-looking inventions that Claude Code does not recognize as imports.

Answer: B. Read-only operations such as file reads and Grep searches

Claude Code uses a tiered permission system in which read-only tools like file reads and Grep never require approval. Bash commands and file modifications both require approval in default mode: Bash approvals persist per project directory and command only when you choose the don't-ask-again option, and file edit approvals last until the session ends. There is no automatic session-wide trust for previously used commands or domains.

Answer: C. The developer notices they are typing the same correction into chat that they typed in a previous session

The docs frame CLAUDE.md as the place to write down what you would otherwise re-explain: repeated corrections, repeated mistakes, and context a new teammate would need. Long multi-step procedures or narrowly scoped guidance belong in skills or path-scoped rules instead, keeping CLAUDE.md concise. Secrets should never go in a memory file, and anything requiring guaranteed enforcement belongs in settings (permissions or hooks), not in context.

Answer: A. The stderr output is shown to Claude as feedback, but the command has already executed and cannot be blocked

PostToolUse fires after a tool call completes, so exit code 2 cannot prevent something that already happened; it only surfaces stderr to Claude so the model can react, for example by fixing a failing check. Claude Code does not roll back tool effects, retry the call, or preemptively block future tool calls based on the exit code.

Answer: D. The command is blocked, because deny rules are evaluated before allow rules and rule specificity does not change that order

Rules are evaluated in the fixed order deny, then ask, then allow, and the first match wins regardless of how specific each rule is. A broad deny like Bash(aws *) therefore blocks every matching call, including ones that also match a narrower allow rule, so a deny rule cannot carry allowlist exceptions. There is no prompt or warning-and-run behavior for this situation.

Answer: C. Only to that engineer, and only in the current project, because the default is local scope stored under the project's entry in ~/.claude.json

Local scope is the default for claude mcp add: the server is recorded under the current project's path inside the user's ~/.claude.json, so it is private to that engineer and loads only in that project. Writing to the shareable .mcp.json requires --scope project, and machine-wide personal availability requires --scope user. Organization-wide deployment is done through managed configuration, not the default add command.

Answer: C. Headless runs cannot display permission prompts, so pre-approve the needed tools, for example --allowedTools "Bash,Read,Edit"

Non-interactive mode has no way to show a permission prompt, so a tool that has not been pre-approved causes the run to fail instead of pausing; --allowedTools (or a permission mode such as acceptEdits) grants the required tools up front. --verbose only changes logging and cannot capture approvals. Plan mode is read-only exploration, which would still block edits, and --max-turns has no default limit and is unrelated to permissions.

Answer: D. Set tool_choice to {"type": "tool", "name": "classify_ticket"}

any only guarantees that at least one tool is called, leaving the choice of which tool to the model, while {"type": "tool", "name": ...} forces one specific tool. Tool ordering does not change any's behavior, auto makes tool use optional rather than forced, and none prevents tool calls entirely regardless of prompt instructions.

Answer: B. Give each subagent a single tool (for example report_findings) whose input_schema is the desired output schema, and force it with tool_choice {"type": "tool", "name": "report_findings"}

Forcing a single tool whose input schema mirrors the desired output makes the model emit one schema-shaped object in the tool_use input, which is the documented tool-based path to structured JSON. Per-field tools fragment the result across multiple calls, prompt instructions alone cannot guarantee validity, and a prefill only continues from the end of the provided text, so the model cannot go back and overwrite placeholders inside a prefilled skeleton.

Answer: B. Validate each response against the JSON schema and, on failure, send a follow-up request containing the invalid output plus the specific validation errors, asking Claude to return a corrected object

Schema validation plus an error-informed retry loop is the standard reliability pattern when hard output constraints are unavailable: the model sees exactly what was wrong and can fix it deterministically. Substituting empty objects silently drops data, raising temperature reduces consistency without targeting the schema violation, and regex renaming cannot repair missing fields or invalid enum values reliably.

Answer: B. Generation was cut off at the token limit, leaving the JSON incomplete; raise max_tokens or stream

Structured outputs guarantees the JSON conforms to the schema only when the model finishes generating; a max_tokens cutoff truncates the output mid-object, producing unparseable JSON. The fix is to increase max_tokens (and stream for large outputs). Schema compilation happens before generation and would not produce a truncated body, and the guarantee explicitly does not hold when stop_reason is max_tokens.

Answer: C. Prefill the assistant turn with "{" so Claude skips the conversational preamble and continues directly with the JSON object

Prefilling the assistant message with an opening brace is the documented way to skip the preamble and force direct JSON output, because the response must continue from the prefilled character. Temperature controls randomness, not whether a preamble appears. A "{" stop sequence would terminate generation at the start of the JSON, the opposite of the goal, and the API performs no XML-based post-processing that strips prose.

Answer: D. Enclose each review in <review>...</review> tags and tell Claude to treat tagged content as data to analyze, not instructions to follow.

Delimiting the untrusted content with XML tags and telling Claude the tagged text is data-to-analyze makes it far less likely to act on instructions embedded in that data. Moving instructions, changing temperature, or prefilling doesn't establish the data/instruction boundary.

Answer: C. Including a few well-crafted example inputs and outputs directly in the prompt to steer Claude's format, tone, and structure

Multishot (few-shot) prompting means placing a few well-crafted examples in the prompt itself, which the docs call one of the most reliable ways to steer output format, tone, and structure. Re-running a prompt and comparing outputs is best-of-N verification, splitting work across calls is prompt chaining, and the Messages API has no parameter that returns multiple candidate completions.

Answer: B. Claude must actually output its reasoning in the response; without outputting its thought process, no thinking occurs

Anthropic's chain of thought guidance stresses always having Claude output its thinking, because without the thought process appearing in the output, no thinking occurs. That rules out silent internal reasoning while emitting a one-word reply. Manual CoT is a prompting technique that works without the extended thinking API feature, and CoT instructions work in user messages as well as system prompts.

Answer: A. Refactoring a large module with many interacting constraints and edge cases.

Extended thinking pays off on complex, multi-constraint problems where deeper reasoning helps, like a constraint-heavy refactor. Trivial edits gain nothing and just cost more thinking tokens and latency.

Answer: D. Code grading is fast and reliable but lacks nuance; human is nuanced but slow; LLM scales but needs validation.

The docs rank code-based grading (exact match, string match) as fastest, most reliable, and extremely scalable but lacking nuance; human grading as most flexible and high quality but slow and expensive, to be avoided when possible; and LLM-based grading as fast, flexible, and suitable for complex judgment once reliability is validated. The other options invert these tradeoffs: humans are the slow path, LLM grading exists precisely for nuanced judgments, and code rules cannot capture every subjective assessment.

Answer: C. end_turn: the model reached a natural stopping point and finished its response on its own.

end_turn means the model completed its turn naturally and the response can be used as-is. max_tokens signals the output hit the requested token cap (safety declines surface as the refusal stop reason), and tool_use means the model is requesting that your application execute a tool, not that execution already finished. stop_sequence indicates one of your custom stop_sequences was generated; rate limiting is reported as an HTTP 429 error, never as a stop_reason.

Answer: C. Most batches complete in less than 1 hour, but processing can take up to 24 hours, after which the batch expires.

The system processes each batch as fast as possible: most batches finish in under 1 hour, and results become available when all requests complete or after 24 hours, whichever comes first. Batches that do not finish within 24 hours expire. There is no scheduled nightly window, no 1-hour guarantee, and no unbounded processing.

Answer: B. vector_db-search_v2

Tool names must match the regex ^[a-zA-Z0-9_-]{1,64}$: only ASCII letters, digits, underscores, and hyphens, with a length of 1 to 64 characters. Spaces, periods, and accented or other non-ASCII characters are all rejected, which rules out the other three options. Underscores and hyphens are both permitted, so mixing them as in the correct option is fine.

Answer: A. Aim for at least 3 to 4 sentences per tool, and more for complex tools

The documentation says to aim for at least 3 to 4 sentences per tool description, and more for complex tools. Ultra-short descriptions appear as the poor example in the docs, the API does not truncate description text at any short word count, and Claude weighs the description heavily rather than relying on input_schema alone.

Answer: A. Aim for at least 3-4 sentences per tool description, and more when the tool is complex

The documentation recommends at least 3-4 sentences per description, with more detail for complex tools. Descriptions are injected into the tool use system prompt and strongly influence behavior, so they are not inert metadata. The docs' "poor description" example is exactly the terse one-liner style, which leaves Claude with open questions about usage.

Answer: D. name, description, and input_schema (a JSON Schema object describing the tool's expected parameters)

Each custom tool in the tools parameter is defined by a name, a description, and an input_schema expressed as JSON Schema; an optional input_examples array can also be added. The API never invokes your code directly, so there is no endpoint, HTTP method, or handler to register: your application executes the tool when Claude emits a tool_use block. The function_name/arguments/return_type shape belongs to other providers' APIs, not the Claude Messages API.

Answer: B. {"type": "tool_result", "tool_use_id": "toolu_01...", "content": "Rate limit exceeded. Retry after 60 seconds.", "is_error": true}

Anthropic recommends instructive error messages that state what went wrong and what Claude should try next, paired with is_error: true; the docs use 'Rate limit exceeded. Retry after 60 seconds.' as the model example. A generic 'failed' gives Claude nothing to reason about. Omitting is_error makes the text read as successful tool output rather than a failure signal, and omitting content entirely deprives Claude of the context it needs to recover or adapt.

Answer: B. An id to match results to the call, the name of the tool, and an input object conforming to the tool's input_schema

A tool_use block carries an id used to match the eventual result, the name of the tool, and an input object that conforms to the tool's input_schema. tool_use_id, content, and is_error are fields of the tool_result block you send back, not of tool_use. There is no output field because the API does not execute client tools, and input arrives as a parsed JSON object rather than an encoded arguments string.

Answer: A. tool_choice: {"type": "tool", "name": "record_entities"}

tool_choice with type tool plus the tool's name forces Claude to call that specific tool on the request. type any only guarantees that at least one of the provided tools is used, without controlling which. There is no required field on the auto option, and strict: true enforces schema-valid inputs but does not force Claude to call the tool at all.

Answer: B. In a single user message whose content array contains three tool_result blocks, each matched to its call by tool_use_id

Parallel tool calls must be answered with one tool_result per tool_use block, all together in the next single user message, matched by tool_use_id. Spreading results across separate user messages is explicitly called out as a mistake that reduces Claude's tendency to make parallel calls in later turns. Concatenating everything into one block leaves the other tool_use ids unresolved and triggers a 400 error, and tool_result blocks always travel in user messages.

Answer: D. Tools, resources, and prompts

MCP servers expose tools (executable functions), resources (data sources for context), and prompts (reusable templates). Sampling, roots, and elicitation are client-side features, not server primitives (and as of the 2026-07-28 spec, Roots and Sampling are deprecated, leaving Elicitation as the active client feature). Hooks and skills are Claude Code concepts rather than MCP protocol primitives.

Answer: D. A resource, identified by a unique URI, that the client retrieves with resources/read

Resources are passive, read-only data sources with unique URIs that the application retrieves and decides how to use, which matches static policy content exactly. Tools are for executable actions the model invokes, sampling is a server-initiated request for an LLM completion rather than a way to publish data, and roots are client-provided filesystem boundaries, not something a server exposes.

Answer: B. JSON-RPC 2.0, with requests, responses, and notifications encoded as UTF-8 JSON.

MCP's data layer is built on JSON-RPC 2.0, and every transport (stdio, Streamable HTTP, or a custom transport) must preserve that message format, encoded as UTF-8. MCP is not defined in terms of Protocol Buffers, REST resource semantics, or GraphQL, even though Streamable HTTP happens to use HTTP as a carrier.

Answer: D. The client launches the server as a subprocess and exchanges JSON-RPC messages over its stdin and stdout.

In the stdio transport the client launches the server as a subprocess, writes JSON-RPC messages to the server's stdin, and reads responses from its stdout, with messages delimited by newlines. WebSockets, shared memory, and Unix domain sockets are not part of the two standard MCP transports, which are stdio and Streamable HTTP.

Answer: B. The server exposes one MCP endpoint; each JSON-RPC message is a new POST, answered with JSON or an SSE stream.

Streamable HTTP uses a single MCP endpoint: every client message is a new HTTP POST, and the server responds with Content-Type application/json or text/event-stream for that request. In the 2026-07-28 revision the old GET listening endpoint was replaced by subscriptions/listen, a long-lived POST-response stream for opted-in change notifications. The two-endpoint design describes the deprecated HTTP+SSE transport, and MCP's standard transports do not use WebSockets or pipelined POST bodies.

Answer: C. Host the server so it is publicly reachable over HTTP (Streamable HTTP or SSE transport), because the connector cannot connect to local STDIO servers

The connector's documented limitation is that servers must be publicly exposed through HTTP (Streamable HTTP or SSE transports); local STDIO servers cannot be connected directly, so the team must deploy the server behind an HTTPS URL. The mcp_servers type field currently supports only "url", so there is no stdio option with command and args. The Files API and the code execution container do not host or execute MCP servers.

Answer: A. Prompt injection: untrusted content returned in tool results enters the model's context and can steer the agent toward unintended actions

Tool results flow into the model's context just like user input, so instructions hidden in fetched content can attempt to hijack the agent's behavior; this is the prompt injection risk Anthropic highlights for tools that touch external content. Mitigations include using trusted servers, restricting risky tools, and keeping human approval in front of consequential actions. Large pages can cost tokens but that is not the attack shown, OAuth tokens are transmitted in request headers rather than tool results, and model weights are never updated by inference-time text.

Answer: A. The total amount of text the model can reference when generating a response, including the response it generates, functioning as its working memory

The docs define the context window as all the text a model can look back on and reference when generating a response, plus the new text it generates, acting as working memory. It is explicitly distinct from the training corpus. The Messages API is stateless and does not maintain a server-side conversation cache, and max_tokens caps output length rather than defining the window.

Answer: A. The system prompt, tool definitions, every message in the conversation (including tool results and documents), and the output Claude generates for the turn, including its extended thinking

Everything in the request counts toward the window: the system prompt, tool definitions, and all messages including tool results and documents, plus the output generated for the turn, including current-turn thinking. Output shares the same window as input, so max_tokens must fit in the remaining space. Cached tokens still occupy the window; prompt caching changes what you pay for those tokens, not whether they count.

Answer: A. 1,000,000 tokens, the default with no beta header

Claude Opus 5.5, like Fable 5.1, Sonnet 5.5, and Claude 4.6+ Opus and Sonnet models, has a 1M-token context window, and 1M is the default: no beta header is required and long-context requests bill at standard pricing. 200K applies to other models such as Haiku 4.5, the context-1m beta header belonged to the older Sonnet 4/4.5 beta, and 500K is not an offered size.

Answer: D. POST /v1/messages/count_tokens, which accepts the same request shape as message creation (model, system, tools, messages) and returns an input_tokens count

The token counting endpoint mirrors the Messages request structure, including system prompts, tools, images, and PDFs, and returns the total input token count. It is free to use, subject to its own requests-per-minute limits separate from the Messages API, and the count is an estimate that may differ slightly from actual usage. The other two endpoints and the dry_run parameter do not exist in the Claude API.

Answer: B. The interpolated timestamp changes the prefix bytes on every request, so nothing is reused

Caching is an exact-prefix match, and a live timestamp at the front of the system prompt makes the prefix differ every request, so each call writes a fresh entry and never reads one. The fix is to move volatile values like timestamps to the end of the messages, after the last breakpoint, or drop them.

Answer: A. It summarizes the conversation history and replaces the older transcript with that summary, freeing context so the session can continue

/compact performs compaction: Claude Code summarizes the conversation and continues from the condensed summary, and you can even steer it with custom instructions such as /compact Focus on code samples and API usage. Wiping the whole history is what /clear does. Summarization is lossy by design, not lossless compression, and the model's context window size is a fixed model property that commands cannot shrink.

Answer: B. Find the smallest possible set of high-signal tokens that maximizes the likelihood of the desired outcome

Anthropic's context engineering guidance states that context must be treated as a finite resource with diminishing marginal returns, and that good context engineering means finding the smallest possible set of high-signal tokens that maximize the likelihood of the desired outcome. Packing the window with everything available degrades recall rather than improving it. There is no documented rule that attention stops at 50 percent of capacity.

Answer: C. Just-in-time retrieval: hold lightweight identifiers or references and fetch full content only when it is actually needed

Just-in-time loading keeps the working set small by fetching full content only on demand, which counters context rot. Preloading everything, maxing the window, or stuffing the system prompt all inflate the context and degrade recall.

Answer: D. A condensed summary of its findings, keeping the raw source text in its own isolated context so the orchestrator's window stays lean

Subagents isolate heavy exploration and hand back only condensed findings, so the orchestrator's context stays small. Returning full transcripts or copying context verbatim defeats the isolation, and a bare status code loses the work entirely.

Answer: D. 429 means your organization exceeded its own rate limit while 529 means the API is broadly overloaded; both are retryable, but 429 should honor retry-after and 529 uses backoff

429 is your own rate limit (honor retry-after); 529 is server-side overload (retry with backoff). Both are transient and retryable, so neither is a permanent client error, and the two codes are not swapped.