How to Set Up Google Antigravity on macOS & Windows (2026)

Google Antigravity shipped version 1.18.3 on February 19, 2026, alongside the Gemini 3.1 Pro model upgrade that deprecated both previous Gemini 3 Pro variants. If you downloaded Antigravity months ago, the IDE you installed no longer connects to its primary reasoning engine. If you haven't installed it yet, you're arriving at the best possible moment — the platform has stabilized through three months of public preview, the WSL2 integration quirks on Windows are well-documented, and the model lineup now includes Gemini 3.1 Pro, Claude Sonnet 4.5, Claude Opus 4.5, and GPT-OSS-120B without requiring a single API key.

This guide walks through the complete setup process for macOS and Windows, from system verification through first agent task, with the security configuration decisions that matter for professional development environments. Whether you manage development infrastructure for a team or you're evaluating Antigravity for personal projects, the goal is the same: a working installation with sensible defaults that won't surprise you at 2 AM when an agent decides to rm -rf something important.

Understanding What Antigravity Actually Is

Before running any installer, it helps to understand what you're adopting. Google announced Antigravity on November 18, 2025, alongside Gemini 3. The platform is a heavily modified fork of Visual Studio Code — whether it descends directly from VS Code or from Windsurf (itself a VS Code fork, acquired when Google bought the Windsurf team for $2.4 billion in July 2025) remains a matter of community debate. What's not debatable is that it supports VS Code extensions, keybindings, and themes, so the editor surface will feel immediately familiar.

The departure from a standard editor happens across three integrated surfaces. The Editor View functions as a traditional AI-powered IDE with tab completions, inline commands, and an agent sidebar. The Agent Manager — what Google calls "Mission Control" — is a dashboard for spawning, orchestrating, and monitoring multiple autonomous agents working in parallel across separate workspaces. The Browser Integration, powered by a Chrome extension, lets agents navigate web pages, click buttons, fill forms, capture screenshots, and record browser sessions for verification. Together, these surfaces let you assign an agent a high-level task like "build a JWT authentication system with Redis session management" and watch it plan, code, test, and validate the implementation across editor, terminal, and browser simultaneously.

Agents communicate their work through Artifacts — structured deliverables like task lists, implementation plans, code diffs, screenshots, and browser recordings. Artifacts solve the trust gap inherent in autonomous code generation. Instead of scrolling through raw tool calls to verify what an agent did, you review its Artifacts the way you'd review a pull request. If something looks wrong, you leave feedback directly on the Artifact and the agent incorporates it without stopping execution.

macOS Installation: Step by Step

System Requirements

Antigravity supports macOS 12 (Monterey) or newer on both Apple Silicon (M1, M2, M3, M4) and Intel processors. Apple Silicon Macs deliver optimal performance, including support for the Nano Banana local image generation model that runs on-device. Intel-based Macs may route certain local AI features to cloud processing with slightly higher latency.

Step 1: Download the Installer

Navigate to antigravity.google/download in your browser. The page auto-detects your hardware and recommends the correct build. Select "Download for Apple Silicon" or "Download for Intel" depending on your Mac. A Universal .dmg option is also available if you're unsure. The download is approximately 150–200 MB.

Step 2: Verify the Code Signature (Recommended)

Before installing, verify that the download is genuinely from Google. Open Terminal and run:

codesign -dv --verbose=4 /Volumes/Antigravity/Antigravity.app

Confirm the Authority line shows "Developer ID Application: Google LLC". This step is particularly important for organizations deploying Antigravity across development teams, where supply-chain verification should be standard practice.

Step 3: Install the Application

Open the downloaded .dmg file and drag the Antigravity icon to your Applications folder. macOS Gatekeeper may display a security warning since this is a relatively new application. Click "Open" to proceed. For enterprise deployments using MDM solutions like Jamf, the .dmg can be deployed with pre-configured security policies.

Step 4: First Launch and Authentication

Launch Antigravity from Applications. The initial setup wizard walks through several configuration screens:

• Import Settings: Choose whether to import settings and extensions from VS Code, Cursor, or Windsurf, or start with a fresh configuration.
• Editor Theme: Select Light, Dark, or High Contrast.
• Development Mode: Choose between Agent-Driven (maximum autonomy), Agent-Assisted (agent decides when to ask for review — recommended), or Review-Driven (you approve everything).
• Google Sign-In: Authenticate with your personal Gmail account. This opens Chrome for the OAuth flow. Ensure you allow a new Chrome Profile to be created for Antigravity.
• Terms of Use: Review and accept.

