Anthropic CCAR-F Claude Certified Architect – Foundations Exam Practice Test

Option B identifies the missing executable capability. Defining specialized agents makes their configurations available, but the coordinator must still be permitted to call the tool that invokes them. Without that tool, Claude can describe an intended delegation in ordinary text but cannot create a subagent execution.

The current Claude Agent SDK documentation requires " Agent " in allowedTools to auto-approve subagent invocations. The tool was renamed from " Task " to " Agent " in Claude Code 2.1.63, so the terminology in the original candidate question required correction. Older integrations may still expose " Task " in initialization or permission records.

Option A is unlikely because properly written AgentDefinition.description values already tell Claude when each agent should be used. Option C misinterprets context isolation: the parent supplies the subagent’s assignment through the Agent tool’s prompt, and no additional automatic forwarding setting is required. Option D would normally produce truncation evidence or a max_tokens stop reason rather than silent absence of every invocation. The coordinator needs both agent definitions and permission to use the invocation tool.

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

Option A establishes a clear destination without forcing the subagent to follow a brittle route. The prompt should define the research question, boundaries, expected deliverable, acceptable source types, recency requirements, coverage expectations, and verification criteria. The subagent can then broaden, narrow, reformulate, or follow emerging leads according to observed search results.

Anthropic’s research-agent guidance emphasizes giving each subagent an objective, output format, source guidance, and clear task boundaries. It also describes research as dynamic and path-dependent, requiring agents to adapt their strategy as new information emerges.

Option B removes too much structure and may cause duplicated work, incomplete coverage, or inconsistent output. Option C handles only one known failure condition and still restricts the agent to a predetermined procedure. Option D adds classification complexity and creates an artificial boundary between topic types that may change during investigation. Objective-based delegation retains accountability because results can be evaluated against explicit quality criteria, while preserving the agent’s ability to discover alternative terminology, unexpected sources, and useful adjacent evidence. This is controlled autonomy rather than either procedural micromanagement or unrestricted exploration.

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

Option B teaches Claude the actual decision boundaries behind the team’s judgments. Contrasting examples can demonstrate why one apparent security pattern is acceptable within the organization’s deployment controls while a superficially similar implementation is genuinely unsafe. The same technique can distinguish established style conventions from deviations and intentional performance trade-offs from accidental inefficiencies.

Anthropic identifies relevant, diverse, and clearly structured examples as one of the most reliable ways to improve Claude’s accuracy and consistency. Its official prompting guidance recommends examples that closely mirror the production task while covering important variations and edge cases. This encourages generalization based on demonstrated criteria instead of memorization of prohibited wording.

Option A can suppress legitimate findings merely because they contain a selected keyword. Option C will become lengthy, difficult to maintain, and incapable of enumerating every future code variation. Option D is too vague and may reduce recall by discouraging Claude from reporting uncertain but genuine defects. Few-shot contrasts provide precise, maintainable behavioral guidance without imposing a blanket suppression policy.

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

