Google on July 7, 2026, added four capabilities to Managed Agents in the Gemini API: background execution for long-running tasks, direct integration with remote Model Context Protocol servers, custom function calling alongside built-in sandbox tools and a mechanism to refresh network credentials mid-session without losing an agent's existing state. The update was published on Google's official developer blog and authored by Philipp Schmid, Developer Relations Engineer at Google DeepMind, and Mariano Cocirio, Product Manager at Google DeepMind. Neither author's post included financial figures, adoption numbers or a broader rollout timeline beyond immediate availability.

Managed Agents sit inside Google's Gemini Interactions API, a system where a developer sends a single request and Gemini handles reasoning, code execution, package installation, file management and web browsing inside an isolated cloud sandbox, according to the company. That single-endpoint design was the core pitch when Google introduced the Managed Agents API at Google I/O 2026 on May 19, 2026, alongside the Gemini 3.5 model series and Antigravity 2.0, the company's agent-first development environment.

What changed on July 7

The most structurally significant addition is background execution. Previously, a developer calling the Interactions API had to hold an HTTP connection open for the full duration of a task; if that task involved cloning a repository, scanning thousands of lines of code or running a lengthy analysis, the connection itself became a point of failure. Google's post frames the old approach plainly: holding a connection open for long-running work is fragile.

The fix is a new parameter. Setting background: true on an interaction tells the API to run the task asynchronously on Google's servers rather than over a live connection. The API returns an interaction ID immediately, and the calling application can poll that ID for status updates, stream progress, or disconnect entirely and reconnect later once the agent has finished. Google's example code demonstrates the pattern with a task that clones a GitHub repository, searches the codebase for outstanding TODO comments and writes a summary - the kind of job that could run for minutes without a client needing to babysit the request.

Remote MCP server integration is the second addition. The Model Context Protocol, an open standard Anthropic introduced in November 2024, defines how AI systems connect to external data sources and tools. Google's update lets a managed agent connect directly to a remote MCP server at interaction time, alongside built-in sandbox tools such as Google Search or code execution. According to the company's documentation, developers can pass an mcp_server tool object specifying a name and URL, letting the agent query internal systems such as observability or telemetry servers without the developer first writing custom proxy middleware. Before this update, reaching a private database or an internal API from inside the sandbox required that kind of custom bridge code; the new integration removes that step for MCP-compatible endpoints.

Custom function calling is the third piece, and it works through what Google calls step matching. Built-in tools, such as code execution, continue to run automatically inside the sandbox. Custom, developer-defined functions behave differently: when the agent decides it needs to call one, the interaction transitions to a requires_action status, and the responsibility for actually executing that function - hitting a local API, querying a proprietary database, running business logic that lives outside Google's infrastructure - shifts to the client application. Google's sample code shows a weather-lookup function paired with code execution, illustrating how a single interaction can mix server-side sandbox work with client-side business logic without the developer building a separate orchestration layer to route between the two.

The fourth addition addresses a narrower but persistent operational problem: expiring credentials. Access tokens and short-lived API keys do not last forever, and until now a developer working inside a long agent session had limited options once a token lapsed. Under the July 7 update, a developer can pass the same environment_id from an earlier interaction alongside a new network configuration, and the new authorization rules take effect immediately, replacing the old ones. Google states that the sandbox's filesystem state, installed packages and cloned repositories all remain intact through the refresh - meaning a developer does not need to restart a session or re-provision an environment purely because a bearer token rotated.

The technical access path

Developers reach these features through the @google/genai JavaScript SDK, with equivalent support in Python and cURL documented in Google's separate Antigravity agent documentation. Google also points AI coding agents themselves toward a skill installer - npx skills add google-gemini/gemini-skills --skill gemini-interactions-api - a detail that reflects how much of the target audience for this update is now agentic tooling rather than only human engineers reading API docs directly.

The default managed agent identifier remains antigravity-preview-05-2026, the same Antigravity harness running on Gemini 3.5 Flash that Google introduced at I/O in May. That harness is explicitly the same infrastructure Google uses internally; the company's own materials state that developers get access to the technology and infrastructure that powers Google's own agents. The Interactions API also continues to support direct, non-managed calls to gemini-2.5-pro and gemini-2.5-flash on the same endpoint, separate from the managed-agent sandbox path.

Three tools were available when the Managed Agents API entered public preview in May: code execution, Google Search and URL context. The features Google added on July 7 - background execution, remote MCP connections, custom function calling and credential refresh - extend that initial tool set into what the company describes as capability for building reliable, production-ready agents, addressing what it characterizes as direct developer feedback.

Why this matters beyond developer tooling

None of the four features announced on July 7 are, by themselves, advertising or marketing products. They are infrastructure. But infrastructure choices inside Google's agent stack have repeatedly become the plumbing beneath tools that marketers, publishers and platforms eventually touch directly, and this update arrives inside a broader pattern PPC Land has tracked closely over the past several months.

The Antigravity harness underneath Managed Agents is not a side project. It is the same system Google has connected to Search itself, where Koray Kavukcuoglu, CTO of Google DeepMind, described the Antigravity SDK available to outside developers as identical to the one Google's own Search team uses to build agentic features. That structural point carries forward into this update: a developer using background execution or remote MCP integration in the Interactions API is working with the same class of infrastructure that already underlies Google's consumer-facing Search agents and the Gemini Spark background assistant.

