Google has introduced Tool Retrieval, a new preview feature for its Gemini API designed to make artificial intelligence agents more efficient when working with large collections of tools. The feature allows developers to load tool parameter schemas only when an agent needs them, instead of sending the complete definitions of every available tool with every request.
Announced on November 19, 2026, Tool Retrieval is available through Google’s Gemini Interactions API. The feature addresses a growing challenge in agent development: as AI agents connect to more business applications, databases, APIs and external services, the amount of information required to describe those tools can increase token consumption, add latency and make tool selection more difficult.
Key Takeaways
- Google has launched Tool Retrieval in preview for the Gemini Interactions API.
- The feature allows AI agents to load tool schemas on demand.
- Developers can keep hundreds of tools available without including every full parameter definition in each prompt.
- Tool Retrieval is designed to reduce input-token consumption and improve tool-selection efficiency.
- It supports Gemini 3.6 and later models, including Gemini 4 models.
- The feature also supports remote Model Context Protocol (MCP) servers.
- Google does not charge a separate fee for Tool Retrieval, but standard model token charges still apply.
What Is Google’s Gemini API Tool Retrieval?
Tool Retrieval is a feature that helps developers manage large tool libraries connected to AI agents.
An AI agent often needs access to external functions to complete tasks. These functions might include searching a database, checking an order, issuing a refund, sending an email, updating a customer record or retrieving information from a third-party application.
To use these functions, an AI model needs to understand what each tool does and what information it requires.
Developers normally provide this information through tool schemas. A schema describes a tool’s name, purpose, parameters and required inputs.
The problem is that an agent connected to dozens or hundreds of tools may need to receive a large collection of these definitions repeatedly.
Google’s Tool Retrieval changes that process.
Instead of loading every complete tool definition into the model’s context immediately, developers can defer the parameter schemas. The model initially sees the names and descriptions of available tools. When it identifies a tool needed for the current task, the API retrieves its full schema.
This means the agent can access a large collection of functions without carrying all their technical definitions in every prompt.
How Tool Retrieval Works
Google’s feature uses a mechanism called deferred loading.
Developers add a tool_search tool to their API request and set defer_loading: true on functions whose complete schemas should remain outside the initial context.
The model can still see the names and descriptions of those functions. When it needs one, it requests the relevant schema through Tool Retrieval.
The API then makes the schema available and the model generates the corresponding function call.
The process takes place within the same server-side interaction rather than requiring the developer to manually search for and insert every tool definition.
A Simple Example
Imagine an AI customer-service agent connected to 100 business functions.
These functions might include:
- Checking an order status.
- Issuing a customer refund.
- Updating delivery information.
- Searching customer records.
- Cancelling subscriptions.
- Creating support tickets.
- Sending confirmation emails.
Without deferred loading, the developer may need to send all 100 complete tool schemas with each request.
With Tool Retrieval, the model initially sees the available tool names and descriptions. If a customer requests a refund, the system can retrieve the complete refund-function schema without loading the definitions for unrelated tools.
The model then generates the required function call, and the developer’s application executes the actual operation.
This can reduce unnecessary context consumption, particularly when an agent has a large number of tools but uses only a small subset for each task.
Why Reducing Tokens Matters for AI Agents
Tokens are the units used by AI models to process text and other information.
Every tool definition included in an API request can contribute to input-token consumption. As developers connect more services and functions to an agent, these definitions can become a significant part of the prompt.
This creates several challenges.
Higher API costs: Sending large tool schemas repeatedly can increase input-token consumption and therefore API expenses.
Longer processing times: More information in the prompt can increase the amount of work required to process each interaction.
Context-window pressure: Tool definitions occupy space that could otherwise be used for conversation history, documents and task-specific information.
Tool-selection complexity: When an agent has many similar functions available, selecting the correct one can become more difficult.
Google says Tool Retrieval is designed to address these problems by making full parameter schemas available only when required.
However, the actual savings depend on how many tools an agent uses, how large its schemas are and how much other information is already included in the conversation.
Google Says Tool Retrieval Can Work With Hundreds of Tools
The feature is particularly relevant for developers building sophisticated AI agents.
Simple chatbots may require only a few functions. Enterprise agents, however, can connect to large collections of internal and external services.
For example, an enterprise AI assistant might need access to:
- Customer relationship management software.
- Financial and accounting systems.
- Human resources databases.
- Inventory management platforms.
- Enterprise search systems.
- Project management applications.
- Customer support platforms.
- Internal reporting tools.
Sending every full schema repeatedly can become inefficient.
Google’s approach allows developers to keep frequently used functions available immediately while deferring less frequently used tools.
The company also recommends leaving the most commonly used tools undeferred and using retrieval for the longer tail of less frequently accessed functions.
This creates a balance between fast access to important functions and reduced prompt size.
Tool Retrieval Supports Model Context Protocol Servers
Another important part of the announcement is support for remote Model Context Protocol servers.
MCP is an open standard that allows AI applications to connect with external tools, services and data sources through a common interface.
It has become increasingly important as developers build agents that interact with multiple applications.
Google says developers can set defer_loading: true on an MCP server tool to load the functions exposed by that server on demand.
This means developers can connect large MCP servers without manually including every available function in the initial tool definitions.
For companies operating complex agent systems, this could make it easier to connect internal applications and external services without creating unnecessarily large prompts.
Google Offers Both Server-Side and Client-Side Tool Retrieval
Google provides two approaches for retrieving tool definitions.
Server-Side Retrieval
In the default approach, Gemini handles the search for relevant tool schemas.
Developers do not need to create or maintain a separate search index for the deferred tools.
The model identifies the function it needs, and the API retrieves its full definition.
This approach is designed for developers who have a relatively fixed collection of tools.
Client-Side Retrieval
Developers can also manage retrieval themselves.
This option is useful when an application maintains its own tool registry, embedding index or user-specific permissions.
For example, an enterprise application may expose different functions depending on an employee’s role.
The application can search its own registry and return the relevant tool definitions to Gemini.
Client-side retrieval provides more control but introduces an additional network round trip because the developer’s application must perform the lookup.
The two approaches offer flexibility depending on how an AI agent is designed and where its tool definitions are managed.
Does Tool Retrieval Have Additional API Costs?
Google says Tool Retrieval does not have a separate charge.
However, developers still pay the standard input and output token rates associated with the Gemini model they use.
The feature adds a small fixed block of input tokens for the search functionality. Each retrieved schema is also billed as input and remains in the conversation context for subsequent interactions.
This means Tool Retrieval does not automatically make every agent cheaper.
Google’s documentation explains that the savings depend on whether the cost of schemas that are never retrieved exceeds the additional overhead introduced by the retrieval mechanism.
For agents with hundreds of large tool definitions, the feature could produce meaningful savings.
For agents with only a handful of tools, the additional search overhead could make retrieval more expensive than loading the schemas directly.
Google recommends measuring performance and token consumption using actual application traffic rather than assuming that deferred loading will always reduce costs.
Prefix Caching Could Become More Efficient
Google also highlighted compatibility with prefix caching.
Prefix caching allows AI systems to reuse previously processed portions of a prompt instead of processing the same information repeatedly.
This can help reduce processing costs and improve efficiency when agents send similar requests over multiple interactions.
With Tool Retrieval, deferred schemas are added later in the conversation rather than being included at the beginning of the prompt.
As a result, the initial system instructions, tool list and earlier conversation history can remain unchanged.
That can help preserve a reusable prompt prefix across requests.
However, developers should also consider the minimum prompt-size requirements for caching. Removing large tool schemas could cause some prompts to fall below the minimum size needed for caching benefits.
The overall result will therefore depend on the structure and size of each application.
Which Gemini Models Support Tool Retrieval?
Google says Tool Retrieval works with Gemini 3.6 and later models, including all Gemini 4 models.
The feature is currently available in preview through the Gemini Interactions API.
Developers should also note that it is not a universal feature across every Gemini API interface. Google’s announcement specifically identifies the Interactions API as the supported environment.
The preview status means developers should expect possible changes to the API before a general release.
Google has not announced a general-availability date.
What This Means for the Future of AI Agents
The announcement reflects a broader shift in AI development.
The next generation of AI applications is expected to do more than answer questions. Agents are increasingly being designed to interact with software, retrieve information, make decisions and execute multi-step workflows.
As these systems become more capable, they will need access to larger collections of tools.
However, giving an agent access to more functions also increases the complexity of managing its context, permissions and API costs.
Google’s Tool Retrieval addresses one part of this challenge by separating tool discovery from the complete technical information required to execute a function.
This could make it easier to build agents that interact with hundreds of services without repeatedly sending every parameter definition.
The feature also reflects increasing competition among AI companies to make agent development more efficient. Anthropic has previously introduced its own Tool Search Tool for Claude, alongside other advanced tool-use capabilities.
The competition is gradually moving beyond model performance toward the infrastructure and developer tools required to operate reliable AI agents at scale.
The Bigger Picture
Google’s Tool Retrieval launch highlights an important problem emerging as AI agents become more sophisticated: the cost of connecting models to the software they need to operate.
A powerful AI model is only one part of an agent. It also needs access to relevant tools, accurate instructions, application permissions and reliable execution systems. As the number of connected services grows, managing all their definitions becomes an increasingly important engineering challenge.
By loading tool schemas only when needed, Google is attempting to make large agent systems more efficient without requiring developers to build an entirely separate retrieval infrastructure. The feature does not eliminate API costs or guarantee savings, but it provides another way to manage the growing complexity of agent-based applications.
Looking Ahead
Developers will now be able to experiment with Tool Retrieval through the Gemini Interactions API and measure how it affects their applications’ token consumption, latency and tool-selection accuracy. Its usefulness will be particularly important for enterprise agents connected to large collections of business systems and remote MCP servers. Google may refine the feature as it receives feedback during the preview period.
The broader significance is that AI companies are increasingly competing to make agents practical for real business workflows, not just more capable at generating text. Reducing the overhead associated with tool access could help developers build larger and more efficient agent systems. Whether Tool Retrieval becomes a standard part of AI development will depend on its real-world cost savings, reliability and eventual general availability.
Get the day’s top stories in your inbox
One concise email. No spam, unsubscribe anytime.



