Free Anthropic Claude Certified Architect – Professional (CCAR-P) Sample Questions

Correct answer: C — Search results, because it provides citation-quality source attribution for custom knowledge bases outside the public web.

• A. Incorrect. The web search tool augments Claude with public web content and is not the mechanism for attributing answers to a private, internal ticket archive.
• B. Incorrect. Web fetch retrieves content from specified URLs on the web; it is not designed to provide citation attribution over an internal, non-web knowledge base.
• C. Correct. Search results is built to enable natural citations for RAG applications, achieving web-search-quality citations for custom knowledge bases and internal tools.
• D. Incorrect. Code execution runs sandboxed code for analysis and file processing; it is not a citation or source-attribution feature for retrieval-augmented answers.

Correct answers: A, B — Context editing, which supports clearing tool results automatically as a conversation approaches the token limit; The memory tool, which lets Claude store and retrieve information across separate conversations over time

• A. Correct. Context editing is documented as supporting automatic clearing of tool results when approaching token limits, directly addressing the first need in the scenario.
• B. Correct. The memory tool is documented as enabling Claude to store and retrieve information across conversations, building knowledge over time, which addresses retaining facts across separate sessions.
• C. Incorrect. Fine-grained tool streaming reduces latency for large tool-call parameters; it has no role in clearing stale context or retaining cross-session facts.
• D. Incorrect. Compaction summarizes conversation history automatically, but it is a distinct, separate feature from context editing, not a replacement that makes context editing unnecessary.
• E. Incorrect. Code execution runs sandboxed code for analysis tasks; it does not manage context size or persist facts across sessions.
• F. Incorrect. The Files API avoids re-uploading document content across requests, which is useful but does not clear stale tool results or persist project facts across separate sessions.

Correct answer: A — Orchestrator-workers, where a central LLM inspects the repository and dynamically delegates each file edit to a worker LLM

• A. Correct. When the subtasks cannot be predetermined and must be discovered at runtime by inspecting the codebase, a central LLM dynamically decomposing and delegating work is orchestrator-workers.
• B. Incorrect. Prompt chaining requires a fixed, known sequence of steps decided in advance; here the files and edits are unknown until inspection occurs.
• C. Incorrect. Sectioning requires the subtasks to be known and separable in advance; the scenario explicitly states the scope cannot be known until inspection.
• D. Incorrect. Routing selects among a fixed set of predefined prompts; it cannot handle a variable, unpredictable number of file-level subtasks discovered at runtime.

Correct answers: A, C — In orchestrator-workers, a central LLM determines subtasks at runtime, whereas sectioning requires subtasks predefined before execution; Orchestrator-workers suits subtasks that vary unpredictably case to case, while sectioning suits tasks that split cleanly into known subtasks

• A. Correct. The core distinction is that orchestrator-workers decomposes subtasks dynamically at runtime, while sectioning requires the subtasks to be known and fixed before execution starts.
• B. Incorrect. Orchestrator-workers does not imply a fixed predetermined order for its workers, and this option's framing misstates the relationship between the two patterns.
• C. Correct. Orchestrator-workers fits unpredictable, case-varying subtask requirements, while sectioning fits tasks that decompose cleanly into known independent pieces ahead of time.
• D. Incorrect. Sectioning combines independent subtask outputs directly; requiring a second LLM to evaluate and combine them describes evaluator-optimizer, not sectioning.
• E. Incorrect. Aggregating multiple independent votes on the same input to reach a majority answer describes parallelization by voting, not orchestrator-workers or sectioning.

Correct answer: A — Define an orchestrator agent that invokes specialized subagents through the Agent tool, each configured with a scoped tool set and description matching its subtask domain

• A. Correct. The Agent SDK's subagent capability lets an orchestrator delegate focused subtasks to specialized agents, each with its own scoped tools and description, then aggregate their results — the intended decomposition pattern for multi-dimensional review work.
• B. Incorrect. A single undifferentiated prompt forces one agent to hold all three review contexts and tool needs at once, losing the isolation and specialization benefits of decomposition.
• C. Incorrect. Exposing checks as tools on one MCP server still leaves a single agent responsible for orchestrating and interpreting all three domains itself, rather than delegating focused reasoning to specialized subagents.
• D. Incorrect. A larger context window and extended thinking add reasoning depth but do not decompose the task into independently scoped, delegatable units of work.

