How to Download and Install Google Antigravity Locally

Step-by-step setup

Step 1: Download Antigravity from the official site

Open:

https://antigravity.google/download

Use the download button for your operating system.

For Windows, download the Windows installer and run it from your Downloads folder.

For macOS, download the macOS installer for your chip type, open the downloaded file, and move Antigravity into Applications if the installer asks you to.

For Linux, use the Linux package or install command provided by the download page for your distribution.

Avoid third-party mirrors. Agentic IDEs have broad access to your code, terminal, browser context, and local files. The installer should come from Google's Antigravity download page.

Step 2: Install on Windows

On Windows:

1. Download the Windows installer from antigravity.google/download.
2. Run the installer.
3. Follow the setup prompts.
4. Launch Antigravity from the Start menu or desktop shortcut.
5. Sign in with your Google account when prompted.

If Windows blocks the installer, make sure the file came from the official download page before allowing it. Do not bypass a security warning for an installer from an unknown mirror.

Step 3: Install on macOS

On macOS:

1. Download the macOS build from antigravity.google/download.
2. Open the downloaded file.
3. Move Antigravity into Applications if prompted.
4. Launch Antigravity.
5. Sign in with your Google account.

If macOS shows a security prompt, confirm that the installer came from the official Google Antigravity site. Early developer tools can trigger extra prompts, but the source of the file still matters.

Step 4: Install on Linux

On Linux:

1. Open antigravity.google/download.
2. Choose the Linux option.
3. Follow the package instructions shown for your distribution.
4. Launch Antigravity from your app menu or terminal.
5. Sign in with your Google account.

Linux installation details can vary by package type and distribution. Use the official download page's current command or package format rather than copying an old command from a forum.

Step 5: Sign in with Google and connect Gemini access

On first launch, Antigravity asks you to sign in. Use the Google account that has the Gemini access, subscription, or developer entitlements you want to use.

Signing in matters because Antigravity's agent features are tied to model access. Your account is what lets the app synchronize available Gemini models, rate limits, and account-level settings.

After sign-in:

• Confirm the selected model in Antigravity's model settings.
• Check whether the app shows Gemini models.
• Open a small project before trying a large repository.
• Run one simple agent task before giving broader instructions.

For a first test, use a harmless prompt such as:

Inspect this project and summarize its structure. Do not modify files.

That confirms the agent can read the workspace without immediately changing anything.

Step 6: Import VS Code or Cursor settings

Antigravity is familiar to VS Code and Cursor users because the editor experience follows the same general pattern: file explorer, tabs, terminal, source control, extensions, themes, keybindings, and settings.

During first-run setup, use the import flow if Antigravity offers it. Typical items to import include:

• Settings
• Keybindings
• Themes
• Compatible extensions
• Editor preferences

For VS Code, choose the VS Code import option.

For Cursor, use the Cursor import option if it appears. If Cursor is not listed separately, treat Cursor as a VS Code-compatible editor and import the detected profile or settings where Antigravity allows it.

After importing, open a small project and check:

• Theme
• Font size
• Formatter settings
• Language extensions
• Terminal profile
• Git integration
• Keybindings you rely on daily

Do not assume every extension will behave exactly the same. Antigravity is an agentic IDE, not a drop-in replacement for every VS Code extension.

Step 7: Understand the Agent Manager and IDE split

Antigravity works best when you use the IDE and Agent Manager together.

Use the IDE when you want to:

• Edit code directly
• Inspect diffs
• Run a terminal command yourself
• Debug a small issue
• Review generated files
• Work synchronously

Use the Agent Manager when you want to:

• Spawn an agent for a larger task
• Watch multiple workstreams
• Review plans and artifacts
• Let an agent run tests or browser checks
• Comment on an artifact instead of restarting a task
• Keep background work separate from your active editor flow

This is the practical "dual-wielding" setup: keep the IDE open for hands-on work, and use the Agent Manager as the control surface for asynchronous agents.

Step 8: Run your first safe agent task

Open a small repository, then start with a read-only task:

Analyze this repository and create a short task list for improving the test setup. Do not edit files.

Review the artifact the agent produces. Then ask for one narrow change:

Add one missing unit test for the smallest low-risk function you found. Show me the diff before applying anything else.

This teaches the right habit early: delegate small, reviewable work before letting agents make broad changes.

Step 9: Review artifacts before accepting changes

Antigravity agents produce artifacts so you can verify what happened without reading every raw tool call.

Review:

• Implementation plans
• Task lists
• Code diffs
• Terminal results
• Screenshots
• Browser recordings
• Test output

Artifacts are the review layer. Use them before accepting broad edits, especially when an agent changes multiple files or touches setup scripts.

Verify it works

Antigravity is ready for first use when the app launches, your Google sign-in completes, Gemini models appear in the model settings, a small repository opens correctly, and a read-only agent task produces an artifact without changing files. Do not treat the setup as finished until you have reviewed at least one plan, diff, terminal result, or artifact in the Agent Manager.

Common problems

The download page does not show the right operating system

