Google Rolls Out Managed Agents Inside the Gemini API

Google is quietly rewriting what it means to “call an API.” The Gemini API doesn’t just return model outputs anymore – it now lets you spin up fully managed AI agents that think, plan, write code, browse the web, juggle files, and keep state, all from a single call. In other words, Google is taking the messy infrastructure work behind serious “agentic” apps and stuffing it behind one endpoint.

If you’ve spent the last year watching AI “agents” go from buzzword to GitHub rabbit hole, this move will feel like a turning point. Instead of wiring together sandboxes, tool runners, vector stores, and retry logic yourself, Google is saying: point your request at our managed agents, describe the behavior you want, and we’ll handle the guts.

And yes, it even has a sci-fi name: Antigravity.

At the heart of this launch is the Antigravity agent, Google’s new general-purpose managed agent built on Gemini 3.5 Flash. When you call it through the Interactions API or Google AI Studio, Google provisions an ephemeral Linux environment on its side – a real sandboxed machine – and drops an agent inside that can reason, call tools, execute code, manage files, and browse the web.

That code execution piece is a big deal. Antigravity can run Bash, Python, and Node.js, install packages, run tests, build small apps, and read or write files inside the sandbox. Those files persist across interactions, so you can iterate: first ask it to scaffold a project, then come back and have it refactor a specific module, then run tests, all in the same backed-up environment. It’s essentially giving every request its own little cloud devbox, without you touching a VM or container.

On top of that, Antigravity has built-in web access: it can hit Google Search and fetch arbitrary URLs to pull in fresh data. Combine that with long-context support – Google says it automatically compacts context around roughly 135k tokens to keep sessions going – and you get an agent that can run genuine multi-step workflows instead of just answering a single prompt.

Google has actually been dogfooding this idea for a while. Late last year, it quietly shipped Deep Research, a managed agent designed for complex, multi-step research tasks like market analysis or due diligence, and that product ran on the same internal harness that is now being exposed through the Gemini API. With managed agents, Google is taking that internal scaffolding – the orchestration, sandboxes, tool loop, web access, and persistence – and handing it to developers as a configurable platform.

If you’ve tried building your own agent system from scratch, you already know where all the pain lives. You don’t just “call the model” – you need to create a planning loop, choose or build a framework, manage execution in a secure sandbox, plug in tools, store state somewhere, and then harden it all for production. It’s fun for a weekend project, but it gets brittle fast.

Google’s pitch with managed agents is pretty simple: you shouldn’t have to reinvent that harness every time you want an AI-powered workflow. The managed agents use a pay-as-you-go model, billing based on Gemini tokens plus whatever tools get used, and under the hood, an interaction can spin multiple reasoning loops as the agent plans, acts, observes, and repeats until it’s satisfied with the result.

Crucially, this is still “just” an API. You aren’t deploying containers or managing an agent runtime cluster; you’re making a single call to the Antigravity agent or to a custom managed agent, and the platform handles provisioning the Linux environment, running code, preserving state, and cleaning everything up when you’re done. That’s very different from stitching together a model API, a separate sandbox service, a file store, and a vector database yourself.

This is also where Google is leaning into its scale advantage. The same harness that powers Antigravity and Deep Research is used internally across Google’s own agents, and now third-party developers are sitting on that same infrastructure instead of rolling their own. To put it bluntly: Google wants your “agent stack” to look a lot more like “just call Gemini, we’ll do the rest.”

Where this gets interesting for developers is the customization story. Google isn’t just giving you a generic agent; it’s letting you define your own agents using a surprisingly simple abstraction: markdown files.

Instead of wiring up orchestration logic in a framework and scattering behavior across configs and code, you can describe an agent, its behavior, and its skills in files like AGENTS.md and SKILL.md, then register that definition as a managed agent. Those files become versionable artifacts – you can check them into Git, ship them through your regular release process, and treat “agent behavior” as something you manage alongside your application code.

On top of that, Google is shipping a Gemini API agent skill specifically to help coding agents scaffold and manage these custom agents. That’s a very “eat your own dog food” move: you can use an agent to help you build other agents, from adding new skills to restructuring your AGENTS.md configuration.

