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.
- The developer adds a
tool_searchtool to thetoolsarray of an Interactions API request. Exactly onetool_searchtool 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. - The developer sets
defer_loading: trueon 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. - 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_descriptionfield, or the first sentence of its full description if no short description is set. - The model requests a tool by name. It emits a
tool_search_callstep whose arguments, in Google's example, are a list of function names. - The API loads the schema. A
tool_search_resultstep returns the full declaration, parameters included. - The model calls the function. A normal
function_callstep follows, the developer's own code executes it and returns afunction_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_idis passed, so the completetoolsarray 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_resultstep 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 | ||
|---|---|---|---|
| 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_searchtool plusdefer_loading: trueon 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; onetool_searchtool per request - Step types:
tool_search_call,tool_search_result,function_call, then the developer'sfunction_result; recorded ininteraction.steps - Optional field:
short_descriptionon deferred function declarations, used instead of the full description in the listing - MCP:
defer_loading: trueon anmcp_servertool 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_tokensand billed at the input rate - Sample model in Google's code:
gemini-4-hydrogen
Timeline
- October 7, 2025 - Google releases an open-source MCP server for the Google Ads API with two read-only tools
- November 24, 2025 - Anthropic introduces its Tool Search Tool, which defers tools with
defer_loading: true - February 2, 2026 - Amazon opens its Ads MCP Server to AI agents in beta
- March 5, 2026 - OpenAI launches GPT-5.4 with tool search in its API
- March 2026 - Google adds project spend caps to the Gemini API
- July 7, 2026 - Google adds background execution and remote MCP servers to the Interactions API
- July 16, 2026 - Meta opens its ads MCP server to any developer with a Meta app
- July 21, 2026 - Google launches Gemini 3.6 Flash at $1.50 per million input tokens and $7.50 per million output tokens
- August 21, 2026 - a16z finds agents use close to five times as many tokens as humans, with more than 85% in the cached prompt
- August 24, 2026 - X launches its Ads MCP with 23 tools
- September 1, 2026 - Google's agentic video mode cuts tokens per query by up to 88% at standard rates
- September 4, 2026 - Agencies report metering AI agents by the token
- September 21, 2026 - Adform says AI assistants can reach more than 800 functions of its FLOW platform through MCP
- October 8, 2026 - Google Cloud adds real-time spend caps that pause Gemini agents
- October 13, 2026 - Google prices Gemini 4 Argon at $2 per million input tokens, with cached input 95% off
- November 2, 2026 - Google Ads MCP server version 0.0.6 brings the tool count to seven
- November 10, 2026 - Gemini 4 Carbon becomes generally available at $2 per million input tokens
- November 12, 2026 - Gemini 4 Hydrogen launches at $1.50 per million input tokens
- November 19, 2026 - Google puts Tool Retrieval into preview in the Gemini Interactions API
Related PPC Land coverage
- Google lets Gemini agents run background tasks without breaking connections - The July update that brought remote MCP servers and background execution to the Interactions API.
- Google cuts Gemini video analysis tokens by up to 88% in agentic mode - An earlier Gemini API token-saving mode, billed at standard rates and backed by benchmark tables.
- Google cuts Gemini Flash prices as 3.6 uses 17% fewer output tokens - The launch of the oldest model Tool Retrieval supports.
- Google Search gains Gemini 4 Hydrogen for all users, not just subscribers - The model in Google's Tool Retrieval code samples, and its API price.
- Google prices Gemini 4 Argon at $2 per million tokens, paid users only - Argon's introductory pricing and cached-input discount.
- Gemini 4 Carbon reaches AI Mode for $99.99 Ultra subscribers only - The Gemini 4 model missing from the Tool Retrieval documentation's supported list.
- Agents burn 5x more tokens than humans as Zapier traffic drops - a16z data showing where agent token spending concentrates.
- AI agents now buy media, so agencies are metering them by the token - How agencies cap and track token use by staff and agents.
- Google finally adds Gemini API spend caps - after billing chaos hit devs - Monthly per-project limits on Gemini API spending.
- Google Cloud adds project spend caps that pause Gemini agents at the limit - Hard spending limits for Gemini agents in Google Cloud.
- Google releases open source MCP server for Ads API integration - The first, read-only release of the Google Ads MCP server.
- Google Ads MCP server gains 4 write tools, still can't change budgets - The November update that took the server to seven tools.
- Amazon opens its advertising APIs to AI agents through industry protocol - The Amazon Ads MCP Server and its pre-built multi-step tools.
- Meta opens ads MCP to any app, cutting integration code to zero - Meta's ads MCP server and the areas of the ad system it covers.
- X Ads MCP gives Grok and Claude Code 23 tools to run ad campaigns - X's 23-tool ads server, with campaigns created paused.
- Adform says AI assistants can access 800 of its ad platform capabilities - Adform's claim that its FLOW platform offers AI assistants more than 800 functions through MCP.
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.
Discussion