Agents and the Agent SDK practice questions

The name field contains an underscore.

Why it fails: Tool names following standard naming conventions, including underscores, are fully supported by the Anthropic API. The issue lies within the schema structure rather than the naming convention, as names provide identifiers for the model to reference during the tool invocation process.

The description is too short for the model to use.

Why it fails: While descriptive text helps the model understand tool utility, the primary failure point in tool selection is usually the parameter schema definition. A short description might impact precision, but it rarely causes a total failure to identify the tool as a potential action.

The tool lacks a response schema definition.

Why it fails: The Anthropic API requires a JSON schema for tool inputs, not tool outputs. The model does not need a schema for the response to invoke the tool successfully; it only needs to know how to construct the input arguments for the function.

It forces the model to ignore all other tool calls.

Why it fails: Stop sequences do not block tool calls; they only define the character sequences that terminate the output generation process. The model can still decide to use a tool, and the stop sequence will only trigger if the model generates that specific string.

It is used to handle exceptions during function execution.

Why it fails: Stop sequences are related to text generation, not function execution. Exception handling must be managed by the application logic that runs the tool, as stop sequences have no visibility into the runtime state of the code being executed by the tool.

It increases the probability of correct tool selection.

Why it fails: Stop sequences do not influence the reasoning process that selects a tool. They only affect when the model stops generating text. The tool selection process happens before the stop sequence would even trigger, based on the input and available tool definitions.

Increasing the model temperature to 1.0 to encourage varied outputs.

Why it fails: Raising temperature introduces more randomness into the model's next-token predictions, which might break a loop but also reduces the reliability of tool-calling parameters. This technique does not address the underlying logic failure and can lead to hallucinated tool arguments or invalid JSON formatting in the agent's response blocks.

Hard-coding a strict tool execution sequence in the system prompt.

Why it fails: Creating a rigid sequence of tool calls removes the agent's ability to reason dynamically based on intermediate results. While it prevents loops, it fundamentally transforms the agent into a basic script, losing the flexibility and adaptive problem-solving capabilities that characterize advanced agentic workflows and autonomous reasoning modules for Claude.

Reducing the context window to force the agent to forget history.

Why it fails: Reducing the context window might force the agent to forget previous tool calls, but this actually increases the risk of loops because the model loses the history of what it has already attempted. Effective agents require sufficient context to track their progress and avoid repeating failed or redundant steps.

It automatically encrypts all model outputs using AES-256 standards.

Why it fails: MCP is a protocol for tool and data integration, not a security encryption standard for model outputs. While security is important in agent design, encryption of the communication channel is typically handled by the transport layer (like HTTPS) rather than the Model Context Protocol itself, which focuses on data exchange formats.

It eliminates the need for any system prompt engineering in agents.

Why it fails: MCP provides the 'how' for tool connections, but the 'why' and 'when' still depend on effective system prompts. Prompt engineering remains a critical skill for guiding the agent's reasoning process, ensuring it uses the MCP-connected tools at the right time and interprets their results correctly for the user.

It reduces the token cost of model calls by 50% through compression.

Why it fails: While efficient data exchange is a goal, MCP does not inherently compress model tokens or guarantee a specific cost reduction. Token usage is primarily determined by the size of the messages and tool definitions sent to Claude. MCP's value lies in architectural standardization rather than direct manipulation of the model's pricing.

Increase the max_tokens value on each request so the model has more room to emit a complete tool_use block before it stops generating.

Why it fails: max_tokens bounds output length; it does not influence whether the model chooses to call a tool. Truncation would only matter if tool_use blocks were being cut off mid-generation, which is not the described symptom. Raising the limit wastes latency and cost while leaving the selection problem untouched.

Enable streaming responses so tool_use blocks arrive incrementally and the agent can begin executing a tool before the model finishes its turn.

Why it fails: Streaming affects how output is delivered, not which tool the model picks or whether it hallucinates a name. Executing a tool from a partially received block is unsafe because the JSON input may be incomplete. Streaming improves perceived latency but does nothing for the described reliability problems, so it is not a remedy here.

Send the entire tool registry again as a system message on every turn so the model is reminded which tools exist before it responds.

Why it fails: Tools are already supplied through the dedicated tools parameter on each request; duplicating them as system text does not change how the model selects them and can create conflicting guidance. The invented tool names stem from weak descriptions and unconstrained output, not from the model forgetting the registry, so this adds noise without fixing the cause.

A complex system prompt with strict negative constraints.

Why it fails: System prompts are prone to prompt injection and accidental overrides by the model. Relying solely on natural language to restrict database operations is insufficient for security because the model might ignore these constraints when faced with conflicting instructions or unexpected user input sequences.

The Agent SDK's built-in session state management.

Why it fails: Session state management handles conversation history and context tracking but does not provide security boundaries for external tool execution. It is designed to maintain conversational flow rather than enforce operational access control over downstream database queries or external API calls.

The model's internal safety filtering layer.

