Google just made a quiet but significant move in the agent infrastructure war. On July 7, the company announced expanded capabilities for Managed Agents in the Gemini API — adding background task execution, remote Model Context Protocol (MCP) support, and a raft of reliability improvements that suggest Google is getting serious about developers actually shipping agent-powered products to production. Not just experimenting. Shipping.
Why Agent Infrastructure Matters Right Now
Here’s some context that gets lost in the feature announcement noise: building an AI agent that works in a demo is genuinely easy. Building one that works reliably for thousands of users, handles long-running tasks without falling over, and connects to real enterprise tools without bespoke glue code — that’s the hard part. It’s where most teams stall.
Google introduced Managed Agents in the Gemini API as a way to abstract away some of that complexity. Instead of developers stitching together their own orchestration layers, memory management, and tool-calling logic, Managed Agents handles a lot of the scaffolding. Think of it as the difference between building a server from scratch versus using a managed cloud service — the primitives are still there, but you’re not reinventing every wheel.
The timing isn’t accidental. OpenAI has been aggressively pushing its own Agents SDK and function-calling improvements throughout 2025 and into 2026. Anthropic’s Claude has earned a strong reputation among developers for instruction-following in agentic workflows. And open-source frameworks like LangChain and LlamaIndex have built enormous communities around agent orchestration. Google needed to close gaps — and fast.
What’s Actually New: A Breakdown
The announcement covers several distinct additions. Let me break them down properly, because grouping them all as “new features” undersells what some of these actually do.
Background Task Execution
This is arguably the most practically important addition. Previously, agents built on the Gemini API were fundamentally synchronous in nature — you send a request, wait for a response, move on. That works fine for short interactions. It falls apart completely for anything that takes more than a few seconds: processing a large document, running a multi-step research workflow, coordinating actions across multiple tools.
Background task execution lets agents run asynchronously. A developer can kick off a task, get a task ID back immediately, and then poll for results or receive a webhook callback when it’s done. This is how you build agents that can, say, spend 20 minutes autonomously pulling data from multiple APIs and assembling a report — without the user sitting there waiting, and without the developer having to build a custom async queue from scratch.
It sounds basic. In practice it’s the difference between an agent that’s a toy and one that’s useful for real work.
Remote MCP Support
The Model Context Protocol — originally developed by Anthropic and now increasingly adopted across the industry — is essentially a standardized way for AI models to connect to external tools and data sources. Instead of every developer writing custom integration code for every tool, MCP provides a common interface.
Until now, Gemini’s MCP support was largely local — useful for development environments but limiting for production deployments where your tools are running on remote servers. The new remote MCP support changes that. Agents can now connect to MCP servers running anywhere, which opens up integration with the growing library of MCP-compatible enterprise tools without custom connectors.
This matters because the MCP ecosystem has been growing quickly. There are now MCP servers for everything from GitHub and Slack to internal databases and custom business logic. Plugging into that ecosystem rather than fighting it is a smart move.
Additional Capability Improvements
Beyond those two headline features, Google outlined several supporting improvements:
- Improved session management — persistent context across multi-turn agent interactions, so agents can maintain state over longer workflows without context getting dropped or corrupted
- Better error handling and retry logic — production agents fail. The question is how gracefully. Managed Agents now includes more sophisticated handling for tool call failures and network issues
- Enhanced tool use reliability — more consistent behavior when agents are orchestrating multiple tool calls in sequence, reducing the “hallucinated tool call” problem that has plagued agentic systems
- Expanded model support within the framework — developers can now route different subtasks to different Gemini models depending on the complexity and cost requirements of each step
That last point is worth sitting with. Being able to use Gemini Flash for cheap, fast reasoning steps and reserve the heavier models for complex decisions is exactly how you build agents that are economically viable at scale — not just technically impressive in isolation.
What This Means for the Developer Landscape
Google is clearly trying to win on infrastructure, not just model quality. That’s a different kind of competition than the benchmark wars of 2024.
Here’s the thing: most enterprise developers aren’t choosing an AI platform based on which model scores 0.3% better on MMLU. They’re choosing based on which platform lets their team ship faster, debug easier, and not get paged at 2am because the agent got stuck in a loop calling a broken tool indefinitely. The Managed Agents additions — especially background tasks and better error handling — speak directly to those concerns.
The remote MCP support is also a subtle competitive move. Anthropic invented MCP and has strong native support. By fully embracing it rather than building a proprietary Google-only tool protocol, Google is saying it wants to play in the same ecosystem rather than fragment it. Developers who have already invested in building or integrating MCP servers don’t have to start over to use Gemini.
Compare this to the direction Gemini’s model lineup has been taking — faster, cheaper, more specialized models for different use cases — and you start to see a coherent strategy. The platform is being built for production economics, not just capability showcases.
That said, Google has a trust problem to work through. The company has a history of launching developer products with fanfare and then deprecating or significantly changing them — sometimes with limited notice. Developers building production agents on Managed Agents are making a real infrastructure bet. Google will need to demonstrate long-term commitment to these APIs in a way that goes beyond a blog post. Pricing stability and clear deprecation policies matter as much as features at this point.
Who Benefits Most
Not every team building with AI agents is going to feel this update equally. Here’s a rough breakdown of who gains the most:
Enterprise Development Teams
The background task execution and session management improvements are squarely aimed at enterprise workflows — the kind where an agent might need to spend significant time coordinating between internal systems, processing large datasets, or handling multi-step approval flows. If you’ve been frustrated by synchronous API limits, this is the update you’ve been waiting for.
Teams Already Using MCP
If your stack already includes MCP servers for tools like GitHub, databases, or internal APIs, remote MCP support in Managed Agents means you can potentially drop some custom integration code. That’s not nothing — integration code is where bugs live and where maintenance costs accumulate.
Startups Building Agent Products
The reliability improvements lower the floor for teams that don’t have the engineering bandwidth to build robust orchestration layers from scratch. A small team can now focus on what their agent actually does rather than how it handles failures, retries, and state management. For context on how agent deployment is evolving across the industry, it’s worth looking at how Gemini’s own personal intelligence features have been handling long-running user context — the underlying engineering problems are similar.
The developers least affected? Those already deeply invested in alternative orchestration frameworks like LangChain with custom backends, or teams using OpenAI’s Assistants API who’ve built significant tooling around it. Switching costs are real, and Google’s improvements, while meaningful, aren’t so dramatic that they’d justify a complete platform migration for a working system.
Key Takeaways
- Background task execution is now available in Gemini API Managed Agents, enabling genuinely async, long-running agent workflows
- Remote MCP support means Gemini agents can connect to the growing library of MCP-compatible tools without custom connectors
- Session management, error handling, and tool reliability improvements make this a meaningful production-readiness update, not just a feature addition
- Multi-model routing within a single agent workflow — mixing Flash and more capable models — creates real cost optimization opportunities
- The move to embrace MCP rather than build proprietary tool protocols signals Google’s intent to compete on integration breadth, not walled gardens
What is Gemini API Managed Agents?
Managed Agents is Google’s hosted infrastructure layer for building AI agents on top of Gemini models. It handles orchestration, tool calling, session state, and now background task execution — so developers don’t have to build those components themselves. It’s aimed at teams building production agent applications rather than one-off experiments.
How does remote MCP support work in practice?
Developers can now point Managed Agents at any MCP-compatible server running remotely — a GitHub MCP server, a custom internal tool, a database connector — and the agent can call those tools using the standardized MCP interface. Previously, MCP support in Gemini was primarily local, which limited its usefulness in real deployment environments.
When is this available and what does it cost?
Google announced these capabilities as of July 7, 2026, with availability through the Gemini API. Specific pricing details weren’t broken out separately from existing Gemini API pricing tiers — developers should check the Google AI developer portal for current API pricing, as costs will depend on model selection and usage volume.
How does this compare to OpenAI’s Agents SDK?
OpenAI’s Agents SDK has had async and background task support for longer, and its tool ecosystem is mature. But Google’s MCP adoption gives Managed Agents a potential interoperability advantage for teams already using MCP-based tooling. Neither platform has a definitive lead right now — the choice still comes down to which model family you prefer and where your existing integrations live. For a broader view of where OpenAI is pushing its own infrastructure, this piece on OpenAI’s engineering priorities offers useful context.
The agent infrastructure space is going to look very different in 12 months. Background tasks and remote MCP are table stakes — the real differentiation will come from reliability at scale, developer tooling quality, and which platform makes debugging a broken agent workflow something less than a nightmare. Google has moved in the right direction here. Whether it can maintain that momentum and actually earn developer trust over time is the more interesting question.