Correct answers: A, B — Server-side fallback, which retries a refused request against a backup model within the same API call for a timely response; Choosing a model with faster comparative latency, such as Claude Haiku 4.5, for the latency-sensitive triage path

• A. Correct. Server-side fallback keeps a request from failing outright by automatically retrying against a named backup model within the same call, directly protecting availability and response-time commitments when the primary model declines a request.
• B. Correct. Selecting a model chosen for faster comparative latency, such as Haiku 4.5, directly targets the sub-2-second p95 requirement on the synchronous triage path, making it a core lever for meeting the SLA.
• C. Batch processing is designed for asynchronous, non-latency-sensitive workloads with an extended completion window, which is the opposite of what a sub-2-second synchronous SLA requires.
• D. Agent Skills extend task capability for document-format work such as spreadsheets or slides; they are not a mechanism for protecting response latency or uptime commitments.
• E. The Files API reduces redundant re-uploading of documents across requests, which helps with convenience and token efficiency but is not a direct lever for latency or availability SLA protection.

Correct answer: A — Use prompt caching so the unchanging reference specification is cached and reused across requests, cutting cost and latency

• A. Correct. Prompt caching is designed exactly for this pattern: providing Claude with recurring background context, such as an unchanging reference document, so subsequent requests reduce both cost and latency instead of reprocessing the same content each time.
• B. Batch processing trades same-day turnaround for cost savings on non-urgent work, which conflicts with the client's requirement to keep individual inspection turnaround fast throughout the day.
• C. Raising the effort parameter increases reasoning depth and token usage per request, which adds cost rather than reducing the redundant token spend the client wants to cut.
• D. Re-uploading the full reference document in every request is the exact redundant-token pattern the client wants eliminated, and it neither reduces cost nor improves turnaround.

Correct answers: A, B, C — State a system prompt policy that content returned by tools is untrusted data and must never override the system prompt or the user's original request; JSON-encode the email body when passing it as a tool result so quotes or tags in the content cannot break out of the surrounding structure; Screen tool outputs with a lightweight classifier model before passing them to the main agent, and strip or flag content if an injection is suspected

• A. Correct. Stating explicitly that tool-returned content is untrusted data that must not override instructions is a core documented mitigation for indirect prompt injection.
• B. Correct. JSON-encoding untrusted content provides unambiguous delimiters so an attacker cannot break out of the data context into an instruction context.
• C. Correct. Screening tool outputs with a lightweight classifier before they reach the main conversation is a documented pattern for catching injected instructions in tool results.
• D. Incorrect. Anthropic explicitly advises against placing your own instructions in tool results, since Claude is trained to treat tool-result content as untrusted data and may ignore or flag instructions placed there.
• E. Incorrect. This violates the least-privilege principle; broad unscoped access increases the damage a successful injection could cause rather than limiting it.

Correct answer: A — Define a prompt template with the fixed instruction text and a placeholder such as {{text}}, substituting only the variable content on each call while the surrounding instructions stay constant.

• A. Correct. A prompt template separates fixed instructions from variable placeholders like {{text}}. This keeps the instructional wording consistent across calls, lets the variable content change per request, and makes it straightforward to version and track the fixed portion independently of what's being translated.
• B. Incorrect. Regenerating the complete prompt including instructions on every call defeats the goal of keeping instructional wording consistent, because the surrounding text may drift. It also makes it harder to track changes to the instructions independently from the user's text.
• C. Incorrect. Storing the entire prompt as one static string and editing it by hand conflates fixed instructions with variable content, making it error-prone and hard to test edge cases. This approach does not allow tracking instruction changes separately from the translated text.
• D. Incorrect. Splitting into two API calls and concatenating responses adds unnecessary complexity and cost without providing reusable instruction wording. It does not achieve the goal of maintaining consistent, separately trackable instructions.

Correct answer: A — Configure a clear_tool_uses_20250919 edit with trigger set to 30000 input tokens, keep 3 tool uses, exclude_tools set to web_search.

