The Antigravity Setup Guide: From Installation to Your First AI System

Google Antigravity is a free, locally-installed agentic development platform - and the one I use to run a 27-agent system that replaced an entire team. It can build, test, and deploy entire systems while you watch - or while you do something else entirely.

This guide takes you from zero to a working Antigravity setup in one sitting. You will install it, configure it for real work, and understand every major concept - agents, skills, rules, workflows, and the project structure that makes it all hold together. By the end, you will have a system ready to build anything from a marketing team to an analytics department to a full business operations stack.

No coding experience required. If you can install an app and edit a text file, you can do this.

Part 1: Install Antigravity

System Requirements

Antigravity runs on macOS, Windows, and Linux. Check that your machine qualifies:

macOS: Version 12 (Monterey) or later. Works on both Apple Silicon and Intel Macs.
Windows: Windows 10 (64-bit) or later.
Linux: Ubuntu 20+, Debian 10+, Fedora 36+, or RHEL 8+.

You also need:

Google Chrome installed (required for the browser agent features)
A Google account (free Gmail account works)

Download and Install

Go to antigravity.google/download
Download the installer for your operating system
Run the installer and follow the prompts

That is it. No package managers, no terminal commands, no dependencies to chase down.

First Launch Setup

When you open Antigravity for the first time, it walks you through a short setup wizard. Here are the decisions that matter:

Import VS Code settings? If you already use VS Code, choose “Import settings.” Your extensions, keybindings, and preferences carry over. Antigravity is built on the VS Code codebase, so everything you are used to works the same way. If you do not use VS Code, choose “Start fresh.”

Choose a theme. Light or dark.

Choose a development mode. This is the most important decision in the setup. You have three options:

Agent-driven development (“Autopilot”): The agent writes code, creates files, and runs commands automatically. Maximum speed, minimum control. Best for experienced users who trust the system and want to move fast.
Review-driven development: The agent asks your permission before every action. Maximum control, minimum speed. Best if you want to understand every change before it happens.
Agent-assisted development: The recommended middle ground. You stay in control of the overall direction, and the agent handles safe automations (like installing packages or running tests) without asking. Start here if you are new.

You can change this later in settings. Do not overthink it.

Terminal policy. Set to “Auto.” This lets the agent run terminal commands without asking permission for safe operations (like npm install) while still requiring approval for potentially destructive ones.

Sign in with Google. Use your Google account. This gives you access to the AI models that power the agent. A free account works - you get access to all models and all features. The free tier has rate limits that refresh weekly, which is enough for learning and lighter use. If you hit limits during longer sessions, Google AI Pro ($19.99/month) refreshes them every five hours.

Select a reasoning model. You will see several options. Start with Gemini 3.1 Pro (high). It is the most capable default model and handles complex multi-step tasks well. You can switch models anytime.

Part 2: Understand the Interface

Antigravity has three distinct surfaces. You will use all three, but for different purposes.

The Editor

This is your primary workspace. It looks and feels like VS Code because it is built on the same codebase. You edit files, browse your project, and use the terminal here.

The key addition is the Agent Side Panel on the right side. This is where you talk to the agent - give it tasks, ask questions, and review what it produces. I run 27 agents through a system built on this foundation. The side panel is where that starts.

The Agent Manager

Press Cmd + E (Mac) or Ctrl + E (Windows) to toggle between the Editor and the Agent Manager.

The Agent Manager is your mission control. When you are running multiple agents across multiple projects, this is where you oversee all of them. It shows:

Active tasks and their progress
Artifacts the agent has produced (documents, diagrams, code diffs)
Knowledge Items the agent has learned from your conversations

You do not need the Agent Manager when you are working on a single project. But when you start running parallel workstreams - researching in one workspace while building in another - this becomes essential.

The Browser

Antigravity includes a built-in browser agent that can control Chrome. It opens a separate Chrome profile (isolated from your personal browsing) and can:

Navigate to URLs, click buttons, fill forms
Read and extract content from web pages
Take screenshots and record actions
Test your web applications end-to-end

You do not need to configure this separately. It works out of the box as long as Chrome is installed on your machine.

Part 3: The Three Ways to Interact with the Agent

Antigravity gives you three ways to communicate with the AI, each designed for different situations.

Agent (for complex tasks)