Use the OS selector on the download page if available, or open the page from the target machine. If the page still fails, try a different browser.

Google sign-in fails

Use your default browser, disable aggressive privacy extensions for the sign-in flow, and make sure your system clock is correct. Corporate SSO or managed Google accounts can have additional restrictions.

Gemini models do not appear

Confirm you signed in with the intended Google account. Then reopen Antigravity and check the model settings. If your organization manages model access, the available model list may depend on that account policy.

VS Code or Cursor import misses extensions

Import settings first, then reinstall missing extensions manually. Some extensions may not be available or may behave differently inside Antigravity.

The agent wants to run risky commands

Pause and review the command. Do not grant broad terminal execution to a new tool until you understand its behavior in a test project.

Next useful actions

After the first read-only task works, import only the editor settings you actually use, open a low-risk test repository, and ask the agent for one small change that must show a diff before applying. Add larger repositories, browser tasks, and autonomous work only after the review loop feels predictable.

Background, planning, and caveats

What Google Antigravity is

Google Antigravity is Google's agentic development platform for software work. It is built around two main ways of working:

• The IDE or Editor View, where you edit code, use a terminal, review files, and work in a familiar code editor layout.
• The Agent Manager or Manager Surface, where you spawn, observe, and guide agents that can plan, edit, run commands, test, and produce artifacts.

That split is the important mental model. Antigravity is not only a code editor with a chat panel. It is designed for delegating larger tasks to agents while still keeping a human review loop through plans, diffs, screenshots, task lists, browser recordings, and other artifacts.

Questions to answer before installing

• Is your machine policy clear on Google sign-in and data-sharing rules?
• Are you prepared to run all first runs as read-only tasks?
• Will you need local offline coding only, or persistent cloud-connected agents from day one?
• Do you already have a budget lane for Gemini usage if you scale from small tests to daily heavy tasks?
• Who can access the Google workspace account and revoke credentials if needed?

Approximate U.S. planning cost

• Software licensing: app install itself has no documented license fee in the current public flow.
• Local hardware: existing machine cost only unless you need workstation upgrades for heavier workloads.
• Model/API spend: depends on Gemini access path, not on the installer itself.
• Optional cloud/VPS: only if you move agent work to remote servers or managed CI nodes.
• Developer time: 30 to 90 minutes for first successful local task flow.

Cost breakdown

• Baseline install and local workspace: $0 software + your existing machine.
• Optional model provider spend: usage-based and provider billed.
• Storage growth: local repository and artifact history in workspace and OS temp locations.
• Team operations: shared accounts, governance tooling, and extra approvals if needed.

Official-source caveats

Official Antigravity source pages are heavily app-hosted and can change quickly in script-loaded builds. Use the official download page and in-app release notes for the latest:

• https://antigravity.google/download
• https://ai.google.dev/gemini-api/docs/billing/
• https://ai.google.dev/gemini-api/docs/pricing

If pricing or entitlement statements are ambiguous, verify from the Google AI Studio billing and pricing pages before committing monthly spend.

Security notes

Antigravity is powerful because agents can operate across editor, terminal, and browser surfaces. That also increases risk.

Use these rules:

• Start with a test repository.
• Keep secrets out of project files.
• Review terminal commands before approval.
• Use version control before agent edits.
• Do not open sensitive client code until you understand account and data policies.
• Treat browser automation as sensitive if it can access logged-in sessions.
• Review artifacts before accepting changes.

Credential handling

• Use a dedicated Google account for coding work if your org permits it.
• Do not copy account-level tokens from browser prompts into project notes.
• Prefer local OS password managers for any generated app or API credentials.
• Revoke and rotate if a session appears on an unmanaged device.
• Confirm whether app-level permissions include drive, browse, or terminal scopes for your project type.

Filesystem permissions

Antigravity creates local workspace state and artifacts. Keep that area minimal and explicit:

• Avoid broad 777 or public directory permissions.
• Keep workspace folders on a disk with standard user-level write control.
• If your security policy is strict, use per-project locations rather than a shared global scratch space.

Rollback and update guidance

Use a practical low-risk flow:

1. Keep a backup branch or zip of the first working workspace.
2. Enable only a read-only test task in the first run.
3. Install updates only after you have a clean baseline in version control.
4. If a new release changes behavior, restore from backup and stage rollout one step at a time.

On managed systems, use OS-level rollback and app reinstall points before retrying a risky workflow.

Red flags

• Running real-world repository changes before artifact review is stable.
• Connecting a personal Google account to business-owned code without policy review.
• Ignoring command outputs from the Agent Manager before approving file edits.
• Reusing a shared profile for local workspace and credentials across teams.

Bottom line

Download Google Antigravity from https://antigravity.google/download, install the Windows, macOS, or Linux build, sign in with the Google account you want to use for Gemini access, and import your VS Code or Cursor setup during onboarding. Then work with both surfaces: the IDE for direct coding and the Agent Manager for orchestrating autonomous agents.

Treat the finish as:

• finish a read-only onboarding task,
• verify artifact visibility and model attribution,
• then approve broader changes once workspace permissions and cost controls are set.