Google today put Tool Retrieval into preview in the Gemini API, a mode that lets an AI agent keep most of its tools out of each prompt and fetch a tool's full definition only when a task calls for it. Announced in a three-minute post by Lucia Loher, a product manager on the Gemini API, and Nora Kassner, a research scientist at Google DeepMind, the feature works only in the Interactions API and on Gemini 3.6 and later models, carries no separate fee, and follows near-identical designs from Anthropic in November 2025 and OpenAI in March 2026, down to the name of the flag that switches it on.

In Short

Google has added an option to its Gemini developer platform that lets AI agents hooked up to dozens or hundreds of tools carry only a one-line note about each tool, pulling in the full instructions for a tool only when a job needs it. That matters to anyone building agents on top of advertising platforms' AI connectors, where every connected tool's full definition has until now been resent, and billed, with every request. Google gives no figure for the savings, and its own documentation shows that each lookup adds a billed pass of its own, so the effect on cost depends on how many tools an agent has and how often it goes looking for one.

One new tool and a flag

"Today we're launching Tool Retrieval in the Gemini API, available in preview in the Interactions API," the post begins. Published on Google's blog under the Developer tools and AI tags, it runs to two code samples and a pricing section. There is no benchmark, no customer name and no general availability date.

The problem it addresses is stated in a single paragraph. "When an agent connects to dozens or even hundreds of tools, sending every full parameter schema on every request adds up fast," according to Google. "It inflates input token counts, adds latency, and lowers tool-selection accuracy as the candidate list grows." Google attaches no number to any of those three effects.

Some background explains why the schemas pile up. In conventional tool calling, a developer declares every function an agent is allowed to use, and each declaration includes a parameter schema: a structured list of the function's arguments, their types and which of them are required. The whole set travels with each request, so the model can read it before deciding what to call. Every schema consumes tokens, the units in which model providers meter and bill text, and every schema takes room in the model's context window, whether the task at hand needs that tool or not.

Tool Retrieval splits each declaration in two. The name and a short description stay in the prompt. The parameter schema stays out until the model asks for it.

How it works, according to Google

According to the post and the documentation it links to, server-side Tool Retrieval runs in six steps.

  1. The developer adds a tool_search tool to the tools array of an Interactions API request. Exactly one tool_search tool is allowed per request, according to the documentation, which also states that the feature is in preview and requires the v1beta version of the API.
  2. The developer sets defer_loading: true on each tool to be held back. This works on individual function declarations and on entire remote MCP servers, the connectors through which software vendors publish tools for AI agents. Google's sample code defers "50+ other deferred functions" and carries the comment "leave frequent tools undeferred"; the post says the most-used tools can stay loaded up front while "the long tail" is deferred.
  3. The model sees a compact listing. It "still sees the name and description of every deferred tool, so it knows what's available, but the parameter schemas stay out of context," according to the post. The documentation is more specific: each deferred tool adds one line containing its name and an optional short_description field, or the first sentence of its full description if no short description is set.
  4. The model requests a tool by name. It emits a tool_search_call step whose arguments, in Google's example, are a list of function names.
  5. The API loads the schema. A tool_search_result step returns the full declaration, parameters included.
  6. The model calls the function. A normal function_call step follows, the developer's own code executes it and returns a function_result. "From here it's normal function calling," according to Google.

Steps four to six happen, in Google's words, "all inside the same request." Google's example is a customer-service agent asked to refund 40 dollars on a damaged order, A-1042. The model searches for a function called issue_refund, receives its schema, which takes an order_id string and an amount number, and emits a call with {"order_id": "A-1042", "amount": 40}. All three steps are recorded in interaction.steps, which the post describes as a way "to inspect which tools the model considered when debugging tool names or descriptions."

"There's no index to build or host," according to Google. "Gemini runs the search on the server, so the only changes to your code are the new tool and a flag on the tools you want to defer."

What the post calls a search is, in its own example, a selection: the model names the function it wants from a list it already holds. Neither the post nor the documentation explains how the server matches tools beyond that.

Remote MCP servers and the cached prefix

Two further claims in the post bear directly on agents that sit on top of third-party platforms.

