At Google I/O 2026, the company made a bet that looks subtle on the surface but may be the most strategically important developer product announcement of the event. Managed Agents in the Gemini API, launched on May 19, are not just another API endpoint. They represent Google’s attempt to abstract away every genuinely hard part of building production AI agents — sandboxing, tool execution loops, session management, environment persistence — and deliver them as a native platform primitive.

The message is direct: you no longer need to assemble your agent infrastructure from scratch.

What Managed Agents Actually Do

With a single API call, developers can now provision an isolated Linux environment where an agent — powered by the Antigravity harness running on Gemini 3.5 Flash — can reason, execute code, manage files, and browse the web autonomously. The agent does not just respond to prompts. It plans, iterates on its own output, calls external tools, and persists state across sessions, making multi-step workflows feasible without any custom infrastructure on your part.

Under the hood, Google has packaged everything that made Deep Research (their first managed agent, launched in December 2025) work and opened it up for any developer to customize. The Antigravity agent harness handles the orchestration. Gemini 3.5 Flash provides the reasoning engine — a model Google claims runs four times faster than other frontier models while outperforming Gemini 3.1 Pro across almost all benchmarks. And the Linux sandbox handles isolation, file management, and network access.

The result is that a single API call replaces what would otherwise require wiring together a VM, a tool-calling loop, a code execution sandbox, a browser automation layer, and a session store.

Define Agents in Markdown, Not Code

The most surprising design decision is how you define these agents. Instead of writing Python orchestration code with LangChain, CrewAI, or a custom loop, developers describe their agent in two plain markdown files:

  • AGENTS.md — Agent instructions, personality, and configuration.
  • SKILL.md — Tool definitions, capabilities, and available actions.

These files are versionable, reviewable, and readable by anyone who understands markdown. Google is betting that declarative agent definition will win over imperative orchestration — and they may be right. The insight is that most agent behavior can be described as a combination of instructions and permitted tools, not as branching logic in code. If you can write clear documentation, you can define a production-grade agent.

For developers who prefer a visual environment, Google AI Studio now includes managed agent templates in its playground. For those who work at the API level, the Interactions API handles everything programmatically.

Stateful Sessions and Security

Environments persist across API calls. A follow-up interaction resumes with all files, context, and state intact — no need to reload knowledge or reconstruct working memory. Sessions auto-delete after seven days of inactivity, and VMs spin down during idle periods to conserve resources, restoring state on the next request with a cold start.

On the security front, each agent runs in an OS-level sandbox. Network access is unrestricted outbound by default, but developers can configure an allowlist to restrict traffic to specific domains. Credential injection happens through an egress proxy with header transformations — credentials are never exposed inside the sandbox itself. For teams building internal tools or customer-facing agents that touch sensitive systems, this matters.

Pricing and Limits During Preview

Managed agents use a pay-as-you-go model based on Gemini model tokens and tool usage. A single interaction can trigger multiple reasoning loops, typically consuming 100,000 to 3 million tokens depending on task complexity. During the preview period, environment compute is not billed — you only pay for the tokens.

Each developer can have up to 1,000 managed agents. Early testers include Ramp, ResembleAI, Klipy, and Stitch, who have been using the system to handle everything from financial data extraction to media production workflows.

The Bigger Picture: Google’s Agent Stack

Managed Agents are the developer-facing surface of something much larger. The same Gemini 3.5 Flash model, the same Antigravity harness, and the same infrastructure that powers Deep Research, Gemini Spark, and AI Mode in Search is now available to any developer through an API.

This is the through-line of Google I/O 2026. Gemini 3.5 Flash is the reasoning engine. Antigravity 2.0 is the orchestration layer. Spark is the consumer agent. AI Mode in Search is the mass-market interface. And Managed Agents are the developer runtime. Together, they form a single distributed agent stack — and Google controls every layer of it.

The strategic bet is straightforward: if agents become the primary interface for software — if the boundary shifts from “the app” to “the task” — then owning the agent runtime is more valuable than selling model tokens alone. Managed Agents are the on-ramp.

Contrast with the Framework Approach

For the past two years, building a capable agent meant stitching together components from LangChain, CrewAI, AutoGen, and a half-dozen other frameworks. You would write glue code to connect an LLM to tools, implement a loop that decides when to call functions versus respond, configure a sandbox for code execution, and build a session store for multi-turn interactions. It worked, but it was bricolage — flexible, educational, and fragile.

Managed Agents do not invalidate that approach. LangChain and CrewAI remain excellent for prototyping, for experiments, and for teams that need maximum control over every layer. But Google is offering a credible alternative: a managed runtime that handles all of that infrastructure so you do not have to. For teams that want to ship an agent without operating a distributed system, the trade-off is obvious.

The Bottom Line

The real story is not that Google launched a new API feature. It is that Google is trying to make agent infrastructure invisible — to turn the hardest parts of building autonomous systems into a platform service that any developer can consume.

By lowering the barrier from “write orchestration code” to “write a markdown file,” Google is broadening the definition of who can build agents. You do not need to be a systems engineer. You do not need to understand sandbox escape vectors or session replication. You need to understand your use case and be able to describe it clearly.

That shift — from prompts to action, from framework tinkering to platform service — is what makes Managed Agents more than a feature launch. It is a bet on how software will be built in the agent era.