• A. Correct. clear_tool_uses_20250919 is the appropriate edit for clearing old tool results. Setting the trigger to 30,000 input tokens, keeping the 3 most recent tool uses, and excluding web_search meets all specified requirements: auto-clears at the token threshold, preserves the last 3 exchanges, and never clears web_search results.
• B. Incorrect. The clear_thinking_20251015 edit is designed to manage extended thinking blocks, not tool results. Using it would fail to clear old file-read outputs, regardless of trigger or exclusion settings.
• C. Incorrect. This configuration triggers on a tool_uses count of 30,000 instead of the required input token threshold. Additionally, without setting keep or exclude_tools, recent tool exchanges are not preserved, and web_search results are not protected from clearing.
• D. Incorrect. Excluding file_read instead of web_search results in file_read results being never cleared, while web_search results remain subject to automatic clearing—the opposite of the requirement.

Correct answer: B — Break the task into separate API calls: generate a fix, review it against the criteria, then refine the fix, so each step can be logged independently.

• A. Incorrect. Asking Claude to handle everything in one response with extended reasoning keeps the review internal to the model's generation process. The intermediate verification step cannot be extracted or logged separately, which fails to meet the team's logging requirement.
• B. Correct. Breaking the task into separate API calls implements a self-correction chaining pattern where each phase—generation, review against criteria, and refinement—is isolated. Each step can be independently inspected, logged, or branched on, exactly matching the need for separate logging.
• C. Incorrect. While adding <thinking> tags might seem to separate the review visually, the entire generation, review, and refinement still occur in a single API response. This makes it impractical to reliably extract and log a clean intermediate review step without mixing it with the draft or refinement content.
• D. Incorrect. Providing few-shot examples for Claude to mimic bypasses the explicit review-against-criteria step entirely. Without performing a distinct review and refinement cycle, there is no intermediate step to log, so this approach fails to satisfy the requirement.

Correct answer: A — Build a custom tool that runs the embeddings search and returns tool_reference blocks in its tool_result for Claude to expand.

• A. Correct. A custom client-side tool search implementation can run any retrieval method, including embeddings, and return standard tool_result content with tool_reference blocks, which the API expands into full tool definitions.
• B. BM25 is a term-frequency-based lexical ranking method, not a true semantic embedding similarity search, so it would not reproduce the intended embeddings-based matching.
• C. Regex matching operates on literal patterns against names and descriptions and cannot capture semantic relationships between sparse, differently worded tool descriptions.
• D. Loading every definition up front abandons retrieval entirely and reintroduces the context bloat problem that made an embeddings-based discovery approach necessary.

Correct answer: A — Return the retrieved passages as search result content blocks from a retrieval tool, each carrying source and title metadata, so Claude generates natural citations per ticket.

• A. Correct. This approach uses a retrieval tool to dynamically fetch only relevant passages per query, with each result block including source and title metadata. This enables Claude to generate natural citations without resending the entire corpus, which is efficient and aligns with the need for exact source passage citations.
• B. Incorrect. Uploading all 500 documents in the system prompt sends the full corpus with every request, defeating the purpose of avoiding corpus resending. It also wastes context on irrelevant passages, making it inefficient for a repeated ticket-answering workflow.
• C. Incorrect. Concatenating the full corpus into a long user message per request is costly in terms of tokens and degrades accuracy as context grows. It skips the targeted retrieval step that efficiently supplies only relevant passages, which is what this query pattern requires.
• D. Incorrect. The memory tool is intended for Claude to persist notes across conversation turns, not as a document retrieval index. Storing each document as a memory entry and loading all entries for each query is inefficient and does not support targeted retrieval with source metadata for citations.

Correct answer: A — Split chunks along natural boundaries such as paragraphs or sections, and add a small overlap between adjacent chunks so boundary sentences appear intact in at least one chunk.