After authentication, Antigravity initializes your workspace and downloads necessary components. This takes 2–3 minutes on most systems.

Step 5: Grant macOS Permissions

macOS will request permissions for file system access, network connections, and potentially Accessibility features. Grant these to ensure full functionality — particularly Terminal access, which agents require to execute commands. You can review and modify permissions later in System Settings → Privacy & Security.

Step 6: Install the Command Line Tool

During editor configuration, enable the agy command line tool. This lets you open Antigravity from Terminal with:

agy .                    # Open current directory in Antigravity
agy ~/projects/my-app    # Open a specific project

This mirrors the code . workflow familiar to VS Code users.

Windows Installation: Step by Step

System Requirements

Antigravity supports Windows 10 or Windows 11 (64-bit only), on both x64 and ARM64 architectures. There is one critical prerequisite that catches most Windows users off guard: Antigravity requires Windows Subsystem for Linux 2 (WSL2) for sandboxed terminal execution.

Step 1: Verify or Install WSL2

Open PowerShell as Administrator and check whether WSL2 is already installed:

wsl --status

If WSL2 is not installed, run:

wsl --install

Restart your computer after installation completes. WSL2 installs Ubuntu by default, which is sufficient for Antigravity's terminal sandbox.

Step 2: Download and Run the Installer

Navigate to antigravity.google/download. Select "Download for x64" for most modern Windows PCs, or "Download for ARM64" for ARM-based devices like Surface Pro X. Double-click the downloaded .exe file to launch the installation wizard.

Windows Defender SmartScreen may display a warning. Verify the publisher shows "Google LLC" before clicking "Run anyway". The installer requests Administrator privileges for system-wide installation. The default path is C:\Program Files\Google\Antigravity. Installation typically takes 3–5 minutes.

Step 3: Configure Firewall Access

Windows Defender Firewall will prompt for network access permissions. Antigravity requires outbound connections to Google's AI services. For corporate networks with restrictive firewall policies, whitelist the following domains:

*.google.com
*.googleapis.com

Step 4: First Launch and Setup Wizard

Launch Antigravity from the Start Menu. The setup wizard mirrors the macOS experience — import settings, choose a theme, select your development mode, sign in with your personal Gmail, and accept the Terms of Use.

Step 5: Connect to WSL (For Terminal-Dependent Workflows)

By default, Antigravity runs terminal commands through its WSL2 integration. If you need to explicitly connect a workspace to WSL, press Ctrl+Shift+P, type "wsl", and select "Remote-WSL: Connect to WSL". Antigravity will set up the new WSL-connected workspace immediately. No additional extension installation is required — this capability is built in.

When working in WSL mode, be aware that the workspace path should show [WSL: Ubuntu] with a Linux-style path relative to your home directory — not the \\wsl.localhost path that Windows uses to access WSL files.

Step 6: Set Up the agy CLI for WSL

The agy command line tool doesn't work from WSL out of the box. To enable it, create a symlink in your Linux environment:

ln -sf "/mnt/c/Users/YOUR_USERNAME/AppData/Local/Programs/Antigravity/bin/antigravity" \
  ~/.local/bin/agy

Replace YOUR_USERNAME with your Windows username. After creating this symlink, agy . will open Antigravity from any WSL terminal.

Setting Up the Browser Agent (Both Platforms)

The browser subagent is what transforms Antigravity from a smart editor into a full-stack development platform. It allows agents to navigate web pages, interact with UI elements, capture screenshots, record sessions, and verify that the code they wrote actually works in a browser. Setting it up is straightforward on macOS but requires additional steps on Windows with WSL2.

macOS Browser Setup

The browser agent configures itself on first use. Open the Agent Manager, start a new task in Playground, and give it a browser-dependent instruction like "go to antigravity.google." The agent will recognize it needs browser access and prompt you to click "Setup". This opens Chrome and directs you to the Chrome Web Store to install the Antigravity extension. Click "Add to Chrome", grant the requested permissions, and you're done. The agent will immediately complete the browser task.

Windows Browser Setup (WSL2 Complications)

When running Antigravity through WSL2, the browser agent hits a networking barrier. WSL2 operates as a virtualized environment, and Chrome runs on the Windows side — the two environments can't communicate over localhost by default. The community has documented several workarounds, but the cleanest approach uses WSL2's mirrored networking mode.

On Windows 11, add or verify these lines in %USERPROFILE%\.wslconfig:

[wsl2]
networkingMode=mirrored

Save the file, then run wsl --shutdown in PowerShell and relaunch WSL. This allows the WSL2 instance to share the Windows network stack, enabling the browser subagent to communicate with Chrome directly.

If the Antigravity extension fails to auto-install in Chrome when launched from WSL, open chrome://extensions manually, search for "Antigravity" in the Chrome Web Store, and install it. Then configure the Chrome binary path in Antigravity under Settings → Browser Subagent:

/mnt/c/Program Files/Google/Chrome/Application/chrome.exe

Terminal Security: The Most Important Configuration Decision

During initial setup, Antigravity asks you to select a Terminal Command Auto Execution policy. This single setting determines how much autonomous control agents have over your system. Get it wrong, and an agent could execute destructive commands without your knowledge. Get it right, and you maintain full auditability while preserving development velocity.

The Auto policy with a carefully curated Deny List offers the best balance for most professional developers. To configure your Deny List, navigate to Antigravity → Settings → Advanced Settings → Terminal and add commands that should always require manual approval:

# Recommended deny list entries
rm -rf
sudo
chmod
chown
curl | bash
wget -O - | sh
docker rm
kubectl delete

Conversely, if you choose the Off policy for maximum security, build an Allow List of commands the agent can execute freely — like ls, cat, git status, and npm test — so routine operations don't require constant approval clicks.

These settings can be modified at any time via Settings → Advanced Settings, and you may need to restart Antigravity for changes to take effect.

Choosing and Managing AI Models

Antigravity doesn't lock you into a single AI backend. As of February 2026, the platform supports multiple models that you can switch between within any project based on the task at hand.

To switch models, click the model selector dropdown in the Agent Manager panel or the chat sidebar. A practical workflow is to use Gemini 3.1 Pro for initial architectural planning, then switch to Gemini 3 Flash for rapid implementation of standard components. Reserve Claude Opus 4.5 or Gemini 3 Deep Think for the hardest reasoning-intensive subtasks.

To check your current model access and remaining quota, navigate to Settings → Models. The quota screen shows your usage relative to your subscription tier's limits.

Rate Limits and Subscription Tiers

Antigravity is free during public preview with all features available regardless of tier. The difference between subscription levels is rate limits — how much agent work you can do before hitting a cooldown period. Google measures quota by "work done" (a proxy for token consumption) rather than raw request counts, so straightforward tasks consume less quota than complex reasoning chains that span dozens of files.

For most individual developers working on a single project at a time, the free tier is sufficient. The quota wall typically hits during intensive multi-agent sessions where several agents are running complex tasks simultaneously. If you're consistently hitting limits, the Google AI Pro subscription at $19.99/month also includes higher rate limits for Gemini CLI, Jules (Google's async coding agent), and $10/month in Google Cloud credits. The Ultra tier bumps Cloud credits to $100/month and includes 30 TB of storage across Google services [Google AI Plans].

Customizing Agent Behavior: Rules, Workflows, and Skills

Antigravity provides three distinct mechanisms for customizing how agents behave. Understanding when to use each one is the difference between an agent that generates generic code and one that follows your team's exact conventions.

Rules: Always-On Guidelines

Rules function as persistent system instructions. They're always loaded into the agent's context, governing every code generation and planning decision. Think of them as your team's coding constitution.

Rules are stored as Markdown files at two scopes:

• Global Rules: ~/.gemini/GEMINI.md — apply across all projects
• Workspace Rules: .agent/rules/ within your project root — apply only to that project

Example global rule file (~/.gemini/GEMINI.md):

# Global Development Rules

- Always use TypeScript over JavaScript
- Add comprehensive docstrings to all functions
- Never generate hardcoded API keys or secrets
- Use semantic commit messages following Conventional Commits
- All React components must be functional with hooks (no class components)

Workflows: On-Demand Saved Prompts

Workflows are repeatable procedures that you trigger with the / command in the agent chat. Where Rules are passive (always on), Workflows are active (triggered by you). They're ideal for recurring tasks like generating pull request descriptions, running test suites, or creating boilerplate.

Workflows are stored as Markdown files:

• Global Workflows: ~/.gemini/antigravity/global_workflows/
• Workspace Workflows: .agent/workflows/

Example workflow file (.agent/workflows/draft-pr.md):

# PR Description Generator

Goal: Draft a professional Pull Request description.