The first concerns servers built on the Model Context Protocol. "Tool Retrieval also works with remote MCP servers in the Gemini API," the post says. Setting defer_loading: true on an mcp_server tool means "every tool that server exposes is loaded on demand, so you can connect a large server without listing its tools one by one." The mcp_server tool object itself is recent: Google added remote MCP server support to the Interactions API on July 7, 2026, alongside background execution for long-running agent tasks.

The second concerns caching. Model providers charge less for input that repeats exactly from one request to the next, but only while the opening stretch of the prompt, the prefix, stays unchanged. A schema inserted near the top would break that. "Deferred schemas stay out of the start of the prompt, and the schemas the model loads are added later in the conversation, so the cached prefix stays the same from turn to turn," according to Google.

The point is not academic. When a16z analysed agent traffic on the OpenRouter network in August, it found that more than 85% of agentic token burn sat in the cached prompt, and that agents used close to five times as many tokens as human users. For Gemini 4 Argon, Google priced cached input at 95% off the standard input rate. A feature that disturbed the cache would cost more than it saved; Google's claim is that this one does not.

Client-side retrieval for companies with their own registry

A second mode hands the search to the developer. Companies that run their own tool registry, embedding index or per-user permission filter, the three cases the post names, can declare the tool_search tool with "execution": "client" and define their own search parameters. In Google's sample, the tool is named search_tools and takes a single query string.

The model then emits an ordinary function call to that search tool. The application runs the lookup against its own systems and returns matching function declarations in a function_result, in a follow-up request that references the earlier one through previous_interaction_id. According to Google, this costs one additional round trip per search, because the application rather than Google runs the lookup.

The trade-off buys flexibility. "Tools do not need to be declared upfront," according to the post, so an agent can be handed new tools mid-conversation, for instance "when a user connects an integration." With a per-user permission filter, the application rather than Google decides which tools a given user's agent can reach. Server-side and client-side retrieval cannot be mixed in a single request, according to the documentation.

What it costs

"Tool Retrieval has no separate charge," according to Google. "Input and output tokens are billed at the standard rates for the model you call." That does not make it free. Read together, the post and the documentation set out how the bill is built.

Billing component What Google says Source
The feature itself "no separate charge" Blog post
Turning on tool_search "a small, fixed block of input tokens"; size not given Blog post
Each deferred tool's listing line About 26 tokens per deferred tool in early testing Documentation
Each schema the model loads Billed as input "for the rest of the conversation, the same as a tool declared up front"; cannot be unloaded Blog post and documentation
Each server-side search An additional model call in the same request, reading the full context plus the loaded schemas; reported as total_tool_use_tokens and billed at the input rate; every further search in the request adds another pass Documentation
Each client-side search One extra round trip between the application and the API Blog post

The last two rows matter most, and only one of them appears in the post. The blog describes the search, the schema load and the function call as happening "inside that single API call." The documentation confirms that they share one request, and adds that inside it the API runs a second model call over the whole context to process the search. For a long conversation with a large context, that pass is not small.

Google's own conclusion is hedged. Savings arrive when the schemas never loaded outweigh the ones that are, "which is the usual case for large libraries," according to the post, which closes its pricing section by telling developers to measure the effect "against your own traffic."

How much does the listing itself cost? At about 26 tokens a line, a library of 100 deferred tools adds roughly 2,600 input tokens to every request, by PPC Land's calculation. At Gemini 4 Hydrogen's published rate of $1.50 per million input tokens, that is about $0.004 per request, or about $3.90 per thousand requests, before any schema is loaded, any search pass is run or any output is generated (PPC Land calculation). What the same 100 tools would cost with full schemas cannot be calculated from Google's material, because neither the post nor the documentation gives an average schema size.

Which models qualify, and a discrepancy

"Tool Retrieval works with Gemini 3.6 and later models, including all Gemini 4 models, in the Interactions API," according to the post. The documentation narrows that statement. It lists four supported model codes and says requests that set defer_loading on any other model return a 400 error. The older generateContent method does not support the feature at all.