From a developer’s perspective, this has a few immediate benefits:

You can start from the Antigravity agent as a sane default – reasoning, planning, code, files, web – then layer your own instructions, tools, and data on top.
You get a consistent, production-grade harness that will behave the same way in your prototypes and in your shipped products.
You get a configuration surface that’s legible to more than just the person who wrote the orchestrator – product teams can read and review the markdown specs.

It’s a subtle but important shift: instead of every company inventing its own private agent framework, Google is trying to standardize on “managed agents + markdown definitions + the Gemini API.”

There’s also a bigger enterprise story here, and it’s clearly one of the reasons this product exists. On the consumer and indie developer side, managed agents live in the Gemini API and Google AI Studio, but for larger organizations, they’re also being wired directly into the Gemini Enterprise Agent Platform in private preview.

That platform, announced around Google Cloud Next, is essentially “mission control” for AI agents in the workplace – a place to build, scale, govern, and optimize fleets of agents across business units. It includes things like Agent Identity, which gives each agent a cryptographic ID so its actions are traceable against defined authorization policies, and an Agent Registry that acts as a central library of approved agents and skills.

That governance layer matters. When you scale from one or two experimental bots to hundreds or thousands of agents touching sensitive systems, you suddenly care about audit trails, permissions, and who can deploy what. The Managed Agents API is designed to sit inside that environment, giving enterprises the same sandboxed, config-driven runtime as indie developers, but wrapped in controls that IT and security teams can actually live with.

Taken together, the messaging is pretty clear: Gemini isn’t just a family of models, it’s a full agent stack. You can talk to a model directly, or you can outsource whole workflows to managed agents that live inside a governed sandbox, whether you’re a solo dev or a Fortune 500 IT org.

One interesting thing about this launch is that it doesn’t really come out of nowhere. Over the past year, the industry has been converging on “agentic” patterns – planning loops, tool use, memory, self-correction – and a wave of open source frameworks like LangGraph, CrewAI, LlamaIndex, and others have helped popularize the idea of building rich agent workflows on top of model APIs.

Google has been participating in that ecosystem, publishing guidance on how to build agents with Gemini using those frameworks, from function calling to more advanced self-correction and dynamic planning strategies. Managed agents are not an attempt to replace all of that; they’re Google’s answer to the question: what if the harness itself lived right next to the model, with first-class support for code execution, web browsing, and long-running sessions?

You can imagine a pretty natural split. Some teams will keep using open frameworks to build complex, multi-agent systems wired into custom infra, especially when they have very specific requirements. Others will be happy to let Google own the sandbox, the tool loop, and the context management, and focus on the product layer: what should the agent do, how should it talk, which internal data should it see.

The pricing model – pay-as-you-go based on model tokens and tool usage – also hints at where this is going. If agentic workloads become the default way people interact with AI systems, the unit of work stops being “one prompt, one response” and becomes “one workflow, many steps, one agent call.” Google wants that agent call going through its Gemini API and its managed agent runtime.

For developers, the practical question is simple: what can you actually build with this that you couldn’t build before?

The honest answer is that most of what managed agents can do was technically possible already – you could wire up a model, a sandbox, a set of tools, a search API, a database, and an orchestration framework and arrive at something similar. The difference now is the friction. A lot of the hardest, least glamorous parts of building production-grade agents have been moved behind a managed surface, wrapped in markdown configs and a single endpoint.

That opens the door for smaller teams – or even solo developers – to ship experiences that look suspiciously like the advanced agents Google is building for itself. You can prototype in Google AI Studio using ready-made templates, tweak your AGENTS.md until the behavior feels right, then drop that same configuration into your app and let the Gemini API handle the orchestration.

It also raises the bar for what “calling an AI API” means. If we look back a year or two from now, the idea of manually managing sandboxes and writing custom tool loops for every new agent may feel as dated as hand-rolling your own web server instead of dropping your code on a serverless platform.

Google isn’t alone in chasing that future, but with managed agents on the Gemini API, it’s staking out a very specific position: the future of AI apps is not just better models, it’s better agents – and those agents will live inside managed runtimes that abstract away most of the infrastructure we wrestle with today.