Google Managed Agents API: Agents in a Single Call

Google's Managed Agents API launched on May 19, 2026 as a public preview, giving any developer the ability to spin up a Gemini 3.5 Flash agent with code execution, web search, and URL fetch in a single Interactions API call — no orchestration framework, no sandbox provisioning, no agent loop to maintain.

The timing produced the week's sharpest narrative collision: on the same morning, at Code with Claude London, Anthropic added self-hosted sandboxes and MCP tunnels to its own product — also called "Managed Agents." Two frontier labs, one product name, opposite runtime philosophies. Google's version runs exclusively inside Google's infrastructure; Anthropic's runs in yours.

This guide covers what Google actually shipped: the Interactions API surface and its previous_interaction_id state model, the Antigravity harness that powers the runtime, which tools are available in preview and which are gated, how preview pricing works, and how the three managed-agent primitives from Google, Anthropic, and OpenAI now sit side by side. For the full Google I/O 2026 announcement roundup, see our hub post.

The cleanest story of the week is a naming accident that happened in real time. Google I/O 2026 went live on May 19 with "Managed Agents in the Gemini API" — a hosted agent runtime accessed via the Interactions API. Hours later, at the Code with Claude London event, Anthropic announced self-hosted sandboxes and MCP tunnels for its own product: "Claude Managed Agents." Both products share every word of the name. Neither team knew the other was shipping.

The architectural difference is the story. Google's Managed Agents runs exclusively inside Google's infrastructure — the antigravity-preview-05-2026agent ID is a Google-hosted runtime you cannot move or inspect at the infra level. Anthropic's Managed Agents is explicitly multi-tenant: the session can run on Anthropic's cloud or inside your own perimeter via self-hosted sandbox providers (Cloudflare, Daytona, Modal, Vercel). Same product category, opposite trust models. This is not a minor implementation detail — it maps directly to compliance, data sovereignty, and vendor lock-in decisions.

OpenAI's position is the third pole: the OpenAI Agents SDK (openai-agents, v0.17.3 as of May 2026) runs in your process against the Responses API and is provider-agnostic — supporting 100+ LLMs including non-OpenAI models. The "Sandbox Agents" pattern in that SDK (using UnixLocalSandboxClient) is the local-process equivalent, not a hosted runtime.

The broader implication: the "managed agent" category has split into at least three distinct runtime models in the span of one week. The table in section 07 maps all three against each other. For a detailed look at Anthropic's same-day Code with Claude London launch, see that companion post.

Google's pitch is in one sentence from the announcement: "With a single call, you can now spin up an agent that reasons, uses tools and executes code in an isolated, ephemeral Linux environment." The mechanics behind that sentence are worth unpacking.

The consumer endpoint is POST https://generativelanguage.googleapis.com/v1beta/interactions. The enterprise / Vertex path is POST https://aiplatform.googleapis.com/v1beta1/projects/{PROJECT_ID}/locations/{LOCATION}/interactions. In both cases, the request body replaces the standard model field with an agent field pointing to a managed agent ID. The response is an interaction object with a status, an output, and an environment ID for follow-up calls.

Each interaction runs in an isolated, ephemeral Linux sandbox hosted by Google. The sandbox has no implicit outbound network — network access must be explicitly configured per agent. Google's docs describe it as "secure Google-hosted remote environments" without specifying the isolation technology (virtualization layer, syscall filtering, or similar). Do not assume a specific isolation primitive; the spec says "isolated ephemeral Linux environment."

The interaction status field reports six states: in_progress, requires_action, completed, failed, cancelled, incomplete, and budget_exceeded. For long agent loops, set background=True to offload the loop server-side and poll with the interaction ID, or set stream=True to receive Server-Sent Events as the agent runs.

The Interactions API is a new unified RESTful surface for stateful and agentic workloads. It extends generateContentwith server-side state, agent execution, and tool orchestration — but it does not replace it. Google's migration guide is explicit: "generateContent remains the primary path for standard production workloads; we recommend the Interactions API for all new development" involving agents or stateful sessions. Teams running existing generateContent integrations have no forced migration.