• A. Correct. Chunking on natural document boundaries such as paragraphs or sections, combined with a small overlap, ensures that sentences near chunk edges appear intact in at least one chunk. This directly addresses the problem of split-sentence retrieval failures.
• B. Incorrect. Reducing chunks to single sentences by splitting on punctuation eliminates mid-sentence breaks, but loses the surrounding context necessary for accurate retrieval. Additionally, multi-sentence ideas are still separated across chunks, which can degrade answer completeness.
• C. Incorrect. Removing overlap and using smaller fixed-size chunks increases the likelihood that a relevant sentence will be split across a chunk boundary. This strategy worsens the original problem rather than resolving it.
• D. Incorrect. Increasing the embedding model's context window does not change where the pipeline cuts text; with fixed 500-character boundaries, sentences near the cuts remain split. The retrieval misses at boundaries persist regardless of the model's capacity.

Correct answer: A — Set disable-model-invocation: true in the frontmatter of each side-effecting skill so Claude cannot select them automatically and only the user can invoke them with /name.

• A. Correct. Setting `disable-model-invocation: true` in the frontmatter hides the skill from Claude's automatic selection, so it cannot be triggered by vague description matches. The skill becomes accessible only when a user explicitly invokes it with `/name`, thus reducing the effective capability surface as intended.
• B. Incorrect. Deleting skill descriptions may prevent automatic matching, but skills also rely on descriptions for proper discovery and correct invocation by users. This approach is not the documented method for controlling automatic model invocation and could lead to confusion or broken workflows.
• C. Incorrect. Moving skills into `CLAUDE.md` would load them as always-on context in every session, meaning Claude could still act on them without an explicit user request, potentially increasing the effective capability surface rather than reducing it.
• D. Incorrect. Adding instructions to ask for confirmation does not prevent Claude from auto-triggering the skill based on description matches; the skill may still be activated automatically, only then prompting for confirmation. This does not restrict invocation to explicit user commands.

Correct answer: A — Require summaries to average at least 4 out of 5 on a completeness rubric across a 500-claim sample

• A. Correct. This criterion is specific (completeness rubric), measurable (numeric threshold), achievable (a 4/5 average rather than perfection), and relevant (tied directly to summary quality), and it defines a concrete sample size for measurement.
• B. Incorrect. Requiring a perfect score from every adjuster is not achievable in practice; SMART criteria should be realistic targets grounded in frontier model capability, not unattainable perfection.
• C. Incorrect. "Sound less robotic" and "read more naturally" are not measurable without a defined metric or scale, so this fails the Measurable requirement of SMART criteria.
• D. Incorrect. This describes a manual sign-off process, not a measurable success criterion for the model's output quality, so it does not give the evaluation team a quantifiable target.

Correct answer: B — Telemetry is enabled but no exporter was selected, so OTEL_METRICS_EXPORTER and OTEL_LOGS_EXPORTER default to producing no export at all

• A. Incorrect. The enhanced telemetry beta flag is only required to unlock distributed tracing spans; metrics and log events do not depend on it, and it has no bearing on whether an exporter is configured.
• B. Correct. Enabling telemetry alone does not choose a destination. Each signal has its own exporter switch (OTEL_METRICS_EXPORTER, OTEL_LOGS_EXPORTER, OTEL_TRACES_EXPORTER), and leaving them unset means nothing is exported even though telemetry generation is on.
• C. Incorrect. The console exporter is one optional choice among several (otlp, prometheus, console, none); it is not a prerequisite the CLI requires before other exporters will function.
• D. Incorrect. OTEL_EXPORTER_OTLP_HEADERS carries authentication for the collector endpoint, not an Anthropic Admin API key, and its absence would cause auth failures at the collector, not a total absence of any emitted telemetry.

Correct answers: A, B, C — Enable server-side compaction so earlier turns are automatically summarized once the conversation nears the context window limit; Configure context editing to clear old tool results once a token threshold is reached, keeping only recent tool use/result pairs; Use the memory tool to persist critical state to durable storage before old context is cleared, so a session recovers quickly

• A. Correct. Server-side compaction is the primary strategy for long-running conversations that approach context window limits: it automatically summarizes earlier turns on the server so the session can continue past the limit.
• B. Correct. Context editing's tool result clearing removes old tool results once a configured trigger is reached while preserving the most recent tool use/result pairs, directly freeing context space in tool-heavy agentic sessions.
• C. Correct. The memory tool's multi-session pattern is designed to offload critical state to durable storage before context is cleared or a new session starts, so essential information is not lost when older turns are summarized or removed.
• D. Lowering effort reduces token spend per turn but does not prevent the accumulated conversation history itself from growing and eventually approaching the context window limit.
• E. The Batch API is for independent asynchronous requests without immediate responses, not for continuing a single long-running interactive session, and splitting it into fresh-context chunks would lose the conversation's accumulated state.
• F. Raising effort to max increases token spend per turn for maximum capability; it does not reduce the number of turns needed and does not itself address a growing context window, since higher-effort turns can consume context faster.

