Google introduced Tool Retrieval in preview on November 19, changing how agents expose large function libraries to Gemini. Instead of resending every parameter schema, developers can defer schemas until the model needs them.
The launch announcement places the feature in the Interactions API. Google positions it as a way to reduce input-token overhead and preserve tool-selection accuracy as libraries grow. Actual savings and reliability still depend on the application's workload.
Tool names remain visible while schemas wait
Developers enable server-side retrieval by adding a tool_search tool and marking selected functions with defer_loading: true. The model still sees each deferred tool's name and description. Its parameter schema stays outside context until requested.
When the model chooses a function, it asks for that function by name. The API loads the schema and the model produces a function call within the same request. The search call, retrieval result and eventual function call appear in interaction.steps, giving developers a record to inspect.
Google's example uses gemini-4-hydrogen to request a $40 refund for damaged order A-1042. The model retrieves issue_refund and emits the order and amount as arguments. The application must still execute the refund and return a function_result; schema retrieval does not itself move money or authorize a transaction.
That boundary is important for agents with sensitive tools. Better discovery does not replace application permissions, validation or business rules.
Server retrieval avoids hosting an index
The server-managed option requires no developer-hosted search index. Frequently used tools can remain fully declared, while occasional functions use deferred loading. Names and descriptions therefore remain important even when large schemas disappear from the initial context.
The feature also works with remote MCP servers. Setting defer_loading: true on an mcp_server lets its tools load on demand, without listing each one separately.
Google says retrieval works with prefix caching: deferred schemas stay out of the initial prompt, then enter later in the conversation when loaded. That arrangement keeps the cached prefix stable across turns. It does not mean subsequently loaded schemas become free.
Client lookup keeps the application's registry in control
Applications with an existing registry, embedding index or user-specific permission filter can choose client execution. They declare tool_search with "execution": "client", a search function and its parameters.
When the model asks to search, the application performs the lookup and returns matching function schemas through function_result. Google's continuation example uses previous_interaction_id to connect the follow-up to the existing interaction.
This approach adds a round trip for each search because the lookup runs in the application. In return, tools need not all be declared at the start. A newly connected integration can introduce tools during a conversation, and the application's own registry can determine the candidates returned.
That is a distinct trade-off from server-managed retrieval. Control over discovery comes with another application step and its associated latency and failure handling.
Token savings depend on which schemas stay unloaded
Tool Retrieval has no separate fee. Input and output tokens use the selected model's standard rates. Enabling tool_search introduces a small fixed input block, and each retrieved schema is billed as input for the rest of the conversation.
The potential saving comes from schemas that never enter context. A large library with a small relevant subset has more opportunity to benefit than a conversation that eventually loads nearly everything. Google recommends measuring against real traffic; its announcement supplies no universal percentage saving.
The preview supports Gemini 3.6 and later, including all Gemini 4 models, within the Interactions API. That scope should not be expanded to every API surface. For developers, the next useful evidence is the application's own token use, tool-selection behavior and client-lookup latency under those supported conditions.