The key new body field is previous_interaction_id. Pass the ID returned from a prior interaction to resume the session with all files and state intact inside the same sandbox environment. Google's own description: "Each interaction creates or receives an environment, which you can use in follow-up calls to resume the session with all files and state intact." Custom environments have a 7-day standard TTL; you can also pre-load Cloud Storage data into the sandbox file system at creation time.

Sessions can be forked. Passing the same previous_interaction_id from two different new requests creates two divergent branches off the same parent — useful for A/B exploring agent paths without re-paying setup cost. The thinking_level parameter from Gemini 3.5 Flash is also available via generation_config.thinking_level (string enum: minimal | low | medium | high, default medium). See our Gemini 3.5 Flash benchmarks and API guide for a full treatment of the thinking parameter surface.

The architectural parallel between the Interactions API and OpenAI's Responses API is deliberate and observable in the specs. Both use a single unified endpoint, both model state via a previous_*_idpattern, and both expose a tool catalog as first-class fields on the request body. Google's version adds the hosted-sandbox layer — the agent runs inside Google's infrastructure rather than calling out to external tools you host. That is the meaningful architectural delta.

The default managed agent ID is antigravity-preview-05-2026. This is Google's Antigravity harness running Gemini 3.5 Flash — the same infrastructure that powers Google's own coding products. Google's announcement states: "You get access to the same technology and infrastructure that powers our own agents." The Interactions API also supports gemini-2.5-pro and gemini-2.5-flash for non-managed (direct model) calls on the same endpoint.

Custom agents replace orchestration code with versionable markdown files. AGENTS.md defines the agent — its purpose, constraints, and the list of skills it can invoke. SKILL.md defines individual invocable skills, using YAML frontmatter for metadata and a markdown body for the skill instructions. When a session opens, the agent reads the list of skill names and descriptions; when a task matches, the agent loads the full SKILL.md body. The result: agent behavior is version-controlled, reviewable, and deployable without a code change. For a detailed look at how Antigravity 2.0 fits the broader desktop-agent picture, see our Antigravity 2 deep dive.

This converges on a pattern emerging across all three frontier labs: markdown as agent runtime DSL. Google uses AGENTS.md / SKILL.md; Anthropic's tooling uses CLAUDE.md; the OpenAI Agents SDK uses instructions strings that are, in practice, markdown documents. The convergence on human-readable instruction files as the primary agent configuration surface is itself a signal about where the agent development model is heading.

The Interactions API schema declares a comprehensive tool catalog, but what's actually available for managed-agent runs during preview is a strict subset. The gap between the schema and the preview reality is the most practically important detail for any team evaluating this for production use.

Additional tool types declared in the schema but unavailable during managed-agent preview: google_maps, function_calling (custom functions), and structured output. These limits are reported by secondary coverage and should be treated as subject to change — the preview matrix may shift daily as Google opens capability flags. Always verify against the live Interactions API reference before shipping production workloads. If your use case requires MCP or custom functions, the current recommendation is to use the Interactions API in direct model mode (with model rather than agent) until those tool types are enabled for managed agents.

Google's pricing model during the preview period has two components. Sandbox compute — CPU time, memory, and execution duration inside the Linux environment — is not separately metered. Model usage is billed at standard Gemini 3.5 Flash rates, which apply regardless of whether the call is a standard completion or a managed-agent interaction.

The practical cost implication: an agent loop that generates 100K output tokens (reasoning traces + code + responses) costs approximately $0.90 in model usage at current rates, with sandbox compute free. At GA, compute charges will change that arithmetic. For teams evaluating managed-agent economics relative to self-hosted alternatives, the preview window is the right time to benchmark actual token consumption — the compute-free period gives you clean signal on the model-cost component before the full pricing materializes.

There are two access paths for the Managed Agents API: public preview on the Gemini API (available to any developer account) and private preview on the Gemini Enterprise Agent Platform (qualified enterprise customers on Vertex AI). The enterprise path adds the Vertex API endpoint, IAM-based access controls, and enterprise SLAs. Our AI transformation practice can help you evaluate which path fits your compliance and scale requirements.