This is the main interaction mode. Open the Agent Side Panel and type what you need. The agent will plan, execute, and iterate on multi-step tasks.

Examples:

“Build a REST API for a todo app with authentication”
“Research the top 5 competitors in the dental SaaS space and write a competitive analysis”
“Refactor this function to handle edge cases and add tests”

The agent can switch between two modes:

Planning Mode: For complex tasks. The agent breaks the work into subtasks, shows you the plan, and executes step by step. Use this when the task has multiple moving parts.
Fast Mode: For simple tasks. The agent executes directly without an explicit planning phase. Use this for quick edits, renames, or one-step operations.

Tab (for inline code)

While you are writing code, Antigravity offers intelligent completions. Three types:

Supercomplete: Full code suggestions near your cursor. Press Tab to accept.
Tab-to-Jump: Suggests the next logical place you should edit. Press Tab to jump there.
Tab-to-Import: Detects missing imports and suggests them. Press Tab to add.

This is not file-level autocomplete. It understands your entire project, not just the current file.

Command (for inline instructions)

Press Cmd + I (Mac) or Ctrl + I (Windows) to open the Command bar. Type a natural language instruction right where your cursor is. This works in both the code editor and the terminal.

Examples:

In code: “Create a React component for a pricing table with three tiers”
In terminal: “Find all processes running on port 3000 and kill them”

Use Command for quick, targeted actions. Use Agent for anything that requires planning or multiple steps.

Part 4: Project Structure

This is where most people either build a system or build a mess. The folder structure you set up determines whether your agent is a powerful assistant or a confused tool that forgets everything between conversations.

The Configuration Hierarchy

Antigravity uses a layered configuration system:

Global configuration (applies to every project):

~/.gemini/
├── GEMINI.md                              # Global rules for the agent
└── antigravity/
    ├── skills/                            # Global skills (available everywhere)
    │   └── my-global-skill/
    │       └── SKILL.md
    └── mcp_config.json                    # MCP server connections

Workspace configuration (applies to one project):

your-project/
├── .agent/
│   ├── rules/                             # Project-specific rules
│   │   └── coding-standards.md
│   ├── skills/                            # Project-specific skills
│   │   └── my-project-skill/
│   │       └── SKILL.md
│   └── workflows/                         # Project-specific workflows
│       └── my-workflow.md
└── ... your project files

GEMINI.md - The Brain File

GEMINI.md is the single most important file in your setup. It is a plain markdown file that tells the agent who it is, what it is working on, and how it should behave. The agent reads it before doing anything.

Your global GEMINI.md (at ~/.gemini/GEMINI.md) contains rules that apply everywhere - your coding preferences, communication style, tools you use. Your workspace-level rules (in .agent/rules/) add project-specific context.

Here is a starter GEMINI.md for a business project:

# Project Configuration

## Business Context
- Company: [Your company name]
- Industry: [Your industry]
- What we do: [One sentence]
- Key tools: [The platforms and services you use]

## How to Work
- Be direct. No filler. Every output must be actionable.
- When uncertain, say so. Never fabricate data.
- Cite sources when making claims.
- Ask clarifying questions before starting complex tasks.

## Code Standards
- Language: TypeScript (strict mode)
- Framework: [Your framework]
- Style: Follow existing patterns in the codebase
- Tests: Write tests for new functionality

Keep it concise. Write it in plain language. Update it as your project evolves. You will rewrite this file several times in the first month - that is normal and expected.

Tip: You do not have to write GEMINI.md from scratch. Ask the Antigravity agent to draft or improve it based on your project. It already understands your codebase.

Part 5: Skills - Teaching the Agent New Capabilities

Skills are reusable packages of knowledge that extend what the agent can do. A skill is a folder containing a SKILL.md file with instructions the agent follows when working on specific tasks.

Why Skills Matter

Without skills, the agent uses its general knowledge for every task. That is like hiring a generalist for every role in your company. Skills let you create specialists - a researcher who knows your competitive landscape, a copywriter who matches your brand voice, an analyst who follows your reporting framework.

The system I use to run Ravenopus - 27 agents, zero employees - is built entirely on skills. They are not a nice-to-have. They are the difference between a chatbot and an operations layer.

Creating a Skill

Skills live in .agent/skills/ (workspace-specific) or ~/.gemini/antigravity/skills/ (global). Each skill gets its own folder with a SKILL.md file inside.