MCP allows a Claude application to connect to multiple servers and expose their enabled tools within the same agentic interaction. Anthropic’s MCP connector documentation explicitly supports connecting to multiple MCP servers in one request. Once connected, Claude can invoke a server’s tool when the user’s request corresponds to the capability described by that tool. ( https://docs.anthropic.com/en/docs/agents-and-tools/mcp-connector )

In this scenario, the git server can provide the branch-creation operation, the documentation server can locate the relevant links, and the Jira server can update ticket JIRA-123. The agent can coordinate these capabilities without requiring a separate conversational turn that restricts it to only one server. Tool descriptions and schemas tell Claude what each operation does and what inputs it requires.

Option B incorrectly describes sequential capability discovery. Server identity and tool definitions are established through the MCP configuration rather than discovered by querying every server for each operation. Option C is incorrect because connecting several servers does not inherently restrict the agent to a single selected server. Option D imposes a one-server-per-turn limitation that MCP does not require.

Access can still be controlled through allowlists, denylists, permissions, and per-tool configuration. Those controls restrict which tools are enabled; they do not change the fundamental ability to make tools from multiple configured servers available together.

Official references/topics: MCP Server Configuration, Multi-Server Tool Access, Tool Discovery, MCP Tool Permissions.

Option A establishes the caching architecture before consuming thousands of implementation lines. The base class or protocol reveals the supported operations, lifecycle, cache-key rules, and invalidation contract. Imports, subclasses, registrations, and call sites can then direct the agent toward only those concrete implementations relevant to the proposed trigger. Anthropic’s effective context-engineering guidance explains that context is finite and that recall degrades as irrelevant tokens accumulate. It identifies Glob and Grep as mechanisms for retrieving code just in time rather than loading an entire repository upfront. Option B assumes file size or naming determines architectural importance; a small interface may define the system while a large service file contains incidental caching calls. Option C loads approximately 8,000 lines before establishing which portions matter. Option D is overly lexical and can miss invalidation implemented through event publication, key-version changes, inherited methods, or generically named hooks. Dependency-guided exploration provides a compact conceptual model first and expands the investigation only when concrete relationships show that additional files are relevant.

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

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.

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

Option A separates competing objectives so each review call can devote its attention and examples to a coherent concern. Anthropic’s Building Effective AI Agents describes sectioning as a parallelization pattern in which independent aspects are handled by separate model calls and then aggregated. It specifically notes that models generally perform better on complex tasks when each consideration receives focused attention. The evaluation results demonstrate prompt interference: optimizing business-logic detection reduces API-design recall.

A security and API-design reviewer can use examples, terminology, and evidence criteria appropriate to interfaces and vulnerabilities. A business-logic reviewer can focus on state transitions, arithmetic boundaries, invariants, and domain-specific edge cases. Their structured findings can then be deduplicated and ranked before posting. Option B may improve only the weak category and can overfit to known quiz-scoring failures. Option C assumes that model capacity alone removes prompt interference without evaluation evidence. Option D adds substantial unrelated context and does not isolate the competing review objectives. The split prompts should be evaluated independently and together so consolidation does not reintroduce omissions or duplicate findings.

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

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 A preserves disagreement as meaningful evidence. The report should identify the two estimates separately, explain that they arise from different methodologies and source types, retain the peer-reviewed study’s stated confidence interval, and classify the market size as contested rather than manufacturing false agreement. It may then explain what additional evidence would resolve the discrepancy.

Anthropic’s research prompting guidance recommends developing competing hypotheses, tracking confidence, verifying across sources, and retaining structured research notes. This supports calibrated synthesis rather than arbitrary selection or vague hedging.

Option B discards potentially important minority evidence and incorrectly treats corroboration count as equivalent to reliability. Option C creates numerical precision unsupported by the original sources; confidence scores from different agents are not automatically comparable, and averaging incompatible estimates can be meaningless. Option D introduces survivorship bias by suppressing uncertainty before synthesis. A systematic reporting structure distinguishes consensus, disagreement, evidence quality, methodological limitations, and unresolved questions. That produces an actionable briefing without overstating certainty or weakening every conclusion with generic qualifications.

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

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.

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

Option D uses the established integration mechanism without creating unnecessary infrastructure. Anthropic’s Claude Code MCP documentation specifically recommends connecting an MCP server when users repeatedly copy information from an external system, such as an issue tracker, into conversations. Once connected, the server exposes Jira operations through named, schema-defined tools that Claude can discover and invoke directly. This allows the agent to retrieve ticket descriptions, acceptance criteria, comments, and metadata while preserving the server’s authentication and access controls.

Option A exposes authentication details to shell commands and requires the agent to construct requests and parse responses repeatedly. Option B is justified only when no existing server provides the required capabilities or the workflow requires highly specialized operations. The question requires standard Jira information, so building and maintaining another server is unnecessary. Option C creates stale, manually synchronized copies that lose permissions, current comments, and authoritative ticket state. The team should therefore select a trusted Jira MCP implementation, configure appropriate read-only scopes where possible, and verify its tool descriptions and data-access boundaries before enabling it.

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

Option C allows orchestration effort to scale according to the actual evidence and processing requirements of each request. A factual lookup might require one search operation and a direct coordinator response, while comparative research may justify parallel search, document analysis, synthesis, and formal report generation.

Anthropic’s orchestrator-workers guidance describes a central model dynamically decomposing a task, choosing workers, and combining their results. This pattern is particularly appropriate when required subtasks cannot be predicted reliably in advance. Anthropic’s multi-agent research architecture similarly uses a lead agent to analyze the query and determine an appropriate research strategy.

Option A creates an inflexible two-route system and still sends every non-factual query through the most expensive workflow. Option B requires labeled training data, an externally maintained classifier, and a stable definition of the optimal agent combination. Option D is less expensive to implement but becomes brittle as query types evolve beyond predetermined categories. Dynamic coordination uses the model’s existing reasoning ability to assess source requirements, analytical depth, expected output, and uncertainty before invoking only the specialists that materially improve the result.

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

The evaluation results demonstrate prompt interference: improving attention to business-logic examples reduces performance on API design. Option C isolates the competing objectives so each model call can apply focused terminology, examples, evidence requirements, and evaluation criteria. The resulting structured findings can then be merged, deduplicated, and ranked before being posted.

Anthropic’s Building Effective AI Agents describes parallelization through sectioning, where independent aspects of a task are handled by separate model calls and subsequently aggregated. This pattern is appropriate when one prompt must evaluate several distinct considerations and a single call does not handle all of them reliably.

Option A increases context volume without resolving competition between the review objectives; irrelevant repository content may further dilute attention. Option B may improve known quiz-scoring cases but can overfit the reviewer to an incomplete checklist and does not restore API-design recall. Option D assumes that additional model capability will eliminate prompt interference without supporting evaluation evidence. Separate specialized review passes directly address the measured failure. Each pass should be evaluated independently, followed by an end-to-end evaluation confirming that consolidation preserves recall and does not introduce duplicated findings.

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

Option A describes the principal reason an independent review context is valuable. The implementing session contains the assumptions, interpretations, and reasoning that produced the refactor. When asked to review its own work, Claude may continue operating within those same assumptions and therefore overlook defects caused by them. A fresh reviewer evaluates the resulting diff and stated requirements independently, without inheriting the implementation narrative.

Anthropic’s Claude Code best-practices guidance explicitly recommends an adversarial review step using a fresh subagent or separate context. It explains that the reviewer should see the diff and review criteria rather than the reasoning that produced the change. Option B is possible in an unusually long session, but the scenario provides no evidence that the context window was exhausted. Option C could influence review quality, but no prompt difference is established. Option D is factually incorrect: a local Claude Code session can inspect the checked-out repository through its filesystem tools. The reliable workflow is therefore a writer/reviewer separation in which implementation occurs in one context and correctness review occurs in a fresh context with explicit evidence and reporting criteria. Claude Code best practices

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

Option B combines lossless persistence with selective restoration. Each agent should checkpoint structured records containing completed document IDs, extracted findings, source metadata, unresolved work, validation status, and schema version. A coordinator-level manifest records where those artifacts are stored and which pipeline stages completed. On resumption, the coordinator can skip the 12 completed documents and inject only the artifacts relevant to each restarted agent. Anthropic’s effective context-engineering guidance recommends structured note-taking outside the context window so agents can preserve project state across resets while loading only the information needed later. A vector store, option A, is useful for relevance retrieval but can omit exact details through similarity-based selection and is unsuitable as the sole recovery record. Option C fragments ownership of recovery state and makes cross-agent consistency difficult to verify. Option D preserves an extensive trace, but replaying a complete conversation wastes context and mixes obsolete instructions, intermediate reasoning, and redundant outputs. Structured checkpoints plus a manifest provide deterministic recovery, auditability, exact provenance, and efficient prompt reconstruction. Checkpoints should be written atomically and validated before the corresponding stage is marked complete.

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

Option A is the only configuration that establishes both required limits inside Claude Code. The official CLI reference defines --max-turns as the maximum number of agentic turns permitted in print mode; Claude Code exits with an error when that limit is reached. It defines --max-budget-usd as the maximum dollar expenditure on API calls before execution stops, including applicable subagent expenditure.

These controls address different failure dimensions. The turn limit prevents an investigation from continuing through excessive read-search-analyze cycles, while the budget limit stops an invocation whose expensive turns consume the monetary allowance before reaching the turn ceiling. Supplying both therefore creates an effective per-run boundary.

Option B controls how permission requests are handled; it does not limit the number of already permitted tool calls or API expenditure. Option C applies an external wall-clock timeout and merely observes cost, violating the requirement that Claude Code itself enforce both limits. Option D lowers expected cost per turn but creates no hard ceiling: the agent can still perform many iterations and exceed the intended budget. A cheaper model also does not guarantee that the review will terminate within a predictable number of turns.

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

Path-scoped rules directly satisfy the requirement that instructions load only when Claude works with matching files. Each infrastructure domain can have a separate Markdown file under .claude/rules/ , with YAML paths frontmatter targeting Terraform files, Kubernetes manifests, or pipeline configuration.

Anthropic documents that .claude/rules/ keeps project guidance modular and supports conditional loading based on glob patterns. Rules with a paths field apply only when Claude works with matching files, reducing irrelevant context and token consumption. Rules without path frontmatter load unconditionally. ( https://code.claude.com/docs/en/memory )

Option B improves readability but leaves all 500-plus lines in every session. Option C can provide directory-specific CLAUDE.md guidance, but path-scoped rules are more precise when conventions depend on extensions or patterns spanning multiple directories. Option D still requires manual imports and does not provide the documented conditional rule-loading mechanism.

A suitable design would use rules such as terraform.md scoped to terraform/**/*.tf , kubernetes.md scoped to kubernetes/**/*.{yaml,yml} , and pipelines.md scoped to the pipeline directory. Broad project-wide commands and repository etiquette can remain in the root CLAUDE.md.

Official references/topics: .claude/rules/ ; Path-Specific Rules; YAML Frontmatter; Context-Efficient Instruction Loading.

The most reliable architecture separates semantic interpretation from deterministic normalization. Claude is well suited to identifying that “$12” and “12.00” represent prices, or that a leaf icon represents a dietary classification. However, canonical conversion—removing currency symbols, converting values to decimal types, mapping icons to controlled labels, and enforcing locale-specific rules—is more predictably performed in application code.

Structured Outputs guarantee that Claude returns valid JSON matching the supplied schema, but that guarantee concerns structural conformance. It does not by itself guarantee that every semantically equivalent source representation will be normalized identically. Anthropic’s evaluation guidance identifies code-based checks as the fastest, most reliable, and most scalable mechanism for rule-based validation. ( https://platform.claude.com/docs/en/build-with-claude/structured-outputs )

Option D therefore minimizes model responsibility: Claude extracts the evidence as represented, and deterministic post-processing converts it into the canonical downstream format. This also makes normalization rules independently testable, version-controlled, and auditable.

Option A increases latency and cost without solving normalization. Option B improves output structure, but prompt-based normalization can still vary across ambiguous formats. Option C introduces unnecessary stochasticity and majority-vote logic where explicit parsing rules are available. The downstream contract should remain stable, but format conversion should be implemented using deterministic transformations rather than repeated probabilistic inference.

Official references/topics: Structured Outputs—schema compliance; Evaluation Design—code-based validation; Reliable extraction pipelines.

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.

Option D identifies the dominant capacity problem. Anthropic states that everything sent in a request counts toward the context window : the system prompt, messages, documents, tool results, tool definitions, and the output Claude generates. A 175,000–190,000-token document is therefore not the complete input. Adding a 2,500-token tool schema, system instructions, wrappers, and the reserved output budget can push a nominally sub-200,000-token document close to or beyond the effective limit. Anthropic also warns that more context is not automatically better and that accuracy and recall can degrade as token count grows, a behavior described as context rot. That combination explains why short documents remain accurate while long documents lose information. Option A predicts a problem independent of document length, contradicting the measurements. Option B is an unsupported generalization and does not account for tool-definition overhead. Option C recognizes long-context degradation but ignores the concrete evidence that hidden prompt components consume the same window. The correct response is to count tokens for the complete request before submission, reserve output capacity, and chunk or retrieve relevant sections when the total approaches the model’s supported window.

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

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.

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

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 C identifies the fundamental trade-off introduced by batch processing: lower cost in exchange for asynchronous completion and potentially substantial latency. Anthropic states that most Message Batches complete within one hour, but results may become available only when all requests finish or after 24 hours, whichever occurs first. Therefore, the workflow must remain useful even if security findings arrive considerably later than they would through synchronous requests.

The reviews are explicitly non-blocking, so batch processing can be suitable if developers can still act on delayed findings through follow-up commits. Option B describes an implementation requirement because batch results may be returned out of submission order, but Anthropic provides a deterministic solution through each request’s unique custom_id. Option A incorrectly focuses on near-instant feedback, which batch processing does not provide. Option D is not decisive because batches support independent Messages API requests containing system prompts, tool use, and multi-turn conversation content. The primary decision is therefore whether the maximum practical feedback delay is acceptable to the development workflow. Anthropic Message Batches documentation

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

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.

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

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 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.

Option A implements an iterative orchestrator-worker loop in which synthesis is treated as an evaluation checkpoint rather than an irreversible transition to report generation. When synthesis identifies missing evidence, the coordinator can formulate focused follow-up tasks, send them to the agents with the appropriate tools, and repeat synthesis after receiving the additional findings.

Anthropic’s multi-agent research architecture follows this pattern: the lead agent synthesizes subagent findings and determines whether further research is required. If gaps remain, it creates additional subagents or refines the research strategy. This preserves specialization and centralized control.

Option B makes the incompleteness visible but does not improve research coverage. Option C may increase initial cost without guaranteeing that the specific gaps discovered during synthesis will be addressed. Option D weakens separation of concerns by giving the synthesis agent search capabilities that belong to the research specialists. Targeted redelegation is more efficient because the second research round is informed by concrete deficiencies rather than speculative breadth. It also allows the coordinator to track completeness explicitly before authorizing final report generation.

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

Stratified random sampling provides both an ongoing quality-control mechanism and an unbiased measurement framework. By reviewing a fixed proportion of high-confidence outputs across meaningful strata—such as document type, field, source format, and business risk—the organization can estimate the residual error rate, compare performance across releases, and discover failure patterns that were not anticipated when existing rules were designed.

Anthropic recommends measurable success criteria and evaluations that mirror the real-world task distribution, including edge cases. Evaluation volume and repeatability are important because improvements must be demonstrated empirically rather than inferred from isolated examples. ( https://docs.anthropic.com/en/docs/build-with-claude/develop-tests ) A weekly sampling program creates a stable benchmark and allows confidence intervals, trend analysis, regression detection, and error-taxonomy updates.

Option A detects only disagreements between stochastic extractions. Two attempts may produce the same plausible but incorrect answer, so agreement is not equivalent to factual correctness. Option B addresses known patterns but will miss new failure modes and may generate excessive false positives. Option C actually lowers the review threshold in the wrong direction: documents between 70% and 85% would be treated as automated rather than reviewed if the routing rule remains “below threshold,” and changing thresholds alone does not measure high-confidence error prevalence.

Official references/topics: Evaluation Design; Representative Test Distributions; Continuous Reliability Measurement; Human-in-the-Loop Sampling.

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.

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

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.

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

The Messages API exposes stop_reason specifically so the application can determine why Claude stopped generating and what action is required next. A value of tool_use means Claude is requesting one or more tools and expects the application to execute them and return corresponding tool_result blocks. A value of end_turn means Claude has naturally completed the response. ( https://platform.claude.com/docs/en/build-with-claude/handling-stop-reasons )

Anthropic’s agent-loop tutorial implements this as a loop that continues executing tools and returning results while stop_reason remains tool_use . Once the value changes, the response is treated according to the new terminal or continuation condition. ( https://platform.claude.com/docs/en/agents-and-tools/tool-use/build-a-tool-using-agent )

Option A is unreliable because an assistant response can contain both text and tool-use blocks. Text alone does not prove that the workflow is complete. Option B requires the application to predict that no further tool call is needed, defeating Claude’s ability to adapt from tool results. Option D is an important safety limit but is not the primary completion signal; an arbitrary maximum may terminate a valid workflow prematurely.

The harness should check stop_reason , process every requested tool call, append results to the conversation, and maintain a separate maximum-turn safeguard against runaway loops.

Official references/topics: Messages API stop reasons, tool-use loops, tool-result continuation, bounded orchestration.

Option A preserves provenance as first-class data throughout the pipeline. Each finding should contain the summarized claim, supporting excerpt, source identifier, URL or document title, and location information such as a page or content-block index. The synthesis agent can combine findings without severing the association between evidence and source, while the report generator can render citations directly from the structured records. Anthropic’s Citations documentation explains that reliable citations identify the supporting passage and its precise source location, including PDF page ranges or content-block indices. Passing all raw output, option B, preserves evidence but introduces excessive context and makes source selection harder. Inline references in prose, option C, are vulnerable to being altered, omitted, or detached from claims during subsequent summarization. Option D repeats research after report generation and may locate a different source rather than the evidence originally used. A structured provenance contract should therefore be required in every subagent’s output and validated at each handoff. The report generator should reject or flag factual claims that lack an associated evidence record instead of inventing or retrospectively reconstructing citations.

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

Option C converts an empirically validated source hierarchy into an explicit extraction rule. The downstream contract requires one battery_capacity value, and historical analysis establishes that the detailed specifications table is substantially more reliable than the summary section. Claude should therefore be instructed to inspect all occurrences, detect conflicts, and select the detailed-table value when the two locations disagree.

Anthropic’s prompting guidance emphasizes clear, direct instructions, relevant context, and explicit decision rules when order or completeness matters. Providing the reason for the precedence rule also helps the model generalize it to comparable specification conflicts. Option A preserves every value but transfers a known and repeatable decision into downstream systems, unnecessarily changing the schema. Option B rejects approximately 15% of otherwise processable documents even though a reliable precedence policy is available. Option D creates a costly manual-review queue for conflicts that can usually be resolved deterministically. The extraction system should still retain source quotations or locations in internal provenance metadata when auditability matters, but the output field should follow the established detailed-table precedence. Anthropic prompting best practices

Option B eliminates an unnecessary agent boundary. The coordinator already possesses the accumulated findings and can answer a straightforward follow-up without serializing more than 80,000 tokens into a fresh subagent context, waiting for another model execution, and receiving the result back. Anthropic’s multi-agent research engineering guidance emphasizes scaling effort to task complexity: simple fact-finding or lightweight processing should use substantially fewer agents and tool calls than complex research. It also reports that multi-agent systems consume far more tokens than ordinary interactions, making avoidable delegation expensive and slow. Option A adds an interactive retrieval protocol between agents and additional round trips. Option C spends compute proactively on summaries that users may never request and creates cache-invalidation problems whenever findings change. Option D could reduce repeated input cost where caching is applicable, but the subagent still receives and processes an unnecessarily large context and still incurs spawning latency. Delegation is valuable when an isolated context or specialized capability materially improves the result. For a direct summary already supported by the coordinator’s active context, local handling is the faster and simpler architecture.

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

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 A matches the standard coordinator-managed subagent model. The coordinator invokes the web-search agent, receives its final result, selects the useful URLs or source records, and then supplies them explicitly when invoking the document-analysis agent. This keeps task ownership, provenance, and execution order visible to the coordinator.

The Claude Agent SDK subagent documentation states that a subagent begins with a fresh context window and does not inherit the parent’s conversation history or previous tool results. The information passed through the Agent tool’s prompt is the primary parent-to-subagent context channel. Consequently, the analysis prompt must include the source URLs, documents, retrieval notes, and any questions the analyzer must answer.

Option B requires nested delegation that is neither stated nor necessary and reduces centralized observability. Options C and D describe valid custom architectures only if the application has deliberately implemented a queue or shared memory system; neither is automatic Agent SDK behavior. Coordinator-mediated handoff is therefore the expected approach. For reliability, the handoff should use structured source records rather than an informal prose statement, ensuring that the analyzer receives identifiers, provenance, relevant excerpts, and analysis objectives.

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

First-contact resolution does not require pretending that every backend operation succeeded. The agent can still resolve the informational portion of the interaction by explaining the charge and confirming eligibility using the successfully retrieved customer and order data. It must then distinguish that verified conclusion from the uncompleted refund transaction.

Anthropic’s tool-error guidance states that Claude should receive the failure information so it can retry, request clarification, or explain the limitation. A tool timeout must therefore be surfaced honestly rather than converted into an unsupported success claim. ( https://platform.claude.com/docs/en/agents-and-tools/tool-use/build-a-tool-using-agent?utm_source=chatgpt.com ) Anthropic also emphasizes transparent, simple agent designs and carefully constructed tool interfaces, which support explicit disclosure of tool failure and controlled escalation. ( https://www.anthropic.com/engineering/building-effective-agents )

Option A can create an unbounded or excessively long interaction; retries should be limited and conditioned on retryability. Option B falsely represents an incomplete financial operation as completed. Option D discards the useful work already performed and escalates before providing the customer with the available explanation.

Option C preserves trust, delivers the information already established, clearly states what remains incomplete, and gives the customer a practical next step through bounded retry or human escalation.

Official references/topics: Graceful tool failure, transparent customer communication, bounded retry, human escalation.

Claude Code supports resuming a specific saved session by either its identifier or its assigned name. Because the engineer knows the target session is named auth-deep-dive , the appropriate command is:

claude --resume auth-deep-dive

Anthropic’s CLI reference explicitly states that --resume can resume a session by ID or name and gives named-session usage in the same form. Resuming restores the relevant conversation history and accumulated context, including the prior analysis and files discussed during the investigation. ( https://docs.anthropic.com/en/docs/claude-code/cli-reference )

Option B is incorrect because --continue resumes the most recent session in the current directory. The engineer has conducted three subsequent sessions, so it may open an unrelated investigation. Option A uses a flag that is not the documented Claude Code mechanism for selecting a prior session; --resume itself accepts the session identifier when an ID is used. Option C discards two hours of established context and unnecessarily repeats codebase exploration.

Named sessions are particularly useful when engineers alternate among multiple projects or parallel investigations. Assigning descriptive names allows the correct thread to be retrieved deterministically rather than depending on chronological recency.

Official references/topics: Claude Code Session Persistence, Named Sessions, --resume , --continue .

The reviewer corrections have exposed a narrow and repeatable interpretation failure. The desired policy is clear: informal measurements are valid source values and must be preserved verbatim rather than normalized into invented quantities or treated as missing. This behavior can be communicated efficiently through targeted few-shot examples.

Anthropic recommends examples for demonstrating expected behavior and improving consistency. Examples can pair source phrases such as “a handful of spinach,” “a splash of vinegar,” and “a pinch of salt” with outputs that retain handful , splash , and pinch exactly. Additional counterexamples can show that Claude must not convert these phrases into grams, millilitres, or estimated serving quantities. ( https://docs.anthropic.com/en/docs/about-claude/use-case-guides/ticket-routing )

Option A introduces a substantially heavier training workflow for a problem that can be addressed directly through the prompt. Option C creates a parallel extraction mechanism based on pattern matching; it will be brittle across linguistic variations and may populate a value without understanding its relationship to the correct ingredient. Option D adds useful classification metadata, but it does not instruct Claude to preserve the original measurement instead of inventing or omitting it.

The revised prompt should combine an explicit verbatim-extraction rule with several varied examples derived from the corrected cases, followed by regression evaluation against the identified failure set.

Official references/topics: Few-Shot Examples, Feedback-Driven Prompt Improvement, Verbatim Extraction, Regression Evaluation.

The schema already supports the correct representation of missing evidence: null . The remaining defect is behavioral. Claude must be explicitly instructed that absence of information is a valid outcome and that values may be populated only when directly supported by the supplied article.

Anthropic’s hallucination-reduction guidance recommends explicitly permitting Claude to express uncertainty, grounding outputs in the source, and retracting claims that lack supporting evidence. It also recommends restricting the model to the provided documents rather than allowing unsupported external knowledge. ( https://docs.anthropic.com/en/docs/test-and-evaluate/strengthen-guardrails/reduce-hallucinations ) Option C translates those controls directly into the extraction contract: when no source evidence exists, the model returns null .

Option A may improve baseline performance but does not remove the architectural ambiguity that encourages completion of missing fields. Option B is counterproductive because non-nullable required fields force the model to provide values even when the article contains none. Structured validation would confirm that the response is syntactically valid while accepting fabricated content. Option D adds cost, latency, and another probabilistic model decision; a second model can repeat or endorse the original hallucination.

A robust implementation should supplement the instruction with source spans or quotations for populated fields and automated checks where feasible. Nevertheless, among the options, explicit null behavior is the direct and most effective correction.

Official references/topics: Reduce Hallucinations; External-Knowledge Restriction; Nullable JSON Schema Fields; Grounded Extraction.

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.

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

The decisive trade-off is whether the workflow can tolerate asynchronous completion. Anthropic’s Message Batches API documentation states that batch requests receive a 50% discount and that most batches finish within one hour, but processing can continue for as long as 24 hours. Therefore, the review process is suitable for batching only if potentially delayed feedback remains useful.

Option C directly tests that operational requirement. The reviews are already non-blocking, which makes batching promising, but non-blocking does not automatically mean that feedback delivered many hours later still has value. If developers have already merged and moved to unrelated work, delayed security findings may increase remediation cost or remain unaddressed.

Option A is manageable through each request’s unique custom_id, which allows results to be correlated regardless of return order. Option B is incorrect because batch requests can contain supported multi-turn conversation histories and tool-use configurations; each request is processed independently, but it need not represent a single conversational turn. Option D reverses the relevant consideration: batch processing is not intended to provide near-instantaneous responses. The real question is whether the cost saving justifies its longer and nondeterministic completion time.

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

Option C parallelizes independent work while retaining centralized orchestration. Each precedent can be analyzed without waiting for the previous precedent, so the coordinator can divide the 12 cases into balanced subsets and invoke several document-analysis subagents concurrently. It then receives their final outputs, records which precedents completed or failed, and aggregates the results before synthesis. Anthropic’s multi-agent research architecture uses an orchestrator-worker pattern in which the lead agent creates specialized subagents that operate in parallel and return findings for consolidation. Keeping spawning decisions at the coordinator also produces a clearer execution trace for monitoring and debugging. A generic asynchronous queue, option A, adds infrastructure but does not define how results remain associated with the correct research task. Options B and D create nested or recursive delegation, making execution paths, permissions, failures, and token consumption harder to observe. Anthropic also cautions that multi-agent systems consume substantially more tokens than ordinary interactions, so unbounded recursive decomposition is inefficient. Coordinator-controlled parallel fan-out followed by deterministic aggregation provides the latency improvement without sacrificing operational visibility.

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

Option B removes the prompt-level suppression responsible for the false negatives while preserving machine-readable metadata. Anthropic’s current code-review prompting guidance warns that instructions such as “only report high-severity issues” or “be conservative” may be followed literally: Claude can identify genuine defects during analysis but omit them from its output. Anthropic recommends requesting all findings and applying filtering separately.

Confidence and severity fields allow downstream code to apply adjustable thresholds without forcing the model to discard evidence during generation. A schema can require fields such as file, line, description, severity, confidence, evidence, and recommended action; Anthropic’s Structured Outputs documentation supports enforcing such a response contract. Option A repeats the same suppressive instruction and is likely to reproduce the same omissions. Option C removes the explicit reporting structure and leaves filtering behavior undefined. Option D may improve analysis depth, but extended reasoning does not override a direct instruction to suppress uncertain findings. Separating detection from deterministic filtering preserves recall, structure, and operational control.

Option B removes the identified startup work while deliberately restoring the one source of project context the reviews require. Anthropic documents that --bare skips automatic discovery of hooks, skills, plugins, MCP servers, auto memory, and CLAUDE.md files. It is specifically intended for CI and scripted execution where fast, reproducible startup behavior is more important than loading every locally configured extension.

Because bare mode also skips the root CLAUDE.md, the pipeline must supply that content explicitly. --append-system-prompt-file ./CLAUDE.md loads the standards while retaining Claude Code’s default coding-agent behavior and tool guidance. Option A replaces the default system prompt but does not, by itself, establish the same minimal startup path as --bare; replacement also discards valuable default coding instructions. Option C can work technically but duplicates repository policy inside every pipeline invocation and creates configuration drift. Option D improves prompt-cache reuse by relocating machine-specific prompt sections, but it does not eliminate discovery of hooks, MCP servers, plugins, skills, and nested instructions. Bare mode plus an explicitly appended standards file directly addresses both performance and policy requirements. Claude Code bare-mode documentation

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