Gemini API tooling updates: what builders need to know about combined function calling

Here at industry sources, we tracked Google's latest Gemini API updates and found three concrete additions that shift how developers build tool-using agents. First: you can now combine custom function calling with Google's built-in tools - Search, Maps grounding, and others - in a single API call. Previously, this required orchestration across multiple calls or workarounds. Second: context circulation lets models reuse and refine context across multiple turns without redundant API overhead. Third: Maps integration adds geographic grounding directly into Gemini 3, reducing the friction of location-aware reasoning.

The technical shift matters because it collapses workflow complexity. Instead of chaining calls or building middleware to coordinate tools, your prompts and functions work alongside Google's managed tools natively. This is table-stakes for agentic systems - you need clean tool composition to handle multi-step reasoning without balloons in latency or token cost.

Context circulation is the efficiency play. When your agent reasons through a problem over multiple turns, the model can now hold and refine context without re-parsing the same information. For builders, this reduces token bloat on long-running tasks - think customer support agents or iterative research workflows where context depth matters but token counts blow up fast.

• Combine custom functions + built-in Google tools in one call - no orchestration required
• Context circulation reduces redundant re-processing across multi-turn conversations
• Maps grounding enables location-aware reasoning without external geo APIs
• Available now on Gemini 3 models via the Gemini API

If you're building autonomous systems, this update simplifies the tool layer. Before: you'd write orchestration code to call your custom functions, then conditionally call Google Search or Maps, then parse results back into the model loop. Now: describe all tools - yours and Google's - in a single function schema. The model chooses which to use. This is less code, fewer failure points, and cleaner retry logic.

The Maps grounding specifically matters for location-based agents. Real estate search, field service dispatch, local commerce - these used to need external geolocation services bolted in. Now that reasoning path is built in. If you're shipping an agent that needs to understand geographic context, you can skip that integration sprint.

Context circulation hits harder for long-horizon tasks. Customer support bots that handle 10-turn conversations, code analysis agents that examine multiple files, research assistants that iterate on queries - these all benefit from efficient context reuse. You're paying per input token, so any reduction in re-parsing the same context is margin you keep. This isn't flashy, but it's operational.

• Single tool schema replaces multi-layer orchestration code
• Cleaner error handling because the model sees all tools at once
• Maps grounding eliminates dependency on external geolocation libraries
• Context circulation reduces per-token cost on iterative workflows
• Easier to debug agent decisions when tool selection is unified

Google is moving fast on the agent stack. These updates underscore that they're treating tool composition as a core product, not a feature. OpenAI's function calling is mature, but it doesn't have built-in Google Search or Maps grounding - you still integrate those yourself. Anthropic's tool use is solid, but again, no native integrations. Google's advantage here is data moat - they own Search and Maps, so they can optimize the integration in ways competitors can't match.

That said, native integrations create lock-in risk for builders. If your agent relies on Google Maps grounding and Search, switching models later is friction. That's a consideration. For many use cases - especially location-aware or real-time information tasks - the benefit outweighs the switching cost. For others, staying tool-agnostic might matter more.

The broader signal: we're past the 'can AI use tools' phase and into 'how do we compose tools efficiently at scale.' That's a builder problem, not a model problem. Whoever makes tool composition easiest and cheapest wins. Google's bet here is that their data integrations tip the scale.

• Google owns the integrations (Search, Maps) - advantage in optimization but risk of lock-in
• OpenAI and Anthropic have function calling but no built-in data integrations
• Tool composition efficiency is becoming a key differentiator between platforms
• Native integrations reduce time-to-agent but increase platform dependency

First move: if you have an agent in flight, audit your tool architecture. Are you managing multiple tool calls externally? Is context bloat a performance drag? If yes to either, test whether moving to unified Gemini function calling with the new updates improves latency or cost. Run a side-by-side comparison on a production workflow.

Second: if you're building location-aware or real-time info agents, prioritize testing Maps and Search grounding. Don't assume your current external integrations are cheaper or faster. Google's integration cost is opaque in the API pricing, but integration time is zero. Run the math.

Third: understand the lock-in trade-off. Document which parts of your agent rely on Google-specific tools versus portable function calling. This isn't a show-stopper, but it's a decision worth making explicitly. If your entire agent logic hinges on Maps grounding, that's different from using it as one optional path.

The momentum in this space continues to accelerate.

• Benchmark your current multi-tool orchestration against unified Gemini function calling on real workloads
• Test Maps and Search grounding on location or real-time agents - measure latency and token cost vs. external APIs
• Map your agent architecture to identify hard Google dependencies vs. portable tool calls
• Plan for tool composition patterns that minimize vendor lock-in if multi-model support is a long-term need