Correct answer: A — Lower the effort parameter for routine turns, since it reduces token spend while letting Claude think harder when warranted

• A. Correct. The effort parameter is described as a behavioral signal that trades thoroughness for token efficiency across text, tool calls, and thinking, within a single model. At lower effort, Claude still thinks on sufficiently difficult problems but spends fewer tokens on simpler ones, which is exactly the described goal.
• B. Cache writes do cost more than base input, but cache reads cost 90% less; disabling caching entirely removes the possibility of cheap cache reads and would generally increase, not decrease, cost for any repeated content.
• C. The Batch API requires asynchronous processing without immediate responses, which is incompatible with an interactive chat feature, and it does not adapt token spend to per-turn difficulty.
• D. A small fixed max_tokens risks truncating responses on genuinely hard questions where more output is needed, directly conflicting with the requirement to preserve quality on complex turns.

Correct answer: A — The target is unachievable because it exceeds realistic frontier-model capability. It should instead be grounded in benchmark results, prior experiments, or comparable industry performance.

• A. Correct. The target of 100% accuracy with zero tolerance is unachievable because it exceeds realistic frontier-model capability. It should be grounded in benchmark results, prior experiments, or comparable industry performance to ensure the success criterion is realistic and attainable.
• B. Incorrect. The target is already specific: 100% accuracy is a single numeric metric. The real problem is that it is unachievable, not that it lacks specificity, so replacing it with an arbitrary percentage like 95% without considering feasibility does not address the core issue.
• C. Incorrect. Accuracy targets are relevant and appropriate for reasoning tasks; the problem is the unrealistic threshold, not the use of an accuracy metric. Additionally, latency and cost are not the only meaningful production metrics—accuracy and safety are also critical.
• D. Incorrect. Open-ended reasoning tasks can be scored automatically using methods like LLM-based evaluation or rubric-based grading, so measurability is not the main problem. The core issue is that the 100% zero-tolerance target is unachievable and not grounded in realistic performance.

Correct answer: A — Evaluate the leading prompt candidate on a separate held-out test set not used during iteration to confirm that improvements generalize beyond the development set.

• A. Correct. Reusing the same development set throughout iterations risks overfitting, so the candidate may not generalize. Testing on a separate held-out set is essential to confirm that improvements extend beyond the development data.
• B. Incorrect. Another round of refinement on the same set only deepens overfitting to that specific data, making the prompt less reliable on new examples. Maximizing the development score does not guarantee real-world performance.
• C. Incorrect. Discarding failing examples creates an artificially high accuracy that masks the prompt's true weaknesses. This cherry-picking prevents fair assessment and leads to an unreliable final metric.
• D. Incorrect. The highest score on the iteratively used development set likely reflects overfitting to that set's specific patterns. Production readiness requires validation on unseen data to ensure the prompt performs well in practice.

Correct answers: A, B, C — On a use-case benchmark, accuracy on multi-step reasoning subtasks stays below threshold even after prompt revisions.; The workflow needs nuanced understanding across long chains of interdependent steps where partial errors compound.; Manual review shows the extraction errors resemble genuine reasoning mistakes rather than missing or truncated input.

