Skip to main content

Claude Certified Architect Foundations CCAR-F Exam Questions

Preparing for the CCAR-F exam is simple with ITPrepCerts. We offer easy-to-understand study materials that help you learn the most important exam topics. You can study using our PDF questions, practice online with a real exam-style test, or use the desktop practice software. Choose the study method that works best for you and prepare at your own pace.

At ITPrepCerts, we keep our CCAR-F practice questions up to date. Whenever the exam syllabus or objectives change, we update our study materials so you always learn the latest topics. This helps you save time, avoid outdated content, and feel more confident when you take your exam.

Download Exam View Entire Exam
Page: 4 / 5
Question #16 (Topic: Demo Questions)

You are building a customer support resolution agent using the Claude Agent SDK. The agent handles high-ambiguity requests like returns, billing disputes, and account issues. It has access to your backend systems through custom Model Context Protocol (MCP) tools ( get_customer , lookup_order , process_refund , escalate_to_human ). Your target is 80%+ first-contact resolution while knowing when to escalate.

Your process_refund tool returns two types of errors: technical errors (“503 Service Unavailable”, “Connection timeout”) that are transient (~5% of calls), and business errors (“Order exceeds 30-day return window”, “Item already refunded”) that are permanent (~12% of calls). Monitoring shows the agent wastes 3–4 turns retrying business errors that can never succeed. Currently, both error types return only a plain text message to Claude.

What’s the most effective way to reduce wasted retries while improving customer-facing response quality?

A.

Implement automatic retry logic at the tool layer for technical errors only, passing business errors to Claude without retries.

B.

Add few-shot examples showing how to distinguish retriable from non-retriable errors by parsing error message text.

C.

Add a check_refund_eligibility tool that must be called before process_refund to prevent business rule violations.

D.

Return structured error responses with " retriable " : false for business errors and a customer-friendly explanation for Claude to use

Correct Answer: D
Explanation:

The error response must explicitly communicate both control semantics and user-facing meaning. Setting " retriable " : false tells the agent that repeating the same operation cannot change the outcome. Providing a customer-friendly explanation allows Claude to respond accurately without exposing internal implementation details or inventing its own interpretation of the business rule.

