CCAR-F Questions and Answers

The dependency must be enforced by orchestration rather than left to probabilistic tool selection. Anthropic documents that tool_choice: { " type " : " tool " , " name " : " ... " } forces Claude to invoke the specified tool. By contrast, auto allows Claude to decide whether and which tool to call, while any requires some tool but does not force a particular one. ( https://platform.claude.com/docs/en/agents-and-tools/tool-use/define-tools )

Option A therefore establishes a deterministic two-stage workflow. The first API turn forces extract_metadata , producing the DOI and other structured paper details. The application validates and stores that result. A subsequent turn then exposes or permits verify_doi and lookup_citations , passing the extracted DOI as explicit state. This design converts an implicit tool dependency into an application-controlled execution graph.

Option B is incorrect because array order is not a documented precedence mechanism and cannot guarantee selection. Option C forces extract_metadata on every call, including turns where enrichment should occur, potentially creating an infinite or non-progressing workflow. Option D guarantees only that one available tool is called; Claude could still select lookup_citations before the DOI exists.

For stronger input integrity, the tools can also use strict schemas so their arguments conform to the declared JSON Schema. The sequencing requirement, however, remains the responsibility of the orchestration layer.

Official references/topics: Tool Choice; Forced Tool Invocation; Multi-Turn Tool Orchestration; Tool Dependency Management.

Request B benefits substantially more from an explicit multi-phase workflow because it is broad, judgment-intensive, and likely to affect multiple execution paths. Improving error handling requires the agent to identify current failure modes, determine which exceptions should be caught, preserve useful diagnostic information, prevent partial state corruption, and verify that the resulting behavior remains consistent across the module. An analyze → propose → implement → review sequence separates those concerns and creates checkpoints before consequential edits are made.

Request A is comparatively deterministic. The function and target name are already defined, and the task primarily requires locating references, applying the rename, and running tests or static analysis. Anthropic’s Claude Code guidance states that planning is most useful when the approach is uncertain, the work spans multiple files, or the developer is unfamiliar with the affected code. For a small change that can be described as a straightforward diff, direct implementation is usually preferable. ( https://code.claude.com/docs/en/best-practices )

Anthropic also characterizes prompt chaining as appropriate when a task can be divided into fixed stages and additional latency is justified by increased accuracy. Request B fits that pattern because analysis and review materially reduce the risk of introducing swallowed exceptions or inconsistent recovery behavior. ( https://www.anthropic.com/research/building-effective-agents )

Official references/topics: Prompt Chaining; Plan Before Editing; Multi-Phase Coding Workflows; Verification and Review.

The --system-prompt flag replaces Claude Code’s complete default system prompt. Although this does not technically remove the available tools, it discards the default coding-agent guidance that tells Claude how to gather repository context, navigate code, use tools, and verify findings. The replacement prompt says only to analyze the supplied diff, so the observed diff-only behaviour is consistent with the configured instructions.

Option B preserves the standard Claude Code identity and tool guidance while adding the custom review criteria. The Claude Code CLI reference states that --append-system-prompt appends instructions to the default prompt, whereas --system-prompt replaces it. Anthropic specifically recommends appending when Claude should remain a coding assistant that follows additional per-invocation rules.

Option A is incorrect because print mode does not inherently disable Read, Glob, or Grep; --allowedTools restricts or pre-authorizes tools but does not restore overwritten behavioural guidance. Option C is incorrect because replacement system prompts remain compatible with tools, although the replacement must supply suitable tool instructions. Option D changes where the diff appears but does not restore Claude Code’s default code-navigation behaviour. Appending the review instructions directly addresses the configuration error.

================

Option D preserves Claude Code’s standard coding-agent instructions while adding the specialized review criteria. Anthropic documents that --system-prompt replaces the entire default system prompt, including its tool guidance, safety instructions, and coding conventions. It does not technically disable tools, but removing that guidance can make the invocation behave like a narrowly scoped text processor. --append-system-prompt retains the default behavior and layers the review instructions on top.

The prompt should explicitly direct Claude to use Read, Glob, and Grep to inspect definitions, callers, tests, and related modules whenever the diff alone is insufficient. Option A is incorrect because --system-prompt is not incompatible with tools. Option B is also inaccurate: --allowedTools pre-approves tool execution; it does not make tools available when -p would otherwise disable them. In this command, --dangerously-skip-permissions already bypasses permission prompts. Option C is false because Claude Code officially supports piped standard input in non-interactive mode. The repaired invocation should therefore use --append-system-prompt and include an explicit repository-exploration requirement. Claude Code programmatic usage , CLI system-prompt reference

================

Option C is the only approach that guarantees the required terminal condition independently of the model’s behavior. When the agent loop stops, the orchestration layer evaluates the recorded outcome. If neither a successful resolution nor a confirmed human escalation occurred, deterministic application code invokes escalate_to_human using the information accumulated before termination.

The max_turns limit is a host-controlled safety boundary. Once that boundary is reached, the model may no longer have an opportunity to follow a prompt instruction or make another tool call. Therefore, the required fallback cannot depend entirely on Claude deciding to escalate before its remaining turns are exhausted.

Option A escalates based on an arbitrary 80% threshold and may prematurely terminate cases that could have been resolved successfully within the remaining budget. Option B provides additional turn capacity but does not guarantee that the second agent will complete its work or escalate before its own limit is reached. Option D remains probabilistic and cannot operate after an unexpected termination has already occurred.

The orchestration fallback should be idempotent, ensuring that repeated completion checks cannot create duplicate escalation records. It should also include verified customer information, relevant order data, completed actions, failure reasons, and the unresolved request in the handoff payload.

Official references/topics: Agent-loop termination, deterministic fallback orchestration, terminal-state validation, human handoff guarantees.

The prompt’s conservative reporting policy is directly causing the low recall. Claude may discover a legitimate race condition during analysis but suppress it because it cannot satisfy the instruction to report only issues about which it is certain. Option C separates two objectives that should not be conflated: broad defect discovery and strict acceptance filtering.

Anthropic’s current code-review prompting guidance explicitly recommends reporting every issue, including uncertain or lower-severity findings, assigning confidence and severity metadata, and allowing a separate verification stage to filter them. This maximizes recall while retaining control over developer-facing noise.

Option A leaves the suppression policy intact, so additional examples cannot guarantee that discovered problems will be reported. Option B improves recall but relies on historical category-level suppression, which can discard genuine findings that happen to belong to noisy categories. Option D can improve analysis quality but does not remove the instruction responsible for withholding findings. A dedicated finding stage followed by an independently configurable verification or thresholding stage produces measurable recall and precision controls without forcing one model call to optimize competing objectives.

================

Option C directly searches source-file contents for imports of @company/auth . Anthropic’s Claude Code tools reference states that Grep locates patterns within files, while Glob matches filenames and paths. The search can account for the repository’s supported module syntaxes, including static imports, require() calls, dynamic imports, and re-exports. It can also restrict results by file type or directory when appropriate. Option A identifies packages that declare the dependency but does not prove which source files import or invoke it; workspace-level dependency declarations may cover many packages. Option B finds authentication-related filenames, which are unrelated to whether a file imports the package. Option D searches directory names and therefore has the same limitation. After Grep returns the matching files and line numbers, the agent can read the surrounding code to determine whether each import supports middleware registration, token verification, authorization checks, or re-exporting. This produces an accurate usage inventory while minimizing context consumption and unnecessary file reads.

================

The root cause is an incomplete tool contract. Claude sees that process_refund requires an order_id , but the tool description does not explain the parameter’s trusted source or the prerequisite lookup sequence. Option A makes the dependency explicit and prohibits fabricated values.

Anthropic states that tool descriptions should explain what a tool does, when it should be used, how it behaves, and any important limitations. Its prompting guidance also states that dependent tool calls must be executed sequentially and that Claude must never use placeholders or guess missing tool parameters. ( https://platform.claude.com/docs/en/agents-and-tools/tool-use/define-tools )

Option B merely forces some tool use; it does not force the correct tool or prevent a fabricated identifier. Option C is an essential defense-in-depth control, but it detects the invalid ID after the model has already made the faulty call. It does not correct the selection logic that caused the fabrication. Option D works only when the customer actually provides an identifier and introduces an unnecessary preprocessing dependency.

The process_refund schema should describe order_id as a verified identifier returned by lookup_order , and the tool description should state that the tool is unavailable until the corresponding order has been retrieved and eligibility established.

Official references/topics: Tool descriptions, prerequisite tool calls, parameter provenance, sequential tool orchestration.

Option A reduces the maximum output required from any single response while preserving the structured schema and complete severity range. The pipeline can partition files into coherent groups, execute bounded reviews, validate each returned array, and merge and deduplicate findings using stable fields such as file path, line number, category, and description.

Anthropic’s stop-reason documentation confirms that max_tokens means generation reached the configured output limit and the response must be treated as incomplete. Structured output constraints can guarantee schema-valid generation when completion succeeds, but they cannot create unlimited output capacity. A large findings array can still exceed the available token budget.

Option B may postpone the failure but provides no durable guarantee for still-larger pull requests, and aggressively shortening descriptions may eliminate necessary evidence. Option C abandons machine-validated structure without reducing the amount of generated content. Option D deliberately suppresses medium- or low-severity findings and repeats an oversized request rather than addressing its scope. Partitioning establishes predictable output bounds, supports targeted retries, retains every required finding category, and prevents a single truncated response from invalidating the complete review.

================

Option C respects the customer’s explicit request for human assistance. The agent should not attempt to retain the interaction, gather additional account information, or require the customer to repeat the request. Because the escalation decision has already been made by the customer, further autonomous investigation would create unnecessary delay and disregard clear human direction.

Anthropic’s trustworthy-agent framework emphasizes maintaining meaningful human control over agent autonomy. Anthropic’s customer-support implementation guidance also recommends defining interaction branches and measuring escalation efficiency as part of the system’s success criteria.

Option A deliberately delays escalation despite an unambiguous request. Option B performs unnecessary tool calls and may expose or retrieve account information that is not required before transferring the conversation. Option D similarly introduces another conversational barrier. Since the current exchange is short and contains no tool-generated evidence, passing the available conversation history gives the human agent the immediate context—the customer’s frustration, repeated unsuccessful attempts, and explicit transfer request—without pretending that account investigation has occurred.

================

Option B expresses both independent delegations in the same orchestration turn, allowing the runtime to execute them concurrently and return their results together. The current Claude Agent SDK calls the subagent-spawning capability the Agent tool; Task is its former name. Anthropic’s SDK subagent documentation explicitly identifies parallel analysis as a primary subagent use case. Claude tool responses can also contain multiple tool_use blocks , enabling independent calls to be handled as one parallel group rather than as serial model turns. Option A shortens each execution but does not remove the unnecessary wait between them and may reduce analysis quality. Option C provides useful behavioral guidance, but instructions alone do not establish the required response structure; the coordinator must actually emit both calls together. Option D duplicates coordinator execution, complicates state management, and creates unnecessary aggregation work. The correct flow is parallel fan-out from one coordinator, followed by a synchronization point that validates both results before synthesis begins. Failures should be tracked independently so that only the unsuccessful branch requires retrying.

================

Option C preserves provenance as part of the data contract instead of attempting to reconstruct it after synthesis. Each finding should carry a stable claim identifier and one or more source records containing the URL or document identifier, relevant location, supporting excerpt, retrieval date, and applicable qualification. The synthesis agent can combine or rewrite claims while retaining their source relationships.

Anthropic’s structured-output documentation supports schema-constrained, parseable results for downstream workflows. Its citation documentation explains that reliable citations depend on valid pointers to provided source material. Anthropic’s skill guidance similarly recommends cross-referencing each major claim and verifying its citation before completion.

Option A reconstructs attribution probabilistically and may associate a claim with a similar but incorrect passage. Option B encodes metadata inside prose, making transformations and parsing fragile. Option D retains excessive context and adds another model stage to recover information that should never have been discarded. Structured claim-source mappings permit deterministic merging, citation validation, deduplication, and audit trails. The report generator can therefore cite the exact evidence supporting each conclusion without replaying complete research transcripts.

================

Option A combines lossless persistence with selective restoration. Each agent should checkpoint structured records containing completed document identifiers, extracted findings, source provenance, unresolved work, verification status, and schema version. A coordinator-level manifest can record which stages completed and where their artifacts are stored. On recovery, the coordinator skips completed documents and injects only the state required by each restarted agent.

Anthropic’s effective context-engineering guidance recommends structured notes stored outside the active context window and reloaded when needed. This preserves critical dependencies and progress without replaying an entire execution history.

Option B fragments recovery ownership across agents and makes cross-agent consistency, versioning, and dependency validation difficult. Option C preserves extensive logs but wastes context on redundant tool calls, obsolete instructions, and intermediate messages. Option D is useful for relevance retrieval but semantic search can omit exact details and should not serve as the authoritative recovery record. Structured checkpoints and a validated manifest provide deterministic recovery, efficient context reconstruction, auditability, and precise provenance. Writes should be atomic so partially produced exports are never mistaken for completed work.

================

The agent must preserve durable state for several concurrently open issues without keeping every conversational turn in the active context window. Option D creates a structured issue ledger containing identifiers, issue type, requested action, current status, completed steps, unresolved questions, and relevant tool outputs.

Anthropic recommends structured note-taking for long-horizon agents. In this pattern, critical state is written outside the context window and retrieved later, allowing the agent to preserve dependencies and progress across dozens of tool calls. Anthropic also describes compaction as retaining critical details while discarding redundant raw messages and historical tool output. ( https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents )

Option A is better than retaining the entire transcript, but a narrative summary can merge separate issues or obscure exact identifiers and statuses. Option B will discard the refund conversation because it occurred outside the most recent 30 turns. Option C may recover current backend facts, but it cannot reconstruct conversational commitments, prior explanations, or why a particular action remains pending.

A structured context layer should maintain one record per issue and be updated after every material action. The active prompt can include compact summaries of all open issues and expanded details only for the issue currently being discussed.

Official references/topics: Structured note-taking, external agent memory, context compaction, multi-issue state management.

The venue server must be available to every project contributor, so it belongs at project scope. Claude Code stores project-scoped MCP configurations in the repository-root .mcp.json file, which can be committed to version control and shared with the team.

The experimental playlist server should remain private. Local-scoped MCP servers are stored under the current project’s entry in ~/.claude.json , while user-scoped servers are also stored in ~/.claude.json but load across all projects. Because this server is described as a personal experiment, either private scope is conceptually appropriate; among the listed choices, option B correctly separates shared project configuration from private personal configuration. ( https://code.claude.com/docs/en/mcp )

Option A prevents the team from receiving the venue configuration. Option C reverses the intended visibility. Option D exposes the experimental server configuration to other contributors and may commit machine-specific commands or credentials.

The preferred commands would specify --scope project for the shared venue server and --scope local for an experiment limited to the current repository. Project-scoped servers also require user approval before Claude Code activates configurations received through .mcp.json .

Official references/topics: MCP Installation Scopes; Project Scope; Local Scope; .mcp.json ; ~/.claude.json .

Option C corrects the weak selection signal presented to the model. Claude chooses among available tools using their names, descriptions, parameter schemas, and the current request. “Extracts a function from code” does not explain whether the tool understands syntax trees, preserves imports, updates call sites, validates scope, or offers advantages over Write and sed. Anthropic identifies prompt-engineering tool descriptions as one of the most effective ways to improve agent tool use. Descriptions should state what the operation performs, when it should be selected, what inputs are required, what output it returns, and any limitations.

Option A adds a separate probabilistic routing layer without improving the tool contract Claude ultimately sees. Option B ignores the server’s intended value. Option D removes a broadly useful capability and may prevent unrelated edits without guaranteeing that the MCP tools are used correctly. Each refactoring tool should instead describe its semantic behavior and contrast it with plain text manipulation—for example, that rename_variable performs scope-aware symbol renaming and updates references. Clear schemas, concrete examples, and evaluation against real refactoring tasks should accompany the improved descriptions.

================

A concrete test case converts an imprecise correction into an executable success criterion. The input demonstrates the failing null-value condition, while the expected output defines exactly how the migration must handle it. Claude can modify the implementation, run the test, inspect the result, and continue iterating until the behavior passes.

Anthropic recommends giving Claude a verification mechanism such as a test suite, build result, linter, fixture comparison, or screenshot. Without such a mechanism, Claude can only judge that its output appears correct. A pass-or-fail test closes the feedback loop by allowing Claude to perform the work, evaluate the result, and refine it using objective evidence. ( https://code.claude.com/docs/en/best-practices )

Option A provides no additional specification and may generate a different but still incorrect implementation. Option B fixes the immediate defect manually but fails to use Claude’s iterative capabilities or establish a regression check. Option C supplies more description, but regenerating the entire script increases the risk of altering already-correct behavior and still lacks objective validation.

The best workflow is to add the failing case to the migration test suite, request the smallest necessary correction, run the relevant tests, and retain that test permanently to prevent the null-handling defect from recurring.

Official references/topics: Executable verification, test-driven iteration, regression protection, tight feedback loops.

Option D directly addresses cache entries expiring before later batch requests are processed. Anthropic’s batch-processing documentation specifically notes that Message Batches can take longer than five minutes and recommends the one-hour prompt-cache duration for batches containing shared context. The prompt-caching documentation confirms that the default TTL is five minutes and that " ttl " : " 1h " creates an extended entry.

Option A may improve cache locality, but it introduces the sequential-processing latency explicitly prohibited by the requirement. Option B seeds the cache initially, but the prewarmed entry still expires after five minutes unless the TTL is extended; it therefore does not solve misses among requests scheduled later. Option C places the breakpoint on request-specific content, defeating reuse of the stable 8,000-token prefix and attempting to cache scripts that are not byte-for-byte identical.

The system should retain the breakpoint at the end of the shared system content and apply the one-hour TTL there. Cache-usage fields should then be monitored to confirm that cache_read_input_tokens rises and later batch requests reuse the intended prefix.

================

The agent is behaving inconsistently because every failure is represented identically. “Operation failed” contains no information about permanence, user correctability, authorization, or whether another attempt is likely to succeed. Adding structured fields converts the error into an actionable interface contract.

Anthropic instructs tool implementations to mark failures using an error flag and return information Claude can use to retry with corrected input, ask for clarification, or explain a limitation. Tool design should expose sufficient detail for the model to choose the correct next action rather than forcing it to infer the cause from a generic message. ( https://platform.claude.com/docs/en/agents-and-tools/tool-use/build-a-tool-using-agent?utm_source=chatgpt.com )

With error_category , isRetryable , and a causal description, the agent can retry transient network failures, request corrected identifiers for validation errors, and escalate or report permission failures without pointless repetitions. Option B retries permanent validation and permission failures unnecessarily. Option C adds another tool call and failure point merely to classify information the original tool already possesses. Option D relies on parsing variable text and examples rather than providing explicit machine-readable semantics.

The tool should preserve isError: true , return a stable structured error object, include a safe customer-facing message where appropriate, and avoid exposing internal secrets or stack traces.

Official references/topics: MCP error contracts, actionable tool results, retryability metadata, agent-computer interface design.

The reference to generic rendering patterns indicates that the current context has become saturated or that important earlier details are no longer receiving sufficient attention. Anthropic documents that performance can degrade as a Claude Code context window fills with conversation history, file contents, and command output; symptoms include forgetting earlier instructions and making less precise responses. ( https://code.claude.com/docs/en/best-practices )

Option C preserves the high-value rendering discoveries while isolating the physics investigation. The summary should identify the relevant rendering classes, synchronization boundaries, debug-overlay interfaces, and unresolved integration questions. A physics-focused subagent can then inspect collision and simulation code in its own context without adding dozens of additional files to the already crowded main conversation.

This explicit summary matters because an ordinary named subagent starts with a fresh, isolated context and does not automatically receive the parent’s full conversation history or previously read files. Claude constructs a delegation message containing the task context, so the essential rendering findings must be supplied deliberately. ( https://docs.anthropic.com/en/docs/claude-code/sub-agents )

Option A omits the integration context needed to guide the physics search. Option B destroys useful prior analysis. Option D keeps expanding an already degraded context and treats the symptom rather than controlling context growth.

Official references/topics: Context-Window Management; Subagent Isolation; Delegation Summaries; Codebase Exploration.

The key difference is reviewer independence. In the original session, Claude retains the reasoning, assumptions, implementation decisions, and intermediate conclusions that led to the refactor. That context can anchor the subsequent review toward defending or confirming the chosen approach instead of evaluating the resulting code independently. The separate CI review begins with fresh context and can assess the implementation solely against the code and review criteria.

Anthropic’s Claude Code best-practices documentation explicitly states that fresh context improves code review because Claude is not biased toward code it has just written. It recommends a writer/reviewer pattern using separate sessions or a review subagent with an isolated context.

Option B is possible in an uncontrolled comparison, but the scenario’s defining distinction is that one review occurs in the implementation session and the other is independent. Option C is false because local Claude Code can read and search the repository when permissions and tools permit it; it is not inherently restricted to the current file. Option D would require evidence of context saturation, such as degraded instruction following or an almost-full context window. No such evidence is supplied. Prior-reasoning bias most directly explains the observed discrepancy.

================

Option B introduces an evaluator-and-refinement loop at the correct orchestration layer. The coordinator already owns the research plan and delegation decisions, so it should inspect the synthesis result against the required questions, identify coverage gaps, and issue focused follow-up assignments. Anthropic’s description of its multi-agent research system follows this pattern: the lead agent synthesizes returned findings, determines whether additional research is required, and creates new subagents or refines its strategy before producing the final result. Increasing the initial query breadth, option A, may generate additional irrelevant material and cannot guarantee that unforeseen gaps will be covered. Option C merely documents the incompleteness instead of correcting it. Option D weakens role separation by giving the synthesis agent search capabilities, increasing tool complexity and bypassing the coordinator’s centralized tracking. Targeted re-delegation preserves specialized responsibilities and creates an observable sequence of research, evaluation, refinement, and resynthesis. The coordinator should also maintain explicit coverage criteria and limit the number of refinement rounds so the system improves completeness without entering an uncontrolled research loop.

================

Option D allows orchestration effort to scale with the actual request. A simple factual query may require only the web-search agent and a direct coordinator response, whereas a comparative investigation may require web research, document analysis, synthesis, and report generation. Anthropic’s Building Effective AI Agents describes the orchestrator-workers pattern as a central model dynamically identifying subtasks, delegating them, and combining the results. It is specifically appropriate when the required subtasks cannot be predicted reliably in advance. Anthropic’s multi-agent research architecture likewise emphasizes varying the number of agents and tool calls according to task complexity. Option A introduces an inflexible binary decision and still sends every non-factual request through the full pipeline. Option B requires labeled data, ongoing retraining, and reliable definitions of the “optimal” agent combination. Option C is easier to implement but will become brittle as new query types appear. A capable coordinator can examine the requested output, necessary evidence, source requirements, and analytical depth at runtime, then invoke only the specialists that materially contribute to the answer.

================

Option C matches the distinction between reasoning about delegation and executing it. Defining subagents makes their descriptions available for selection, but the coordinator must still invoke the SDK’s subagent-spawning tool. Current Claude Agent SDK documentation calls this the Agent tool; Task was its earlier name and remains relevant to older SDK configurations. Anthropic’s Subagents in the SDK documentation instructs developers to include Agent in allowedTools so subagent invocations are approved automatically. Without that permission, an invocation can fall through to a permission callback or be denied under a non-interactive permission mode. Option A is unlikely because the configured subagent descriptions already tell Claude when each agent should be selected, although explicit prompting can improve invocation reliability. Option B misstates context isolation: context must be included in the spawning prompt, but that issue occurs after an invocation is attempted and does not explain the absence of all subagent executions. Option D would normally produce truncation evidence or incomplete output rather than consistent verbal promises with no tool call. The configuration should therefore permit Agent, explicitly request delegation where necessary, and log subagent invocation events.

================

The prompt explicitly instructs Claude to suppress uncertain and lower-severity findings. Increasing reasoning depth cannot override that reporting policy: Claude may identify a real defect during analysis and still omit it from the final response. Option B separates comprehensive detection from acceptance filtering, removing the source of the false negatives while retaining metadata needed for automated decisions.

Anthropic’s current code-review prompting guidance recommends reporting every issue, including uncertain or lower-severity candidates, and attaching confidence and estimated severity so a separate verification or filtering stage can rank them. A structured schema can additionally require fields such as file path, line number, category, confidence, severity, evidence, and recommended action.

Option A may improve investigation quality but leaves the suppression instruction intact. Option C removes the problematic threshold but also discards the explicit structured classification needed by downstream processing. Option D repeats the same review policy, so the second pass can suppress the same findings as the first. Option B preserves recall and machine-readable output while allowing deterministic, adjustable downstream thresholds. This is more reliable than embedding an overly restrictive acceptance decision inside the model’s initial detection task.

================

Option C avoids an unnecessary agent boundary. The coordinator already possesses the accumulated findings and can perform a straightforward summary without serializing, transferring, and reprocessing more than 80,000 tokens in another context window. Subagents should be reserved for work that requires isolated context, specialized instructions, separate tools, or an independent analytical process.

Anthropic’s current prompting guidance advises using subagents for independent workstreams and parallel or context-isolated tasks, while handling simpler tasks directly. Anthropic also notes that excessive subagent use creates unnecessary cost and latency.

Option A generates multiple summaries speculatively, consuming resources even if they are never requested and creating cache-invalidation complexity whenever findings change. Option B may reduce repeated input-token cost, but it does not eliminate subagent startup, message processing, or the unnecessary orchestration round trip. Option D introduces an iterative request protocol that will likely increase latency further. Direct coordinator summarization uses information already available in active context and therefore provides the smallest architectural change, lowest token-transfer overhead, and fastest response while preserving subagent synthesis for genuinely complex comparative or cross-source analysis.

================

In the standard Claude tool-use loop, the application executes lookup_order and sends its output back as a tool_result . That result becomes part of the conversation state available to Claude. Claude then evaluates the purchase date, refund policy, customer request, authorization constraints, and available tools before selecting the next action.

Anthropic describes client-tool orchestration as a repeated loop: Claude emits a tool_use request, the application executes it, returns a tool_result , and Claude continues reasoning from the updated conversation. Claude, rather than the tool implementation, selects when and how to invoke the next available tool unless the application has explicitly implemented a fixed workflow. ( https://platform.claude.com/docs/en/agents-and-tools/tool-use/how-tool-use-works )

Options B and C describe possible custom orchestration architectures, but neither is stated in the scenario. Option D is inconsistent with adaptive agent behavior because later actions depend on information that did not exist before lookup_order completed. A rigid sequence would not respond appropriately to different purchase dates, eligibility states, or order conditions.

The tool result should return high-signal fields such as purchase date, return-window status, refund eligibility, existing refund status, and stable order identifiers so Claude can make the subsequent decision accurately.

Official references/topics: Tool-result continuation, adaptive agent loops, model-directed tool selection, sequential dependency handling.

Option A supplies the missing project context before Claude evaluates the code. Anthropic’s CLAUDE.md documentation defines project-level files as persistent, version-controlled instructions for coding standards, architecture, workflows, and conventions. The described exceptions are stable repository facts: force-unwrapping is permitted in tests, coordinator classes follow an intentional pattern, and an internally maintained dependency remains approved despite its public deprecation status. Recording these facts concisely allows every review session to interpret the patterns correctly.

Option B removes surrounding evidence and would make architectural and cross-file judgments less reliable. Option C hides findings after generation and can suppress genuine bugs containing the same keywords. Option D adds noise to source files and distributes policy across individual call sites instead of documenting it centrally. The CLAUDE.md entries should be specific and scoped—for example, limiting the force-unwrapping exception to test paths rather than approving it globally. Anthropic notes that shorter, precise instructions are followed more consistently, so the file should state the accepted convention, its scope, and any conditions that would still make the pattern reportable.

================

Option D fixes the actual failure while avoiding needless reprocessing. Anthropic’s Message Batches API treats every request independently, records the result against its unique custom_id, and explicitly states that one failed request does not affect the others. The 9,700 successful documents therefore require no retry. The failed requests exceeded the available context; increasing max_tokens changes the permitted output budget, not the size of the input context, so option C does not correct the cause. Resubmitting all 10,000 requests would repeat paid work, and prompt caching would only reduce some repeated-input cost without repairing oversized requests. Chunking each failed document reduces the input presented to Claude so every replacement request fits within the model’s context window . The application can then merge the extracted partial structures deterministically, retaining the original document identifier and chunk ordering. Anthropic recommends retry logic for failed batch requests and using custom_id to match results because batch results can arrive out of order. Consequently, selective retry plus chunking is both the technically correct recovery path and the lowest-cost option.

================

Option A gives the report generator the finished narrative context plus the evidence required to verify and cite its claims. The 3,000-token synthesis draft supplies organization and conclusions, while the source index preserves URLs, supporting excerpts, and claim-to-source mappings without transferring 120,000 tokens of raw search material. Anthropic’s effective context-engineering guidance recommends curating the smallest high-signal context and having subagents return condensed, distilled results rather than flooding later stages with their complete working history. Anthropic’s citation guidance likewise depends on retaining specific supporting passages and source locations. Option B is complete but inefficient and introduces context pollution that can reduce attention to relevant evidence. Option C separates citation insertion from the reasoning that produced the claims, making incorrect or unsupported matches more likely. Option D retains source names but discards the passages needed to demonstrate that each source actually supports the associated claim. The structured index should use stable source IDs and include only the excerpts necessary for the report’s factual claims, with validation that every cited claim maps to at least one evidence entry.

================

Option C defines the reviewer’s actual objective instead of relying on an undefined notion of confidence. The prompt should identify reportable categories such as correctness defects, security vulnerabilities, data-loss risks, broken requirements, and meaningful performance regressions. It should also specify that cosmetic preferences, lint-enforced formatting, speculative refactoring, and intentional repository conventions must not be reported unless they cause concrete incorrect behavior.

Anthropic’s Claude Code best-practices guidance recommends telling a reviewer to report gaps affecting correctness or stated requirements and to treat other observations as optional. Without such criteria, a reviewer asked to “find issues” will predictably return technically defensible but operationally low-value observations. Option A adds cost and another probabilistic decision layer before correcting the primary prompt. Option B relies on self-reported confidence, which does not necessarily align with developer value or severity. Option D can suppress genuine defects that require inference or cross-file verification because “highly confident” is undefined. Explicit scope, evidence requirements, and examples of both reportable and excluded findings directly calibrate the review toward what developers will act upon. Claude Code best practices

================

Option A exposes both independent invocations in the same assistant turn, allowing the Agent SDK or application tool runner to execute them concurrently. The coordinator can then receive both results together and continue with synthesis only after the independent research branches have completed.

Anthropic’s parallel tool-use documentation explains that a response may contain multiple tool-use blocks. Independent, read-only operations can be executed concurrently to reduce latency, after which all corresponding tool results should be returned together. The term “Agent” is used here because current Claude Agent SDK releases renamed the earlier “Task” tool.

Option B may shorten individual execution but does not eliminate the sequential waiting pattern and could reduce research quality. Option C expresses the desired behavior but does not correct an orchestration implementation that processes only one tool call per turn. Option D introduces unnecessary coordinators, duplicated context, and substantially more complex state management. A single coordinator issuing both independent Agent calls preserves centralized monitoring and result association while removing the avoidable serial dependency. The runtime must process every returned tool call concurrently rather than stopping after the first one.

================

Option A is the most sustainable open-world design. The property-type domain is demonstrably not closed: uncommon values already occur, and new labels continue to appear. An enum is appropriate only when the valid vocabulary is stable and exhaustive. If the source contains a legitimate value outside that vocabulary, the schema either rejects it or pressures the model to map it inaccurately. A free-form string preserves the source meaning, while deterministic post-processing can normalize “studio,” “loft,” “duplex,” and future terms into an evolving canonical taxonomy. Anthropic’s Structured Outputs documentation distinguishes structural schema conformance from the semantic decisions made within that schema; it also documents that JSON Schema constraints such as enums govern allowable output shapes and values. Few-shot mapping to the nearest existing enum, option B, discards real distinctions. Continually expanding the enum, option C, creates recurring schema changes and still lags newly observed values. An “other” bucket with detail, option D, is workable but collapses all emerging categories at the primary field and complicates analytics until downstream interpretation occurs. Capturing the raw type first and normalizing it in code provides lossless extraction, testable mappings, and forward compatibility.

================

Option C preserves the information structure that makes each source useful. Financial metrics share comparable fields and therefore benefit from rows, columns, aligned units, and reporting periods. News findings require connected prose to preserve chronology and causal relationships, while patent technology areas are naturally represented as categorized lists. Anthropic’s output-consistency guidance recommends specifying the exact output format needed for the task rather than relying on an unspecified default. Anthropic’s discussion of its multi-agent research system also recognizes specialized output stages for reports, structured data, and visualizations because specialist prompts can produce better results than generic coordinator processing. Option A destroys the comparative structure of numerical data. Option D can provide a useful provenance contract internally but does not determine how the executive briefing should present heterogeneous content. Option B risks creating a lowest-common-denominator representation that discards source-specific advantages. The synthesis contract should preserve normalized facts and provenance internally while directing the report generator to select presentation forms according to the content’s semantic structure and the executive reader’s needs.

================

An unchanged retry repeats the same task specification and therefore commonly reproduces the same invalid interpretation. The validator has generated precise corrective information— quantity requires a float, but the model returned the range string 2 to 3 . Supplying that error in a follow-up turn converts a generic retry into an iterative repair operation.

Anthropic identifies iterative refinement as a method for detecting and correcting inconsistencies by feeding an earlier output back into a subsequent request with targeted instructions. ( https://docs.anthropic.com/en/docs/test-and-evaluate/strengthen-guardrails/reduce-hallucinations ) Option A applies that pattern directly. Claude receives the invalid output, the exact Pydantic error, and an instruction to return a schema-compliant correction. The application should cap retries, retain the original source, and escalate cases that cannot be represented without information loss.

Option B does not guarantee correct formatting; lower temperature may make the same wrong output more repeatable. Option C can be valuable for systematic OCR or source-format problems, but it is unnecessarily broad when the immediate failure is already described by the validator. Option D increases cost and complexity without first using the actionable feedback available from the existing validation layer.

For supported models, native Structured Outputs should also be considered because they guarantee schema-conformant JSON and can prevent many Pydantic shape failures before they occur. ( https://platform.claude.com/docs/en/build-with-claude/structured-outputs )

Official references/topics: Iterative Refinement; Validation-Error Feedback; Bounded Retry Loops; Structured Outputs.

Option C preserves the semantic strengths of each information type instead of forcing heterogeneous evidence into one presentation structure. Financial values share comparable fields and therefore belong in a table. News developments require connected prose to preserve chronology and causality. Patent technology areas are naturally represented as grouped or prioritized lists.

Anthropic’s prompting best practices recommend giving explicit output-format instructions and matching the requested format to the intended communication goal. The synthesis prompt should therefore include rendering rules for each recognized content type while maintaining common provenance fields behind the presentation.

Option A damages numerical comparability and makes trends harder to scan. Option B can be useful as an internal exchange schema, but presenting the entire briefing as uniform JSON does not produce an effective executive document. Option D normalizes transport but does not correct the synthesis agent’s bullet-only rendering policy; a common representation can still be displayed badly. The correct design separates structured internal interchange from audience-facing presentation. The synthesis agent should preserve citations and metadata while selecting the most legible form for each class of evidence.

================

The primary risk is not implementation difficulty but incomplete requirements. Production caching introduces decisions involving invalidation, stale-data tolerance, cache keys, tenant boundaries, serialization, stampede prevention, failure behavior, observability, deployment topology, and consistency expectations. Implementing Redis with a five-minute TTL before resolving these questions can produce a technically functional but operationally unsafe design.

Anthropic recommends having Claude interview the user before beginning a larger feature when important requirements remain uncertain. The AskUserQuestion workflow is intended to surface technical implementation concerns, edge cases, trade-offs, and assumptions the user may not have considered. Anthropic further recommends converting the resulting answers into a self-contained specification with explicit scope and an end-to-end verification step. ( https://code.claude.com/docs/en/best-practices )

Option B provides useful codebase context but postpones requirement discovery. Option C creates avoidable rework by allowing architecture to emerge from production failures. Option D documents uncertainty but delegates unresolved design choices during implementation, when they may already constrain the code.

After the interview produces a caching specification, Claude can enter plan mode to inspect the endpoint and map those requirements onto the existing architecture before implementation.

Official references/topics: Requirements Interviewing; AskUserQuestion; Specification Development; Edge-Case and Trade-Off Discovery.

Option D builds an evidence-based architectural map without indiscriminately loading hundreds of files. Authentication entry points may include route handlers, middleware registration, token-validation functions, session constructors, or identity-provider callbacks. After Grep identifies those anchors, targeted Read operations can establish their responsibilities, while imports, call sites, and configuration references reveal the downstream authorization flow. Anthropic’s large-codebase guidance recommends scoping Claude to the portion of a repository touched by the task because unrelated instructions and file reads consume tokens and degrade performance. Its common workflows guidance similarly recommends beginning broadly and narrowing into specific components. Option A launches agents before the relevant service boundaries are known and may produce overlapping, inconsistent investigations. Option B is an uncontrolled lexical sweep that will include tests, documentation, unrelated tokens, and incidental terminology. Option C appropriately checks project guidance but incorrectly delegates technical file selection to a new engineer who may not know the architecture. Incremental dependency tracing maintains context efficiency while producing a verifiable end-to-end map grounded in actual code paths.

================

Option D improves the generation conditions instead of filtering defective output afterward. Anthropic recommends using CLAUDE.md for repository-wide standards and information that Claude should apply in every session. The file can define what constitutes a useful test, require assertions on observable behavior, identify approved fixture factories, prohibit duplication of existing scenarios, and provide contrasting examples of strong and trivial tests. These instructions are available before Claude decides what tests to create.

Option A may remove some weak tests, but it doubles model work and still permits the first stage to generate low-quality material. Option B treats line coverage as a quality measure even though a trivial assertion can execute new lines without validating behavior. Option C abandons difficult areas rather than improving generation. The standards should also direct Claude to inspect nearby tests and fixtures before writing new cases, identify the behavior or regression each test protects, and run the relevant suite afterward. Because CLAUDE.md consumes context in every session, the guidance should remain concise; lengthy testing procedures are better placed in a reusable skill referenced from the project instructions.

================

Option D separates durable case history from volatile operational data. The new session receives a compact, structured summary describing the billing dispute, the customer’s objective, actions previously taken, and the unresolved status. It does not inherit outdated backend observations as though they were still authoritative. Fresh tool calls then retrieve the current refund or order state before the agent responds.

Agent SDK sessions preserve conversation history, including earlier tool calls and tool results. Resuming the complete transcript therefore reintroduces stale system data into the active context, even though the external backend may have changed substantially during the four-hour gap. Conversation persistence must not be confused with persistence of external-system truth.

Option A performs unnecessary calls to every previously used tool, including tools unrelated to the returning customer’s current question. Option B relies on prompt compliance while retaining contradictory historical evidence in context. Option C manually removes tool results from an existing transcript and may damage the logical relationship between prior tool_use and tool_result blocks while still retaining a long, unstructured conversation.

A structured summary should preserve stable identifiers, previous actions, customer commitments, and unresolved issues. Time-sensitive fields such as refund status, delivery state, account balance, or expected resolution should always be refreshed through authoritative tools.

Official references/topics: Session persistence, stale tool-result management, context compaction, fresh-data retrieval.