Antigravity Agent | Gemini API | Google AI for Developers

Google just dropped the Antigravity Agent, a managed, sandboxed AI agent accessible via the Gemini API, fundamentally changing how developers deploy autonomous AI workflows. This isn't just another LLM endpoint; it's a complete runtime environment that reasons, executes code, manages files, and browses the web, all within a secure Linux sandbox hosted by Google.

The Agentic Leap: Beyond Pure LLMs

The Antigravity Agent isn't just a new model; it's a paradigm shift in how we build and deploy AI. You're not just calling an API to get text back; you're instantiating an autonomous worker in its own secure Linux sandbox. This general-purpose managed agent, powered by Gemini 3.5 Flash, uses the same robust harness as the Antigravity IDE, meaning it’s built for heavy lifting. It means your AI isn't just thinking; it's doing. A single API call kicks off an entire tool-use loop: the agent plans, acts, observes results, and repeats until the task is done. This radically simplifies orchestrating complex tasks that would otherwise require intricate prompt chaining and external infrastructure. The Antigravity Agent | Gemini API | Google AI for Developers stack offers a powerful, integrated solution for agentic AI.

A Linux Sandbox on Demand: Your AI's Private Playground

Every interaction with the Antigravity Agent provisions or reuses a dedicated Linux sandbox. This is huge. Forget about managing your own execution environments, dealing with dependencies, or worrying about security vulnerabilities from untrusted code. Google handles it. You get a clean, isolated environment every time you specify "remote" for the environment parameter, or you can reuse an existing environment by ID (e.g., "env_abc123") to preserve state and files. This means your agent can literally write and run Python scripts, compile C++ code, or execute Node.js programs without ever touching your local machine. The filesystem tools, which are automatically enabled when you set the environment parameter, let the agent read, write, edit, search, and list files within its sandbox. This level of integrated execution is a game-changer for iterative development and complex multi-step tasks. It provides a consistent, reproducible canvas for your AI to operate on, making debugging and deployment far more predictable.

Tools at Its Disposal: Code, Search, and Web Context

This agent comes pre-equipped with a powerful set of default tools designed for real-world tasks. Out of the box, it has code_execution, google_search, and url_context. code_execution isn't just theoretical; it lets the agent run shell commands, bash scripts, Python, or Node.js, capturing stdout and stderr. This means it can install packages, manipulate data, or test code directly. google_search gives it access to the entire public web, allowing it to find information, research topics, or verify facts. The url_context tool lets it fetch and read web pages, understanding their content for summarization or data extraction. You're not locked into these. You can limit the agent to specific tools, too. Say you only want it to research and summarize without running code:

from google import genai
client = genai.Client()
interaction = client.interactions.create(
    agent="antigravity-preview-05-2026",
    input="Search for the latest AI research papers on reasoning and summarize them.",
    environment="remote",
    tools=[
        {"type": "google_search"},
        {"type": "url_context"},
    ],
)
print(interaction.output_text)

This fine-grained control over available tools ensures your agent operates within defined boundaries, enhancing both security and predictability.

Multimodal Inputs: Images Fueling Agentic Reasoning

The Antigravity Agent doesn't just process text; it sees the world through image inputs too. This is a crucial capability for modern AI applications. You can provide base64-encoded data for images directly in your input, allowing the agent to analyze charts, understand diagrams, or interpret visual information alongside textual prompts. Imagine an agent that can not only read a financial report but also analyze the accompanying stock charts, then summarize trends. This multimodal input capability unlocks a new class of problems for autonomous agents, moving them beyond pure language processing into richer, more human-like understanding. It's a critical step towards agents that can truly interact with diverse real-world data.

import base64
from google import genai
client = genai.Client()
with open("path/to/chart.png", "rb") as f:
    image_bytes = f.read()
interaction_inline = client.interactions.create(
    agent="antigravity-preview-05-2026",
    input=[
        {"type": "text", "text": "Analyze this chart and summarize the trends."},
        {
            "type": "image",
            "data": base64.b64encode(image_bytes).decode("utf-8"),
            "mime_type": "image/png",
        },
    ],
    environment="remote",
)

This is a powerful primitive for building agents that can understand complex visual contexts, like UI mockups or data visualizations.

Customization and Control: Shaping Your Agent's Behavior