• A. Correct. Accuracy below threshold on multi-step reasoning subtasks that persists after prompt revisions indicates that the model's inherent reasoning capability is insufficient. This persistent underperformance points to a capability ceiling rather than a prompt engineering issue. Evaluating a more capable model like Claude Opus 4.8 is warranted.
• B. Correct. A workflow that requires nuanced understanding across long chains of interdependent steps, where partial errors compound, is inherently complex and exceeds the typical strengths of a lighter model. Such complexity is a direct signal of a model-capability mismatch. A more capable model is better suited to handle this demanding reasoning.
• C. Correct. When manual review shows extraction errors are genuine reasoning mistakes rather than issues from missing or truncated input, it highlights a fundamental limitation in the model's reasoning. This suggests the model is failing at logic or understanding, not just input processing. Upgrading the model may address these deep reasoning errors.
• D. Incorrect. Exceeding the monthly budget is a cost-management concern and does not indicate whether the current model is capable enough for the task. Moving to a more expensive model would likely increase costs, making this observation irrelevant to a capability mismatch.
• E. Incorrect. Occasional timeouts due to ordinary network latency are an infrastructure issue external to the model. This type of failure does not reflect the model's reasoning ability and can occur with any model regardless of capability.
• F. Incorrect. A prompt designed for an older model may not leverage the current model's strengths and should be adapted and retested before judging capability. Without prompt optimization, poor performance cannot be attributed to a model-capability mismatch.

Correct answer: D — Instruct Claude to first extract exact, word-for-word quotes relevant to data retention, and only then analyze compliance by referencing those extracted quotes

• A. Incorrect. Relying on general knowledge instead of the provided document is the hallucination risk being addressed, not a fix for it.
• B. Incorrect. Summarizing first discards detail and can itself introduce the drift and inaccuracy the task is trying to eliminate.
• C. Incorrect. Response length has no bearing on whether cited clauses actually appear in the source document.
• D. Correct. For long documents, having Claude extract word-for-word quotes before analyzing grounds its output in the actual text and reduces hallucinated citations.

Correct answer: A — Register a PreToolUse hook scoped to the wire-transfer tool that returns permissionDecision "ask" for every call, since hooks execute before deny rules, ask rules, the permission mode check, and allow rules, and their decision holds even under bypassPermissions.

• A. Correct. Hooks run first in the evaluation order and a PreToolUse hook's decision applies regardless of permission mode, including bypassPermissions, guaranteeing the prompt for this tool.
• B. Incorrect mechanism. A bare allow-rule entry auto-approves every matching call and the call never reaches canUseTool, so this design silently removes the intended approval step.
• C. Incorrect. acceptEdits only auto-approves file edits and specific filesystem commands; other tools still fall through to normal permission handling, which could still resolve via an existing allow rule rather than always prompting.
• D. Incorrect. Deny rules are evaluated before canUseTool in the flow, so the callback has no mechanism to reverse a deny decision for a specific call.

Correct answers: A, B, C — Run paired-scenario evaluations comparing summary tone and detail across employee groups given identical underlying performance notes.; Document, in a form reviewers can inspect, which specific decision factors the assistant is instructed to weigh whenever it drafts a summary.; Give every employee, regardless of role or seniority, a mechanism to request the specific factors that shaped their own summary.

• A. Correct. Paired-scenario testing across demographic groups is a direct, evidence-based way to detect tone or detail disparities that would indicate bias, mirroring how Anthropic evaluates paired requests for evenhandedness.
• B. Correct. Documenting the decision factors the assistant weighs gives reviewers a transparent, inspectable basis for the summaries, directly addressing the transparency requirement.
• C. Correct. Giving employees a way to request the factors behind their own summary extends transparency to the people most affected by the assistant's output, supporting fairness and accountability.
• D. Incorrect. Deferring bias testing until after complaints arise reverses the compliance team's request for pre-launch controls and lets biased summaries reach employees before any check occurs.
• E. Incorrect. Unlogged silent overrides of the standardized template reintroduce exactly the kind of unaccounted inconsistency that undermines both fairness and transparency.
• F. Incorrect. A single reviewer with no secondary sign-off removes an accountability check rather than adding one, working against the governance goals of the review.

Correct answers: A, B, C — The specific capabilities the model must have to meet the prospect's needs; How quickly the model must respond within the prospect's application; The prospect's available budget for development and production usage

• A. Correct. Capabilities is one of the key criteria Anthropic's guidance lists to establish before choosing a model.
• B. Correct. Speed, meaning how quickly the model must respond, is explicitly named as a key criterion to evaluate first.
• C. Correct. Cost, meaning the budget for development and production usage, is explicitly named as a key criterion to evaluate first.
• D. Incorrect. Headcount in the IT department is not one of the documented model-selection criteria and does not inform capability, speed, or cost decisions.
• E. Incorrect. Marketing channel usage is unrelated to model capability, speed, or cost requirements and is not a discovery criterion for model selection.
• F. Incorrect. A third-party ticketing software version is an integration detail, not one of the capability, speed, or cost criteria used to scope model selection.

