Google has introduced Tool Retrieval, a new preview feature for its Gemini API designed to reduce token consumption when AI agents work with dozens or hundreds of external tools. Announced on November 19, 2026, the feature allows Gemini to load detailed tool definitions only when they are needed instead of including every tool’s complete parameter schema in every request.
The update targets an important problem in building AI agents: as developers connect more tools, the instructions describing those tools consume increasing amounts of context, increase processing overhead and can make it harder for models to select the right function. Google’s approach keeps less frequently used tools on standby and retrieves their full definitions when required, potentially making complex AI agents more efficient and scalable.
What Is Google’s New Tool Retrieval Feature?
Tool Retrieval is a new capability available in preview through Google’s Gemini Interactions API.
To understand its importance, it is necessary to understand how AI agents use external tools.
An AI agent can connect to different applications and services to perform tasks. For example, a business AI agent might have access to:
- Gmail for sending and reading emails.
- Google Drive for managing documents.
- Payment systems for processing transactions.
- Databases for retrieving information.
- CRM platforms for managing customers.
- Calendar applications for scheduling meetings.
- Internal company software for managing operations.
Each tool has a definition, including its name, description and parameter schema. The schema explains what information the AI must provide when calling that tool.
Traditionally, developers send the complete definitions of all available tools with every API request. When an agent has hundreds of tools, this creates a large amount of additional input context.
Google’s Tool Retrieval changes this process by allowing Gemini to retrieve the detailed definition of a tool only when it decides that the tool is relevant to the current task.
How Does Tool Retrieval Work?
The new feature uses a system called deferred tool loading.
Instead of providing Gemini with every tool’s complete definition immediately, developers can mark selected tools for deferred loading.
The model initially receives their names and descriptions but does not receive their full parameter schemas.
When Gemini determines that a particular tool is necessary, it requests that tool by name. The API retrieves its complete schema and makes it available for the model to execute the function.
The process happens within the same API request for Google’s server-side retrieval system.
Step-by-Step Example
Imagine a company has developed an AI customer-support agent connected to 100 different tools.
A customer asks the agent to refund an order that arrived damaged.
Without Tool Retrieval, the system may send the definitions of all 100 tools, even though only the refund function is required.
With Tool Retrieval, the process works differently:
- The developer provides Gemini with the available tool names and descriptions.
- The customer requests a refund.
- Gemini identifies the refund function as relevant.
- The API retrieves the complete refund function schema.
- Gemini generates the function call with the required order details.
- The company’s software executes the refund and returns the result.
This avoids loading the complete definitions of unrelated tools into the initial context.
How Developers Can Enable Tool Retrieval
Google has introduced two main configuration elements for enabling the feature.
The first is tool_search, which allows Gemini to search for the functions it needs.
The second is defer_loading: true, which tells the API to keep selected tool schemas out of the initial prompt.
A simplified Python example looks like this:
tools = [
{"type": "tool_search"},
{
"type": "function",
"name": "issue_refund",
"description": "Refund an order to the original payment method.",
"defer_loading": True,
"parameters": {
"type": "object",
"properties": {
"order_id": {"type": "string"},
"amount": {"type": "number"}
},
"required": ["order_id", "amount"]
}
}
]
Developers can use the same approach for large collections of functions, leaving frequently used tools available immediately and deferring less frequently used ones.
Google also provides a server-side retrieval mechanism, meaning developers do not need to build or host a separate search index for the default implementation.
How Much Can Tool Retrieval Reduce Token Consumption?
Reducing input tokens is one of the primary objectives of the feature.
Every tool definition consumes tokens when included in an API request. A large agent connected to hundreds of functions can therefore spend substantial amounts of context describing capabilities it may never use during a particular interaction.
Tool Retrieval is designed to reduce this unnecessary overhead.
Google says the feature can also reduce latency and help maintain tool-selection accuracy as the number of available functions increases.
However, Google has not published a universal measured token-reduction percentage. The actual savings depend on the number of tools, the size of their schemas and how frequently the model needs to retrieve them.
There is also an important consideration: retrieving a tool’s schema involves additional processing. If an agent has only a small number of tools or needs to retrieve schemas on nearly every request, the feature may not reduce overall token consumption.
Developers should therefore measure performance using their own workloads.
Tool Retrieval Also Supports MCP Servers
Another important capability is support for remote Model Context Protocol (MCP) servers.
MCP is an open protocol that allows AI applications to connect with external tools, data sources and services through a standardized interface.
For example, an AI agent might connect to an MCP server that provides access to a company’s internal database, project-management software or customer-support platform.
Previously, connecting to large tool collections could introduce significant overhead because the model needed access to their definitions.
With Tool Retrieval, developers can defer loading the tools exposed by a remote MCP server.
Gemini can then retrieve the relevant tools when a task requires them instead of loading every available function upfront.
This could be particularly useful for enterprise AI agents connected to multiple business applications.
Server-Side and Client-Side Tool Retrieval
Google also supports two approaches to retrieving tool definitions.
| Feature | Server-side retrieval | Client-side retrieval |
|---|---|---|
| Search execution | Managed by Gemini | Managed by the developer’s application |
| Tool registry | Managed through the API request | Can use a custom registry |
| Additional infrastructure | No separate search index required | Developer manages the search system |
| Additional round trip | Search happens within the same request | Requires an additional round trip |
| Best suited for | Large, relatively fixed tool libraries | Custom and frequently changing tool libraries |
Server-side retrieval is designed to make implementation simpler.
Client-side retrieval is more flexible for developers who maintain their own tool registries, embedding indexes or user-specific permissions.
For example, an enterprise application could use client-side retrieval to expose different tools depending on an employee’s access rights.
Which Gemini Models Support Tool Retrieval?
Google says Tool Retrieval works with Gemini 3.6 and later models, including the Gemini 4 family.
The feature is currently available in preview through the Gemini Interactions API.
It is important to note that Tool Retrieval is not supported through the older generateContent API method.
The preview status also means that developers should expect possible changes to the API before the feature becomes generally available.
Google has not announced a final general-availability date.
Does Google Charge Extra for Tool Retrieval?
Google says there is no separate feature fee for using Tool Retrieval.
Developers continue paying the standard input and output token rates of the Gemini model they select.
However, enabling the feature adds a small fixed amount of input tokens for the tool-search mechanism. Retrieved schemas are also billed as input tokens.
The economic benefit comes from avoiding the repeated inclusion of large schemas that are not needed for a particular task.
Google recommends keeping frequently used tools loaded upfront while deferring less frequently used functions.
The feature also works with prompt caching, helping preserve the initial prompt prefix when retrieved schemas are added later in the conversation.
Why This Update Matters for the AI Agent Industry
The launch addresses one of the practical challenges facing developers building increasingly sophisticated AI agents.
As agents become capable of handling more complex workflows, they need access to larger collections of external tools.
A customer-service agent may need to retrieve orders, issue refunds, update customer records and create support tickets. An enterprise assistant may need access to hundreds of internal systems.
Sending every tool definition with every request can become inefficient.
Tool Retrieval introduces a more selective approach in which an AI model accesses the detailed instructions for a function only when necessary.
This could make it easier to build agents that operate across larger software ecosystems without continuously consuming context on unused tool definitions.
The Bigger Picture
Google’s Tool Retrieval announcement highlights an important shift in AI development: improving agent efficiency is becoming as important as improving model intelligence.
As AI agents move from answering questions to completing multi-step tasks, their ability to interact with external applications becomes increasingly important. Managing those interactions efficiently can influence operating costs, response times and reliability.
The feature also strengthens the Gemini API’s position in the growing market for agentic AI development, where companies are competing to provide better infrastructure for building autonomous software systems.
Looking Ahead
The next stage will depend on how developers adopt Tool Retrieval and whether it produces measurable improvements across real-world agent workloads. Its preview release gives developers an opportunity to experiment with deferred schemas, remote MCP servers and custom tool registries before the feature reaches general availability.
For Google, the objective is to make Gemini agents capable of handling much larger tool ecosystems without unnecessary context overhead. If the approach proves effective, on-demand tool discovery could become an important part of how developers build and operate complex AI agents.
SEO Title: Google Launches Gemini API Tool Retrieval to Cut AI Agent Token Costs
Meta Description: Google introduces Tool Retrieval in the Gemini API, allowing AI agents to load tool schemas on demand and reduce token usage when working with large tool libraries.
Suggested URL Slug: google-gemini-api-tool-retrieval-reduce-token-costs
Focus Keyword: Gemini API Tool Retrieval
Secondary Keywords: Google Gemini API update, AI agent tools, token optimization, deferred tool loading, MCP server integration, Gemini Interactions API, autonomous AI agents
Get the day’s top stories in your inbox
One concise email. No spam, unsubscribe anytime.



