Google Antigravity SDK
A Python SDK for building stateful agents powered by Google Antigravity and Gemini.
Per-dimension scores and reasoning
Evidence shows default read-only mode and a policy system (deny/allow/ask_user) to restrict tool permissions, but specific least-privilege implementation details are not clear. User confirmation exists via ask_user policy but not shown as default or enforced. Data flow transparency is insufficient; no details on how data is processed, stored, or transmitted. Sensitive data handling only mentions API keys and ADC, without encryption or protection measures. Dependency security lacks vulnerability scanning or pinned versions, only ranges. External effects are mitigated by default read-only mode but no explicit prevention of unintended writes. Rollback is not mentioned. Source attribution is present via copyright and author info, but publisher is unverified.
Self-consistency is good; README examples align with code structure, but actual execution not verified. Dependency availability is clear with explicit list but no locked versions or compatibility matrix. Failure messages lack specific error handling or user prompt examples.
Target audience is clearly developers; scenarios include simple agent, streaming, tool calls, MCP integration. Capability boundaries are defined via CapabilitiesConfig and policy system, but default capabilities not detailed. Trigger precision is shown via triggers example but not detailed configuration. Environment fit supports Vertex AI and local mode, but not all platforms.
Information architecture is clear with README TOC and component docs. Install notes are explicit, emphasizing PyPI installation. Naming stability lacks version history or API stability notes. Examples are rich but FAQ missing. Known limitations not explicitly listed. License is Apache-2.0, complete. Versioning and changelog not provided. Maintenance responsibility is not explicit but SECURITY.md and GitHub Actions exist.
Output usability is good with streaming and text extraction. Marginal value is high with multimodal, tools, MCP features. Cost-benefit lacks performance or resource consumption data.
Claim traceability is moderate; README features not directly mapped to code. Cross-source corroboration is insufficient, relying on single repo. Fact-inference separation is unclear; documentation claims vs actual implementation not distinguished.
- Publisher identity is unverified; treat source with caution.
- Dependencies are not pinned, posing supply chain risk.
- Default read-only mode is good, but enabling all tools requires careful permission control.
- No rollback mechanism provided; be cautious with irreversible operations.
- Data flow transparency is insufficient; sensitive data handling details are missing.
What does this agent do, and when should you use it?
Google Antigravity SDK is a Python SDK for agents powered by Antigravity and Gemini. Its high-level Agent manages binary discovery, tool wiring, hook registration, and policy defaults through an async context manager, and starts in read-only mode. For direct session control, Conversation works with ConnectionStrategy and ToolRunner while exposing history, turn counts, and the last response. ChatResponse supports asynchronous text streaming as well as separate thoughts and typed ToolCall streams. The SDK accepts text plus image, video, audio, and document content, and supports Python tools, MCP servers, hooks, policies, and scheduled triggers.
An application configures LocalAgentConfig with system instructions, tools, MCP servers, policies, or triggers, then calls await agent.chat(...) inside async with Agent(config). chat accepts text or a list containing content objects such as Image and from_file(...), returning a ChatResponse; await response.text() collects text, while async for token in response streams it. For lower-level control, Conversation.create(strategy) opens a stateful session, send(...) submits a message, and receive_steps() yields Step objects while history, turn_count, and last_response accumulate. Python functions can be registered through tools, and McpStdioServer exposes external MCP tools; CapabilitiesConfig() enables all tools including writes, while deny, allow, ask_user, and enforce can govern tool dispatch.
- A Python developer building a Gemini assistant that needs to call a registered Python function such as get_weather(city).
- A console or UI team that wants token-by-token output and separate indicators for response.thoughts and response.tool_calls.
- An application developer who needs an agent to analyze a PDF, image, video, audio file, or document alongside written instructions.
- An engineering team with an existing MCP stdio server that wants to make its tools available through McpStdioServer.
- A developer who needs multi-turn state, step history, or direct consumption of streamed Step objects through Conversation and LocalConnectionStrategy.
- A Google Cloud team using Gemini Enterprise Agent Platform that can configure vertex=True, project, and location with ADC authentication.
What are this agent's strengths and limitations?
- Agent packages binary discovery, tool wiring, hook registration, and policy defaults behind one async context manager.
- Conversation exposes history, turn_count, last_response, send, and receive_steps for stateful, step-level integrations.
- The chat interface supports mixed text and image, video, audio, or document content, including the from_file(...) shortcut.
- It supports both in-process Python tools and external MCP servers, with declarative policies for controlling tool calls.
- Its documented core is tied to Google Antigravity and Gemini; the supplied material does not show an alternative model-provider path.
- A platform-specific PyPI wheel is required for the compiled runtime, so cloning the repository alone is insufficient.
- Agent is read-only by default, but CapabilitiesConfig() enables all tools including writes; adopters need to define appropriate policies and permissions.
- The Enterprise path requires GCP project and location configuration plus Application Default Credentials or the documented environment variables.
How do you install or deploy this agent?
Install from PyPI:
pip install google-antigravityDo not rely on a repository clone alone: the required compiled runtime binary is included in the platform-specific wheels published to PyPI. For Gemini API usage, set GEMINI_API_KEY="your_api_key_here". For Gemini Enterprise Agent Platform (formerly Vertex AI), set vertex=True, project, and location in LocalAgentConfig, or export GOOGLE_GENAI_USE_VERTEXAI=True, GOOGLE_CLOUD_PROJECT, and GOOGLE_CLOUD_LOCATION, then run gcloud auth application-default login.
How do you use this agent?
Minimal invocation:
from google.antigravity import Agent, LocalAgentConfigasync with Agent(LocalAgentConfig()) as agent:
response = await agent.chat("Hello!")
print(await response.text())After setting GEMINI_API_KEY, the included quickstart can be run with: python ./examples/getting_started/hello_world.py. Explicit LocalAgentConfig arguments take precedence over environment variables for the Enterprise configuration.
How does this agent compare with similar options?
Agent is the higher-level option: it manages lifecycle concerns in an async context and exposes chat directly. Conversation with ConnectionStrategy and ToolRunner is for implementations that need connection-lifecycle control, accumulated step history, or streamed Step handling.