.agent/skills/
  researcher/
    SKILL.md
  strategist/
    SKILL.md
  copywriter/
    SKILL.md

The SKILL.md Format

Every SKILL.md starts with YAML frontmatter that tells the agent what the skill does:

---
name: researcher
description: "Conducts competitive intelligence and market research.
  Produces structured research briefs with sourced findings
  and strategic implications."
---

# Market Researcher

## Role
You are a market research analyst. You gather, synthesize,
and structure information into actionable research briefs.

## How You Work
- Every claim must include a source or be labeled as inference
- Organize findings by theme, not by source
- Include a "So What" section: what do these findings mean
  for our next move?

## Output Format
1. Executive Summary (3-5 sentences)
2. Key Findings (organized by theme)
3. Strategic Implications

The description field is critical. When you start a conversation, the agent sees a list of all available skills with their names and descriptions. If a skill looks relevant to your task, the agent reads the full SKILL.md and follows the instructions. You do not need to tell the agent which skill to use - it decides based on context. But you can mention a skill by name to force activation.

What Makes a Good Skill

Keep it focused. One skill, one job. A “researcher” skill and a “copywriter” skill are better than a “do everything” skill.

Write a clear description. This is what the agent reads to decide whether to activate the skill. Be specific: “Conducts competitive analysis for SaaS companies using LinkedIn, G2, and Crunchbase data” is better than “Does research.”

Include quality standards. Tell the agent what good output looks like. “Every claim must include a source” is a quality standard. “Do good research” is not.

Add examples. If the skill produces a specific type of output, include an example of what the finished product looks like. Examples beat instructions every time.

Additional Skill Resources

A skill folder can contain more than just SKILL.md:

.agent/skills/researcher/
  SKILL.md          # Main instructions (required)
  scripts/          # Helper scripts the agent can run
  examples/         # Reference outputs to learn from
  resources/        # Templates, data files, reference material

The agent can read these files when following the skill’s instructions. If your skill includes scripts, encourage the agent to run them with --help first rather than reading the entire source code.

Tip: You do not have to write skills from scratch. Describe the role you want to the Antigravity agent and ask it to create the SKILL.md for you. It will generate the frontmatter, instructions, and output format - then you refine from there.

Part 6: Rules - Persistent Context for the Agent

Rules are constraints that the agent follows across conversations. They live in .agent/rules/ as markdown files.

Rules vs. GEMINI.md

Your GEMINI.md (or global ~/.gemini/GEMINI.md) is one big configuration file. Rules are modular - separate files for separate concerns. Use rules when you want to:

Apply different constraints to different file types
Toggle rules on and off without editing your main config
Share rules across team members

Rule Activation Modes

Each rule has an activation mode that determines when it applies:

Mode	When It Activates
Always On	Applied to every conversation automatically
Manual	Only when you @mention the rule name
Model Decision	The agent decides based on a natural language description you provide
Glob	Applied only when the agent works on files matching a pattern (e.g., `.tsx`, `src//.test.ts`)

Creating Rules

Open the Customizations panel (click ”…” at the top of the Agent Side Panel), navigate to Rules, and click ”+ Workspace” or ”+ Global.”

Example rule for TypeScript projects:

# TypeScript Standards

## When to apply
All .ts and .tsx files

## Rules
- Use strict TypeScript. No `any` types unless absolutely necessary.
- Prefer `interface` over `type` for object shapes.
- All exported functions must have explicit return types.
- Use descriptive variable names. No single-letter variables outside loops.

Keep them focused and concise.

Part 7: Workflows - Repeatable Multi-Step Processes

Workflows are sequences of steps that guide the agent through repetitive tasks. Think of them as saved recipes.

When to Use Workflows

Use workflows for anything you do more than twice:

Deploying a service
Setting up a new project from a template
Running a code review process
Generating a weekly report

Creating a Workflow

Open the Customizations panel, navigate to Workflows, and click ”+ Workspace” or ”+ Global.” Give it a name and describe the steps.

Invoking a Workflow

Type /workflow-name in the Agent chat. The agent reads the workflow definition and follows the steps.

Chaining Workflows

Workflows can call other workflows. A deployment workflow might call a testing workflow first:

Step 1: Run /run-tests
Step 2: If all tests pass, build the production bundle
Step 3: Deploy to staging
Step 4: Run /smoke-test against staging URL
Step 5: If smoke tests pass, deploy to production

Part 8: MCP - Connecting External Tools

MCP (Model Context Protocol) lets Antigravity connect to external services - databases, APIs, project management tools, cloud platforms, and more.

The Built-in MCP Store

Click ”…” at the top of the Agent Side Panel, then “MCP Store.” Antigravity includes pre-configured servers for popular services:

Development: GitHub, Firebase, Supabase, Prisma
Project management: Linear, Notion
Design: Figma
Payments: Stripe, PayPal
Cloud: Google Cloud, Netlify, Heroku
Data: MongoDB, Redis, BigQuery, Postman
Search: Perplexity

Click a server, authenticate, and it is connected. The agent can then interact with that service directly - creating GitHub issues, querying your database, deploying to Netlify, all from the chat.

Custom MCP Servers

For services not in the store, configure them manually in ~/.gemini/antigravity/mcp_config.json:

{
  "mcpServers": {
    "my-custom-server": {
      "command": "npx",
      "args": ["-y", "my-mcp-server"],
      "env": {
        "API_KEY": "your-api-key"
      }
    }
  }
}

Tip: Never paste real API keys directly into config files. Use environment variables or a .env file to keep your secrets out of your project files.

MCP is what turns Antigravity from a code editor into a full operations platform. When your agent can read your database, check your analytics, update your project board, and deploy your code - all in one conversation - you are no longer context-switching between ten browser tabs. Everything flows through one interface.

Part 9: Knowledge Items - The Agent’s Memory

Antigravity automatically builds persistent memory from your conversations. These are called Knowledge Items.

How They Work

As you work with the agent, it identifies important patterns, decisions, and solutions and stores them as Knowledge Items. Each item contains a title, a summary, and related artifacts.

When you start a new conversation, the agent automatically reviews relevant Knowledge Items from past sessions. This means it remembers:

Architectural decisions you made and why
Patterns and conventions in your codebase
Problems you solved and how
Your preferences and working style

Viewing Knowledge Items

Switch to the Agent Manager (Cmd + E) to see all stored Knowledge Items. You can review, edit, or delete them.

Why This Matters

Without persistent memory, every conversation starts from zero. The agent re-reads your codebase, re-learns your preferences, and re-discovers patterns it already found yesterday. Knowledge Items eliminate this cold-start problem. The longer you use Antigravity, the smarter it gets about your specific projects.

Part 10: Putting It All Together

Here is what a well-configured Antigravity workspace looks like for a real business project:

my-project/
├── .agent/
│   ├── rules/
│   │   ├── code-standards.md          # How to write code
│   │   └── brand-voice.md             # How to write copy
│   ├── skills/
│   │   ├── researcher/
│   │   │   └── SKILL.md               # Market research specialist
│   │   ├── strategist/
│   │   │   └── SKILL.md               # Strategy and planning
│   │   ├── copywriter/
│   │   │   └── SKILL.md               # Content creation
│   │   └── analyst/
│   │       └── SKILL.md               # Data analysis
│   └── workflows/
│       ├── deploy.md                   # Deployment process
│       └── code-review.md             # Code review checklist
├── GEMINI.md                          # Project brain file
├── src/                               # Your application code
├── docs/                              # Documentation
└── outputs/                           # Agent-produced deliverables

The workflow:

GEMINI.md tells the agent the business context and global rules
Rules add specific constraints for different situations
Skills create specialist roles the agent can activate on demand
Workflows automate multi-step processes you repeat
MCP connections give the agent access to your external tools
Knowledge Items accumulate over time, making the agent smarter about your project

This is not a toy setup. This is the same architectural pattern behind production systems that replace entire departments - research teams, analytics teams, content teams, operations teams. The difference between a basic chatbot and a system that runs your business is the quality of the configuration layer you build around it.

What Comes Next

You now have a working Antigravity installation with a clear understanding of every major concept. The next step is to build something real.

If you want to see what a production-grade AI system looks like - one that runs an actual agency with 27 agents and zero employees - I share the full architectures, templates, and live builds inside the Built, Not Hired community.

Join Built, Not Hired - $49/month, founding member pricing.

Or if you want a ready-to-deploy system you can install today, browse the AI Blueprint Templates - complete agent configurations, skills, automation workflows, and setup guides for specific business niches.