You're not stuck with a generic agent; you can deeply customize its instructions, skills, and overall behavior. The Antigravity Agent supports a straightforward, filesystem-native approach to customization. You can mount configuration files like AGENTS.md directly into the sandbox to provide detailed instructions or inject custom skills under a .agents/skills/ directory. This means you can define specific functions or workflows for your agent to use, making it highly specialized for your tasks. The beauty here is the iterative workflow: you can experiment with configurations inline during development, then save them as a managed agent when you're ready for production. This flexibility allows for rapid prototyping and continuous improvement of your agent's capabilities without needing to re-architect your entire system. It truly empowers developers to craft bespoke AI solutions.

Antigravity vs. Codex: The Managed Runtime Advantage

Comparing the Antigravity Agent to OpenAI's Codex reveals a key architectural divergence: the managed runtime. Both are powerful coding agents. Codex, as OpenAI's offering, excels at reading, editing, and running code within its own cloud environment, integrating deeply with GitHub for pull requests and issue management. It's fantastic for code-centric tasks, and its IDE extension for delegating work is a strong feature. However, Antigravity's explicit, API-driven Linux sandbox provisioning and integrated tools (like google_search and url_context built-in, not just code execution) give it a distinct edge for broader, more autonomous workflows.

Codex offers cloud environments, but Antigravity’s approach feels more intrinsically tied to the Gemini API ecosystem, making the sandbox a first-class citizen in every interaction. It's less about "running code for you" and more about "giving an agent a fully functional computer to accomplish a task." When you're building complex agentic UIs or even just debugging agent behavior that interacts with web elements, precise context for your prompts is non-negotiable. That's where tools like markagent come in. It captures exact DOM context, component names, and screenshots, exporting structured prompts that can feed directly into your agent pipeline, whether it's Antigravity, Codex, or another AI. The Antigravity Agent's explicit toolset and managed execution environment offer a powerful, integrated solution for complex, multi-modal, and truly autonomous agentic tasks, pushing the boundaries of what an API-driven agent can achieve.

The Cost of Autonomy: Understanding Agentic Workflows

Autonomy comes with a price, and it's not just token count anymore. The Antigravity Agent operates on a pay-as-you-go model, but you need to understand the billing dynamics. Unlike a standard chat request that produces a single output, an Antigravity interaction triggers an entire "agentic workflow." This involves an autonomous loop of reasoning, tool execution, code running, and file management. Each step in that loop consumes tokens and compute resources. Google provides estimated costs, which range from $0.30 for simple research tasks to over $3.25 for complex data processing. A single complex interaction can easily accumulate 3–5 million tokens, potentially costing up to $5.

The agent autonomously determines how many tool calls, code executions, and file operations are needed. This means tasks that seem simple on the surface might trigger a cascade of internal agent actions, increasing costs. For instance, "read Hacker News, summarize the top 10 stories, and save the results as a PDF" isn't a single API call; it's a sequence of url_context calls, summarization, code_execution for PDF generation, and filesystem operations. During the preview period, environment compute (CPU, memory, sandbox execution) isn't billed, which is a massive advantage for experimentation. But as this moves to general availability, optimizing agent prompts and tool usage to minimize unnecessary steps will become critical for cost-effective deployment. Understand the workflow, not just the prompt.

Limitations and What's Next

The Antigravity Agent is powerful, but it's still in preview. Key limitations exist. You can't currently customize parameters like temperature, top_p, top_k, or max_output_tokens directly for the agent's internal reasoning. Features like file_search, computer_use, google_maps integration, or advanced function_calling beyond the explicit tools aren't yet available. You also can't set an environment to run in background=True or store=True for persistent, always-on agent instances.

This is Google's opening salvo in the managed agent space. Expect rapid iteration. These limitations aren't roadblocks; they're signposts for future development. As the agent matures, we'll likely see more granular control over its reasoning parameters, a wider array of integrated tools, and more sophisticated environment management options. This is just the beginning for truly autonomous, API-driven agents.

The Antigravity Agent fundamentally redefines AI development, moving beyond simple API calls to managed, autonomous workflows. It's a powerful tool, providing a secure sandbox and integrated capabilities that push the boundaries of what AI can accomplish directly from an API. Get familiar with it now.