Most AI coding tools force you to adopt their worldview: either you live entirely inside a forked code editor, or you live exclusively inside a terminal chat loop. Google Antigravity took a noticeably more modular route, evolving into a four-surface agentic platform where your rules, skills, MCP servers, and models follow you seamlessly across an IDE, a standalone desktop mission-control app, a fast terminal CLI, and a native Python SDK.
If you have only tried one corner of Google Antigravity—say, installing the standalone IDE or kicking off a quick agent from the macOS Gemini app—it is easy to miss how the pieces lock together.
In practice, senior engineering teams rarely stay inside a single window all day. You might sketch a database refactor interactively inside Antigravity IDE at 9 a.m., schedule a recurring dependency-audit cron inside Antigravity 2.0 before lunch, SSH into a staging box with the agy CLI in the afternoon, and run nightly pull-request verification scripts powered by the google-antigravity Python SDK overnight.
Here is a practical, hype-free breakdown of all four surfaces, how workspace customizations connect them, and which surface fits each part of your engineering workflow.
Surface 1: Antigravity IDE — Three Speeds of In-Editor Coding
Built on a familiar VS Code foundation so your muscle memory, keybindings, and themes carry right over, Antigravity IDE organizes AI interaction into three distinct modalities depending on how much control you want to keep in your own hands:
- Passive Flow (
Tab Autocomplete & Supercomplete): Instead of just completing the current line, Antigravity Tab watches your open tabs, recent terminal output, and surrounding edits. Supercomplete proposes multi-line diffs (including clean deletions) in a subtle floating overlay, Tab to Jump predicts the exact line forty rows down where your cursor needs to go next, and Tab to Import wires up missing top-of-file imports automatically. If you only want part of a suggestion, Cmd+Right (Ctrl+Right on Linux) accepts it word by word. - Instructive Edits (
Cmd+I / Ctrl+I Inline Command): Highlight a 30-line controller method, press Cmd+I, and ask to extract validation into a FormRequest or add PHPDoc array shapes. Critically, Inline Command is strictly scoped—it edits only your highlighted block and leaves the rest of the file untouched. - Collaborative Sidebar Agent & Planning Mode: When a task crosses ten files, requires running
php artisan test or npm run build, and talks to external databases via Model Context Protocol (MCP) servers, Agent Mode steps in. Combined with Inline Code Lenses above classes/functions and Diagnostic Auto-Fix triggers right inside the Problems pane, you review clean red/green visual diff overlays in context before committing.
Surface 2: Antigravity 2.0 Desktop App — Mission Control Beyond the Editor
Why build a separate desktop Electron app (Antigravity 2.0) when Antigravity IDE already exists? Spend a week managing three repositories at once and the answer becomes obvious: managing autonomous agents feels very different from typing code.
Figure 2: The lightweight agy CLI brings full agent orchestration, headless print pipelines, and remote SSH workflows into any terminal emulator with zero GUI overhead.
Antigravity 2.0 decouples agent orchestration from editor tabs. Its left-hand sidebar gives you a unified command center across Projects, Scheduled Tasks (cron jobs and one-shot delayed timers), Skills & Customizations, and granular Security Settings. Inside the main Chat Canvas, / slash commands trigger structured workflows (/plan, /boost, /teamwork, /grill-me, /schedule) while @ mentions attach files, folders, past conversations, terminal sessions, or specific MCP tools directly to your prompt.
Where Antigravity 2.0 really earns trust with security-conscious teams is its two-tier Permission Architecture (Global defaults + Project-level overrides):
- Tool Execution Policies: Choose between
always-proceed, request-review, strict, or proceed-in-sandbox. - Terminal Sandbox & Network Boundaries: Lock experimental repos inside a restricted OS terminal sandbox, enforce command allowlists/denylists, block file reads outside the workspace root, and restrict browser automation to an explicit domain allowlist.
Surface 3: The agy CLI — Speed, SSH, and Headless Unix Pipelines
When you are working over SSH on a remote Linux workstation, living inside tmux in Ghostty or Kitty, or wiring AI steps into shell scripts, launching a desktop GUI is a non-starter. That is where the Antigravity CLI (agy) shines.
Configured via ~/.gemini/antigravity-cli/settings.json, agy gives you both a responsive interactive Terminal User Interface (TUI)—complete with /changelog, /plugin marketplace installation, and animated /swarm status boards—and a scriptable headless --print (-p) mode for Unix pipelines:
# 1. Interactive session resuming your most recent workspace conversation
agy -c --model gemini-4-argon-medium
# 2. Headless JSON-schema enforced code audit inside a CI shell script
git diff origin/main...HEAD | agy -p "Audit this diff for SQL injection or leaked secrets" --model gemini-4-carbon-high --output-format json --json-schema '{"type":"object","properties":{"safe":{"type":"boolean"},"findings":{"type":"array","items":{"type":"string"}}},"required":["safe","findings"]}'
# 3. Sandboxed execution with restricted terminal boundaries
agy --sandbox --mode accept-edits --effort medium
Surface 4: The google-antigravity Python SDK — Programmatic Agent Orchestration
For platform engineers who want to build custom developer portals, automated QA bots, or self-healing data pipelines, Google publishes the official Python SDK (google-antigravity) on PyPI, bundling the compiled runtime binary directly inside platform-specific wheels.
By default, LocalAgentConfig boots agents in safe read-only mode unless you explicitly pass CapabilitiesConfig() to grant write and command tools. Even better, you can stream internal reasoning thoughts and strongly typed tool-call events asynchronously in real time:
import asyncio
import sys
from google.antigravity import Agent, LocalAgentConfig, CapabilitiesConfig
async def audit_repository() -> None:
# Default read-only mode keeps automated CI audits 100% non-destructive
config = LocalAgentConfig(
system_instructions=(
"You are a senior reliability engineer. Inspect failing test logs "
"and pinpoint the exact root-cause file and line range."
),
)
async with Agent(config) as agent:
response = await agent.chat(
"Analyze tests/Feature and explain any brittle time-dependent assertions."
)
# Observe internal reasoning deltas alongside tool executions
async for thought in response.thoughts:
print(f"[Reasoning] {thought.strip()}")
async for call in response.tool_calls:
print(f"[Tool] {call.name}({call.args})")
async for token in response:
sys.stdout.write(token)
sys.stdout.flush()
print()
if __name__ == "__main__":
asyncio.run(audit_repository())
Figure 3: Antigravity 2.0 separates global and per-project security policies—combining Terminal Sandboxing, domain allowlists, and PreInvocation hooks to keep autonomous agents safe.
Which Antigravity Surface Should You Use When?
| Surface | Startup Overhead | Best Daily Use Case | Killer Feature |
|---|
| Antigravity IDE | Desktop Editor | Hands-on coding, inline surgical refactors, visual diff review | Supercomplete + Cmd+I + Inline Code Lenses |
| Antigravity 2.0 App | Desktop App | Running multi-project background agents, cron jobs, and visual reviews | Project-scoped Permission Grants + Scheduled Tasks |
agy CLI | Instant (<100ms) | Terminal power users, remote SSH servers, headless CI pipes | --print (-p) + --json-schema + TUI /swarm board |
| Python SDK | Embedded Library | Custom internal tools, nightly repo bots, programmatic pipelines | Async streaming of response.thoughts & response.tool_calls |
The real magic is that .agents/ workspace customizations—your project rules, custom SKILL.md folders, PreInvocation security hooks, and MCP database/cloud connectors—work identically across the board. Define your Laravel or React architecture conventions once in the repo, pick the right model from Antigravity's multi-model lineup, and every surface immediately speaks your team's language.
How .agents/ Customizations Tie All Four Surfaces Together
One frustration that veteran developers know all too well is spending Friday afternoon configuring custom prompt rules inside an IDE extension, only to discover on Monday morning that none of those conventions apply when running CLI scripts or CI checks. Antigravity eliminates that drift through a unified customization discovery hierarchy rooted in your repository's .agents/ directory and your user-level configuration folder.
Four building blocks travel cleanly between the IDE, Antigravity 2.0, agy, and the Python SDK:
- Project Rules & Path Globs: Instead of stuffing a massive 8,000-word style guide into every single chat turn, you can scope concise Markdown rule files to specific directory globs—so database migration conventions load only when an agent touches
database/migrations/**, while React accessibility standards activate automatically inside resources/js/Components/**. - Reusable
SKILL.md Folders: When your team has a repeatable engineering ritual—such as generating OpenAPI specs, auditing Core Web Vitals, or running zero-downtime deployment preflight checks—you package the instructions, helper scripts, and reference templates into a self-contained skill folder. Agents load the SKILL.md instructions on demand rather than polluting baseline context. - Model Context Protocol (MCP) Servers: Whether you connect a read-only PostgreSQL schema inspector, a cloud DNS manager, or an internal documentation index, Antigravity supports both eager native tools and lazy-loaded tool schemas so agents query live infrastructure state without brittle copy-pasted JSON dumps.
- Deterministic Lifecycle Hooks: PreInvocation and Stop hooks execute real local validation scripts around agent turns, ensuring formatting tools like Laravel Pint, ESLint, or
cargo check pass cleanly before an agent declares victory.
Real-World Day-in-the-Life: Combining All Four Surfaces on One Release
To see how this plays out practically, consider how a three-person product engineering team ships a new customer billing portal over a single Tuesday:
Figure 4: With pip install google-antigravity, teams can embed read-only or write-capable agents directly inside Python test runners, nightly cron audits, and custom internal tools.
At 9:15 a.m., the tech lead opens Antigravity 2.0, selects Gemini 4 Carbon at High effort, attaches the previous sprint's schema notes via @ mentions, and uses /plan to produce a reviewed migration and webhook specification. By 9:45 a.m., the lead switches into Antigravity IDE on Gemini 4 Argon (Medium), accepting Tab Supercomplete diffs across the new Eloquent models and highlighting tricky currency-rounding helpers with Cmd+I to generate edge-case unit tests inline.
After lunch, while SSH'd into a Linux staging instance to verify Stripe webhook signatures against live test traffic, the backend engineer launches agy -c inside tmux, inspects live container logs, and patches an environment-variable mismatch in ninety seconds without ever opening a remote desktop tunnel. Finally, when the pull request opens on GitHub at 4:00 p.m., a lightweight GitHub Actions workflow boots the google-antigravity Python SDK in strict read-only mode, streaming response.thoughts into the build log while verifying that every new route enforces tenant authorization middleware.
No re-explaining the codebase four times. No copy-pasting stack traces across browser tabs. Just four purpose-built tools sharing one coherent engineering brain.
Frequently Asked Questions (FAQ)
Does Antigravity 2.0 replace the Antigravity IDE?
No. Both are first-class, actively developed surfaces built on the same underlying agent engine. Antigravity IDE is built for hands-on in-editor coding (Tab completion, inline diffs, code lenses), whereas Antigravity 2.0 is a standalone desktop orchestrator for launching, scheduling, and monitoring multi-project agents independently of an editor window.
How do I install the Antigravity Python SDK safely in a CI pipeline?
Always install via pip install google-antigravity so PyPI pulls the platform-specific wheel containing the compiled runtime binary. Leave capabilities unset in LocalAgentConfig when you want guaranteed read-only inspection during untrusted pull-request checks.
Can I connect Google Cloud billing instead of a fixed individual subscription in the CLI?
Yes. Recent agy CLI updates allow Google Cloud teams to choose between standard Gemini subscriptions and Pay-As-You-Go billing right after sign-in, including native Application Default Credentials support via AGY_ADC_AUTH.