Why it fails: Anthropic's internal safety filters target broad harms like hate speech or dangerous content, not the specific operational logic of custom enterprise tools. Developers must implement their own functional access controls within the tool implementation layer to ensure safe business operations.

Increasing the max_tokens parameter to allow longer reasoning.

Why it fails: Increasing token limits does not solve infinite loops; it only delays their impact while increasing costs. More tokens provide more space for the agent to continue its cycle, potentially worsening the effect of an unconstrained loop rather than resolving the underlying logical issue.

Using a higher temperature to encourage creativity.

Why it fails: Higher temperature increases randomness, which is generally detrimental when trying to control agent behavior. It makes the model less likely to follow a deterministic stopping pattern, potentially increasing the likelihood of erratic tool usage and unintended recursive behavior in complex workflows.

Caching all tool outputs for faster retrieval.

Why it fails: Caching improves performance but does not address the logic of the loop itself. If the agent is trapped in a logical cycle, caching the output will simply provide the same input or output faster, without helping the agent realize it should stop acting.

Adding a 'Please provide JSON' phrase at the end of the prompt.

Why it fails: Natural language requests for specific formats are often ignored by models when they get distracted by complex reasoning tasks. This approach relies on the model's instruction following ability rather than structural constraints, leading to inconsistent results that fail during automated parsing.

Lowering the system prompt length to reduce ambiguity.

Why it fails: Reducing prompt length does not address the fundamental issue of structural formatting. While clear prompts are better, the model still lacks a mechanical way to validate its own output structure, meaning it will likely continue to produce non-JSON text regardless of length.

Retrying the call automatically until valid JSON is returned.

Why it fails: Automatic retries are a stopgap measure that increases latency and costs without fixing the root cause. This strategy does not teach the model to format correctly, and it may consume a significant amount of the token budget before finally producing a valid response.

It guarantees that all messages are stored in a database.

Why it fails: Session management is an in-memory or transient process logic, not a storage persistence layer. While it may interact with databases, its primary purpose is context window optimization and state tracking, not long-term storage or durability of conversational history.

It automatically encrypts all user inputs for privacy.

Why it fails: Session management does not inherently provide data encryption at rest or in transit. Security and privacy must be handled by the transport layer and the backend architecture separately from the message state management used by the SDK.

It makes the model faster by skipping validation.

Why it fails: State management has no direct impact on the model's inference speed. The speed of the model is determined by the number of tokens processed and the infrastructure latency, not by the method used to organize the message history sent in the request.

A pre-trained model checkpoint for the tool.

Why it fails: Tools do not require pre-trained models. They are simple functions or APIs that execute logic based on the model's output. Requiring a separate model checkpoint would be unnecessary and computationally expensive, complicating the architecture without adding any functional benefit.

A hardcoded response for every possible input.

Why it fails: Hardcoding responses defeats the purpose of an agentic tool. Tools are intended to perform dynamic actions that produce variable outputs based on real-time data or state, whereas hardcoding limits the agent's ability to handle novel queries or changing environments.

To store the conversation history for later analysis.

Why it fails: Conversation history is stored in the list of message objects, where the system message is just one component. The role's purpose is not storage, but the persistent definition of rules that govern how the model interprets and responds to subsequent user input.

To handle errors generated by the agent's tools.

Why it fails: Error handling is managed by the application code, not the system message. While the system message can instruct the agent on how to handle errors, it does not actually execute the logic or catch exceptions occurring during tool execution.

To provide the user's input to the assistant.

Why it fails: The user's input is provided using the 'user' role. Using the 'system' role for user input would confuse the model, as it would treat that input as behavioral instructions rather than a query to be answered.

Increase the temperature setting of the model.

Why it fails: Temperature settings control the randomness of the model's output generation. They have no impact on the validity of the tool schema definition, which is a static configuration provided to the API before the model even begins generating its response.

Retry the request with a smaller context window.

Why it fails: Context window limits affect the content of the conversation, not the structural validity of the tool definitions. Retrying will not resolve a schema syntax error, as the definition remains invalid regardless of the amount of text in the prompt or conversation history.

Update the system prompt to be more descriptive.

Why it fails: A more descriptive system prompt will not fix a technical schema error in the tool definition. The API error indicates the schema is malformed at the structural level; modifying the natural language instructions will not correct the underlying JSON syntax.

It improves the agent's ability to handle errors.

Why it fails: Redundant tools do not provide better error handling; they actually introduce the risk of the agent choosing a suboptimal tool that may return an error for a task that a different, better-defined tool could have handled successfully.

It allows the agent to cache results more efficiently.

Why it fails: Tool caching is a function of the implementation logic, not the descriptions. Having redundant tools does not help caching; if anything, it complicates the cache lookup, as the system must distinguish between different tool identifiers that serve the same purpose.

It forces the model to use all tools in every turn.

Why it fails: The model does not 'use' all tools; it selects them based on intent. Redundancy causes the model to guess which one is correct rather than choosing them all. If it does try to use them all, it's a sign of poor reasoning caused by the ambiguity.