Correct answer: A — Citations, which let Claude reference the exact sentences and passages in source documents used to generate a response

• A. Correct. Citations is documented as grounding responses in source documents with references to the exact sentences and passages used, matching the auditability requirement described.
• B. Incorrect. Search results attaches source attribution specifically for RAG applications built around a search tool, which is a narrower fit than directly citing provided internal policy documents.
• C. Incorrect. Token counting measures message size before sending; it has no role in producing verifiable source references for auditors.
• D. Incorrect. The Files API avoids re-uploading documents across requests but does not itself produce sentence-level source references in responses.

Correct answer: A — Direct API and other non-Bedrock/Vertex-hosted traffic on Haiku 3.5 must migrate to a supported model before retirement, while deployments specifically on Bedrock or Google Cloud can keep running it under those platforms' own timelines

• A. Correct. Haiku 3.5 is documented as retired except on Bedrock and Google Cloud, meaning direct API usage elsewhere must migrate while those two platforms retain their own continuation timelines.
• B. Incorrect. Retirement affects existing production traffic on the direct API, not just new signups; there is no blanket exemption tied to account age.
• C. Incorrect. This contradicts the documented exception carved out for Bedrock and Google Cloud, which are explicitly excluded from the retirement on the same schedule.
• D. Incorrect. Retirement affects the model's availability for actual inference, not merely a Console UI restriction; direct Messages API traffic on the retired platforms is the traffic that must migrate.

Correct answer: A — Query the Usage and Cost Admin API grouped by workspace and model to reconcile spend against token consumption

• A. Correct - the Usage and Cost Admin API supports grouping by workspace and model, which directly answers where the added spend is coming from.
• B. Re-running the evaluation set measures output quality, not which workspace or model is responsible for the cost increase.
• C. Expanding the agent's own tool permissions to inspect billing is unnecessary and unrelated to how usage and cost reporting is retrieved.
• D. Manually reconciling ticket counts against invoices is far less precise than the granular, per-workspace and per-model data the API already provides.

Correct answer: A — Mark the reusable system prompt and tool definitions as cached blocks so repeated requests reuse the prefix instead of reprocessing it.

• A. Correct. Prompt caching is designed exactly for this scenario: marking the static system prompt and tool definitions as cached lets repeated requests skip reprocessing that content, reducing both cost and latency.
• B. Incorrect. A larger context window changes how much content fits in a request but does not stop the same static content from being reprocessed on every call.
• C. Incorrect. The Files API avoids re-uploading file content, but re-reading a stored file on every request still requires reprocessing it, so it does not address the repeated-processing cost.
• D. Incorrect. Batch processing is for asynchronous bulk workloads with a discount on the whole request, not a mechanism for avoiding repeated processing of a shared prefix on synchronous calls.

Correct answer: A — Adjusting effort trades intelligence for latency and cost within the same model; lowering it from the default may recover budget without the accuracy loss that comes from switching to a different, less capable model.

• A. Correct. Tuning the effort parameter directly trades off intelligence, latency, and cost within the same model; lowering effort from the default can bring latency back within budget while avoiding the accuracy degradation that typically comes from moving to a less capable model. This approach leverages the existing model’s strengths with a controlled trade-off.
• B. Incorrect. The effort parameter actually controls reasoning depth and token usage, which directly influences raw inference latency, not just the number of tool calls. It is a global control over model intelligence, so adjusting it can meaningfully reduce latency without immediately resorting to a model switch.
• C. Incorrect. The effort parameter can be set to levels lower than the default, allowing latency to be reduced on Opus 4.8. There is no restriction preventing decreases; thus, tuning effort is a viable first step before considering model migration.
• D. Incorrect. Effort tuning is available across all surfaces, including Claude Code and the API. The coding-agent product can adjust effort in both environments, so the option’s assertion that it’s API-only is false, making a switch unnecessary on these grounds.

