Google Antigravity IDE Install + Demo

Google released the Gemini 3 model today, and alongside that news, I explored Google Antigravity an AI-powered integrated development environment that is essentially a fork of VS Code. It brings an agent-based workflow into a familiar editor with features built around code generation, task execution, and guided development.

Antigravity is available for Windows, macOS, and Linux. I installed it on Ubuntu to see how it works in practice. The setup is straightforward, and the first-run experience focuses on how you want the agent to participate in your coding workflow: fully driven, assisted, or review-focused.

This article walks through what Antigravity is, how it installs, how to set it up on first run, and what it’s like to work with its agent manager and task system. I’ll keep the flow in the same order I experienced it, from installation to hands-on usage.

What is Google Antigravity?

Antigravity is Google’s agentic development platform, built as a fork of VS Code. It adds an AI agent that can write code, run tasks, and manage workflows from inside the editor and terminal. The product name shown during installation and commands refers to “antigravity,” and in the interface it’s described as an agentic IDE. In one place it’s referenced as “grand,” but the product itself presents as Antigravity throughout the process.

At its core, it runs with cloud models rather than local models. You connect it to Google’s model backends through Vertex AI (GCP Model Garden) or Google AI Studio. Once connected, the IDE integrates AI features such as natural language code commands, context-aware suggestions, and task execution tied to your workspace.

The editor experience remains close to VS Code, with the option to import your existing settings and extensions or start fresh. The agent can either take the initiative, assist as you work, or stay in a review role based on the policy you choose during setup.

Overview of Antigravity

Area	Details
Base Editor	Fork of VS Code
Platforms	Windows, macOS, Linux
Model Access	Cloud-based via Vertex AI (GCP Model Garden) or Google AI Studio
Local Models	Not used; requires cloud model access
Installation (Windows)	Download installer and run standard setup
Installation (Linux)	Add repository, update system, install with apt install anti-gravity
Agent Modes	Agent-driven, agent-assisted (recommended), or review-only
Policies	Configure execution in terminal and review behavior (always proceed, request review)
Features	Natural language code commands, tab autocompletion, configurable/context-aware agent
Agent Manager	Open with a keybinding (e.g., Ctrl+E); manage conversations and multiple agents
Task Monitoring	Task-oriented view with artifacts, progress, and verification results
Permissions	Agent prompts for permission before executing commands in the terminal
Synchronization	Agent activity syncs between the editor and the terminal
Feedback	Built-in feedback controls to refine results
Model Options	Lists models exposed via GCP (includes Anthropic and GPT options in the selector)
Execution Modes	Planning (for complex work) and Fast (for quick tasks)
Dependencies	Agent may install missing dependencies (e.g., Node.js) during task execution
Limits	Free-tier model quotas may throttle and interrupt tasks during high load

Key Features of Antigravity

• Familiar editor, AI-first workflow:

  • Forked from VS Code, with the ability to import VS Code settings and extensions.
  • Natural language code commands and context-aware completion embedded in the editor.

• Task and agent control:

  • Agent-driven, agent-assisted, or review-oriented development modes.
  • Policies for execution, review, and terminal use.

• Monitoring and verification:

  • Task-oriented UI that shows agent activity, artifacts, and verification results.
  • Permission prompts for executing shell commands and changes.

• Model choice and execution modes:

  • Model selection from GCP-backed providers.
  • Planning mode for complex tasks and Fast mode for quick iterations.

• Integrated workflow:

  • Synchronization between code editor and terminal tasks.
  • Built-in feedback to refine behavior over time.

Installation and Setup on Linux (Ubuntu)

Antigravity installs cleanly on Ubuntu through a repository-based process and an apt package. The IDE depends on cloud models; there is no local model mode. You will connect it to Google’s services via Vertex AI (Model Garden) or Google AI Studio.

Prerequisites

• A Google account to sign in for model access.
• Network access that allows calls to Google services through Vertex AI or AI Studio.

Step-by-Step: Install on Linux

1. Add the repository:
   • Follow the project’s repository instructions to add the official Antigravity repo. The exact commands are provided on their page.
2. Update your system:
   • Refresh package lists so apt picks up the new repository.
3. Install the package:
   • Run: apt install anti-gravity
4. Launch the IDE:
   • Start from your application menu or run antigravity from the terminal.

During my install, adding the repo and running the apt install was all that was needed. The package installed without additional manual configuration.

Windows and macOS Notes

• Windows:
  • Download the installer and click through the setup. It’s a standard installation flow.
• macOS:
  • Install using the provided package from the official source. The steps mirror a typical macOS app install.

First Launch and Welcome Flow

On first launch, Antigravity takes a moment to initialize. You’ll see a welcome flow that mirrors the VS Code experience.

• Import or start fresh:
  • Import your VS Code settings and extensions, or start with a clean profile.
• Choose a theme:
  • I picked dark mode.
• Select the agent role:
  • Agent-driven (agent takes control), agent-assisted (recommended), or review mode.
• Set policy and controls:
  • Configure terminal execution (allowed or restricted), and set review behavior such as “always proceed” or “request review.”
• Review key bindings:
  • Antigravity presents default keybindings, including one to open the Agent Manager.

At this point, you’ll be prompted to sign in with Google to enable model access. After authentication, accept the agreement presented in the terminal window. The IDE will then return you to the workspace selection screen.

Signing In and Connecting Models

Antigravity does not use local models. To enable the agent, sign in with your Google account and connect to models through one of these:

• Vertex AI (GCP Model Garden)
• Google AI Studio

Once signed in, the agent can access the models and run tasks in your workspace. If needed, the IDE may prompt you to select your model from a list. The menu shows options that include providers like Anthropic and GPT variants exposed through GCP.

Choosing Workspaces

After signing in, select an existing workspace folder to begin. Antigravity opens your project and enables the agent within that context. You can start fresh or continue work in a current repository.

The agent can run in the terminal, edit files, and track tasks within the notebook-like task view. If a previous workspace session appears, you can remove it and open a new one.

Agent Modes and Policies

During setup, Antigravity asks how you want the agent to behave:

• Agent-driven:
  • The agent takes initiative and drives the process.
• Agent-assisted (recommended):
  • The agent proposes changes and actions; you approve as needed.
• Review mode:
  • The agent reviews or supports without taking control.

You can also set policies for:

• Terminal execution:
  • Allow or restrict execution in the terminal.
• Review rules:
  • “Always proceed,” “request review,” or similar options to control the level of oversight.

These settings determine how much autonomy the agent has and how often it asks for confirmation before taking action.

The Agent Manager

Open the Agent Manager with a keybinding (e.g., Ctrl+E). From there, you can:

• Start a conversation with the agent tied to your workspace.
• Add multiple agents if needed.
• Monitor ongoing tasks in a dedicated panel.

The Agent Manager combines chat-style prompts with a task control interface. It shows planning steps, execution status, and outputs, and it allows you to approve actions when the agent requests permission.

Model Selection and Execution Modes

In the Agent Manager, the model selector lets you choose among the connected options provided through GCP. You can also switch between two execution modes:

• Planning:
  • Suited for complex, multi-step tasks where the agent needs to outline and coordinate multiple actions.
• Fast:
  • A quicker mode for simpler or smaller tasks where rapid iteration is more important than deep planning.

If your task is complex, pick Planning. For brief changes or small code edits, Fast can be more responsive subject to model availability and quotas.

Running a Task Through the Agent

Once your workspace is open and a model is selected, prompt the agent from the Agent Manager. The agent will:

1. Think and plan:
   • It outlines steps, shows its plan, and may ask you to review.
2. Request approvals:
   • It may ask permission to run commands or make changes.
3. Execute in the terminal:
   • With approval, it runs commands in the terminal, creates files, installs dependencies, and proceeds with the plan.
4. Produce artifacts and verification:
   • It shows outputs, logs, new files, and any verification results in the task panel.

During my test, the agent requested permission to run terminal commands and proceeded to install missing dependencies (Node.js) automatically. It handled the installation and continued executing its plan within the terminal.

Task Monitoring, Artifacts, and Verification

Antigravity provides a task-focused interface that displays:

• Progress and state:
  • Planning, executing, waiting for input, or completed steps.
• Artifacts:
  • Generated files, code changes, and logged outputs.
• Verification:
  • Results or checks the agent produced after executing steps.

You can review the artifacts, accept or reject changes, and give feedback to fine-tune how the agent operates in your environment.

Synchronization with the Terminal and Editor

One of the central aspects of Antigravity’s agent workflow is synchronization between the editor and terminal:

• Editor:
  • The agent edits files, inserts code, and updates project structure.
• Terminal:
  • The agent runs shell commands, installs packages, and starts processes when permitted.

Permission prompts appear before execution, ensuring that terminal actions happen only with your approval. This keeps changes transparent while enabling the agent to handle routine setup tasks.

Managing Prompts, Plans, and Reviews

You control how assertive the agent should be. A typical flow looks like this:

• You issue a prompt or task request in the Agent Manager.
• The agent drafts a plan and asks you to review.
• You accept or modify the plan.
• The agent executes, asks for permissions, and continues.
• You review artifacts, test, and provide feedback.

This loop keeps you in charge of decisions while benefiting from automated steps and generated code. Switching between Planning and Fast modes lets you adapt to the complexity of the work at hand.

Quotas, Throttling, and Reliability Notes

During testing with a free-tier configuration, I encountered throttling and quota limits that interrupted tasks. In one case, a task terminated with an “overload” message due to model availability. Switching to a different model or mode reduced issues, but the free-tier quotas still imposed constraints.

Practical takeaways:

• Expect rate limits on free tiers, especially during high-traffic periods.
• Long-running or complex tasks may fail if the quota is exhausted mid-run.
• If a task stops due to throttling, you may need to retry later or opt for a different backend configuration.

These constraints don’t reflect your local machine’s capability; they’re tied to model access and quotas in the backend services.

Post-Install Tips

• Keep policies conservative at first:
  • Start with agent-assisted mode and “request review” enabled for terminal actions.
• Verify model settings:
  • Make sure you’re signed in and connected to the right model in the selector.
• Watch dependencies:
  • If the agent installs packages, confirm they match your project’s requirements and lockfile policies.
• Use the task view:
  • Review artifacts and verification results before merging changes.

Step-by-Step Google Antigravity First-Run Configuration

1. Launch Antigravity:
   • Give it a moment on first load.
2. Import settings or start fresh:
   • Choose to import from VS Code or begin clean.
3. Pick theme:
   • Select dark or light mode.
4. Choose agent role:
   • Agent-driven, agent-assisted (recommended), or review-focused.
5. Set policies:
   • Define terminal execution permissions and review behavior.
6. Sign in with Google:
   • Authenticate and return to the IDE.
7. Accept the agreement:
   • Complete the agreement process in the terminal window.
8. Open a workspace:
   • Select your project folder to begin.

Step-by-Step: Running Your First Agent Task

1. Open Agent Manager:
   • Use the keybinding to bring up the Agent Manager.
2. Select a model and mode:
   • Pick a model from the GCP-backed list and choose Planning or Fast.
3. Enter your prompt:
   • Describe the task you want the agent to perform.
4. Review the plan:
   • The agent outlines its steps. Accept or adjust as needed.
5. Approve execution:
   • Grant permission for terminal commands and file changes when prompted.
6. Monitor progress:
   • Watch the task panel for artifacts and verification.
7. Review output:
   • Inspect generated code, logs, and results; provide feedback if needed.

Notes on Missing Tools and Dependencies

If the agent needs tools your system lacks, it may attempt to install them. In my session, it installed Node.js before proceeding with the plan. You still approve each action, so nothing runs without your knowledge. Keep an eye on:

• Package versions:
  • Ensure installations align with your project’s version constraints.
• Security and permissions:
  • Confirm you trust the commands before approving.

What Stood Out in Daily Use

• Clean UI on top of VS Code:
  • Easy to acclimate if you’re familiar with VS Code.
• Clear task lifecycle:
  • Planning, approvals, execution, and verification are visible and auditable.
• Respect for permissions:
  • Terminal commands require approval, which keeps control in your hands.
• Model flexibility:
  • The selector lets you switch models and execution styles mid-workflow.

Under free-tier conditions, throttling and quota limits were the main operational constraint. Tasks that required extended access sometimes failed due to backend availability, not because of the editor or local setup.

Constraints and Expectations

• No local models:
  • You must connect through Vertex AI or Google AI Studio.
• Quotas and throttling:
  • Free-tier usage is subject to rate limits and can interrupt tasks.
• Agent autonomy is configurable:
  • Pick the mode and policies that fit your risk tolerance and workflow.

These constraints are part of the current experience and worth considering as you adopt Antigravity.

Final Thoughts

Antigravity brings an agent-centered approach to a familiar editor foundation. The integration of natural language commands, a task-oriented panel, and terminal synchronization creates a clear path for guided development. While the free-tier model access can throttle and interrupt tasks during high load, the day-to-day experience of planning, approving, and executing tasks within a single IDE is straightforward.

If you want an AI-assisted IDE that sticks close to the VS Code experience and adds an agent with transparent permissions, Antigravity is easy to install and simple to get started with. The setup is quick, the agent modes fit different comfort levels, and the task system makes it clear what the agent is doing at each step. As long as you’re aware of model quotas and plan accordingly, it’s a practical way to add AI-driven assistance to your coding workflow.