The Claude model itself.

Why it fails: The model generates the tool call request but does not execute the code or manage the loop. It acts as a reasoning engine, while the orchestration must be implemented in the application layer that communicates with the API.

The Anthropic API server-side logic.

Why it fails: The Anthropic API is stateless and does not know about your internal functions or your application's loop. It processes each request independently and waits for the client to provide the subsequent turn, meaning orchestration is entirely the responsibility of the client application.

The system prompt instructions.

Why it fails: System prompts provide guidance but cannot perform the technical orchestration of executing code or managing state across multiple turns. They are for influencing the model's reasoning, not for managing the technical flow of tool execution loops.

It significantly slows down the model inference time.

Why it fails: Inference time is independent of the content of the data. PII content does not impact the speed at which the model processes text; the performance impact is negligible compared to the security risks associated with handling sensitive information in AI pipelines.

It reduces the model's reasoning capabilities.

Why it fails: PII presence does not directly degrade reasoning. The issue is strictly one of data privacy and compliance. Removing PII is a security best practice, not a mechanism for improving the model's logical depth or its ability to process complex instructions.

The model cannot understand PII formats.

Why it fails: The model is fully capable of processing PII formats like email addresses or phone numbers. The restriction on PII is a business and security policy, not a technical limitation of the model's ability to interpret such data in its input.

Requesting the model to solve the entire problem in one turn.

Why it fails: Single-turn solutions for complex tasks often hit context or reasoning bottlenecks. They are prone to failure and difficult to debug, as the model lacks intermediate feedback loops that would allow it to self-correct during the process of solving the problem.

Using the maximum possible context window for every request.

Why it fails: Using a maximum context window is inefficient and expensive. It increases latency because the model must process a larger amount of data in every request, even if that data is irrelevant to the current step in the task.

Adding 'think step-by-step' to the final response request.

Why it fails: While chain-of-thought is useful, it is not a substitute for architectural task decomposition. Relying on internal reasoning for complex multi-step tasks is far less reliable than explicitly executing discrete tools for each logical phase of the problem.

Increasing the model's temperature to 1.5 for variety.

Why it fails: Higher temperature leads to unpredictable behavior, which is the opposite of what is needed in production. For reliability, deterministic behavior is preferred, meaning temperature should usually be set lower, not higher, to ensure consistent responses for the same input.

Hardcoding every possible user query path.

Why it fails: Hardcoding query paths is impossible for generative AI and defeats the purpose of using an agent. It would lead to an unmaintainable codebase that cannot adapt to the diverse and unpredictable nature of user interactions in real-world scenarios.

Ignore the error and let the agent retry with the same input.

Why it fails: Retrying with the same input after a failure is likely to result in the same error. This creates an infinite loop of failure that wastes tokens and time. The agent needs feedback to understand that its previous approach was incorrect or malformed.

Restart the entire conversation history from scratch.

Why it fails: Restarting the conversation is drastic and clears all context, forcing the user to re-state their query. This destroys the agent's progress and is unnecessary, as the model is capable of using failure feedback to continue working on the task effectively.

Send a generic 'try again' message to the agent.

Why it fails: Generic messages do not provide the model with enough information to change its behavior. Without specific details on why the failure occurred, the model will likely repeat the exact same invalid tool call, leading to further failures and wasted token budget.

Persisting the Research agent's output to a global database for the Router.

Why it fails: Global databases add unnecessary latency and complexity for simple state handoffs. While useful for long-term storage, the immediate conversation state is better handled via message passing or shared context objects within the Agent SDK, which are designed for real-time interaction and faster response times between the specialized agent nodes.

Restarting the entire session with the Research output as a new prompt.

Why it fails: Restarting the session loses the original intent and the step-by-step reasoning that led to the Research phase. This results in a disjointed user experience and requires the model to re-process the initial request, leading to higher token costs and potentially different interpretations of the core task requirements.

Using a separate API key for each agent to isolate their environments.

Why it fails: API key isolation provides security boundaries but does nothing to facilitate state handoffs or communication between agents. In fact, it might complicate the integration of a unified SDK instance. State management is a logical application concern regarding message history rather than an authentication or authorization concern between various services.

The 'examples' array within the tool definition.

Why it fails: While examples can help guide the model toward better performance, they are not a structural requirement for defining the input schema. The model primarily relies on the schema definition and descriptions to format its JSON output. Examples are supplementary and cannot replace the formal declaration of required properties and types.

A 'system_prompt' specific to that individual tool.

Why it fails: Tools do not have their own system prompts; instead, they are defined within the scope of a model call or an agent's configuration. The system prompt belongs to the model instance itself, guiding its overall behavior, while the tool definition is a structured metadata object that describes a specific capability available.

The 'output_format' property for return values.

Why it fails: Anthropic's tool use protocol focuses on the input generated by the model. While the developer must handle the tool's output, there is no 'output_format' field required in the tool definition itself. The model learns how to interpret results based on the 'tool_result' block it receives in the next turn of the conversation.