Correct answers: A, B, C — Choose Claude for Teams or Enterprise as the API provider so Claude Code and claude.ai share one per-seat subscription with no infrastructure to run; Use server-managed settings delivered from the claude.ai admin console, since it reaches both local and web sessions without requiring MDM; Use the usage dashboard at claude.ai/analytics/claude-code for centralized spend visibility, available on Claude for Teams and Enterprise plans

• A. Correct. For a company with no infrastructure to run and both Claude Code and claude.ai usage, Claude for Teams or Enterprise as the provider is the default recommendation, combining both products under one per-seat subscription.
• B. Correct. Server-managed settings are delivered from the admin console with no device management infrastructure required, and unlike endpoint-managed settings, they also reach Claude Code on the web, matching the requirement to cover both surfaces.
• C. Correct. The usage dashboard at claude.ai/analytics/claude-code is included on Claude for Teams and Enterprise plans and provides the centralized spend visibility the architect needs without building custom OpenTelemetry infrastructure.
• D. Incorrect. The company has no existing device management, so introducing MDM as the primary channel contradicts the stated constraint; server-managed settings are the appropriate fit for unmanaged devices instead.
• E. Incorrect. Project-level settings are the lowest-precedence tier below managed settings and can be freely overridden by local or user settings, so they cannot establish organization-wide, non-overridable policy.
• F. Incorrect. Server-managed settings are explicitly not available when using third-party model providers like Amazon Bedrock; choosing Bedrock would require a self-hosted Claude apps gateway instead of native server-managed settings, and it does not unify Claude Code and claude.ai billing as required.

Correct answer: A — dontAsk mode, which auto-denies anything not covered by an explicit allow rule

• A. Correct. dontAsk mode only executes actions matching pre-approved allow rules and read-only commands, auto-denying everything else instead of prompting, which makes a session fully non-interactive and safe for a CI pipeline with no human available.
• B. Incorrect. acceptEdits still prompts for Bash commands outside its narrow auto-approved filesystem set, so an unattended CI run could stall waiting on a prompt that no human is present to answer.
• C. Incorrect. plan mode prevents any execution at all, including of pre-approved tools, so it cannot let a pipeline actually apply pre-approved fixes or changes.
• D. Incorrect. auto mode uses a classifier to approve actions dynamically rather than restricting execution to a fixed, pre-approved allow list, which does not match the requirement that only pre-approved tools ever run.

Correct answer: B — Ask Claude to read the log file in smaller chunks, such as a specific line range, or delegate the analysis to a subagent instead.

• A. Incorrect. CLAUDE_CODE_MAX_RETRIES governs retries of failed API requests, not the compaction-thrashing loop. Thrashing happens because the file itself refills the context after each compaction, so retrying compaction more times does not solve the underlying problem.
• B. Correct. Auto-compaction succeeded but the oversized file output immediately refilled the context window several times in a row, so Claude Code stopped retrying to avoid wasted API calls. Reading the file in smaller chunks or moving the work to a subagent's separate context window is the documented recovery path.
• C. Incorrect. Disabling auto-compaction removes the safeguard that prevents the context window from overflowing, so it would make the thrashing problem worse, not better, since the full log would still need to fit in context.
• D. Incorrect. This is more drastic than necessary and discards useful investigation context. The documented recovery steps are to chunk the file, use a targeted /compact, or delegate to a subagent, not to abandon the conversation entirely.

Correct answer: A — Select Reconnect for the server from /mcp, and if the tool count stays at zero, run claude --debug mcp to see the server's stderr output.

• A. Correct. A server that shows connected but lists zero tools has started but isn't returning a tool list. The documented step is to select Reconnect from /mcp, and if the count stays at zero, run claude --debug mcp to inspect the server's stderr output.
• B. Incorrect. A relative path in command or args typically causes the server to fail to start entirely, which shows as failed in /mcp, not connected with zero tools. That is not the situation described here.
• C. Incorrect. Project-scoped approval does not silently expire; once approved, a server stays enabled. This does not explain a connected server returning no tools.
• D. Incorrect. Safe mode disables all MCP servers for the session, so the server would not show as connected at all, let alone connected with zero tools. This is not a diagnostic step for this symptom.