AI agents use tools by turning a model’s proposed action into a structured request that an application or hosted runtime can execute. The model can choose among the tools made available to it, but the integration determines what those tools can do, where they run, and how results return to the model. Function calling describes one way to request an operation; MCP provides a way for an agent runtime to discover and call tools published by connected servers.
What a tool call does—and what it does not do
A tool is an operation an agent can request, such as looking up information or invoking an application function. Its definition gives the model a name and an input shape so the model can produce a structured request. That request is not, by itself, execution: the surrounding application or hosted runtime handles the work and returns a result.
As an Amazon Associate I earn from qualifying purchases.
In Anthropic’s documented flow, Claude can return a tool_use block for a developer-defined function, and the application executes that function. Other platforms may use different request formats or provide hosted tools that execute within their own services. Tool access therefore does not mean the model can execute arbitrary code on its own; the integration controls the exposed operations and execution environment.
The tool-use cycle, from request to result
- Expose tools. The application or runtime supplies one or more tool definitions, or makes tools available through a supported discovery mechanism.
- Request a tool. Given the task and available definitions, the model may return a structured request naming a tool and supplying arguments.
- Execute the request. The application runs its function handler, or a hosted or connected runtime handles the call, depending on the integration.
- Return the result. The execution environment sends the result back to the model, which can use it to answer, request another tool, or continue the workflow.
This is a handoff among the model, the tool interface, and the execution environment—not a single action performed entirely by the model. OpenAI’s tool documentation describes several integration options, including built-in tools, function calling, programmatic tool calling, tool search, and remote MCP servers. The available options and handling depend on the API or runtime in use.
Function calling and MCP solve different parts of the problem
Function calling: request a defined operation
With function calling, a developer provides a callable operation and its input shape. The model can return a request to call it; application code typically handles the execution when the function is developer-defined. This is a direct fit when the application already owns the functions and wants to decide how to run them.
MCP: connect to tools published by a server
The Model Context Protocol (MCP) standardizes how a connected server publishes tool definitions and handles calls. In OpenAI’s documented Agents API flow, the runtime can discover tools from a connected MCP server, call them, and receive their results. MCP addresses connectivity between a client or runtime and a tool server; it does not decide whether a tool is appropriate for a particular request or what arguments the model should ask to use.
These approaches are not interchangeable labels for the same layer. Function calling describes a model-facing request for an operation. MCP describes a server connection and the discovery and handling of tools through that connection. An application may choose direct function handlers, connected MCP tools, hosted tools, or a combination, according to what its platform supports.
How agents find and limit available tools
Tool availability may be configured directly, loaded through tool search, or discovered from a connected MCP server. A broad tool catalogue can be narrowed so an agent sees only operations relevant to its task. For example, OpenAI’s Agents API documentation describes allowed_tools for limiting which tools an agent can discover and call; its Python Agents SDK documentation describes allow/block lists and context-aware filtering.
These are product-specific implementation options, not a universal tool-selection recipe. Filters help scope what is exposed, but they should not be treated as a guaranteed security boundary. Keep execution permissions and validation in the application or service that runs the tool, rather than relying on the model’s choice or on a filter alone.
Choose a runtime by who should own orchestration and state
OpenAI’s Agents API, Agents SDK, and Responses API place different responsibilities with the platform and the application. The comparison below reflects the documented division of responsibilities; exact capabilities and product surfaces can change.
| Option | Orchestration | State and conversation history | Where tools run | When it fits |
|---|---|---|---|---|
| Agents API | Managed by OpenAI. | Supports saved session configuration and turns. | Can use hosted tools and service-connected tools, depending on the integration. | When reducing application-owned orchestration and infrastructure work is a priority. |
| Agents SDK | Runs within the application. | The application can store state or use SDK session mechanisms. | Tools can run in the application environment or use connected services, depending on setup. | When the developer wants SDK-level orchestration in their own application. |
| Responses API | The application works more directly with model responses and integrations. | The application can manage history manually, chain responses, or use Conversations. | Depends on the selected tool integration and application handlers. | When the application needs more direct control over response handling and integration decisions. |
These choices are not a ranking. A managed API can reduce the amount of orchestration infrastructure an application must own, while an SDK or direct Responses integration leaves more decisions to the developer. Compare the required control over state, tool execution, and deployment before selecting a runtime.
The Tool Desk
Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →A practical way to design tool selection
- Start with the task. Identify what information or action the agent needs, then expose only tools that can supply it.
- Make each interface legible. Give operations distinct names and input shapes that make their purpose and expected arguments clear to the model.
- Choose the execution owner. Decide whether the application, a hosted service, or a connected MCP server should execute each call.
- Scope discovery. Configure only the tools needed for the agent’s role; use the relevant platform’s allow-list or filtering mechanisms where available.
- Keep execution checks in the runtime. Validate arguments and enforce the application’s permissions where a tool is executed. A model request is an instruction to the integration, not proof that the operation is authorized.
- Return useful results. Send the model the result it needs for the next decision, so it can continue the task or produce a final response.
This is a design checklist, not a guarantee that a model will always select the right tool. The reviewed platform documentation explains mechanisms for exposing and calling tools, but does not establish one platform-neutral recipe that ensures reliable selection.
Programmatic tool calling for multi-tool workflows
Programmatic tool calling lets a model compose tool work through code in an execution container, rather than requiring the same model-to-application handoff for every individual operation. Anthropic documents this approach as a way to reduce round trips and token use in multi-tool workflows. Its surfaced guide also reports benchmark figures, but the available extract does not establish a publication year; those figures are therefore not suitable for a date-complete comparison here.
Whether this pattern fits depends on the platform’s supported execution environment and the application’s need to control each operation. It is one implementation option, not evidence that programmatic calling will improve every agent workflow.
Keep platform capabilities tied to their documentation
OpenAI’s tool guide lists built-in tools, function calling, programmatic tool calling, tool search, and remote MCP servers as ways to extend model capabilities. Anthropic documents its own tool-use flow and programmatic calling approach. These are vendor-specific descriptions, not a claim that every agent framework exposes the same features or uses the same call format. Check the documentation for the API or runtime you deploy, particularly when deciding where state lives, how a tool is discovered, or which component executes it.
Do these 3 things before closing this tab:
1Repair Windows errors before they cause bigger problems2Fix the driver behind crashes, sound loss and screen glitches3Clear out junk files and repair common Windows errorsConclusion
Effective tool use depends on separating three responsibilities: the model proposes a structured call, the tool interface defines the available operation and its inputs, and an application or hosted runtime executes it. Function calling provides a way to request an operation; MCP provides a standardized connection to server-published tools. Runtime selection then determines who owns orchestration, state, and execution. Design around those boundaries, scope the available tools to the task, and enforce permissions where calls actually run.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