Model Covered by the blog's wording In the documentation's supported list API price per million tokens, input / output (PPC Land coverage)
Gemini 3.6 Flash Yes ("3.6 and later") Yes (gemini-3.6-flash) $1.50 / $7.50
Gemini 3.7 Flash Yes ("3.6 and later") No Not covered here
Gemini 3.8 Flash Yes ("3.6 and later") Yes (gemini-3.8-flash) Not covered here
Gemini 4 Argon Yes ("all Gemini 4 models") Yes (gemini-4-argon) $2 / $10 (introductory)
Gemini 4 Carbon Yes ("all Gemini 4 models") No $2 / $10 (introductory)
Gemini 4 Hydrogen Yes ("all Gemini 4 models") Yes (gemini-4-hydrogen) $1.50 / $7.50

Gemini 4 Carbon, which Google made generally available on November 10 at the same introductory price as Argon, appears nowhere on the documentation page. Neither does Gemini 3.7 Flash, one of the models Google listed for agentic video understanding on September 1. Whether the post or the documentation is out of date, Google does not say. Prices for Gemini 3.6 Flash come from its July 21 launch; the code samples in today's post call gemini-4-hydrogen.

The rules in the documentation

Beyond pricing and models, the documentation sets out several constraints that the post does not mention. In paraphrase:

  • Nothing unloads. Once the model has loaded a tool's schema, there is no way to remove it from the conversation.
  • The full tool list travels every time. The API does not carry tool declarations from one request to the next, even when previous_interaction_id is passed, so the complete tools array has to be sent with every request in a conversation.
  • Named tools cannot be deferred safely. If a tool's name appears in the system instructions or in another tool's output, the documentation says it should not be deferred. Otherwise the model may call it without searching first, and the next request fails with an error beginning Server side tool call context must be circulated.
  • A miss is silent. A query that matches no deferred tool produces a text response rather than a structured retrieval error, and the documentation warns against relying on a tool_search_result step to detect a miss.
  • One mode per request. Server-side and client-side retrieval are mutually exclusive within a request.
  • Subject to change. The API surface may change before general availability.

The first and third rules have practical weight for advertising agents. A schema loaded early in a long session keeps being billed until the session ends. And agent builders commonly name key tools in their system prompts, which the documentation says disqualifies those tools from deferral.

Third to the same idea

Google's post does not mention any other company. The design, however, is not new.

Anthropic OpenAI Google
Announced November 24, 2025 March 5, 2026, with GPT-5.4 November 19, 2026
Feature name Tool Search Tool Tool search Tool Retrieval
Flag defer_loading: true defer_loading: true defer_loading: true
Status at launch Beta Responses API, models from GPT-5.4 on Preview, Interactions API only
Published token figure 85% reduction, from about 77,000 to about 8,700 tokens 47% reduction in total token usage across 250 tasks on 36 MCP servers None
Published accuracy figure Claude Opus 4 from 49% to 74%, Opus 4.5 from 79.5% to 88.1%, on MCP evaluations None found None

According to Anthropic's engineering post, its Tool Search Tool marks deferred tools with defer_loading: true and, in Anthropic's own testing, cut token usage by 85%. According to The Next Web's report of the GPT-5.4 launch, OpenAI measured a 47% reduction in internal tests; OpenAI's tool search documentation describes deferring large sets of tools and grouping related tools into namespaces. Both companies' figures come from their own tests on their own models, and neither is directly comparable with the other.

Google's version therefore arrives almost a year after Anthropic's, using the same parameter name. Like OpenAI's, it lets a developer defer an entire MCP server in one step and choose between server-side and client-side search. It brings no published result of its own, which leaves its accuracy claim, that tool selection degrades as the candidate list grows, without a Gemini-specific number attached.

Why tool counts matter to advertisers and agencies

The marketing industry has spent the past year turning its platforms into tool libraries for AI agents. Google released an open-source MCP server for the Google Ads API on October 7, 2025, with two read-only tools; version 0.0.6, released November 2, 2026, brought the count to seven, four of them write tools. Amazon opened its Ads MCP Server in beta on February 2, 2026. Meta opened its ads MCP server to any developer with a Meta app on July 16, covering campaigns, audiences, catalogs, reporting and lift studies. X's Ads MCP launched on August 24 with 23 tools. And Adform said on September 21 that its FLOW platform exposes "more than 800 functions" to AI assistants through MCP.

