Google Ships Antigravity to Turn Weeks of Agent Setup Into One API Call

Google launches Managed Agents in the Gemini API, letting developers spin up sandboxed, tool-using agents on Google's infrastructure with one call.

·
·
·
Read6 min
TypeNews
TopicAgents · Api
  • Google launched Managed Agents in the Gemini API, provisioning a sandboxed Linux agent in one call.
  • Powered by the new Antigravity agent built on Gemini 3.5 Flash, accessible via Interactions API and AI Studio.
  • Agents defined declaratively as AGENTS.md and SKILL.md files, with Git repos and GCS sources mountable into the sandbox.
  • Native context compaction kicks in at around 135k tokens to prevent long-horizon agent context rot automatically.
  • Network egress is locked down by default; developers explicitly allowlist domains and inject credentials via header proxy.
  • Launch partners include Vercel AI SDK, LiteLLM, Agno, Eigent, and LlamaIndex for framework compatibility.

Google just shipped one of the more consequential pieces of its agent stack to the public. Managed Agents in the Gemini API are now available, turning what used to be weeks of sandbox plumbing into a single HTTP call. A single call now spins up an agent that reasons, uses tools and executes code in an isolated, ephemeral Linux environment, powered by the new Antigravity agent built on Gemini 3.5 Flash and available via the Interactions API and in Google AI Studio.

The pitch is simple: stop building agent infrastructure and start building agent behavior. Building a production-grade agent used to mean managing complex infrastructure, scaffolding and managing isolated sandboxes to serve customers as you prepare to scale. With Gemini Managed Agents, Google is abstracting away the complexity so you can focus on your product experience and agent behavior.

What actually ships when you make the call

Each call to the Antigravity agent provisions a remote Linux environment. Within that environment, the agent can plan tasks, call tools, and execute code. It can also manage files and browse the web to retrieve current information. Each interaction can create or receive an environment. That last bit matters more than it sounds: 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.

Anyone who has built an agent loop on top of a stateless code interpreter knows the pain this removes. In the past, code interpreter-like functions would restart a container with each call, losing all previously pip installed packages, written files, and history. Now the filesystem, installed dependencies, and conversation state live server-side between turns.

The two-API split

The surface area is intentionally small. The Interactions API is the runtime interface: send a task, get back an agent that reasons and acts. The Agents API is the control plane: define, register, and manage named agents with custom instructions, tools, skills, and environment configurations. In practice that means you register an agent once, then hit the runtime endpoint every time a user message comes in.

A minimal first call looks like this:

python
from google import genai
client = genai.Client()
interaction = client.interactions.create(
    agent="antigravity-preview-05-2026",
    environment="remote",
    input="Write a Python script that generates the first 20 Fibonacci numbers and saves them to fibonacci.txt."
)

You pass in the agent as "antigravity-preview-05-2026", which is the current version of the predefined general purpose managed agent, define environment="remote" to provision a fresh sandbox, and create an input defining what you want the agent to do.

Agents as markdown, not orchestration code

The customization story leans heavily on a file-based convention. Managed Agents let you bundle instructions, skills, tools, and an environment into a named agent you invoke by ID. Instead of writing complex orchestration code, you define everything declaratively in markdown files like AGENTS.md and SKILL.md and register them once. Those filenames aren't Google-proprietary either, they map to the emerging AGENTS.md and SKILL.md conventions that other agent tools are adopting.

Environments also accept external data at startup: Git repositories, Google Cloud Storage objects, or inline content can all be mounted into the sandbox before the agent starts working. So a custom agent definition can pull in a skills repo, drop in a system prompt, and reuse a base environment without you wiring any of that infrastructure yourself.

The context-rot problem, handled

One detail buried in the docs is genuinely useful. In long-running, multi-turn conversations, the raw history of reasoning steps, tool calls, and large file contents can quickly grow and consume significant context space. To prevent token limit errors and maintain the agent's focus, the Managed Agents API features a native context compaction step at around 135k tokens. This happens automatically. If you have ever hand-rolled a summarization pass to keep an agent from drowning in its own scratchpad, you get to delete that code.

Security defaults and the cost trap

Network egress is locked down out of the box. By default, every agent performs actions in a sandbox environment with no access to external systems, networks, or credentials. Opening it up is explicit: only specific domains or wildcard patterns added to the allowlist can be accessed by the agent's virtual machine, with patterns like api.github.com or *.googleapis.com. Required credentials can be injected as HTTP headers per domain, passed safely through an egress proxy and never exposed directly as raw text inside the agent sandbox.

The cost model deserves attention before you point this at production. Unlike a standard chat request that produces a single output, the Antigravity Agent executes an autonomous workflow. It plans, runs code, observes results, and iterates. This means a single prompt can result in unbounded token consumption. To manage costs, provide clear termination criteria in your prompts and scope the tasks narrowly for the agent.

Where to start clicking

The fastest on-ramp is the AI Studio Playground. It provides a visual interface to prototype managed agents without having to write API calls. You switch the Playground toggle to Agents and pick from templates that pre-configure the base Antigravity Agent with tool and environment settings. All the templates are open-source and published under the google-gemini/gemini-managed-agents-templates repository.

Where this fits in the broader agent race

Google is not the only vendor moving the agent runtime into the platform. Anthropic has framed managed execution around long-running work and harness design, AWS has added stateful MCP client capabilities to Bedrock AgentCore Runtime for multi-turn agent sessions, and OpenAI has also been expanding agent tooling for developers. The shared bet is that developers would rather rent a battle-tested sandbox and harness than maintain their own.

Google's specific angle is the bundling. The launch gives developers a capable general-purpose agent ready to use out of the box, a clean API for defining and deploying custom agents, and the Antigravity model that can reason and plan, call tools, execute code, manage files, and browse the web, all within a secure runtime Google manages on your behalf. For teams that have already built scaffolding around tools like the Vercel AI SDK or LlamaIndex, the good news is that Managed Agents work with the orchestration frameworks teams already use, with launch partners including Vercel AI SDK, LiteLLM, Agno, Eigent, and LlamaIndex, so existing workflows don't require a full rewrite.

Who should actually care

If you are gluing together a coding agent, a research assistant, a data-analysis bot, or any long-horizon workflow that needs to write files, install packages, and call tools across many turns, this collapses your stack. The trade-off is that the sandbox is Google's infrastructure, so anything that needs deep access to private databases, internal services, or bespoke toolchains may still want a self-hosted harness. For everything else, the orchestration layer largely disappears and you get to spend your time on the part that actually matters: what the agent should do, and when it should stop.

Trending
  • No trending articles

Comments

avatar

Next Reads