Coding & agentsGoogle / Introducing Tool Retrieval in the Gemini API

Gemini Tool Retrieval: check the boundary between discovery and execution

Google introduced Tool Retrieval in preview on November 19. The Gemini Interactions API can load tool schemas on demand, but developers still need to distinguish discovery, execution, authorization and the full cost of a completed task.

A moss-green coding orc selects one copper-handled screwdriver from a lavender tool pegboard beside a closed plum tool chest with a copper latch.
Conceptual illustration.

A preview for agents with growing tool catalogs

Google launched Tool Retrieval on November 19 for the Gemini Interactions API. Instead of placing every parameter schema in the initial prompt, developers can keep less-used tools available for discovery. Google presents reduced latency, token use and better tool selection as benefits; they are vendor claims that need checking against an application’s actual workload.

For a coding assistant connected to issue tracking, deployments and documentation, the practical question is whether it finds the right operation without making the entire catalog expensive to carry. A useful trial should also reveal what happens when two tools sound similar, a capability is unavailable, or a user’s access changes mid-task.

Follow discovery through to the actual operation

Server-side retrieval uses a tool_search entry and defer_loading: true on selected function or mcp_server tools. Names and descriptions remain visible while full parameter schemas wait. Google’s example proceeds from tool_search_call to tool_search_result and then to the requested operation. A discovered schema is therefore an intermediate step, not evidence that the task finished.

The function-calling documentation distinguishes custom functions, which your application executes, from remote MCP tools that the API can run through the connected server. Trace the appropriate path. A schema being returned, a call being proposed and a verified external result should remain separate events in a deployment record.

Choose the retrieval mode and preserve permission checks

The preview requires v1beta and supports the Interactions API, not generateContent. Client-side retrieval uses tool_search with execution: "client"; your application searches its registry and returns matching declarations. It adds a round trip and can fit a catalog that varies by user. Do not combine this mode with defer_loading, which configures server-side retrieval.

Codorc’s recommendation is to filter discovery to the current user and check authorization again when executing an operation. Retrieval ranking cannot establish whether an account may modify a repository or deploy a service. Google’s function-calling guidance separately calls for validating calls and using appropriate authentication. Include an access-revoked case in the evaluation, with no real deployment required.

Keep state and tools consistent across turns

The Interactions overview says previous_interaction_id preserves conversation history, while tools, system_instruction and generation_config are scoped to each interaction. Resend the applicable configuration on later turns, including a turn that returns a tool result. Treat the registry supplied now as an explicit configuration choice rather than assuming history carries it forward.

The retrieval guide also requires preserving retrieval steps and their opaque signatures unchanged in stateless history. Inspect steps for function_call instead of relying only on requires_action status. For a changing registry, record which definitions and permissions applied to each call; a previous successful invocation is not a current access grant.

Measure the whole request and conversation

Google says Tool Retrieval has no separate charge, but search instructions add input and loaded schemas are billed in the continuing conversation. The usage reference identifies total_tool_use_tokens for additional model calls inside a request, billed at the input rate. Counting only the first prompt can therefore miss part of the work.

The caching guide says the Interactions API supports implicit caching, not manually managed explicit caches. Cache savings depend on actual hits. Compare latency and total billed usage over completed tasks, including searches, tool results, retries and unsuccessful attempts. A smaller initial prompt alone does not establish a cheaper or more reliable agent.

Six checks before expanding a tool library

These are proposed application checks, not results from an executed API integration or benchmark. Use a harmless test registry and predetermined expected outcomes:

  • Keep the model, task, repository revision and tool catalog fixed while comparing static and deferred loading.
  • Include two similarly named tools and a no-match task. Record the selected capability and whether the agent describes the limitation accurately.
  • Exercise a denied operation and access revoked between discovery and execution. Verify that application authorization still blocks the action.
  • Continue a conversation after a tool result and after a registry change. Check that current definitions and configuration are supplied deliberately.
  • Retain the complete trace, external outcome and billed usage for every attempt. Separate schema discovery, call proposals and actual execution.
  • Set acceptance criteria for correctness, latency and total task cost before rollout. Keep the previous configuration available if the preview behaves differently.

Event dates refer to the original announcement. Publication dates show when this article first appeared on Codorc.

Continue reading

All stories
A moss-green coding orc measures a copper connector with a caliper beside a lavender port and a small cream ceramic llama.
Coding & agentsggml-org / Hugging Face

llama.cpp 1.0: check API and ABI before upgrading

The November 13 llama.cpp and ggml releases introduce explicit library compatibility boundaries. For an existing integration, review removed APIs, keep headers and binaries aligned, and check RPC peers before changing the deployed build.

A moss-green coding orc adjusts a copper control wired to lavender repository tiles while a separate glass scanning head rests unlit on a wooden arm.
Coding & agentsGitHub

GitHub AI Scan API: enablement is not a completed scan

GitHub’s November 13 update adds repository_scan controls to its AI Scan REST API. Teams can manage rollout settings in code, but policy inheritance, failed combined updates and manual scans still need separate checks.

A small moss-green workshop robot fits lavender interface components into a brass window frame beside organized component trays.
Coding & agentsGoogle Developers

A2UI 1.0: check renderer support before migrating

Google announced A2UI’s first stable protocol on November 11. For developers, the useful next step is a version-by-version integration check: a stable protocol does not mean every renderer or host has completed its upgrade.