Gemini API Gets Managed Agents at Google I/O 2026: Spin Up a Coding Agent With One API Call

Among the developer announcements at Google I/O 2026 today, the one with the largest knock-on effect for backend teams is Managed Agents, a new addition to the Gemini API that lets developers provision an agent with a single API call and have it execute multi-step work in an isolated Linux environment.

For anyone who has built an agent system from scratch in the last two years, this is the announcement to read carefully. Google is shipping what most teams currently glue together themselves.

What Managed Agents Actually Do

According to Google’s developer blog, a Managed Agent provides:

Reasoning over instructions and incoming context
Tool use with built-in and developer-defined tools, including third-party MCP integrations
Code execution inside an isolated Linux environment
Persistent state that survives across multi-turn sessions
Customization via markdown-defined templates that specify instructions and available skills

The agent runs as a managed resource on Google infrastructure. You hit the Interactions API (Google’s name for the long-running agent endpoint) with a single call, the agent provisions itself, and you stream back the results. Sessions are resumable, so an agent can pause for a half-hour while it waits on an external job and then pick up where it left off.

Under the hood, the same agent harness powers Antigravity 2.0, Google’s repackaged developer platform that launched the same morning. The model defaulted to inside both is Gemini 3.5 Flash, which Google co-developed alongside the harness specifically for long-horizon autonomous work.

The Single-API-Call Pitch

The headline feature is provisioning latency. From SiliconANGLE’s coverage of the keynote: developers can “spin up new agents that can reason, use third-party tools and execute code in isolated Linux environments with a single API call.”

A useful comparison: building this yourself today, you would need:

A sandbox (Docker, Firecracker, E2B, Daytona, or a custom container runtime)
Tool definitions and a tool-routing layer
Session persistence so an agent can survive across calls
Cost accounting and rate limiting
Auth, networking, and egress controls
Whatever observability layer your team prefers

Managed Agents collapses items 1 through 5 into the API call itself. Item 6 (observability) is the one Google didn’t talk about in detail; the keynote mentioned “tracing and evals” without committing to specifics.

The pricing model wasn’t fully laid out either. Google says Managed Agents bill against existing Gemini API quotas with surcharges for the isolated execution environment (CPU-seconds, storage, and network egress). Exact rates will go live in the Gemini API pricing page “in the coming days.”

How It Differs From What Anthropic and OpenAI Offer

The comparison everyone will make: how does this stack against Anthropic’s Code Execution tool and OpenAI’s Assistants API.

Anthropic ships Code Execution as a single tool you can attach to a Claude call. It gives you a sandboxed Python environment, file persistence, and tool composition. It does not give you the agent loop, session management, or multi-step orchestration; you build those on top yourself with the Anthropic SDK or Claude Code.

OpenAI’s Assistants API (now deprecated and replaced by the Responses API) bundled threads, retrieval, and tool execution into a managed object. The new Responses API is closer to a stateless inference primitive, with developers building agent loops on top.

Managed Agents is closer to where the deprecated OpenAI Assistants API was headed, but with the agent loop and isolated execution environment as first-class pieces of the platform. The bet is that most teams don’t actually want to assemble the harness themselves; they want a managed agent primitive they can call from any backend.

Custom Agent Templates

Custom templates are the second piece that matters for production teams. You write a markdown file that specifies:

The agent’s high-level instructions
The skills it has access to (built-in or custom)
Any model parameters (temperature, sampling, max steps)

You upload the template to Google AI Studio or the API, and Managed Agents spins up new instances against it. The same template can be served from Antigravity, the SDK, and the API, which means the same agent behaves identically across all three surfaces.

This is the part Google clearly built to compete with Anthropic’s Skills primitive, which lets Claude load packaged capabilities at runtime. The shape is different (Skills are runtime-loadable; Managed Agents templates are deploy-time), but the goal is the same: package agent behavior into a reusable artifact teams can ship and version.

Where This Hits the Market

A few practical takeaways:

Backend teams running their own agent infra. If you have an existing harness running on Firecracker microVMs or E2B sandboxes, the question is whether the operational savings of moving to Managed Agents outweigh the lock-in to Google’s harness and pricing model. For early-stage teams, the answer is almost certainly yes. For larger teams already paying for sandbox infrastructure, it depends on what model flexibility you need.

SaaS products embedding coding agents. The hardest part of shipping a Cursor-competitor or a Claude Code-competitor is the harness, not the model. Managed Agents removes the harness build from the equation. Expect a wave of new agentic dev tools to ship in Q3 2026 built directly on top.

Enterprise teams worried about compliance. Managed Agents runs in Google Cloud, which means data residency, audit logging, and the rest of the GCP compliance posture apply. For teams that previously couldn’t use Claude Code or Cursor in regulated environments, Managed Agents on Vertex AI is a more credible path than rolling a self-hosted harness.

Teams already on Antigravity. Managed Agents is the same harness exposed differently. If you’ve prototyped a workflow in the Antigravity desktop app and want to call it from a backend job, the API is the bridge. No need to re-implement anything; the same template runs in both places.

The Concern

The risk with Managed Agents (and with the Antigravity SDK that ships alongside it) is the same risk every cloud-hosted agent platform has. You’re now paying Google to run the agent loop, not just the inference. If the loop is inefficient (too many tool calls, too much context), you pay for that inefficiency at Google’s margin. If you’ve optimized your own harness aggressively over the last year, moving to a managed version probably costs more, not less, even if it removes the operational burden.

This is the trade-off every team will need to evaluate. Google is betting that, for most teams, the agent loop is not where they want to specialize. The teams that disagree have the SDK to keep building their own. The teams that agree get a managed primitive they can call from anywhere.

The Strategic Frame

Read together, today’s three developer announcements are one announcement: Google is treating “agent platform” as the new center of gravity for developer tools. Gemini 3.5 Flash was trained for it. Antigravity 2.0 is the developer-facing UI and CLI for it. Managed Agents is the API surface for it. The bet is that “vibe coding,” autonomous coding agents, and long-running background tasks all converge into the same primitive: a managed agent you instantiate, configure, and call.

Whether that bet pays off depends on what Anthropic and OpenAI ship in response. Both have agent harnesses internally; neither has shipped them as a public managed product. Google moved first today. The next eight weeks will tell us whether the move sticks.

Sources: