Skip to content

5. Tool use

Tools and Tool Use in Agents

AI agents become significantly more useful when they can move beyond generating text and begin interacting with external systems. While a language model can reason about problems and produce explanations, many real-world tasks require access to data, computation, or services that exist outside the model itself. Tools provide the mechanism that allows agents to bridge this gap.

In an agent system, a tool is any interface that allows the agent to perform actions or retrieve information from external resources. Tools expand what an agent can do by enabling it to query databases, call APIs, search the web, execute code, or interact with enterprise software systems. Instead of relying solely on its internal knowledge, the agent can gather real-time data and perform operations that directly affect external environments.

This capability transforms agents from passive responders into active participants in software systems.

Why Tools Matter

Language models operate within a fixed training dataset and a limited context window. While they are capable of reasoning about many topics, they cannot reliably access up-to-date information or interact with live systems without additional infrastructure.

Tools address these limitations by allowing agents to:

  • Retrieve current data from external sources
  • Perform computations or analysis
  • Interact with business systems and APIs
  • Trigger actions in external environments

For example, if a user asks an agent for the latest stock price of a company, the model itself cannot know the current value. Instead, the agent must call a financial data API to retrieve the most recent information before generating a response.

Similarly, if an agent is tasked with generating a financial report, it may need to query a database for revenue data, calculate growth rates using a computation tool, and retrieve supporting documentation from a knowledge base.

Tools therefore allow agents to operate within the broader software ecosystem, connecting reasoning with real-world data and services.

Common Types of Agent Tools

Although tools can take many forms, several categories appear frequently in agent-based systems.

APIs

APIs are one of the most common types of tools used by agents. An API allows the agent to communicate with external services by sending requests and receiving structured responses.

For example, an agent might use APIs to:

  • Retrieve financial or market data
  • Access CRM or customer support systems
  • Trigger actions in internal business applications
  • Interact with third-party services such as payment systems or messaging platforms

Because APIs provide structured data and well-defined operations, they are particularly well suited for integration with agent systems.

Databases

Agents often need to retrieve or update information stored in databases. Database tools allow agents to run queries, retrieve records, and analyze structured data.

For example, a business intelligence agent might query a data warehouse to retrieve sales metrics or operational statistics. A support automation agent might query a ticket database to review previous customer issues.

By integrating with databases, agents can operate directly on the data that organizations rely on for decision-making.

Search Systems

Search tools allow agents to retrieve relevant documents or information from large knowledge sources.

These systems may include:

  • Web search engines
  • Internal documentation repositories
  • Vector databases containing embedded knowledge
  • Enterprise knowledge management systems

Search tools help agents gather supporting information before generating a response. For example, a research agent may search internal documentation to retrieve relevant reports and then synthesize them into a summary.

Search is especially important when agents must operate over large bodies of information that cannot fit entirely within the model’s context window.

Code Execution

Some tasks require computation that goes beyond what language models can reliably perform through reasoning alone. Code execution tools allow agents to generate and run code in controlled environments.

This enables agents to perform operations such as:

  • Data analysis and statistical calculations
  • Transforming or processing datasets
  • Running simulations or models
  • Generating visualizations

For example, an analytics agent might write and execute Python code to calculate growth rates, generate charts, or process large datasets before summarizing the results.

Code execution tools effectively give agents access to a programmable runtime environment, expanding the range of problems they can solve.

Integrations

Many real-world agent applications require integration with business software systems. These integrations allow agents to interact with tools such as:

  • Customer support platforms
  • project management systems
  • messaging platforms
  • document management systems
  • enterprise resource planning (ERP) tools

Through integrations, agents can automate tasks such as creating support tickets, updating project tasks, or retrieving information from internal knowledge bases.

These integrations are often essential for deploying agents within production environments.

Tool Selection

For an agent to use tools effectively, it must first decide which tool is appropriate for a given task.

This decision process is typically handled by the agent’s reasoning layer. When the agent receives a request, it evaluates whether the task can be completed using its current knowledge or whether external information or computation is required.

If additional resources are needed, the agent selects the most relevant tool from its available set.

For example:

  • A question about current financial data might trigger a financial API call.
  • A request for internal documentation may trigger a knowledge base search.
  • A data analysis task may trigger a code execution tool.

Tool selection often relies on structured tool descriptions that explain what each tool does and when it should be used. These descriptions help the language model determine the appropriate action during its reasoning process.

Tool Calling

Once the agent has selected a tool, it must generate the correct input parameters and invoke the tool.

This process is often referred to as tool calling or function calling.

In practice, tool calling involves several steps:

  1. The agent decides which tool to use
  2. It constructs the required input parameters
  3. The system executes the tool request
  4. The result is returned to the agent

For example, if an agent decides to retrieve weather information, it might construct a request such as:

  • Tool: Weather API
  • Parameter: location = "London"

The system executes the API call, retrieves the result, and returns the data to the agent. The agent then incorporates that information into its reasoning process.

Tool calling allows agents to move fluidly between reasoning and action. The model analyzes the problem, invokes external tools when needed, and integrates the results into subsequent reasoning steps.

Tools as the Bridge Between AI and Software Systems

Tools play a central role in transforming language models into functional agents. They provide the interfaces that allow agents to access real-time data, perform computation, and interact with existing software infrastructure.

Without tools, agents remain limited to generating responses based on internal knowledge. With tools, they can participate directly in operational systems, automate workflows, and solve complex tasks that require coordination across multiple services.

As agent systems grow more sophisticated, managing tool access, ensuring reliable execution, and coordinating tool usage across multiple agents become increasingly important. This is where orchestration platforms and agent infrastructure frameworks provide the underlying systems needed to support large-scale agent deployments.