Three managed-agent / agentic API primitives now exist from the major frontier labs. All three share a common architectural template — single endpoint, state via a previous_*_idpattern, built-in tool catalog — but diverge sharply on runtime location, sandbox model, and provider lock-in. The table below is the canonical cross-vendor reference for Q2 2026.

The choice axis is not primarily about model capability — all three can route to competitive frontier models. The real decision is runtime location and trust model. Google's hosted sandbox removes operational burden at the cost of full vendor dependency. Anthropic's self-hosted option adds operational responsibility in exchange for data residency control. OpenAI's local-first SDK gives maximum flexibility and provider optionality at the cost of running and paying for the execution environment yourself.

For teams building on multiple model providers, our OpenAI Agents SDK vs LangGraph vs CrewAI matrix covers the code-first framework tier, where ADK 2.0, LangGraph, and CrewAI sit. For the model-under-the-hood comparison on agentic coding benchmarks, see our Gemini 3.5 Flash vs GPT-5.5 vs Opus 4.7 head-to-head.

Google I/O 2026 didn't ship one agent product — it shipped a complete stack. The four tiers share the same Antigravity harness underneath but address fundamentally different developer personas and operational trade-offs. Most I/O coverage lists these products as a feature list. The more useful framing is a coordinate system: one axis is hosted vs. self-hosted runtime; the other is low-code vs. code-first orchestration.

The coordinate-system framing resolves most "which Google product should I use" questions: if you want Google to run the agent loop, choose Agent Studio (no-code) or Managed Agents API (REST). If you want to run the loop yourself, choose Antigravity for local development and ADK 2.0 for production multi-agent orchestration. All four tiers use the same Antigravity harness, which means agents authored for one tier can be promoted to another with minimal rework.

The ADK 2.0 GA is the most significant independent milestone in the stack. It adds Go, Java, and Kotlin (beta) alongside the existing Python and TypeScript support, and introduces the Agent-to-Agent (A2A) protocol for cross-layer and cross-vendor agent interop. ADK 2.0 is the code-first sibling to Managed Agents — you build the orchestration yourself instead of paying Google to host it, giving you full control over execution, cost, and observability at the trade-off of operational overhead.

Three near-term developments are worth tracking for any team evaluating the Managed Agents API for production roadmaps.

Preview-to-GA tool expansion. The most immediately consequential gap is the preview lock on file_search, computer_use, google_maps, function_calling, and mcp_server for managed-agent runs. Google has not announced a specific GA timeline for the Managed Agents API, but the declared tool schema suggests these capabilities are engineered — the preview limit is a feature-flag gate, not an architectural constraint. The mcp_server gap in particular is the most significant for teams building on the MCP ecosystem, since every other frontier managed runtime treats MCP as first-class.

Vertex AI enterprise path.The private preview on the Gemini Enterprise Agent Platform brings IAM-based access controls, enterprise SLAs, and the Vertex AI compliance posture to the Managed Agents runtime. As this path opens to broader enterprise access, regulated industries — financial services, healthcare, public sector — gain a viable hosted-agent option that inherits Vertex's existing compliance certifications. Watch for a GA announcement on the enterprise path to signal when production-scale regulated deployments become feasible without additional certification work.

Gemini CLI sunset — June 18, 2026. Google announced that the Gemini CLI will be sunset on June 18, 2026. Pro and Ultra customers using the CLI today must migrate to the Antigravity + Managed Agents stack before that date. This is the most immediate practical pressure for existing Gemini developer customers — not a theoretical future consideration, but a five-week migration window from the date of this post. The migration path leads directly into the Antigravity IDE and the Managed Agents API as the replacement developer surface.

The broader trend these three developments point to is a compression of the "agent deployment" surface area. Compute pricing, tool parity with self-hosted alternatives, and enterprise compliance are the three unlock conditions for wide production adoption. The preview window is the right time to benchmark agent loop economics and tool coverage against your specific workloads — before GA pricing changes the arithmetic. For teams building production-grade agentic workflows, our AI transformation engagements start with exactly this kind of comparative evaluation across managed and self-hosted runtimes.