34 free Anthropic CCAR-F practice questions from the CertStash pack of 134, each with the correct answer and a full explanation. The rule is the same for every exam: ten free on the product page, 34 free here, all 134 in the pack, and each step includes the one before it.
Get all 134 questions (US$39) · Download the first 10 as a PDF
Question 1
The synthesis agent receives summarized findings from the web search and document analysis agents, then passes a consolidated summary to the report generator. During testing, you discover the generated reports make factual claims without proper citations: the report generator cannot attribute statements to their original sources because that metadata was lost during the summarization steps. What’s the most effective approach to ensure proper source attribution in the final reports?
Show answer and explanation
Correct answer: B. Have each agent output structured data separating content summaries from source metadata (URLs, document names, page numbers).
Attribution disappears here because each summarization step compresses findings into prose and drops the record of which source each statement came from. When every agent outputs structured data that keeps content summaries in one field and source metadata (URLs, document names, page numbers) in separate fields, the metadata survives each compression step instead of depending on a summarizer to restate it. The report generator then receives citations as data it can render directly, which fixes the root cause rather than trying to recover attribution after it has been lost.
Why the other options are wrong
- A. Re-locating sources after the report is written is a guess at which source supported each claim, adds extra search calls, and leaves the summarization steps still discarding metadata.
- C. Passing full raw outputs floods the report generator's context with far more text than it needs and abandons the summarization that keeps later stages focused.
- D. Inline references added at the synthesis stage cannot restore metadata that earlier summarization steps already dropped, and free-text citations can still be lost in later rewriting.
Question 2
After the web search agent finds 25 sources (120K tokens of raw content), the document analysis agent extracts key insights (15K tokens), and the synthesis agent produces a coherent narrative draft (3K tokens), the coordinator must pass context to the report generation agent for the final output with proper source citations. What context-passing strategy provides the best balance of completeness and efficiency?
Show answer and explanation
Correct answer: B. Pass the synthesis draft along with a structured source index that maps key claims to their source URLs and relevant excerpts.
The report generator needs two things: the narrative to turn into a report and enough provenance to cite it accurately. The 3K-token synthesis draft supplies the narrative, and a structured source index mapping key claims to their source URLs and relevant excerpts supplies citation-ready provenance, without forcing the generator to wade through the 135K tokens of raw content and extracted insights. Carrying claim-to-source links forward as structured data is what keeps citations accurate after summarization, so this strategy keeps completeness where it matters while keeping the context lean.
Why the other options are wrong
- A. Passing the full accumulated context buries the claims that need citing among more than 135K tokens of raw material, raising cost and making it harder for the generator to focus.
- C. Matching claims to sources after generation means reconstructing links that were never carried forward, so citations can attach to the wrong source or be missed entirely.
- D. Attributing findings by source name only gives the report no URLs or excerpts, so citations cannot be specific or checked.
Question 3
Your multi-agent research pipeline crashed after processing 12 of 28 documents. The web search agent had identified relevant sources, the document analyzer had partially completed extraction, and the synthesizer had begun pattern identification. You need to resume processing without repeating work or losing fidelity of prior findings. What state management approach best balances information fidelity with context efficiency when restoring agent state?
Show answer and explanation
Correct answer: A. Have each agent persist a structured export to a known location. On resume, the coordinator loads the manifest and injects relevant state into agent prompts.
Combining structured state exports with a coordinator-loaded manifest is the standard recovery pattern for a multi-agent pipeline. Each agent writes its progress (sources found, documents already extracted, partial synthesis patterns) to a known location in a structured format, so nothing depends on memory that was lost in the crash. On resume the coordinator reads the manifest, sees which of the 28 documents are done, and injects only the relevant state into each agent's prompt before dispatching the remaining work. Fidelity is preserved because state is stored explicitly, and context stays efficient because each agent receives only what it needs.
Why the other options are wrong
- B. Semantic search returns whatever looks similar to a query, so agents can miss prior findings or pull in unrelated ones, which undermines exact resumption.
- C. Agents reloading their own files independently leaves the coordinator unaware of what each agent completed, so it cannot sequence the remaining work or prevent duplication.
- D. Replaying the coordinator's full log floods agents with every delegation and response instead of the specific state they need, and it holds no clean record of partially completed extraction.
Question 4
You’ve configured the system so that all four subagents have access to the complete set of 18 tools. During testing, agents frequently call tools outside their specialization: the synthesis agent attempts web searches, and the report generator tries to analyze documents. What is the primary cause of this poor tool selection behavior?
Show answer and explanation
Correct answer: A. Choosing from 18 tools instead of 4-5 relevant ones increases decision complexity beyond reliable selection thresholds.
Giving an agent too many tools, such as 18 instead of the 4 or 5 its role needs, degrades tool selection reliability because every decision becomes a choice among many more candidates. The symptoms match this exactly: the synthesis agent reaches for web search and the report generator tries to analyze documents because those tools are available and look plausible, and agents with tools outside their specialization tend to misuse them. The fix is scoped tool access, giving each subagent only the tools for its role, which shrinks the decision space and restores reliable selection.
Why the other options are wrong
- B. The symptom is choosing the wrong tool, not running out of room for task content, and nothing in the scenario points to the context window being exhausted.
- C. The role descriptions state the intended specialization; the off-role calls happen because the agents have off-role tools available to pick, not because the prompts contradict anything.
- D. The coordinator is not misrouting tasks; the subagents themselves choose tools outside their role after receiving correctly routed work.
Question 5
The coordinator provides detailed step-by-step instructions to the web search subagent, specifying exact search queries, source priorities, and date filters. Production monitoring reveals three issues: (1) the subagent reports “insufficient results” rather than trying alternative approaches when pre-specified searches fail, (2) research quality drops for emerging topics that don’t match expected patterns, and (3) the subagent rarely surfaces valuable tangential sources. What’s the most effective way to improve subagent adaptability?
Show answer and explanation
Correct answer: D. Specify research goals and quality criteria (coverage breadth, source diversity, recency) rather than procedural steps, letting the subagent determine its search strategy.
All three symptoms come from procedural micromanagement. When the coordinator dictates exact queries, source priorities and filters, the subagent has no mandate to try anything else, so it reports failure when those queries miss, struggles with topics that do not fit the anticipated pattern, and ignores tangential sources. Specifying research goals and quality criteria (coverage breadth, source diversity, recency) tells the subagent what a good result looks like while leaving the search strategy to it. It can then reformulate queries, adapt to emerging topics and follow promising leads, and still be held to clear standards.
Why the other options are wrong
- A. Classifying requests still leaves procedural scripts in place for the well-defined category and adds a misclassification risk, so the rigidity behind all three symptoms remains.
- B. A fallback directive patches only the insufficient-results symptom and does nothing for emerging topics or tangential sources, since the subagent still follows a fixed script.
- C. Dropping all guidance gives the subagent no quality criteria, so results can become unfocused and inconsistent in coverage, diversity and recency.
Question 6
The synthesis agent completes its initial pass but flags that three key research questions remain unanswered because the web search and document analysis agents didn’t find relevant information on those specific subtopics. The coordinator currently proceeds directly to report generation, producing reports with incomplete coverage. What change would most effectively improve research completeness?
Show answer and explanation
Correct answer: C. Have the coordinator evaluate synthesis output for gaps, then re-delegate to web search and document analysis with targeted queries before invoking synthesis again.
The synthesis agent has already identified exactly what is missing, so the coordinator should act on that before producing the report. In an iterative refinement loop the coordinator evaluates the synthesis output for gaps, re-delegates to the web search and document analysis agents with queries targeted at the three unanswered questions, and re-invokes synthesis with the new findings until coverage is sufficient. Keeping the loop in the coordinator also preserves hub-and-spoke orchestration, where all subagent communication passes through one place for observability and consistent error handling.
Why the other options are wrong
- A. Listing the unanswered questions in the report makes the gaps visible but leaves the coverage just as incomplete.
- B. Broader initial queries raise cost on every request and still may not reach the three specific subtopics that synthesis flagged.
- D. Giving the synthesis agent search tools pushes it outside its role and lets it bypass the coordinator, which loses visibility and control over the research flow.
Question 7
The web search agent has gathered several relevant sources for a research topic. The document analysis agent now needs to examine these sources. How does information typically flow between these two specialized subagents?
Show answer and explanation
Correct answer: C. The coordinator agent receives the web search agent’s output and includes relevant findings in the prompt when invoking the document analysis agent.
In a coordinator-subagent architecture the coordinator manages all communication between subagents. Subagents operate with isolated context and do not see each other's output, so the coordinator receives the web search agent's results and includes the relevant findings in the prompt when it invokes the document analysis agent. Routing everything through the coordinator gives it observability, consistent error handling and control over what each subagent sees.
Why the other options are wrong
- A. An event-driven queue is infrastructure the coordinator pattern does not use, and it would take the coordinator out of the flow it is meant to control.
- B. Subagents do not invoke each other directly; peer-to-peer calls would bypass the coordinator's routing, error handling and visibility.
- D. Subagents receive their context explicitly in the prompt, and a shared store they read and write on their own sidesteps the coordinator's control of information flow.
Question 8
Production reviews reveal inconsistent handling of uncertainty in final reports. Sometimes conflicting subagent findings are synthesized into a single confident statement (losing nuance), while other times reports over-hedge with excessive qualifications (becoming unhelpful). When the web search agent returns “industry analysts estimate $50B market size (methodology varies)” and the document analysis agent returns “peer-reviewed study estimates $35B (±$7B, 95% CI),” the coordinator either picks one arbitrarily or produces vague statements like “the market may be $35B-$50B depending on factors.” What systematic approach best addresses this?
Show answer and explanation
Correct answer: C. Instruct the synthesis agent to structure reports with explicit sections distinguishing well-established findings from contested ones, preserving original source characterizations and methodological context.
Both failure modes come from discarding context: one collapses two credible estimates into a single value, the other replaces them with a vague range. The reliable approach is to keep conflicting statistics with their source attribution and to structure the report into sections that separate well-established findings from contested ones. Here the report would present the analysts' $50B estimate (methodology varies) and the peer-reviewed $35B estimate (±$7B, 95% CI) side by side as a contested finding, each with its original characterization, so readers can see why the figures differ and weigh them.
Why the other options are wrong
- A. A high-confidence filter would discard the analysts' estimate, whose methodology varies, so readers lose a legitimate data point instead of seeing the disagreement.
- B. Two credible estimates that disagree cannot both be corroborated, so a two-source rule could drop both figures and hide the conflict rather than report it.
- D. Converting both characterizations into probability scores and averaging them produces a figure neither source reported and strips out the methodology and confidence interval that explain the difference.
Question 9
In production, final reports frequently contain claims without proper source attribution. Investigation shows that while the web search and document analysis agents correctly attach citations to their outputs, the synthesis agent loses track of which sources support which conclusions when combining findings. What’s the most effective architectural change?
Show answer and explanation
Correct answer: A. Require all subagents to output structured claim-source mappings that the synthesis agent must preserve and merge when combining findings from multiple sources.
The subagents already attach correct citations, so attribution is being lost inside synthesis, where findings are combined as unstructured text. Requiring subagents to output structured claim-source mappings, which the synthesis agent must preserve and merge, makes provenance part of the data that flows through the pipeline. When synthesis combines findings, each conclusion keeps its supporting sources attached, so the report generator can cite them directly instead of guessing.
Why the other options are wrong
- B. A citation-resolution agent reading transcripts has to infer after the fact which sources support each synthesized conclusion, the same link the synthesis step already lost.
- C. Semantic similarity matching guesses attribution from textual resemblance, so paraphrased or combined claims can be matched to the wrong source or to none.
- D. Text prefixes are not structured data; they can be dropped or scrambled when synthesis rewrites and merges passages, and parsing them back out is error-prone.
Question 10
After the web search agent and document analysis agent complete their tasks, the coordinator invokes the synthesis agent. However, the synthesis agent responds that it cannot complete the task because no research findings were provided. What is the most likely cause of this issue?
Show answer and explanation
Correct answer: C. The coordinator did not include the outputs from the previous agents in the synthesis agent’s prompt.
Subagents do not automatically inherit the coordinator's conversation history or share memory with other subagents. Each invocation starts with only what is in its prompt, so if the coordinator leaves out the web search and document analysis outputs when it invokes the synthesis agent, the synthesis agent has no findings to work with and says so. The coordinator must collect the earlier results and pass them explicitly in the synthesis agent's prompt.
Why the other options are wrong
- A. Context is not shared through an API connection; each request contains only the messages sent with it, so sharing a connection passes nothing between agents.
- B. Tools for fetching other agents' histories add indirection to retrieve outputs the coordinator already holds and can simply include in the prompt.
- D. An oversized input would be rejected with a "prompt is too long" error, not arrive as a prompt with no findings at all; the symptom points to data that was never passed.
What people say about the full CCAR-F pack 4.5 from 2
Thanks for your great Anthropic practice questions.
Question 11
Production monitoring shows that follow-up queries like “summarize what we learned about market trends” consistently take 40+ seconds. Investigation reveals the coordinator spawns the synthesis subagent for each summarization request, passing 80K+ tokens of accumulated findings. The coordinator already has these findings in its context from orchestrating the research. What’s the most effective way to improve response time for these follow-up summaries?
Show answer and explanation
Correct answer: B. Have the coordinator handle straightforward summarization requests directly using its existing context, reserving subagent spawning for complex analysis.
The coordinator already holds the accumulated findings in its own context, yet every follow-up summary spawns a synthesis subagent and ships it 80K+ tokens of material it must process from scratch. Letting the coordinator answer straightforward summary requests directly removes the spawn, the transfer and the subagent's separate pass over the findings, which is where the 40+ seconds go. Subagents remain available for complex analysis that benefits from a separate, focused context, so the multi-agent design is kept where it adds value.
Why the other options are wrong
- A. Caching only speeds up processing of a repeated prefix; the subagent still has to be spawned, receive 80K+ tokens and produce a summary the coordinator could write itself.
- C. Pre-generating summaries at several granularities adds work every time findings change and still cannot anticipate the specific question a follow-up asks.
- D. On-demand requests for findings add round trips between subagent and coordinator, increasing latency for information the coordinator already has.
Question 12
Your agent is handling a billing dispute. After calling get_customer and lookup_order, it identifies that the dispute involves a promotional pricing error requiring manager approval, beyond the agent’s authorization level. How should the workflow handle this mid-process escalation?
Show answer and explanation
Correct answer: A. Compile a structured handoff with customer details, order info, and the identified issue before calling escalate_to_human.
Once the agent has established that the promotional pricing error needs manager approval, the right step is to escalate with a structured handoff: customer details, the relevant order information and the identified issue. The human picks up exactly where the agent stopped, with the diagnosis already done, and can move straight to the approval decision. Structured handoffs exist for mid-process escalation so that a human taking over does not have to re-investigate what the agent already found.
Why the other options are wrong
- B. A reference ID to a stored raw history makes the human retrieve and read the whole conversation to find the diagnosis, instead of being handed it.
- C. The original message contains only the complaint, not the order details or the identified pricing error, so the human has to redo the investigation.
- D. Attempting a refund the agent is not authorized to make treats the payment system as the policy check, and if it succeeds it commits a financial action that required manager approval.
Question 13
A customer raises three separate issues during one session: a refund inquiry (turns 1-15), a subscription question (turns 16-30), and a payment method update (turns 31-45). At turn 48, the customer asks “What happened with my refund?” The conversation is approaching context limits. What strategy best maintains the agent’s ability to address all issues throughout the session?
Show answer and explanation
Correct answer: A. Extract and persist structured issue data (order IDs, amounts, statuses) into a separate context layer.
With three separate issues in one long session, the facts that matter are transactional: order IDs, amounts, dates and statuses for each issue. Extracting those into a separate, persistent context layer that is included with every request keeps all three issues answerable no matter how the older conversation turns are trimmed or summarized. When the customer asks about the refund at turn 48, the agent reads its exact order ID, amount and status from that layer instead of relying on turns 1 to 15, which may no longer fit in context.
Why the other options are wrong
- B. A narrative summary blurs exact values such as order IDs and amounts, which are precisely what the agent needs to answer the refund question accurately.
- C. Tools return current backend records but not what was discussed and agreed in the conversation, and the agent must still remember which IDs to fetch once those turns are gone.
- D. A 30-turn window at turn 48 keeps only turns 19 to 48, so everything about the refund from turns 1 to 15 is lost.
Question 14
Your conversational assistant frequently generates multiple clarifying questions when users make ambiguous requests. When a user asks “Can you help me with the report?”, the assistant responds: “I’d be happy to help! Could you tell me: 1) Which report? 2) What kind of help (drafting, reviewing, or formatting)? 3) What’s your deadline?” User analytics show a 40% conversation abandonment rate after these multi-question responses. What’s the most effective way to reduce friction while appropriately handling ambiguity?
Show answer and explanation
Correct answer: C. Modify the system prompt to instruct the assistant to make reasonable assumptions from available context, state those assumptions explicitly, and offer to adjust if the interpretation is wrong.
Users abandon the conversation when an assistant answers a short request with a list of questions. Instructing it to make reasonable assumptions from the available context, state them explicitly and offer to adjust gives the user something useful immediately, for example a draft or review based on the report most recently discussed. Because the assumptions are stated, the user can correct a wrong guess in one short reply, so ambiguity is still handled while most of the friction disappears.
Why the other options are wrong
- A. One question per turn still makes the user answer several questions before getting any help, only spread over more exchanges.
- B. An ambiguity classifier adds latency and infrastructure while high-ambiguity requests still end in the same clarification dialog that drives users away.
- D. Applying defaults without stating them means users get answers built on wrong guesses with no signal that a correction is needed.
Question 15
The document analysis agent has a single analyze_document tool that takes a document and a free-text instruction parameter. During evaluation, requests like “extract the key financial metrics” often return narrative summaries, while “summarize the methodology” sometimes returns raw data tables. The synthesis agent reports that 35% of analysis results require re-requests with clarified instructions. What’s the most effective way to improve reliability?
Show answer and explanation
Correct answer: D. Split the generic tool into purpose-specific tools (extract_data_points, summarize_content, verify_claim_against_source), each with defined input/output contracts
A single analyze_document tool driven by a free-text instruction leaves the output shape to interpretation, which is why 'extract' sometimes yields narrative and 'summarize' sometimes yields tables, forcing a 35% re-request rate. Splitting it into extract_data_points, summarize_content and verify_claim_against_source makes the intended operation part of the tool choice itself, and each tool's defined input and output contract fixes what comes back: structured data points, a narrative summary or a verification result. The synthesis agent receives a predictable format for each request type instead of whatever a given phrasing happened to produce.
Why the other options are wrong
- A. A coordinator pre-classification step adds an extra stage but still passes free-text instructions to the same tool, so the output format remains open to interpretation.
- B. An analyze_type enum still feeds one tool with one loosely defined output, so each mode lacks its own enforced output contract.
- C. More examples in the description still leave the format to the model's interpretation of each free-text instruction, so the mismatches persist.
Question 16
During testing, you find that when a customer says “I need a refund for my recent purchase,” the agent calls process_refund immediately, but populates the required order_id parameter with a plausible-looking but fabricated value instead of first calling lookup_order to retrieve the actual order ID. The refund call fails because the fabricated ID doesn’t exist. Which change directly addresses the root cause of the agent fabricating the order_id value?
Show answer and explanation
Correct answer: B. Update the process_refund tool description to explicitly state that order_id must be obtained from a prior lookup_order call and must never be assumed or invented.
Claude decides how to fill tool parameters largely from the tool's description, and Anthropic recommends detailed descriptions that explain what each parameter means and where its value should come from. The process_refund description apparently says nothing about how order_id must be obtained, so the model treats it as something it may supply itself and invents a plausible value. Stating that order_id must come from a prior lookup_order call and must never be guessed gives Claude the missing dependency, so it calls lookup_order first. That changes the behavior that produces the fabricated ID rather than reacting after it has been sent.
Why the other options are wrong
- A. Setting tool_choice to any only forces some tool call on every turn, which does nothing to make the agent obtain a real order_id and may even encourage premature calls.
- C. Pre-extracting IDs only helps when the customer types an order number, and this customer referred only to a recent purchase, so there is nothing to extract.
- D. Server-side validation catches the bad ID after the agent has already fabricated it, so the refund still fails and the cause of the fabrication is left in place.
Question 17
You are using Claude Code to accelerate software development. Your team uses it for code generation, refactoring, debugging, and documentation. You need to integrate it into your development workflow with custom slash commands, CLAUDE.md configurations, and understand when to use plan mode vs. direct execution. Your team frequently migrates React components to Vue. You’ve written a step-by-step workflow for Claude Code to follow during each migration, and you want every developer on the team to invoke it by typing /migrate-component. The workflow should stay in sync as the team iterates on it. Where should you place the skill file?
Show answer and explanation
Correct answer: B. In .claude/skills/migrate-component/SKILL.md at the project root, committed to version control
Project skills live in .claude/skills/<skill-name>/SKILL.md, and the directory name becomes the slash command, so .claude/skills/migrate-component/SKILL.md is invoked as /migrate-component. Committing the skill to the repository shares it with every developer who clones the project, and changes to the workflow flow through normal version control. This satisfies both requirements: everyone can invoke the same command, and the workflow stays in sync as the team iterates on it.
Why the other options are wrong
- A. Personal skills in ~/.claude/skills/ are not version-controlled, so each developer's copy drifts as soon as the team changes the workflow.
- C. skillOverrides in settings only changes the visibility of existing skills, so it cannot register or define a new workflow.
- D. Instructions in CLAUDE.md load into every session as general guidance and do not create a /migrate-component command for developers to invoke.
Question 18
The coordinator agent has AgentDefinitions configured for all four specialized subagents, each with appropriate descriptions, prompts, and tool restrictions. During testing, you notice the coordinator correctly reasons about when to delegate: it generates messages like “I’ll ask the web search agent to find sources on this topic”, but no subagent execution ever occurs. The coordinator then proceeds as if the delegation happened and continues with incomplete information. Logs show no errors. What is the most likely cause?
Show answer and explanation
Correct answer: B. The coordinator’s allowedTools configuration doesn’t include “Task”, so while it can reason about delegation, it cannot invoke the tool required to spawn subagents.
AgentDefinitions only describe the available subagents; a subagent runs only when the coordinator calls the Task tool (named Agent in current Agent SDK releases). The coordinator's allowedTools must include Task for that call to happen. Without it, the model still sees the subagent descriptions and can reason and write about delegating, but it never emits the tool call that would spawn a subagent. Nothing fails, so the logs stay clean, and the coordinator simply continues as if the work had been done, which matches every symptom in the scenario.
Why the other options are wrong
- A. A max_tokens cutoff would end responses with stop_reason max_tokens mid-output, not produce complete delegation messages followed by normal continuation every time.
- C. The coordinator already names the web search agent and decides when to delegate, so it clearly knows the subagents exist; what is missing is the ability to invoke them.
- D. Context forwarding concerns what a subagent receives once it is spawned, but here no subagent is ever spawned.
Question 19
You are using Claude Code to accelerate software development. Your team uses it for code generation, refactoring, debugging, and documentation. You need to integrate it into your development workflow with custom slash commands, CLAUDE.md configurations, and understand when to use plan mode vs. direct execution. Your team has three requirements for Claude Code’s behavior in your project: 1. Claude must never modify files in the db/migrations/ directory. 2. Claude should prefer your custom logging module over console.log. 3. All TypeScript files must be auto-formatted with Prettier after every edit. All three are currently written as instructions in your project’s CLAUDE.md. During a complex refactoring session, a developer discovers that Claude edited a migration file, violating requirement #1. How should you restructure these requirements across Claude Code's configuration mechanisms?
Show answer and explanation
Correct answer: A. Add Edit(./db/migrations/**) to permissions.deny in the project settings, keep the logging preference in CLAUDE.md, and add a PostToolUse hook on the Edit tool that runs Prettier on changed TypeScript files.
CLAUDE.md is loaded as context, not enforced configuration, which is why Claude could still edit a migration file during a long session. Each requirement should go to the mechanism that matches its nature. The migration ban is a hard rule, so a permissions.deny entry for Edit on db/migrations/** is enforced by the client no matter what Claude decides. The logging preference is a judgment-based convention that suits CLAUDE.md guidance. Prettier must run after every edit without exception, which is exactly what a deterministic PostToolUse hook on the Edit tool guarantees.
Why the other options are wrong
- B. Rules in .claude/rules/ are still instructions loaded into context, so the migration ban remains advisory and can be ignored exactly as it was in CLAUDE.md.
- C. Stronger wording and examples still leave all three requirements as guidance that Claude can miss during a complex session, which is the failure that already happened.
- D. A custom blocking script reimplements what a declarative deny rule already enforces, and injecting a soft logging preference through a hook on every edit adds machinery for guidance that CLAUDE.md handles directly.
Question 20
You are building a customer support resolution agent using the Claude Agent SDK. The agent handles high-ambiguity requests like returns, billing disputes, and account issues. It has access to your backend systems through custom Model Context Protocol (MCP) tools (get_customer, lookup_order, process_refund, escalate_to_human). Your target is 80%+ first-contact resolution while knowing when to escalate. After expanding the agent’s MCP tools with delivery-specific capabilities (check_delivery_status, contact_driver, issue_credit, apply_promo_code, update_delivery_address, reschedule_delivery), the total tool count has grown from 4 to 10. Your evaluation suite shows tool selection accuracy has dropped from 88% to 71%. Log analysis reveals the majority of errors involve the agent selecting between semantically overlapping tools: calling issue_credit when process_refund was correct, and calling check_delivery_status when lookup_order already returns the needed data. Which approach structurally eliminates the semantic overlap identified in the logs as the error source?
Show answer and explanation
Correct answer: D. Consolidate semantically overlapping tools: merge issue_credit and process_refund into a single resolve_compensation tool with an action parameter, and fold check_delivery_status into lookup_order with an optional include_tracking flag.
The logs pinpoint the errors: the agent confuses issue_credit with process_refund and calls check_delivery_status when lookup_order already returns the needed data. Anthropic's tool design guidance favors fewer, non-overlapping tools whose purposes are clearly distinct. Merging issue_credit and process_refund into one resolve_compensation tool with an action parameter, and folding tracking into lookup_order behind an optional include_tracking flag, removes the ambiguous choices entirely. The agent no longer has to pick between near-duplicates; the decision becomes an explicit parameter value, which is the structural change the question asks for.
Why the other options are wrong
- A. Tool search addresses context size and selection across very large tool libraries, but with only ten tools the overlapping pairs remain separately loadable, so the confusion between them is unchanged.
- B. Splitting into sub-agents keeps issue_credit and process_refund together in the financial agent and adds a routing decision, so the identified overlap is still there.
- C. Few-shot examples can nudge selection but leave both overlapping tools in place, so the ambiguity still exists for cases the examples do not cover.
Question 21
A customer returns 4 hours after the initial session about the same billing dispute. The previous 32-turn session contains lookup_order results showing “Status: PENDING, Expected resolution: 24-48 hours.” In testing, you observe that when resuming sessions with stale tool results, the agent often references the outdated data in responses (e.g., “I see your refund is still being processed”) even after subsequent fresh tool calls return different information. What approach most reliably handles returning customers?
Show answer and explanation
Correct answer: A. Start a new session, inject a structured summary of the previous interaction (issue type, actions taken, resolution status), then make fresh tool calls before engaging.
Resuming a 32-turn session carries forward both the old PENDING tool results and the assistant's earlier statements based on them, and testing shows the agent keeps echoing that outdated status even after fresh calls return different data. Starting a new session removes the stale material from context entirely. A structured summary of the earlier interaction (issue type, actions taken, resolution status) preserves the continuity the customer expects, and making fresh tool calls before engaging ensures the agent's picture of the dispute comes from current data. This combines the useful history with reliable, up-to-date facts.
Why the other options are wrong
- B. Stripping only the tool_result messages leaves the earlier assistant turns in place, and those turns already repeat the outdated PENDING status the agent keeps referencing.
- C. Re-calling every tool still leaves the stale results and the 32 turns of reasoning built on them in context, which is exactly the condition under which the agent was observed citing old data.
- D. A prompt instruction to prefer recent results is the kind of guidance already shown to fail, since the agent referenced stale data even when fresher results were present in context.
Question 22
Your control_device tool manages smart home devices through external APIs. When a device doesn’t respond within the timeout period, the tool returns an error. Production logs show that the agent simply tells users “the device is not responding” without offering helpful next steps. Which error response structure would best enable the agent to provide useful follow-up?
Show answer and explanation
Correct answer: D. Set is_error: true with a message explaining the likely cause and suggesting troubleshooting steps the agent can offer the user.
The agent has nothing to offer beyond 'the device is not responding' because that is all the error tells it. Keeping is_error: true marks the outcome correctly as a failure, and adding a message that explains the likely cause and suggests troubleshooting steps, such as checking power or network connectivity, gives the agent concrete next steps to pass on in the same turn. The information the user needs arrives with the failure itself, with no extra lookup and no technical translation required.
Why the other options are wrong
- A. Device IDs, timeout durations and raw response codes are debugging data that the agent cannot turn into practical advice for the user.
- B. A separate troubleshooting tool adds a call the agent may not make, when the same guidance can travel in the error response itself.
- C. Setting is_error: false reports a failed command as dispatched, so the agent would tell the user something untrue instead of helping them fix the problem.
Question 23
Your update_user_profile tool accepts a user_id (required) and an optional fields_to_update object. In testing, Claude frequently omits user_id or passes incorrectly structured data. What is most critical for helping Claude understand what parameter values to provide?
Show answer and explanation
Correct answer: D. Clear parameter descriptions explaining expected format, such as “user_id: UUID of the user to update (required)”
Claude decides what values to provide by reading the tool definition, and parameter descriptions are the part that explains meaning and format. A description such as "user_id: UUID of the user to update (required)" tells Claude what the value is, what form it takes and that it must be present, guiding the call before it is made. Anthropic's tool-use guidance names detailed descriptions as by far the most important factor in tool performance, including what each parameter means; schema types support this by stating structure rather than explaining it.
Why the other options are wrong
- A. Type constraints and a required list state structure but say nothing about what user_id identifies or what format it takes, which is the information Claude is missing when it builds the call.
- B. Packing format hints into names like user_id_string_uuid_format produces awkward identifiers that still cannot explain meaning or nested structure the way a description can.
- C. Error responses arrive only after a bad call has been made, so they repair mistakes rather than guiding Claude to the right values the first time.
Question 24
Your infrastructure-as-code repository includes Terraform modules (/terraform/), Kubernetes manifests (/kubernetes/), and CI/CD pipeline scripts (/pipelines/). Each requires different conventions, but your single root CLAUDE.md has grown to 500+ lines. When developers work on Kubernetes files, Terraform-specific rules load into context unnecessarily, consuming tokens. What is the best approach to reorganize so only relevant guidance loads when editing specific file types?
Show answer and explanation
Correct answer: D. Create files in .claude/rules/ with YAML frontmatter path-scoping (e.g., paths: ["terraform/**/*"]), loading rules only when editing matching files.
Files in .claude/rules/ can carry YAML frontmatter with a paths field listing glob patterns, and such a rule loads into context only when Claude works with files that match those patterns. Moving the Terraform, Kubernetes and pipeline conventions into separate rule files scoped with patterns like terraform/**/* means Kubernetes work no longer pulls in Terraform guidance, which cuts the token cost of the 500+ line root file. Claude Code's documentation recommends exactly this for instructions that matter only for part of a codebase, and glob patterns can target file types as well as directories.
Why the other options are wrong
- A. Subdirectory CLAUDE.md files are tied to folder location rather than file patterns, so they cannot scope guidance by file type the way paths globs in rule files can.
- B. Files pulled in with @path imports load at launch alongside the CLAUDE.md that references them, so every convention still enters context in every session.
- C. Adding headers improves readability but the whole file still loads every session, so Terraform rules still consume tokens during Kubernetes work.
Question 25
You are using Claude Code to accelerate software development. Your team uses it for code generation, refactoring, debugging, and documentation. You need to integrate it into your development workflow with custom slash commands, CLAUDE.md configurations, and understand when to use plan mode vs. direct execution. Your team has connected a custom MCP server that provides DevOps workflow templates. The server exposes several MCP prompts (such as deploy_checklist and incident_response) in addition to tools. How do these MCP prompts become accessible within Claude Code?
Show answer and explanation
Correct answer: D. They appear as slash commands (e.g., /mcp__servername__deploy_checklist) that you can invoke, with arguments passed after the command name.
In the MCP specification, prompts are user-controlled templates, distinct from model-controlled tools, and Claude Code exposes them as commands. Typing / lists the available commands, including each MCP prompt from a connected server, and a prompt can be run as /mcp__servername__promptname. Arguments are passed space-separated after the command name. A developer could therefore run the server's deploy_checklist or incident_response prompt on demand, supplying values such as a service name as arguments, and the filled template is sent into the conversation.
Why the other options are wrong
- A. The @ mention mechanism is for files and MCP resources, not prompts, so the server's prompts do not appear there.
- B. MCP prompts are not injected into every conversation; they run only when the user invokes them.
- C. Prompts are not added to the tool registry, because MCP keeps prompts user-invoked while tools are the capability the model calls on its own.
Question 26
You are using Claude Code to accelerate software development. Your team uses it for code generation, refactoring, debugging, and documentation. You need to integrate it into your development workflow with custom slash commands, CLAUDE.md configurations, and understand when to use plan mode vs. direct execution. You’re implementing a caching layer for API responses to speed up the /products endpoint. You have a rough idea (Redis with a 5-minute TTL), but you’re new to production caching and aren’t sure what other considerations a robust implementation requires. What’s the most effective way to start your iterative workflow?
Show answer and explanation
Correct answer: C. Ask Claude to interview you about the caching requirements before implementing, surfacing considerations like invalidation strategies, cache layers, consistency guarantees, and failure modes.
When you are new to a domain, the biggest risk is the requirements you do not know to ask about. Anthropic's Claude Code best practices recommend having Claude interview you before larger features, asking about implementation details, edge cases and tradeoffs you might not have considered. For production caching that means invalidation strategy, consistency guarantees, cache layers and behavior when Redis fails. Answering those questions first produces a complete specification, so the implementation is built for production conditions rather than patched after problems appear.
Why the other options are wrong
- A. Adding features only as problems surface means issues such as stale data or Redis outages may first appear in production rather than during testing.
- B. TBD markers only cover gaps you already know about, and the scenario says you are unsure what other considerations a robust cache requires.
- D. Analyzing the existing endpoint explains its current structure but does not surface caching concerns such as invalidation or failure modes, and you would still supply requirements you do not yet know.
Question 27
Your track_shipment(tracking_id) tool queries an external logistics API that sometimes fails: the API may be temporarily unavailable, the tracking ID may be malformed, or the shipment may not exist. Currently, your tool raises a Python exception when errors occur. Users report the agent gives unhelpful responses like “I’m having trouble with that request” instead of suggesting alternatives such as verifying the tracking number format or checking by order number. How should you handle errors in tool results?
Show answer and explanation
Correct answer: B. Return structured error information as normal tool output including error type, recoverability status, and actionable context for the user.
A raised exception gives the agent nothing to reason about, so it can only say it is 'having trouble'. Returning the failure as normal tool output with an error type (service unavailable, malformed tracking ID, shipment not found), whether it is recoverable, and actionable context lets the agent respond to the specific problem: suggest checking the tracking number format, offer to look up the order number, or explain that the logistics service is temporarily down. The error stays inside the agent's decision loop, where it can turn into a helpful next step for the user.
Why the other options are wrong
- A. A single generic 'lookup_failed' code hides whether the problem is transient, a malformed ID or a missing shipment, so the agent still cannot suggest the right alternative.
- C. Recovery tools called after a bare failure indicator still leave the agent without knowing which failure occurred, so it cannot tell whether retrying or searching by order number is the right move.
- D. Retrying inside the tool helps only with transient outages; malformed IDs and nonexistent shipments fail on every attempt and still reach the agent without usable context.
Question 28
After 30+ turns, your conversational assistant shows noticeably slower responses and occasionally produces less coherent outputs. Investigation reveals: (1) average conversations reach 50,000 tokens by turn 35, (2) production logs show 94% of user messages only reference the previous 3-5 exchanges, (3) the 6% of queries referencing earlier context typically ask about information the user could easily re-state. Your goal is to improve response speed and quality while maintaining good user experience. What’s the most effective approach?
Show answer and explanation
Correct answer: C. Implement a summarization layer that progressively compresses older conversation turns into a running summary while keeping the most recent 5-6 turns verbatim, maintaining full historical context in condensed form.
Long histories slow every request and dilute the model's attention, which explains both the latency and the drop in coherence after 30+ turns. Since most messages reference only the last few exchanges, keeping the most recent 5-6 turns verbatim preserves the detail that matters for nearly every reply, while compressing older turns into a running summary removes the bulk of the token load. Unlike discarding history, the summary still carries the earlier facts in condensed form, so the occasional question about older context can be answered without making the user repeat themselves. This mirrors the compaction approach Anthropic recommends for long-running interactions.
Why the other options are wrong
- A. Prompt caching lowers the cost of reprocessing a repeated prefix, but the model still works over the full 50,000-token history, so the coherence problems caused by the oversized context remain.
- B. A semantic retrieval layer adds infrastructure and depends on correctly detecting when a query refers to the past, and the full verbatim turns it injects can bring back the context bloat it was meant to avoid.
- D. A hard sliding window throws earlier context away completely and pushes the work of re-stating it onto users, which degrades the experience the design is supposed to maintain.
Question 29
After the web search and document analysis subagents complete their tasks, the coordinator needs to spawn the synthesis subagent to synthesize the findings. What is the correct approach for providing the synthesis subagent with the information it needs?
Show answer and explanation
Correct answer: D. Include the complete findings from both subagents directly in the synthesis subagent’s prompt
Subagent context must be provided explicitly in the prompt, because subagents do not automatically inherit the parent's context or share memory between invocations. The coordinator already holds the outputs from web search and document analysis, so the reliable approach is to include the complete findings directly in the synthesis subagent's prompt. The synthesis agent then has everything it needs in context from the start, with no extra tools, callbacks or retrieval steps that could fail.
Why the other options are wrong
- A. There is no automatic context inheritance, so a subagent spawned with only a brief task description receives none of the findings.
- B. Callback tools add round trips and failure points to retrieve data the coordinator could have placed in the prompt directly.
- C. A shared memory store adds configuration and a retrieval step that can fail, while subagents are designed to receive their context explicitly in the prompt.
Question 30
Your content curation agent discovers articles, analyzes each for relevance, then adds selected articles to themed collections. With separate discover_articles(topic), analyze_article(id), and add_to_collection(article_id, collection_id) tools, you observe 18+ sequential tool calls per request, causing latency issues. The agent must make editorial judgments about which articles fit a collection’s theme: this requires seeing all candidates with their analysis scores simultaneously to select a cohesive set. What tool composition best addresses efficiency while preserving editorial judgment?
Show answer and explanation
Correct answer: C. Create a discover_and_analyze(topic) composite tool that returns all candidates with their analysis scores, keeping add_to_collection separate for selective calls.
Most of the 18+ calls come from discovering articles and then analyzing them one at a time. A discover_and_analyze composite returns every candidate with its analysis score in a single call, which removes that sequential chain and also gives the agent exactly what editorial judgment needs: all candidates and scores side by side. Keeping add_to_collection separate leaves the actual selection with the agent, which can choose a cohesive set and add only those articles. The work that is mechanical is batched, and the decision that needs judgment stays with the model.
Why the other options are wrong
- A. Caching makes repeated analyze_article calls cheaper but does not remove the sequential discovery and per-article analysis calls that cause the latency.
- B. Selecting articles by configurable quality thresholds inside the tool takes the editorial judgment away from the agent, which the scenario requires it to keep.
- D. A preview based on predefined rules replaces the agent's editorial judgment with fixed rules, leaving the agent only to approve or reject the result.
Question 31
You are using Claude Code to accelerate software development. Your team uses it for code generation, refactoring, debugging, and documentation. You need to integrate it into your development workflow with custom slash commands, CLAUDE.md configurations, and understand when to use plan mode vs. direct execution. Your team is configuring MCP servers in Claude Code. You want to add a shared venue lookup server that all team members should have access to, and you personally want to add an experimental music playlist server that only you are testing. Which configuration approach correctly applies MCP server scopes?
Show answer and explanation
Correct answer: C. Add venue server to .mcp.json and playlist server to ~/.claude.json
Claude Code stores project-scoped MCP servers in .mcp.json at the project root, which is checked into version control so every team member gets the same servers. Local and user scopes are stored in ~/.claude.json and are private to one developer. The shared venue lookup server therefore belongs in .mcp.json, while the experimental playlist server that only you are testing belongs in your own ~/.claude.json, where it never reaches teammates or the repository.
Why the other options are wrong
- A. ~/.claude.json is private to your machine, so teammates would never receive the shared venue server.
- B. This reverses the scopes: the shared venue server would stay private to you while your experimental playlist server would be committed for the whole team.
- D. Putting the playlist server in the committed .mcp.json pushes an experimental, personal server onto every team member.
Question 32
Your expense reimbursement agent processes employee requests using a process_reimbursement tool. Company policy requires that reimbursements above $500 must be approved by a manager before funds are disbursed. The agent handles hundreds of requests daily, and you need the threshold enforcement to be tamper-proof regardless of how the agent is prompted. Which design ensures the $500 approval threshold cannot be bypassed?
Show answer and explanation
Correct answer: A. The process_reimbursement tool accepts amount and details, and internally enforces the threshold: amounts <$500 are auto-disbursed and the tool returns a success confirmation; amounts >$500 cause the tool to create a pending approval request and return a status indicating manager review is pending.
The $500 rule is a financial control that must hold regardless of what the agent is told, including injected or manipulated instructions. Enforcing it inside process_reimbursement makes the check part of the only path to disbursement: the tool itself decides whether to pay out or create a pending manager approval, based on the amount. The model supplies the amount and details but never decides whether approval is needed, so no prompt, parameter value or tool choice can route a large reimbursement around manager review.
Why the other options are wrong
- B. An approved_by_manager flag set by the agent leaves the decision with the model, and a nightly audit only finds a bypassed approval after the money has gone out.
- C. Routing between the two tools is left to the agent's prompt-guided choice, so whether a large request reaches manager approval depends on the model, and the PostToolUse log only records that choice afterward.
- D. The tool trusts a requires_approval flag in its input instead of checking the amount itself, so any call that does not pass through the hook, such as another client or a misconfigured hook, disburses without approval.
Question 33
Production logs reveal inconsistent error handling: when lookup_order fails, the agent sometimes retries 5+ times (wasteful when the order ID doesn’t exist), sometimes escalates immediately (premature for temporary network issues), and sometimes asks users for clarification (inappropriate when the issue is a backend permission error). Investigation shows your MCP tool returns uniform error responses: {"isError": true, "content": [{"type": "text", "text": "Operation failed"}]}. The agent cannot distinguish between error types. What’s the most effective improvement?
Show answer and explanation
Correct answer: C. Enhance error responses with structured metadata: include errorCategory (transient/validation/permission), isRetryable boolean, and a description of what caused the failure.
The agent's behavior is inconsistent because every failure returns the same 'Operation failed' text, so it has to guess whether to retry, ask the user or escalate. Adding errorCategory (transient, validation or permission), an isRetryable boolean and a description of the cause gives it explicit grounds for each choice: retry transient network failures, stop and clarify when an order ID does not exist, and escalate permission errors rather than questioning the user. The decision rests on fields the tool sets deliberately instead of on interpreting message text.
Why the other options are wrong
- A. An analyze_error tool adds a round trip after every failure, and it still receives the same uniform 'Operation failed' text, so it has nothing to categorize.
- B. Few-shot examples teach the agent to read error message patterns, but every error currently has the identical text, so there are no patterns to distinguish.
- D. Blanket retries waste time on nonexistent order IDs and permission errors that can never succeed, and the agent still receives an undifferentiated error afterward.
Question 34
A customer sends: “This is frustrating. I’ve explained my issue twice and nothing is being resolved. I want to talk to a real person NOW.” The agent has not yet called any tools to investigate their account. What should the agent do?
Show answer and explanation
Correct answer: A. Immediately call escalate_to_human with the conversation history.
When a customer explicitly and emphatically asks for a human, the agent should honor that request immediately rather than first attempting its own investigation. This customer has already explained the issue twice and demands a real person now, so any further delay or attempt to keep them in the automated flow increases frustration. Calling escalate_to_human with the conversation history gives the human agent the context of what the customer has already said, so the customer does not have to start over. The human agent has full system access and can look up the account as part of handling the case.
Why the other options are wrong
- B. Pitching the agent's capabilities and escalating only if the customer asks again forces them to repeat a request they have already made clearly and forcefully.
- C. Running get_customer and lookup_order first delays the handoff the customer demanded immediately, and the human agent can retrieve the same account data directly.
- D. Asking another question, even a targeted one, makes a customer who has explained the issue twice keep explaining instead of reaching the person they asked for.
That was 34 of 134.
The full Anthropic CCAR-F pack has all 134 questions, each with the answer, the explanation and why the other options are wrong, plus a questions-only copy for timed runs. US$39, paid once, with free monthly updates and a pass-or-your-money-back guarantee.
Not ready yet? Get the first 42 free as one PDF by email. Get the Half Pack →