Anthropic Claude Certified Architect – Foundations Sample Questions:

1. 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.
Production logs show that when the agent handles complex billing disputes requiring 6+ tool calls, it sometimes exhausts its max_turns limit after gathering data but before completing resolution or escalating.
The team's goal is to guarantee that every customer interaction ends with either a completed resolution or a human handoff, regardless of how the agent loop terminates.
Which approach achieves this guarantee?

A) Add system prompt instructions telling the agent to call escalate_to_human with a summary of its findings whenever it determines it cannot complete resolution within its remaining actions.
B) Add orchestration-layer code that checks the agent's outcome after each loop termination-if the loop ended without a completed resolution or escalation, programmatically call escalate_to_human with the accumulated conversation context and tool results.
C) Implement a pre-tool-use hook that counts tool invocations and terminates the loop with an automatic escalation once the agent reaches 80% of its max_turns limit.
D) Split the workflow into two sequential agent invocations-a first agent gathers information via get_customer and lookup_order, then a second agent receives that data and handles process_refund or escalate_to_human, each with separate turn budgets.

2. 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.
A customer contacts the agent about a warranty claim on a power drill. Resolving this requires multiple sequential tool calls: get_customer to look up their account, lookup_order to find the purchase details, and then either process_refund or escalate_to_human depending on warranty eligibility. You're implementing the agentic loop that orchestrates these steps using the Claude API.
What is the primary mechanism your application uses to determine whether to continue the loop or stop?

A) You check whether Claude's response contains a text content block-if text is present, the agent has produced its final answer and the loop should exit.
B) You track the number of tool calls made and exit the loop once a preconfigured maximum is reached.
C) You manually set the tool_choice parameter to "none" after the final expected tool call to force Claude to stop requesting tools.
D) You check the stop_reason field in each API response-the loop continues while it equals "tool_use" and exits when it changes to "end_turn" or another terminal value.

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

4. You are using Claude Code to accelerate software development. Your team uses it for code generation, refactoring, debugging, and documentation. You need to integrate it into your development workflow with custom slash commands, CLAUDE.md configurations, and understand when to use plan mode vs direct execution.
You've asked Claude Code to build a PDF report generation feature. The initial implementation queries the database correctly, but the output has formatting issues: table columns are too narrow causing content truncation, dates display without proper formatting, and page break handling is incorrect. You've noticed these issues interact-changing column widths affects how dates render, and page breaks depend on content height.
What's the most effective approach for iterating toward a working solution?

A) Provide all three issues in a single detailed message with exact specifications for each, allowing Claude to address them together in one update.
B) Start fresh with a detailed prompt specifying all formatting requirements upfront.
C) Address the column width issue first with specific measurements, verify it works, then fix date formatting within the corrected columns, then adjust page breaks-testing after each change.
D) Show Claude an example of a correctly formatted report and ask it to match that output, rather than listing the specific technical issues.

5. 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.
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) Add an error classification step in the agentic loop that intercepts tool errors before Claude sees them, then routes to hardcoded retry or escalation logic.
B) 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.
C) 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.
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.

Solutions: