Getting Started with Google Antigravity

1. Introduction

In this codelab, you will learn about Google Antigravity (referred to Antigravity for the rest of the document), an agentic development platform, evolving the IDE into the agent-first era.

Unlike standard coding assistants that just autocomplete lines, Antigravity provides a "Mission Control" for managing autonomous agents that can plan, code, and even browse the web to help you build.

Antigravity is designed as an "agent-first" platform. It presupposes that the AI is not just a tool for writing code but an autonomous actor capable of planning, executing, validating, and iterating on complex engineering tasks with minimal human intervention.

What you'll learn

Installing and configuring Antigravity
Exploring key concepts of Antigravity like Agent Manager, Editor, Browser and more
Exploring a few use cases with Antigravity

What you'll need

Currently Antigravity is available as a preview for personal Gmail accounts. It comes with a free quota to use premier models.

Antigravity needs to be locally installed on your system. The product is available on Mac, Windows and specific Linux distributions. In addition to your own machine, you would need the following:

Chrome web browser
A Gmail account (Personal Gmail account).

This codelab, designed for users and developers of all levels (including beginners).

2. Installation

We will begin with installing Antigravity. Currently the product is available for preview and you can use your personal Gmail account to get started with it.

Go to the downloads page and click on the appropriate Operating System version that is applicable to your case. Launch the application installer and install the same on your machine. Once you have completed the installation, launch the Antigravity application. You should see a screen similar to the following:

Please proceed with clicking on Next each time. Key steps are detailed below:

Choose setup flow: This brings up the option for you to import from your existing VS Code or Cursor settings. We will go with a fresh start.
Choose an Editor theme type. We will go with the Dark theme but it's entirely up to you, depending on your preference.
How do you want to use Antigravity agent:

Let's understand this in a bit more detail and remember that it is not set in stone and can be changed at any time, even as you interact with the Agent.

Before we delve into the options, let us look at two specific properties here (which you see to the right of the dialog):

Terminal Execution policy

This is about giving the Agent the ability to execute commands (applications/tools) in your terminal. There are three options over here.

Off: Never auto-execute terminal commands (except those in a configurable Allow list)
Auto: Agent decides whether to auto-execute any given terminal command. In case it needs to get your permission, it will decide and ask you for it.
Turbo: Always auto-execute terminal commands (except those in a configurable Deny list)

Review policy

As the Agent goes about its task, it creates various artifacts (Task plan, Implementation plan, etc). The review policy is set such that you can determine who decides if it needs to be reviewed. Should you always want to review it, or let the agent decide on this. Accordingly, there are three options here too.

Always Proceed: Agent never asks for review
Agent Decides: Agent will decide when to ask for review
Request Review: Agent always asks for review

Now that we have understood this, the 4 options are nothing but specific presets for the Terminal execution and review policies for 3 of them and a 4th option available where we can completely custom control it. These 4 options are available so that we can choose how much autonomy you want to give to the Agent to execute commands in the terminal and get artifacts reviewed before moving ahead with the task.

These 4 options are:

Agent-driven development
Agent-assisted development
Review-driven development
Custom configuration

The Agent-assisted development option is a good balance and the recommended one since it allows the Agent to make a decision and come back to the user for approval.

So pick your choice and ideally for now, let's go with the recommended approach.

Configure your Editor: Choose your preferences.
Sign in to Google: As mentioned earlier, Antigravity is available in preview mode and free if you have a personal Gmail account. So sign in now with your account. Ensure that you let a new Chrome Profile get created for this. This will open up the browser allowing you to sign in. On successful authentication, you will see a message similar to the one below and it will lead you back to the Antigravity application. Go with the flow.
Terms of Use: You can make a decision if you'd like to opt-in or not and then click on Next.

This will lead you to the moment of truth, where Antigravity will be waiting to collaborate with you. We are ready to get started.

3. The Agent Manager

Antigravity forks the open-source Visual Studio Code (VS Code) foundation but radically alters the user experience to prioritize agent management over text editing. The interface is bifurcated into two distinct primary windows: the Editor and the Agent Manager. This separation of concerns mirrors the distinction between individual contribution and engineering management.

The Agent Manager: Mission Control

Upon launching Antigravity, the user is typically greeted not by a file tree, but by the Agent Manager, as shown below:

This interface acts as a Mission Control dashboard. It is designed for high-level orchestration, allowing developers to spawn, monitor, and interact with multiple agents operating asynchronously across different workspaces or tasks.

In this view, the developer acts as an architect. They define high-level objectives, examples could be:

Refactor the authentication module
Update the dependency tree
Generate a test suite for the billing API

As the diagram above indicates, each of these requests spawns a dedicated agent instance. The UI provides a visualization of these parallel work streams, displaying the status of each agent, the Artifacts they have produced (plans, results, diffs), and any pending requests for human approval.

This architecture addresses a key limitation of previous IDEs that had more of a chatbot experience, which were linear and synchronous. In a traditional chat interface, the developer must wait for the AI to finish generating code before asking the next question. In Antigravity's Manager View, a developer can dispatch five different agents to work on five different bugs simultaneously, effectively multiplying their throughput.

If you click on Next above, you have the option to open a Workspace.

Think of Workspace as you knew from VS Code and you will be done. So we can open up a local folder by clicking on the button and then selecting a folder to start with. In my case, I had a folder in my home folder named my-agy-projects and I selected that. You can use a completely different folder.

Note, you can completely skip this step if you'd like and you can open up a Workspace at any time later too.

Once you complete this step, you will be in the Agent Manager window, which is shown below:

You will notice that the application is immediately geared to start a new conversation in the workspace folder (my-agy-projects) that was selected. Just notice that you can use your existing knowledge of working with other AI applications (Cursor, Gemini CLI) and use @ and other ways to include additional context while prompting.

Do look at both the Planning and the Model Selection dropdowns. The Model Selection dropdown allows you to choose from one of the models available at the moment, for your Agent to use. The list is shown below:

Similarly, we find that the Agent is going to be in a default Planning mode. But we can also go for the Fast mode.

Let's look at what the documentation says on this:

Planning: An Agent can plan before executing tasks. Use for deep research, complex tasks, or collaborative work. In this mode, the Agent organizes its work in task groups, produces Artifacts, and takes other steps to thoroughly research, think through, and plan its work for optimal quality. You will see a lot more output here.
Fast: An Agent will execute tasks directly. Use for simple tasks that can be completed faster, such as renaming variables, kicking off a few bash commands, or other smaller, localized tasks. This is helpful for when speed is an important factor, and the task is simple enough that there is low worry of worse quality.

If you are familiar with the Thinking budget and similar terms in Agents, think of this as the ability to control the thinking of the Agent, thereby having a direct impact on the thinking budget. We will go with the defaults for now but do remember that at the time of the launch, Gemini 3 Pro model availability is as per limited quotas to everyone, so do expect appropriate messages indicating if you have exhausted those free quotas for Gemini 3 usage.

Let's spend a bit of time now on the Agent Manager (window) here and understand a few things, so that it's clear about the basic building blocks, how you navigate in Antigravity and more. The Agent Manager window is produced below:

Please refer to the above diagram with the numbers:

Inbox: Think of this as a way to track all your conversations in one place. As you send Agents off on their tasks, these will appear in the Inbox and you can click on the Inbox to get a list of all the current conversations. Tapping on any of the conversations will lead you to all the messages that have been exchanged, status of the tasks, what the Agent has produced or even if it is waiting for an approval from your side on the tasks. This is a great way to come back later to a previous task that you were working on. A very handy feature.
Start Conversation: Click on this to begin a new conversation. This will directly lead you to the input where it says Ask anything.
Workspaces: We mentioned about Workspaces and that you can work across any workspace that you want. You can add more workspaces at any time and can select any workspace while starting the conversation.
Playground: This is a great way by which you can simply start a conversation with the agent and then if you'd like to convert that into a workspace, where you have stricter control over the files, etc. Think of this as a scratch area.
Editor View: So far we are in the Agent Manager view. You can switch at any time to the Editor view, if you'd like. This will show you your workspace folder and any files generated. You can directly edit the files there, or even provide inline guidance, command in the editor, so that the Agent can do something or change as per your modified recommendations/instructions. We will cover the Editor View in detail in a later section.
Browser: Finally, we come to one of the clear differentiators that makes Antigravity very powerful and that is its close integration with the Chrome browser. Let's get going with setting up the Browser in the next section.

4. Setting up the Antigravity Browser

As per the documentation, when the agent wants to interact with the browser, it invokes a browser subagent to handle the task at hand. The browser subagent runs a model specialized to operate on the pages that are open within the Antigravity-managed browser, which is different from the model you selected for the main agent.

This subagent has access to a variety of tools that are necessary to control your browser, including clicking, scrolling, typing, reading console logs, and more. It can also read your open pages through DOM capture, screenshots, or markdown parsing, as well as taking videos.

This means that we need to launch and install the Antigravity browser extension. Let's do that by actually starting a conversation in the Playground and going through the steps.

Select Playground and give the follow task go to antigravity.google to the Agent as shown below:

Submit the task. You will see the Agent analyzing the task and you can inspect the thought process. At some point, it will correctly proceed and mention that it needs to set up the browser agent as shown below. Click on Setup.

This will bring up the browser and display a message to install the extension as shown below:

Go ahead and you will be led to the Chrome Extension that you can then install.

Once you successfully install the extension, Antigravity Agent will get to work and indicate that it is expecting you to allow it permission to do its task. You should see some activity in the browser window that has been opened:

Switch back the Agent Manager view and you should see the following:

This is exactly what we expected to happen since we asked the Agent to go and visit the antigravity.google website. Give it the permission and you will find that the website was safely navigated to, as shown below:

Inspecting the Artifacts

Now comes the interesting part. Once the agent has finished its work, you should be able to see its entire work. And that brings in artifacts, the foundation on which you build your trust in terms of what work you have planned to do, what you have done so far and how you have verified the same.

Artifacts solve the "Trust Gap". When an agent claims, "I have fixed the bug" the developer previously had to read the code to verify. In Antigravity, the agent produces an Artifact to prove it.

Antigravity focuses on producing key artifacts depending on the task. This can range from the Task plan to Implementation Plan and finally the Walkthrough plan (with Verification). Inside of these plans, you should consider to have things like the following:

Task Lists & Plans: Before writing code, the agent generates a structured plan. The user can review this plan, edit it, and approve it.
Code Diffs: Standardized diff views showing exactly what lines will change.
Screenshots: The agent captures the state of the UI before and after a change.
Browser Recordings: For dynamic interactions (e.g., "Click the login button, wait for the spinner, verify the dashboard loads"), the agent records a video of its session. The developer can watch this video to verify that the functional requirement is met without running the app themselves.
Test Results: Structured logs of passing/failing tests generated and executed by the agent.

On the Top Right, next to Review changes in Agent Manager view, you should be able to see a button to toggle the artifacts or its its toggled on, you can see the generated artifacts list:

You should see the Artifacts view as shown below. In our case here, we instructed the Agent to visit the antigravity.google page and hence it has captured the screenshot, created a video of the same, etc.

Developers can interact with these Artifacts using "Google Docs-style comments." You can select a specific action or task, provide a command the way you would like it to be and then submit that to the Agent. The Agent will then ingest this feedback and iterate accordingly. Think about using interactive Google Docs, where you provide feedback to the author and the author then reiterates on that.

5. Revisit the Inbox

If you have started a few conversations with the Agents, you should now take a look at your Inbox in the Agent Manager window. This will show you all the conversations. Click on any of the conversations to see the history of that conversation, the artifacts produced and more. In our case, after we ran the first conversation, our Inbox shows the conversation listed, as shown below:

Clicking on that conversation will provide you the details:

You can continue the conversation from here too.

6. The Editor

The Editor retains the familiarity of VS Code, ensuring that the muscle memory of seasoned developers is respected. It includes the standard file explorer, syntax highlighting, and extensions ecosystem.

You can click on the Open Editor button right on the top right in Agent Manager to go to the Editor.

The Editor is augmented with "Agent Awareness".

Inline Command: The editor supports vibe coding and inline instruction, where users can highlight code and instruct the agent to "Make this more efficient" or "Add comments explaining this logic".
Agent Side Panel : Use the panel on the right side of the editor to work directly with the agent. You can spin up new conversations from here or give instructions to change your code.

As we go through some use cases that have got to do with web development, where the Agent creates multiple code files, we can then take a look at the Editor to see the files, make changes and interact directly with the Agent from here.

7. Toggling between the Editor and Agent Manager

Keep in mind that Antigravity is opinionated in the fact that both Editor and Agent Manager are separate windows and there is a clear need for both. You have the option of switching from one to the other, either via the Open Agent Manager button on the top right when you are in Editor or by clicking on the Open Editor button on the top right when you are in the Agent Manager.

Alternately, you also have the following keyboard shortcut to toggle between the two modes: Cmd + E

8. Use Cases

Now that we have a basic understanding of the product, let's dive into a few use cases to see it in action. Note that Antigravity is an Agent first platform. This means that in most cases, we are simply given an instruction to the Agent and the Agent then goes off on its own, does its task, asks permissions if needed, produces the artifacts and then notifies us if the task is done. As a result of that, we cannot produce every single output of the Agent conversation in each of the following use cases. We will share the instructions and a few necessary screenshots of the expected results but your results might differ a bit.

The use cases that we will cover range from automating a few tasks with external sites, to generating and verifying unit test cases for a project, to a full web site development. Let's go.

News Highlights

This is a simple use case but it can be the basis via which you can use the web browser to visit web sites, extract information, do some actions and then return data to the user.

In this case, we are going to visit the Google News site and extract some information from there. But you can easily experiment with a site of your choice and see how it goes.

Ensure that you are in the Agent Manager and have selected the Playground, as shown below:

Then give the following instruction:

This will kick off the Agent process and it will determine that it needs to launch the browser, etc. You should pay close attention to the Thinking process and see how the Agent goes about its work. If all goes well, it should launch the Antigravity browser and visit the site as shown below. The blue border around the site shows that the Agent is now controlling the browser and navigating the site to get the information.

Once it's done with its work, you should also see the Artifacts getting generated, as shown below:

A sample execution by the Agent is shown below:

Notice that on the left, we have the Thought process, you can also scroll through the points and view the playback and other data.

Things to try out

Once you understand this, pick a website that is available and which you would like the Agent to go and get/summarize some data from. Consider some website that you know has Dashboards and charts and ask it to pick a few values.
Try the following prompt: Visit https://docs.cloud.google.com/release-notes and get me a summary of the release notes, categorized by product.

Generate a Dynamic Website with Python + Flask

Let's move now to generate a complete web application. The web application that we are going to create is a site which provides information on a 1-day technical event, which has talks across the day by multiple speakers.

Once again, ensure that you are in the Agent Manager and have selected the Playground.

Give the following prompt:

I would like to generate a website that is a 1-day technical conference informational site.

The website should have the following functionality:
        1. A home page that shows the current date, location, schedule and time table.
        2. The 1-day event is a list of 8 talks in total.
        3. Each talk has 1 or 2 max. speakers. 
        4. A talk has an ID, Title, Speakers, Category (1 or 2), Description and time of the talk.
        5. Each speaker has a First Name, Last Name and LinkedIn url.
        6. Allow for users to search by category, speaker, title.
        7. Give a lunch break of 60 minutes.
        8. Use dummy data for events and speakers, come up with a schedule, the event is about Google Cloud Technologies.
        9. Tech Stack: Python and Flask framework on server side. Front-end is basic HTML, CSS and JavaScript. 
        10. Test out the site on your own for all functionality and provide a detailed README on how to setup, run and make any further changes. 
11. Launch the web application for me to review.

You can begin the conversation by giving the above prompt:

As the Agent goes about its task, it will proceed with creating the artifacts:

Task Artifact
Implementation Artifact
Walkthrough Artifact

The Task Artifact given below was the initial sequence of tasks that the Agent deciphered it should do based on the task given to it. A sample screenshot from the execution is shown below:

You can then click on the Implementation Plan artifact. A sample screenshot is shown below:

And finally, you have the Walkthrough artifact. It contains all that the Agent did as shown below:

Notice that it has started the server and has provided me the URL, which I click and I have the application, a sample screenshot is shown below:

If I switch to the Editor, notice in the screen that it contains the folder where the Python Flask application is generated. You will also notice that the Agent mode is tagged to the right and you can continue the conversation over there too.

Now, let's say that we want to add some more talks to the event. We can stay in the Editor and in the Agent panel, give an instruction like Add two more talks to the schedule.

This will result in the Agent analyzing the requirement, updating the Task, Implementation Plan and then validating the updated functionality too. A sample conversation is shown below:

You can switch back to the Agent Manager if you'd like. This process should help you understand the process between shifting from Agent Manager to Editor, making changes accordingly and so on.

Note: While executing this task, the Agent tried to start the Flask Server on port 5000, which was in use on the current machine. It kept attempting the next free port, till it decided to use 8080 and it was able to start the Server.

Things to try out

Add additional functionality that you would like to the application. Provide the details to the Agent and notice how it goes about its task by first modifying the task list, then implementation plan and so on.
Ask the Agent to generate a README or more documentation for the application.

Generate a simple productivity App

We are going to now generate a simple Pomodoro timer web application.

Ensure that you are in the Agent Manager and have selected the Playground. Give the following prompt:

Create a productivity app that features a Pomodoro timer. Give a calm and aesthetic look to the application.

Notice how it goes about creating the Task list, implementation plan and then goes about that. Keep paying attention to the flow, there might be situations in which it will prompt for your review. A sample run is shown below.

In this case, it should also launch the Antigravity browser, do its own testing and then confirm that the tests succeeded. One of the things that it generated was a Media Artifact that contains the video of its verification. This is a great way to see what it tested. I also suggested some style changes since it didn't take effect and it was able to do that.

The final app looked like the one below and it looks quite good.

How about we can add a nice timer image to the application. All we need to do is issue a follow up instruction as given below:

Add an image to the application that displays a timer.

This resulted in the agent adding a new task to the Task artifact:

It then generated an image as it went through its task:

Finally, the app had the image as we requested:

Things to try out

Notice the background for the hourglass icon in the application is not transparent. Try telling the agent to make that transparent.
Try out a few variations of any application that you would like to generate. Play with the styles, images, ask for changes, etc.

Generate Unit Tests, Mock Stubs and Validate Tests

The final use case that we will try here is that of generating unit tests for a specific code file that we have and for the Agent to also execute the tests and validate them.

For this, we are going to have a workspace that has a single Python file as shown below:

from typing import Dict

# --- Custom Exceptions ---
class InventoryShortageError(Exception):
    """Raised when there is not enough item stock."""
    pass

class PaymentFailedError(Exception):
    """Raised when the payment gateway rejects the transaction."""
    pass

class InvalidOrderError(Exception):
    """Raised when the order violates business rules."""
    pass

# --- External Service Interfaces (To be Mocked) ---
class InventoryService:
    def get_stock(self, product_id: str) -> int:
        """Connects to DB to check stock."""
        raise NotImplementedError("Real connection required")

    def decrement_stock(self, product_id: str, quantity: int):
        """Connects to DB to reduce stock."""
        raise NotImplementedError("Real connection required")

class PaymentGateway:
    def charge(self, amount: float, currency: str) -> bool:
        """Connects to Stripe/PayPal."""
        raise NotImplementedError("Real connection required")

# --- Main Business Logic ---
class Order:
    def __init__(self, 
                 inventory_service: InventoryService, 
                 payment_gateway: PaymentGateway,
                 customer_email: str,
                 is_vip: bool = False):
        
        self.inventory = inventory_service
        self.payment = payment_gateway
        self.customer_email = customer_email
        self.is_vip = is_vip
        self.items: Dict[str, Dict] = {} # {product_id: {'price': float, 'qty': int}}
        self.is_paid = False
        self.status = "DRAFT"

    def add_item(self, product_id: str, price: float, quantity: int = 1):
        """Adds items to the cart. Rejects invalid prices or quantities."""
        if price < 0:
            raise ValueError("Price cannot be negative")
        if quantity <= 0:
            raise ValueError("Quantity must be greater than zero")

        if product_id in self.items:
            self.items[product_id]['qty'] += quantity
        else:
            self.items[product_id] = {'price': price, 'qty': quantity}

    def remove_item(self, product_id: str):
        """Removes an item entirely from the cart."""
        if product_id in self.items:
            del self.items[product_id]

    @property
    def total_price(self) -> float:
        """Calculates raw total before discounts."""
        return sum(item['price'] * item['qty'] for item in self.items.values())

    def apply_discount(self) -> float:
        """
        Applies business logic:
        1. VIPs get flat 20% off.
        2. Regulars get 10% off if total > 100.
        3. No discount otherwise.
        """
        total = self.total_price
        
        if self.is_vip:
            return round(total * 0.8, 2)
        elif total > 100:
            return round(total * 0.9, 2)
        
        return round(total, 2)

    def checkout(self):
        """
        Orchestrates the checkout process:
        1. Validates cart is not empty.
        2. Checks stock for all items.
        3. Calculates final price.
        4. Charges payment.
        5. Updates inventory.
        """
        if not self.items:
            raise InvalidOrderError("Cannot checkout an empty cart")

        # 1. Check Inventory Logic
        for product_id, data in self.items.items():
            available_stock = self.inventory.get_stock(product_id)
            if available_stock < data['qty']:
                raise InventoryShortageError(f"Not enough stock for {product_id}")

        # 2. Calculate Final Price
        final_amount = self.apply_discount()

        # 3. Process Payment
        try:
            success = self.payment.charge(final_amount, "USD")
            if not success:
                raise PaymentFailedError("Transaction declined by gateway")
        except Exception as e:
            # Catching generic network errors from the gateway
            raise PaymentFailedError(f"Payment gateway error: {str(e)}")

        # 4. Decrement Stock (Only occurs if payment succeeded)
        for product_id, data in self.items.items():
            self.inventory.decrement_stock(product_id, data['qty'])

        self.is_paid = True
        self.status = "COMPLETED"
        
        return {"status": "success", "charged_amount": final_amount}

Ensure that you have the above Python file locally in a folder and you load that as a Workspace in Antigravity.

This is a simple Order service that has the following key functionality in the checkout function:

Validates cart is not empty.
Check stock for all items.
Calculates final price.
Charges payment.
Updates inventory.

We are going to assign the Agent the task of generating unit test cases, providing Mock implementations and executing the tests to make sure that they succeed.

We will open our specific workspace folder and you will notice that we can now use the @ symbol too to reference the file. For example, we could do the following:

This comes up with some explanation of what this file is:

We can ask it to generate a better visualization via the prompt:

Can you visually show this class for better understanding

My next step is to generate the unit tests and ask the Agent to test it out. I give the following prompt:

generate unit tests for this module and test it out with mock implementations.

It generated the following Task artifact and went about its task.

You can also see the details of the tests that it ran:

One of the files that it generated was the test file too. A screenshot of which is shown below:

Things to try out

Take your own code and see what you can ask the Agent to do, right from adding more functionality to refactoring parts of your code.

9. Congratulations

Congratulations, you've successfully installed and understood how to use Antigravity, the Agent-first development platform. The different use cases that we tried should help you take your own requirements and explore how Antigravity can collaborate with you to complete them.

Reference docs

Official Site : https://antigravity.google/
Documentation: https://antigravity.google/docs
Usecases : https://antigravity.google/use-cases
Download : https://antigravity.google/download
Youtube Channel for Google Antigravity : https://www.youtube.com/@googleantigravity