Anthropic Claude Certified Architect Foundations (CCA-F) : CCA-F

During testing, you find that when a customer says "I need a refund for my recent purchase," the agent calls process _refund immediately - but populates the required order_id parameter with a plausible-looking but fabricated value instead of first calling lookup_order to retrieve the actual order ID. The refund call fails because the fabricated ID doesn't exist. Which change directly addresses the root cause of the agent fabricating the order_id value?

• A. Update the process_refund tool description to explicitly state that order_id must be obtained from a prior lookup_order call and must never be assumed or invented.
• B. Switch tool_choice from "auto" to "any" to force the agent to make a tool call on every turn.
• C. Pre-parse incoming customer messages to extract any order IDs mentioned, and inject them into the conversation context before passing to Claude.
• D. Add server-side validation that checks whether the order_id exists in your database before executing the refund, returning an error to the agent if not found.

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 level for technical errors only, passing business errors to Claude without retries.
• B. Add a check_refund_eligibility tool that must be called before process_refund to prevent business rule violations.
• C. Return structured error responses with retriable: false for business errors and a customer-friendly explanation for Claude to use.
• D. Add few-shot examples showing how to distinguish retriable from non-retriable errors by parsing error message text.

You are building developer productivity tools using the Claude Agent SDK. The agent helps engineers explore unfamiliar codebases, understand legacy systems, generate boilerplate code, and automate repetitive tasks. It uses the built-in tools (Read, Write, Bash, Grep, Glob) and integrates with Model Context Protocol (MCP) servers.
A developer asks the agent to investigate why a specific API endpoint intermittently returns 500 errors. The codebase has 200+ files and the developer doesn't know which components are involved. The agent must trace the error through routing, middleware, business logic, and database layers. What task decomposition approach would be most effective?

• A. Define a fixed sequence of investigation steps upfront - grep for error patterns, then read error handlers, then check database queries, then examine middleware - executing each step regardless of intermediate findings.
• B. Have the agent dynamically generate investigation subtasks based on what it discovers at each step, adapting its exploration plan as new information about the error path emerges.
• C. Have the agent first create a comprehensive plan mapping all code paths through the endpoint before beginning any file exploration or code reading.
• D. Run parallel worker agents that simultaneously investigate all four layers, then synthesize their findings to identify where the error originates.

Anthropic's tool use documentation states: "Write instructive error messages. Instead of generic errors like 'failed', include what went wrong and what Claude should try next." A billing dispute agent uses lookup_order, which catches all exceptions and returns a tool_result with is_error:
true and the message "Tool execution failed". Monitoring shows two failure modes: the agent retries the identical call until hitting the turn limit, or it immediately calls escalate_to_human without trying alternative tools. Which change follows the documented recommendation and gives Claude the information it needs to select the correct recovery action for each error type?

• A. Implement retry logic with exponential backoff inside each tool implementation so transient errors are resolved transparently within the tool before any failure result is surfaced to Claude in the agentic loop.
• B. Remove is_error: true and return the error details as normal tool content, so Claude reasons about the response as data rather than treating it as a flagged failure condition that biases retry behavior.
• C. Add an error classification step in the agentic loop that intercepts tool errors before Claude sees them, tags each as "retry," "try_alternative," or "escalate," and appends that recommendation to the tool result.
• D. Return error-type-specific messages with is_error: true, e.g., "Order not found-try get_customer to search by phone" for data errors and "Database timeout (transient)-retry should succeed" for infrastructure errors.

An application frequently repeats the same background instructions in every API request. What is a potential downside?

• A. Lower reliability.
• B. Increased hallucinations only.
• C. Reduced model capability.
• D. Higher token usage and cost.