The remote MCP addition is also notable because it slots into an increasingly crowded landscape of MCP implementations across advertising and marketing technology specifically. Google released its own open-source MCP server for the Ads API in October 2025, letting large language models query campaign performance, budget allocation and account structure through natural language rather than manual dashboard navigation. Since then, PPC Land has documented MCP-based integrations spreading across the sector: Amazon Ads moved its own server into open beta in February 2026, AdRoll and PubMatic built a cross-platform agent-to-agent diagnostic tool on the same protocol in April 2026, and Adform opened 29 read-only skills against its FLOW DSP as recently as this month. A managed Gemini agent that can now reach any of these remote MCP endpoints directly, without custom proxy code, lowers one of the practical barriers standing between "a protocol exists" and "an agent actually uses it in production."

There is a security dimension worth naming plainly, because Google's own recent history supplies a cautionary example. In February 2026, researchers at TruffleSecurity disclosed that ordinary Google Cloud API keys - credentials the company had long told developers were safe to embed in public code - silently gained the ability to authenticate against Gemini endpoints the moment a project enabled the Gemini API, exposing files and billable resources to anyone who found the key. PPC Land's coverage of that disclosure documented a scan that found more than 2,800 live, vulnerable keys, including some embedded in Google's own public-facing infrastructure. The July 7 credential-refresh feature does not address that specific vulnerability class - it solves an expiration problem, not a privilege-scoping problem - but it does mean more network credentials will be flowing through managed-agent sessions on an ongoing basis. Google's own separate documentation for the Managed Agents API on its Agent Platform advises developers to use least-privilege credentials, prefer short-lived tokens and review agent network access during initial development, guidance that sits somewhat in tension with a feature explicitly designed to keep long sessions running smoothly across credential changes.

The naming history around "Managed Agents" also bears mentioning, since it is directly relevant to anyone tracking competitive positioning in agentic infrastructure. When Google's Managed Agents API entered public preview on May 19, 2026, Anthropic - the company that originally developed the Model Context Protocol - separately announced its own product carrying the identical name, "Claude Managed Agents," on the same day at a developer event in London. The two products share a name but differ architecturally: Google's version runs exclusively inside Google's own infrastructure, while Anthropic's supports self-hosted sandboxes through third-party providers including Cloudflare, Daytona, Modal and Vercel. The July 7 update extends Google's version of that infrastructure without changing this underlying architectural distinction - a managed Gemini agent remains something a developer calls but does not host or inspect directly.

What the announcement does not say

Google's July 7 post is a feature announcement, not a usage report, and several practical questions it leaves open are worth flagging for anyone evaluating whether to build on this update now. The post does not specify pricing for background-executed interactions relative to standard synchronous calls, nor does it state whether background tasks consume quota differently. It does not disclose how long an agent can run in the background before timing out, nor whether there is a maximum polling interval or a hard ceiling on total background execution time. The custom environments referenced elsewhere in Google's Interactions API documentation carry a seven-day time-to-live, though the July 7 post does not restate that figure in the context of the new background-execution feature specifically, so whether it applies unchanged is not addressed in the material reviewed for this article.

The post also does not name specific enterprise customers, agencies or marketing platforms currently using Managed Agents in production, nor does it provide adoption figures for the feature set introduced in May. Compared to Google's practice on other recent announcements - where the company has published token-processing figures, user counts or specific benchmark comparisons - the July 7 post is comparatively spare on quantitative detail, consistent with its framing as an incremental developer-experience update rather than a headline product launch.

Timeline

  • November 2024 - Anthropic introduces the Model Context Protocol as an open standard for connecting AI applications to external systems.
  • July 2025 - Google begins exploring MCP server integration for its own Ads API.
  • October 7, 2025 - Google releases an open-source MCP server for the Ads API, enabling natural-language queries against campaign data.
  • November 18, 2025 - Google launches Gemini 3, introducing generative UI and the Antigravity agentic development platform.
  • February 2026 - Amazon Ads moves its own MCP Server into open beta.
  • February 25-26, 2026 - TruffleSecurity discloses that Google Cloud API keys silently gain Gemini authentication privileges once the Gemini API is enabled on a project.
  • April 23, 2026 - AdRoll and PubMatic announce a cross-platform, MCP-based agent-to-agent diagnostic integration.
  • May 19, 2026 - Google launches the Managed Agents API in public preview at Google I/O 2026, alongside Gemini 3.5 and Antigravity 2.0; Anthropic separately announces its own "Claude Managed Agents" product the same day.
  • July 1, 2026 - WebKit publishes its Safari MCP server for Safari Technology Preview 247.
  • July 7, 2026 - Google adds background execution, remote MCP server integration, custom function calling and network credential refresh to Managed Agents in the Gemini API.

Summary

Who: Google, through Philipp Schmid, Developer Relations Engineer at Google DeepMind, and Mariano Cocirio, Product Manager at Google DeepMind, announced the update. It affects developers building on Managed Agents within the Gemini Interactions API.

What: Four new capabilities for Managed Agents in the Gemini API - background execution of long-running interactions via a background: true parameter, direct integration with remote Model Context Protocol servers, custom function calling that runs alongside built-in sandbox tools, and network credential refresh that preserves an agent's existing filesystem state and installed packages.

When: Google published the announcement on July 7, 2026, on its official developer blog, with the features available immediately through the @google/genai SDK.

Where: The features apply to the Gemini Interactions API globally, accessible to any developer with API access; Google also documents equivalent usage through Python and cURL via its Antigravity agent documentation.

Why: Google states the changes respond directly to developer feedback and are intended to help developers build reliable, production-ready agents capable of operating asynchronously inside real development environments rather than being constrained by a single open connection, custom integration code for external tools, or manual credential management across long sessions.