Steps:
1. Run git diff main to see all changes
2. Summarize into three sections:
   - What Changed: Bulleted list of technical changes
   - Why: Reasoning behind the changes
   - Testing: How to verify
3. Format output as Markdown ready for GitHub/GitLab

Type /draft-pr in the agent chat, and the agent executes these steps using your actual git diff.

Skills: Agent-Triggered Specialized Knowledge

Skills are the most powerful customization layer. Unlike Rules (always loaded) or Workflows (user-triggered), Skills use progressive disclosure — the agent reads only the skill's lightweight metadata at startup, then loads the full instructions only when the current task matches the skill's description. This keeps the context window lean and prevents instruction fatigue across large projects with dozens of tools.

Skills are stored as directory packages:

• Global Skills: ~/.gemini/antigravity/skills/
• Workspace Skills: <project-root>/.agent/skills/

Each skill directory contains a required SKILL.md file with YAML frontmatter and Markdown instructions, plus optional scripts/ and resources/ folders:

my-skill/
├── SKILL.md          # Required: metadata + instructions
├── scripts/          # Optional: executable scripts
│   └── deploy.sh
└── resources/        # Optional: templates, configs
    └── HEADER.txt

Example SKILL.md:

---
name: code-review
description: Reviews code changes for bugs, style issues, and best practices.
---

# Code Review Skill

When reviewing code, follow these steps:

## Review Checklist
1. **Correctness**: Does the code do what it's supposed to?
2. **Edge Cases**: Are error conditions handled?
3. **Style**: Does it follow project conventions?
4. **Performance**: Are there obvious inefficiencies?

## Feedback Format
- Be specific about what needs to change
- Explain why, not just what
- Suggest alternatives when possible

The Agent Skills format is an open standard that works across multiple agentic platforms including OpenAI Codex, Claude Code, Cursor, and GitHub Copilot. Skills you create for Antigravity are portable to any compatible agent.

Running Your First Agent Task

With installation, permissions, and configuration complete, it's time to verify everything works. Open Antigravity and navigate to the Agent Manager. Create a new workspace or open an existing project.

Start with a simple task to confirm all three surfaces (editor, terminal, browser) are connected:

# Example first prompt
"Create a simple Express.js API with two endpoints:
GET /health (returns status 200) and GET /time (returns current UTC).
Write tests, start the server, and verify both endpoints work
using the browser."

Watch the agent's workflow unfold. It should create the project files in the editor, install dependencies and start the server in the terminal, and navigate to each endpoint in the browser to verify responses. Each step produces Artifacts — an implementation plan, code diffs, terminal output logs, and browser screenshots — that you can review to verify the work.

If the agent gets stuck requesting terminal permission, check your Terminal Command Auto Execution policy. If the browser agent fails to launch, revisit the browser setup section for your platform.

Troubleshooting Common Issues

sudo apt install util-linux-extra && sudo hwclock -s

Enterprise Considerations

For organizations evaluating Antigravity for team deployment, several factors require deliberate planning beyond individual installation. The platform's default configuration prioritizes developer velocity over security guardrails — which is the right default for a public preview targeting individual developers, but needs adjustment for enterprise environments.

Google's own terms of use acknowledge that "Antigravity is known to have certain security limitations." Agents that can execute terminal commands, browse the web, and read your entire codebase represent a fundamentally different threat surface than a standard code editor. The terminal permission system (Turbo/Auto/Off) provides the first layer of control, but organizations should also consider data isolation strategies — ensuring that WSL2 instances, development environments, and browser profiles used with Antigravity don't contain production credentials or sensitive customer data.

Workspace accounts are not yet supported during preview, which complicates centralized administration. Google has signaled Team and Enterprise tiers via Google Workspace AI Ultra for Business, but pricing and feature specifics haven't been finalized. Organizations adopting Antigravity now should document their configuration standards as workspace-level Rules and Skills that can be version-controlled alongside code — ensuring consistent agent behavior across the team regardless of individual developer settings.

For businesses evaluating agentic development platforms alongside broader AI strategy initiatives, the security posture of these tools should be assessed as part of a comprehensive cybersecurity review — not treated as a standalone developer tool decision.

Sources

• Google Developers Blog — Build with Google Antigravity
• Google Blog — Gemini 3.1 Pro Announcement (February 19, 2026)
• Google Codelabs — Getting Started with Google Antigravity
• Google Codelabs — Authoring Google Antigravity Skills
• Google AI Plans — Pricing and Features
• Wikipedia — Google Antigravity

Related Resources