An agent that manages campaigns across several of those platforms at once is precisely the case Google's post describes: dozens of tools, and in Adform's case potentially hundreds. Under conventional tool calling, every one of those schemas is resent with every request. Under Tool Retrieval, each becomes a single line until needed.

Tokens are also becoming a budget line. Agencies have started metering AI agents by the token, with PMG setting daily token caps per user and Brainlabs running tiered allowances. Google itself has added hard limits twice this year: project spend caps for the Gemini API in March, after billing errors left some developers with unexpected charges, and real-time spend caps that pause Gemini agents in Google Cloud in October.

Accuracy carries its own cost in an ad account. An agent that picks the wrong function out of a long list does not simply waste tokens; it can change the wrong setting. Google's post says accuracy falls as the candidate list grows and that Tool Retrieval is "designed to" keep selection accurate. It offers no measurement of either.

There is a pattern here, too. In September, Google's agentic video mode cut tokens per query by up to 88% at standard rates with no feature fee, and published benchmark tables to show it. Today's feature follows the same commercial logic, standard rates and no surcharge, without the tables.

What the post does not say

Google gives no token saving, no accuracy figure, no latency figure and no size for the "small, fixed block" that tool_search adds. Neither the post nor the documentation sets a maximum number of deferred tools, explains how server-side search matches a request to a tool beyond its name, gives a date for general availability, or mentions availability outside the Interactions API in the Gemini API.

Key facts

  • Feature: Tool Retrieval in the Gemini API, enabled by a tool_search tool plus defer_loading: true on deferred tools
  • Status: Preview; Interactions API only; requires the v1beta API version; generateContent not supported (documentation)
  • Source: "Introducing Tool Retrieval in the Gemini API," Google blog, November 19, 2026, by Lucia Loher (Product Manager, Gemini API) and Nora Kassner (Research Scientist, Google DeepMind); 3 min read; tagged Developer tools and AI
  • Documentation: https://aistudio.google.com/docs/tool-retrieval (no update date shown)
  • Execution modes: server-side (default; Gemini runs the search) and client-side ("execution": "client"; the application runs the lookup; one extra round trip per search); mutually exclusive within a request; one tool_search tool per request
  • Step types: tool_search_call, tool_search_result, function_call, then the developer's function_result; recorded in interaction.steps
  • Optional field: short_description on deferred function declarations, used instead of the full description in the listing
  • MCP: defer_loading: true on an mcp_server tool defers every tool the server exposes
  • Supported models (blog): "Gemini 3.6 and later models, including all Gemini 4 models"
  • Supported models (documentation): gemini-4-hydrogen, gemini-4-argon, gemini-3.8-flash, gemini-3.6-flash; others return a 400 error
  • Pricing: no separate charge; standard input, cached and output rates; about 26 tokens per deferred tool listing in early testing; loaded schemas billed as input for the rest of the conversation; each server-side search adds a model pass reported as total_tool_use_tokens and billed at the input rate
  • Sample model in Google's code: gemini-4-hydrogen

Timeline

Summary

Who: Google, through a blog post by Lucia Loher, product manager for the Gemini API, and Nora Kassner, research scientist at Google DeepMind. The feature is aimed at developers building AI agents on the Gemini API, including those connecting agents to advertising platforms' MCP servers.

What: Tool Retrieval, a preview mode in which an agent's deferred tools appear in the prompt as a name and short description, and a tool's full parameter schema is loaded only when the model asks for it. Search runs on Google's servers by default or in the developer's own application. Google charges no separate fee, but tokens are billed at standard rates, including about 26 tokens per deferred tool and an extra model pass for each server-side search, according to the documentation. Google publishes no savings or accuracy figures.

When: Today, November 19, 2026, in preview with no general availability date. Anthropic shipped a comparable feature on November 24, 2025 and OpenAI on March 5, 2026.

Where: The Gemini API's Interactions API, v1beta, on Gemini 3.6 and later models according to the post; the documentation lists four supported models and omits Gemini 4 Carbon and Gemini 3.7 Flash.

Why: According to Google, sending every tool's full schema on every request inflates input tokens, adds latency and lowers tool-selection accuracy as an agent's tool library grows. For marketers, the number of tools available to agents is rising quickly as Google, Amazon, Meta, X and Adform publish their ad systems through MCP, while agencies have begun to meter and cap the tokens those agents consume.