Google Antigravity SDK Released: A Minimalist Python Framework for Building AI Agents

Overview

On May 19, 2026, Google officially released the Antigravity SDK preview — a Python library that provides developers with programmatic access to Google's flagship Antigravity coding Agent. This SDK enables developers to build, prototype, and iterate on complex agentic applications on top of the Antigravity Agent Runtime with minimal code.

Core Architecture: Built on the Antigravity Runtime

The Same Runtime Engine Powering Antigravity 2.0

The Agent Runtime is the core infrastructure layer of modern AI Agent frameworks, responsible for orchestrating the complete execution loop of model inference, tool invocation, state management, and security policies. Unlike traditional software runtimes, an Agent Runtime must handle non-deterministic LLM outputs, asynchronous tool call chains, and multi-turn conversation state, making its design complexity far exceed that of ordinary application frameworks. This is precisely why Google chose to open up its internally validated, production-grade runtime directly to external developers rather than designing a simplified version from scratch.

The Agent runtime provided by the Antigravity SDK is identical to the underlying engine powering Antigravity 2.0 and the Antigravity CLI. This means your Agent inherits a powerful execution environment out of the box, including:

• A rich set of built-in tools
• A declarative security policy engine
• Lifecycle hooks for observing and steering each tool invocation
• Stateful multi-turn sessions that persist across interactions

More importantly, as the Antigravity runtime continues to improve (faster tool execution, smarter planning, better context management), these enhancements automatically flow into SDK Agents without any extra effort from developers.

Launch a Full Agent in Under 15 Lines of Code

Most developers only need a single Agent — an async with block manages the complete Agent lifecycle. The official example demonstrates building a fully functional Agent in under 15 lines of code:

import asyncio
from google.antigravity import Agent, LocalAgentConfig

async def main():
    config = LocalAgentConfig()
    async with Agent(config) as agent:
        response = await agent.chat("What files are in the current directory?")
        print(await response.text())

if __name__ == "__main__":
    asyncio.run(main())

What you might not notice is that the Agent logic is completely decoupled from where it runs. Google has promised that support for switching the local Agent loop to a remote hosted mode is coming soon — the same Agent can be deployed to the cloud directly without rewriting code. This design philosophy of transparent local/cloud switching aligns with the cloud-native "write once, run anywhere" philosophy and signals that Agent infrastructure will evolve toward a Serverless direction.

An SDK Designed for AI-Native Development

The SDK's design philosophy is highly forward-looking — it's not just a tool for building Agent applications, it's also Agent-friendly itself. If you're developing with Antigravity, you can have the Agent write, test, and iterate on SDK code directly within a development session.

The API surface uses clear Python types (Pydantic V2 models, native Python collections), structured outputs, and explicit naming conventions. Pydantic is the most widely used data validation library in the Python ecosystem, with V2 released in 2023, rewritten in Rust at the core for 5-50x performance improvements. Adopting Pydantic V2 in AI SDK design carries significant implications: it not only provides runtime type validation, but its schema export capability (JSON Schema) can be directly understood by LLMs, enabling closed-loop validation of structured outputs — the model generates JSON conforming to the schema, the SDK automatically validates and deserializes it into strongly-typed Python objects, and errors can be caught and fed back to the model for retry. These design choices ensure AI Agents can read, write, and maintain SDK code as fluently as human developers. In essence, the SDK is Antigravity's own API — the Agent building your code understands this framework from the inside.

Tools and Integration System: Four Toolset Types

The SDK supports four toolset types, all sharing the same execution pipeline, streaming infrastructure, and security policies:

1. Built-in tools: File I/O, code editing, shell execution, directory search, image generation, sub-Agent delegation, and more
2. Custom Python functions: Register any Python callable as an Agent-invocable tool
3. MCP server integration: Connect to any Model Context Protocol server (supporting stdio, SSE, or Streamable HTTP) and expose its tools to the Agent
4. Agent skill packs: Provide reusable skill packs (containing instructions, tools, and context) via skills_paths in the configuration

MCP (Model Context Protocol) is an open standard protocol proposed and championed by Anthropic in late 2024, designed to solve interoperability issues between AI models and external tools and data sources. MCP defines a standardized client-server communication specification supporting three transport methods — stdio, SSE (Server-Sent Events), and Streamable HTTP — enabling AI systems from different vendors to access the same tool ecosystem through a unified interface. Google's native MCP support in the Antigravity SDK means that hundreds of existing community MCP servers (covering databases, browser control, code execution, and more) can be directly integrated into Antigravity Agents with zero adaptation cost, vastly expanding its tool ecosystem boundaries.

This unified architectural design means that defining a policy or hook once governs all tools — regardless of their origin.

Security Policies and Lifecycle Hooks

Declarative Security Policy System

In the default configuration, LocalAgentConfig enables all built-in tools but applies a confirm_run_command() policy — most tools run frictionlessly, but shell access is denied by default. Developers can exercise fine-grained control through the declarative policy system:

from google.antigravity.hooks.policy import deny, allow, ask_user

policies = [
    deny("*"),                                    # Block everything by default
    allow("view_file"),                            # Allow reading files
    ask_user("run_command", handler=my_handler),   # Shell requires human approval
]

This "deny by default, explicitly allow" approach