Anthropic recommends returning failed tool operations with an error indicator and sufficiently informative content so Claude can decide whether to retry, request another input, or explain the limitation. Tool interfaces should provide detailed descriptions and structured parameters rather than forcing Claude to infer operational behavior from ambiguous text. ( https://platform.claude.com/docs/en/agents-and-tools/tool-use/build-a-tool-using-agent?utm_source=chatgpt.com )

Option A appropriately limits automatic retries to technical failures, but it does not solve the stated customer-response problem unless business failures also carry clear semantics. Option B relies on fragile parsing of human-readable messages. Option C adds latency and another tool dependency, and eligibility may still change or fail for reasons not covered by the preliminary check.

A complete schema should identify the error code, category, retryability, customer-safe explanation, and permitted next actions. Technical errors can similarly return " retriable " : true with retry guidance and a maximum-attempt policy.

Official references/topics: Structured tool errors, retryability classification, customer-safe explanations, resilient MCP contracts.

Question #17 (Topic: Demo Questions)

You are integrating Claude Code into your Continuous Integration/Continuous Deployment (CI/CD) pipeline. The system runs automated code reviews, generates test cases, and provides feedback on pull requests. You need to design prompts that provide actionable feedback and minimize false positives.

Your pipeline includes a release-notes generation step that classifies and summarizes approximately 200 commits at the end of each weekly release cycle. Each commit is currently sent as a separate Messages API request using a Sonnet-tier Claude model. The release notes are not needed until the following morning, providing approximately 12 hours of acceptable latency.

Your team must reduce the per-token API cost while retaining the same model, prompts, and output quality.

Which approach satisfies all these constraints?

A.

Issue the 200 Messages API requests concurrently because parallel execution reduces the per-token price.

B.

Submit the 200 requests through the Message Batches API with unique custom_id values and retrieve the results after the batch finishes.

C.

Concatenate all 200 commit messages into one Messages API request because reducing the number of requests always reduces token costs.

D.

Replace the Sonnet-tier model with a Haiku-tier model to obtain a lower per-token price.

Correct Answer: B
Explanation:

Option B applies Anthropic’s dedicated asynchronous bulk-processing mechanism while preserving the existing model and prompt for every commit. The Message Batches API accepts independent Messages API requests, each identified by a unique custom_id, and charges both input and output usage at 50% of standard API prices. The approximately 12-hour latency allowance makes the release-notes workload well suited to batching because immediate results are unnecessary.

Option A may reduce wall-clock completion time, but concurrency does not alter the API’s per-token price. Option C changes the task structure and risks exceeding context or output limits, mixing commit-level classifications, complicating retries, and making it harder to associate errors with individual commits. A single large request also does not automatically consume fewer tokens because the model must still process all commit content. Option D violates the requirement to retain the same model tier and output-quality profile. Batch results may arrive in an order different from submission order, so the pipeline must associate every response with its original commit through custom_id. This provides lower cost without changing the individual review prompts. Anthropic Message Batches documentation

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

Question #18 (Topic: Demo Questions)

Production monitoring shows that the research phase takes longer than expected. Analysis reveals that the coordinator invokes the web-search subagent, waits for its response, and then invokes the document-analysis subagent. These tasks are independent; neither requires the other’s output. How should you modify the system to run these subagents concurrently?

A.

Structure the coordinator to emit both Agent tool calls—for web search and document analysis—in a single response message instead of separate conversation turns.

B.

Switch both subagents from a Sonnet-tier model to a Haiku-tier model to reduce their individual execution times.

C.

Add instructions explaining the performance benefits of parallel execution and request that the coordinator invoke both subagents simultaneously.

D.

Create an asynchronous orchestration layer that launches parallel threads, each running a separate coordinator-subagent pair, and then aggregates the results.

Correct Answer: A
Explanation:

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.

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

Question #19 (Topic: Demo Questions)

You are building a multi-agent research system using the Claude Agent SDK. A coordinator agent delegates to specialized subagents: one searches the web, one analyzes documents, one synthesizes findings, and one generates reports. The system researches topics and produces comprehensive, cited reports.

When analyzing complex legal cases that cite multiple precedents, the document-analysis subagent processes each precedent sequentially. A landmark case citing 12 precedents takes more than three minutes to analyze completely.

What is the most effective way to reduce this latency while preserving the coordinator’s ability to monitor and debug the system?

A.

Implement a message queue where precedent-analysis tasks are processed asynchronously by a pool of worker agents.

B.

Enable the document-analysis subagent to spawn its own specialized subagents dynamically when it encounters cases with many citations.

C.

Have the coordinator spawn parallel document-analysis subagents, each handling a subset of precedents, and then aggregate the results before synthesis.

D.

Create a recursive agent hierarchy where analysis agents subdivide work among child agents until reaching single-precedent granularity.

Correct Answer: C
Explanation:

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.

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

Question #20 (Topic: Demo Questions)

You are building a structured data extraction system using Claude. The system extracts information from unstructured documents, validates the output using JSON schemas, and maintains high accuracy. It must handle edge cases gracefully and integrate with downstream systems.

Your extraction pipeline occasionally receives responses that cannot be parsed as valid JSON, causing downstream processing failures. The current implementation prompts Claude to return JSON in the response text and then parses it.

What is the most reliable approach to ensure Claude returns valid, schema-compliant structured data?

A.

Add explicit formatting instructions to the prompt with JSON examples, emphasizing that Claude must return only valid JSON with no surrounding text.

B.

Use regular expressions to locate and extract JSON from the response text, handling cases where Claude includes explanatory text around the JSON block.

C.

Define a tool with a JSON schema specifying the expected structure, using tool use to constrain Claude’s output to schema-compliant JSON.

D.

Implement a retry loop that catches JSON parsing errors and re-prompts Claude with the error details, asking it to correct the malformed output.

Next Question
Correct Answer: C
Explanation:

Option C is the strongest choice among the listed approaches because it moves structured data generation from unconstrained response text into a schema-governed interface. Prompt-only JSON instructions, regular-expression extraction, and corrective retries are probabilistic recovery mechanisms: they may reduce failures, but none guarantees that the first response satisfies the contract. Anthropic now provides two schema-constrained mechanisms: JSON Structured Outputs through output_config.format and strict tool use through a tool definition with strict: true. Strict tool use uses grammar-constrained sampling so the tool input conforms to the declared JSON Schema, including required properties and data types. Therefore, the production implementation represented by option C should define the extraction tool’s input_schema and enable strict mode. The application reads the tool_use block as the extracted record; it does not need to scrape prose or search for braces. Option A remains vulnerable to preambles or malformed output. Option B can select a JSON-looking substring but cannot establish schema validity. Option D adds latency and cost and can still fail repeatedly. The schema-constrained tool contract is consequently the most reliable architecture available in these options.

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