← Volver a las guías

Tool Use and Function Calling: A 2026 Developer Guide

What tool use means

Tool use lets an AI model request an action from your application, such as looking up an order, querying a database, or calling a weather service. Function calling is a common way to represent that request: the model returns a structured function name and arguments, and your code decides whether and how to execute it. The model does not automatically run the function or gain access to your systems. Your application remains responsible for execution, permissions, and the final response.

This distinction matters. A natural-language answer that says it checked an account is not proof that a check occurred. A tool call is a proposed operation that your server must validate and perform before reporting a result.

The tool-calling loop

A typical interaction has four stages. First, your application sends the user’s message and a set of tool definitions to a model. Each definition describes a tool’s purpose and its input schema. Second, the model either answers directly or returns a structured request to call a tool. Third, your application validates the request, runs the corresponding code, and adds the result to the conversation. Finally, the model uses that result to respond or request another permitted action.

For example, a support assistant might receive a request to check an order. It can request a lookup with an order identifier, but your server should verify that the authenticated user is allowed to access that order. After the lookup, return only the relevant status and tracking details to the model, then let it explain the result.

Design tools for reliable execution

• Keep each tool narrow. Prefer a specific operation such as get_order_status over a general-purpose database query. Smaller permissions make behavior easier to test and limit the impact of mistakes.
• Use precise schemas. Define required fields, types, allowed values, and descriptions. Validate arguments server-side even when the model appears to follow the schema. Treat every value as untrusted input.
• Separate authorization from model reasoning. Derive identity and access rights from your application’s authenticated context, not from arguments supplied by the model. Require user confirmation before consequential actions such as purchases, cancellations, or sending messages.
• Handle failures explicitly. Set timeouts, cap retries, and return concise error results that the model can interpret. Avoid retrying non-idempotent actions unless you have an idempotency key or another duplicate-prevention mechanism.
• Limit data exposure. Send the model the minimum tool result needed for the next step. Redact secrets and personal data, and keep credentials inside your server-side integrations.

Make the interaction observable

Log the model request, selected tool, validated arguments, execution outcome, latency, and token usage, while excluding secrets and unnecessary personal information. Give each tool call a request identifier so an error can be traced across your application and external service. Track common failure cases, including invalid arguments, permission denials, timeouts, and repeated calls.

Test more than the happy path. Include malformed inputs, empty results, unavailable services, prompt-injection attempts in retrieved content, and requests the user is not authorized to make. Tool output is data, not trusted instructions. Your application should preserve the distinction between retrieved content and system-level rules.

Choose models and APIs by workload

Tool quality depends on more than a model’s ability to produce structured arguments. Evaluate accuracy on your own tasks, schema adherence, latency, context needs, and total cost. A fast, lower-cost model may suit routine lookups, while more complex multi-step decisions may justify a stronger model. For example, compare Claude Haiku 4.5 for responsive workflows with Claude Sonnet 5.5 for tasks that need more reasoning. Benchmark both with representative prompts and the same validation rules before choosing.

API access also affects implementation effort. 59API is a low-cost, pay-as-you-go relay for models including Claude, GPT, Gemini, DeepSeek, Kimi, GLM, Qwen, and Grok. It offers native official-quality models without downgrades, uses the base URL https://api.59api.com, and is compatible with Claude Code, Codex, Gemini CLI, and OpenAI SDKs. That can make it practical to compare providers or control experimentation costs without rebuilding your integration for each workflow. A referral rebate is also available.

Start with a bounded use case

Begin with one read-only tool, such as searching a help center or retrieving an account status. Define its schema, add authorization and input validation, and test failure cases before enabling actions that change data. Measure success rate, latency, and cost per completed task. Once the workflow is dependable, expand tool access deliberately. Developers who want to compare models with pay-as-you-go access can sign up for 59API and test the same tool workflow against their own evaluation set.

Precios · Docs