Google Antigravity IDE: Complete Setup & Tutorial Guide

Transcript

In this video, I'm going to show you how to download, install, and set up Google's IDE, Anti-Gravity. I'm going to show you exactly what settings you need to be aware of during the setup process, and then also the key features within anti-gravity that you need to know before you start working on any projects. We're going to deep dive into the agent manager interface to show you how you can build powerful multi- aent workflows. I'm also going to show you browser mode which allows you to spin up browser sub aents to perform web-based tasks. So whether you're new to anti-gravity or you just want to learn more about the platform, this video is going to answer all your questions.

The first step is to click download here which is going to download anti-gravity. You then need to click on that download and install it. And then we'll move on to the setup process. Okay. Once you've installed anti-gravity, you'll see this screen for the setup process.

We'll hit next and we'll see we can now choose our setup flow. We can either start fresh or import existing settings from cursor. For this example, we're just going to start fresh. We can then choose our editor theme type. I'm going to switch to dark mode here, but you can choose whichever theme you like here.

Next, we have options here for how we want to set up our anti-gravity agent. Before we dive into the preset options, we'll just have a look at the specific properties available to us on the right. First, we have terminal execution policy. This determines whether the agent will ask for permission when it runs commands in your terminal. The three options we have are turbo, auto, and off.

Turbo means that it will essentially never ask for permission. It will just run commands whenever it needs to. Auto means that it will decide whether it needs to ask for permission or not. So some commands it will run automatically, others it will ask for permission or off means that it will ask for permission every time it runs a command. Next we have review policy.

This relates to any artifacts or plans that the agent creates and whether or not it will ask you to review it. If we use always proceed, it will never ask you to review any artifacts or plans. It will just proceed with the next step. Agent decides means that sometimes it will proceed onto the next step. Other times it will ask you to review the artifact before it continues.

And request review means that it will always ask you to review any artifact or plan once it's created. So it's up to you whether you want the agent to just continue with its work on autopilot. That's when you might use always proceed. If you want to be a consistent human in the loop to review the work that's being done, then that's when request review would be better to use. And finally we have JavaScript execution policy which is similar to the terminal execution policy.

Here we are determining whether we want the agent to execute JavaScript or ask for permission before it does that. The options we have here are turbo which means it will never ask for permission. Auto again means the agent will decide whether it should ask for permission or not. Always ask means it will ask for permission every time it runs JavaScript code. and disabled means it will just never execute any JavaScript.

Finally, we have use the default allow list for the browser and that is by default checked here. We'll leave that checked. This relates to the browser feature in anti-gravity where we can give our agent web-based tasks and it will spin up a browser agent to execute those tasks. We can leave this checked because anytime we do provide a URL to our agent that requires the browser sub agent, it will ask for permission before it visits that URL anyway. And on the left hand side we have our preset profiles.

Firstly we have agentdriven development. This means the agent is essentially going to perform all tasks and commands without asking for permission and it has these preset settings. On the other end of the spectrum we have reviewdriven development. This means that the agent will always ask for permission before it runs commands and will constantly ask you to review the artifacts that it creates. The good middle ground is agent assisted development which is the recommended setting.

That means that the agent will decide whether it needs to ask for permission or not. So some simple tasks it will just continue with. We also have custom configuration. So if you want to choose your own settings you can use that. But as I said for this video we're going to use agent assisted development.

So we'll hit next and we'll see the next section says configure your editor. This is where we can assign key binding settings and also install the recommended extensions. So, they do recommend some language- based extensions that you should install. So, we'll leave that checked and we'll stick with normal keybindings and we'll hit next. We're now prompted to sign into our Google account.

So, we'll do that now. Once we've signed into our Google account, we'll see the final step, which is the terms of use, which we need to agree to. So, I recommend reading through these before you tick the box and agree. We'll hit next. That is now going to set up our workspace within anti-gravity.

Once your IDE loads, you should see a screen similar to this. What we want to do is first open agent manager. So in the top right corner, you'll see open agent manager. Also on the center of the screen, you'll see switch to agent manager, which you can do using shortcut control E. If we click on that, that's going to open up our agent manager workspace.

So this agent manager interface acts as a mission control dashboard. It's designed for high level orchestration allowing developers to spawn, monitor and interact with multiple agents operating asynchronously across different workspaces or tasks. So in this view, the developer acts as an architect. He can spin up multiple agents, define highle objectives and then work on large projects with individual agents working on specific tasks. This architecture addresses a key limitation of previous ideas that had more of a chatbot experience.

So, in a traditional chat interface, the developer has to wait for the AI to finish generating a response before asking the next question. But this agent manager interface allows you to set up and deploy multiple agents working on a host of different tasks at the same time. So therefore, you can multiply your throughput and be a lot more efficient. And on the center of the screen, you can see our chat interface. So this is where we can start a new conversation and spin up a new agent.

We can see we can select the model that is being used for this particular agent. In this case, it's set to Gemini 3 Pro High, but we have other options we can use there. For models, we've also got a mode we can choose from. It's in planning mode at the moment. That means the agent can plan before executing tasks.

So, this is better for deep research or more complex tasks where it needs to make a plan first before it starts working. We also have fast mode which allows the agent to execute tasks directly. So if you just want to do a simple task that can be completed without planning first, you can use fast mode. On the lefth hand side, we can also see workspaces and playground. Workspaces is where we can import project directories and work with existing projects.

Playground is where we can just test before we actually deploy. So anything we do in playground is just essentially a test mode. We can then push that to a actual workspace or project directory if we want to. As an example, I'll just open up a new workspace here where I can click new workspace. That will open up my project directory and I can choose a project folder within my system to open up within anti-gravity.

We can see when we open a new project, it will ask us if we trust the authors of the files. So, we need to approve that and click yes, we trust the author. That's then going to open up our new project folder within anti-gravity. So we can see here anti-gravity demo is now open. You can see that we're now essentially in our anti-gravity demo project workspace.

If we want to start a new conversation that's going to be created within that project. If we click on anti-gravity demo here, we can flick between workspaces. So if we want to switch to a different workspace for a specific task, we can do that here. So if I flick over to playground, that's now changed to starting a new conversation within the playground section. If we have multiple workspaces we're working with, this is just a way that we can navigate between those workspaces for different tasks that we want to run.

We can also see here we've got an inbox section. This is where all of the agent chats will be populated. Anytime an agent finishes a task, that update will then come into our inbox. So, as an example, we'll click start conversation here. That's going to open up our new chat interface to spin up a new agent.

We'll change to anti-gravity demo. And as an example, I'll say create a PRD for a Space Invaders type game. We'll hit send on that. And the agent should now create a PRD for our game. We can see that it is executing the task here.

It's also creating an artifact now to go along with the PRD that it will create. So we can see the task list that it is outlining as part of the prompt. So the agent has completed the task and it has created the PR for our game. If we now go back to inbox, we can see that we have a new item in our inbox from our PR agent that has just finished the task. So if we have a lot of workspaces and a lot of different agents working on tasks, the inbox acts as that central place to see all of the latest updates from our agents.

In this case, we can see the space invaders PR creation has completed one minute ago. We can click proceed to have it then build the PRD or we can click on open to review the file. So if we click open that's going to open the PRD for us to review. But before we proceed with any more prompts and tasks, one other really important thing we need to set up is browser mode. So you'll see in the bottom left here it says browser.

If we click on that, that's going to open up a new window. And you can see here it says anti-gravity browser control. Getting started. The agent can click, scroll, type, and navigate web pages automatically while working. It displays an overlay showing its progress and provides controls to stop execution if you need to intervene.

Example use cases, iterating on website designs and implementations, quality assurance testing, monitoring dashboards, and automating routine tasks like rerunning CI. The first time you open browser mode here, you'll be able to add the Chrome extension. Now, we'll jump back to our IDE and we'll test it out. So, what we'll do here is we'll start a new conversation in playground mode. So, we'll click the plus icon here to start that new conversation.

And I'm going to say go to anti-gravity.google and hit enter. So, our agent should now spin up a browser sub agent and go to that website for us. We can see it has opened a browser window. It's navigating to that site. So, we can see that happening here.

And it's probably taking a screenshot or a screen recording now. So, we'll jump back over to our IDE. We can see the agent has responded. It has successfully navigated to the website that we assigned. Scrolled down and did a screen recording.

We can see playback available. So, we can click view. That's going to open up the artifact on the right hand side. So, we can see the screen recording that the agent has recorded for us. That's an example of browser mode and how you can get screenshots and screen recordings from websites.

In this case, the agent has spun up a browser agent to execute this task and we now have a screen recording of the anti-gravity website. If we go back to inbox now on the left hand side, we should see there's now two items in our inbox. The original space invaders PR creation conversation is here waiting for our next action. And we also have a new item here for the chat that we just started in playground regarding navigating to anti-gravity Google. So we now have two items in our inbox.

This is how you can manage multiple agents. So again, we've only got two at the moment, but you can see that once you have many projects and tasks that you're working on, the inbox is going to be a really valuable place to manage everything. Next, let's have a look at artifacts. So artifacts solves the trust gap. So when an agent says, "I've fixed this bug or I've completed this task," the developer previously had to read the code or the full response to verify.

But in anti-gravity, the agent produces an artifact to prove it. And we can then just find and review that artifact. Anti-gravity focuses on producing key artifacts depending on the task. This can range from the task plan to the implementation plan and finally the walkthrough plan. So it will verify that it has completed a task and built something by providing a walkthrough plan.

Inside of these plans, some of the artifacts might be things like tasks lists and to-do lists, code diffs to see exactly what code has changed, screenshots of websites or apps either live or in dev mode, browser recordings that it can do to verify tests, and test results if it's providing logs from tests it runs. Those will be also provided as artifacts. So, I'll show you now how you can access artifacts. We'll flick back over to our Space Invaders PRD conversation here. Up on the top right, you'll see this toggle panel here where it says toggle changes panel.

If we click on that, that's going to open up this section. And we can see at the top it says artifacts. And we have our two artifacts here currently. If we click on task, we can see this is the task plan that the agent first created when we prompted it to create a PRD. So we can see the exact tasks that it outlined as part of that process.

We can see step one was to create the PRD. Step two is review PD with user. It hasn't completed that task yet because that's the one that's waiting for us in the inbox. The second artifact we have here is the PRD. If we click on that, that's going to open up the PRD.

So this is where we can access that PRD artifact and review exactly what the agent has created. So that's artifacts and any files that are changed will also appear here. So you'll see later when we do some tests on actually creating files that they will appear here and we can click on those to see exactly what code has changed. So this is a really handy thing to use if you want to locate artifacts for specific agents and review files that have been changed. It's also worth noting while the agent manager mode is really valuable and where you'll probably spend most of your time, you can also access editor mode.

So if you're working with a specific conversation and on a specific task, you can still open editor mode and work on that file specifically. So let's say for example, we want to have a closer look at the PRD, review it in more detail in its own standalone editor window. We can click open editor here in the top right. That's going to open up editor mode. We can see in this mode we have our project directory on the left hand side.

So if you're working within a large code base that has a lot of files, it might be handy to have the explorer panel open so that you can see all of the files. On the right hand side, we have our chat window and then in the middle of the screen, we have our PR. So we can review here. If we want to chat with our agent here within editor mode to make some changes to the PRD, we can do this here. Once we're done and we want to switch back to agent manager, we can use that control E shortcut or in the top right we can just now click on open agent manager.

That's going to flick us back to agent manager mode. Let's now have a look at a couple of specific use cases so that we can see the agent process within anti-gravity in action. What I'll do here is I'll spin up a new agent in playground mode. What I'm going to do here is I'm going to say visit news.g google.com and get me the highlights at the moment. So, what the agent should do now is spin up a browser sub agent to visit news.google.com.

It will then scrape the information and the content on that website and come back to me with the highlights at the moment. So, you'll see how the agent completes the task and also delegates to that browser sub agent to get the information it needs. We can see the agent is using the browser. That page has popped up. So we can see it is accessing Google News and we can see what it's doing on the bottom here.

We can minimize this and actually go back to our agent to also see exactly what it's doing. So we can see the thought process and the actions it's taking here within the agent conversation window. We can also see the artifacts being populated as it completes the task. So on the right hand side we've got our task artifact that's just been created. If we click on that, we can see it's just got one step.

Visit news.google.com and extract highlights. So again, if you want to see the exact process the agent has gone through to complete the task, this task artifact will give you the information you're looking for. We've then got a media artifact. So if we click on that, we can see it's generating a recording currently, but that will be a screen recording of what it did on the website to get the information. And we can see it has responded.

Here are the current news highlights from Google News. Tropical cyclone Fina is the top story. That is a simple example of how the agent can work and how it uses the browser sub agents to fetch any web-based queries. Let's now try a slightly more complex task. So again, we will go back to our playground here and start a new conversation.

What I'm going to say is create a productivity app that features a Pomodoro timer. Give a calm and aesthetic look to the application. We'll hit send on that. We're in planning mode because it is a more complex task of building an app. So, what it should do first is create a plan.

Once we review and approve that plan, it should then build the app. So, we'll be able to see the full endto-end process of planning and building an app. We can see it's now creating the task list. So, again on the right hand side, we can see artifacts. If you can't find that, again, it's this icon here to toggle the panel.

If we click that, it will close it. If we click it, that it will open it up. If we click on the task artifact, we can see here that it is outlining all of the tasks that it needs to complete to implement the project. It's now finished its response and you can see it has ticked off the planning steps. Create implementation plan, design, color palette, and typography.

The in progress step, which is highlighted by the blue dot. So, it wants to proceed with creating the basic layout for the app. What we can do first though is flick over to implementation plan. So, you'll see that is also now an artifact. We can see if we click on that here we can see the full app implementation plan.

We've got goal description, the proposed changes, all of the files that need to be created, the verification plan. So we've got a full implementation plan we can review first. If we flick back to task, we can see the full task list. And on the left hand side, we can see the agent is waiting for us to approve a command to run to install Vit so that it can start building the app. So, we'll hit accept and let it start work on the build process.

We can see it will now run these commands and build the app for us. We can follow along in real time to see its progress by having this tasks artifact open. As it completes each task, it will tick this off and then move on to the next one, which will be highlighted by this blue dot. So, we'll be able to see exactly what step it's on throughout the entire process. So you can see in the workflow here in the conversation that it is installing vit once it has completed that task you'll see that be ticked off in the middle here and it will then move on to the next task.

We can see it's now saying the dev server is up and running. It's now shifting to implementation and we can see that reflected on the right hand side. So initialize project has now been ticked off and it's now in progress with all of the implementation steps, the timer logic, the styles and the task list feature. We can see now that it is starting to build the app and it's creating those files. So again on the right hand side in our artifact section we can see files changed and the exact files that are being created.

So if we click on what's now opened the app in dev mode. So we can see it has created the app. It's now clicking on the start button to test the functionality. I'm not doing anything here. This is browser mode in action.

So it has verified that the start button works. We'll see if it clicks pause to test if that works. It's doing that now. So it's verifying that the pause button works. It's now clicking on short break to test that that works.

So it's running through all of these tests as part of this process. So again, the verification step within the plan detailed testing the functionality of the timer and that's what it's doing here. You can see it's even creating a test task to verify that adding a task to the to-do list works. So this is a really cool feature within anti-gravity, the fact that you can use the browser agent to do all of your testing for you. You don't have to go into dev mode and test the apps yourself or whatever you're building.

anti-gravity will do that itself via these uh spun up browser agents. It's a really cool feature and we can see that in action now. We can see it's added the task to the to-do list and then ticked it off. So, it's verified that that is functioning correctly. We might now minimize this and go back to our IDE and see if it has finished testing or whether it's still going through that process.

So, we can see it has now finished the testing process. So it's built the app and it's also fully tested the app. On the right hand side we can see the three files that have been created. We've got our three artifacts here. The implementation plan which initially created the task list which is now checked off.

And then we've also got walk through. We click on walk through. We can see that this is a full walk through of exactly what it's built and tested. So we can see the changes made. It's initialized the project, the structure, styling and logic.

It's also got verification results. I verified the application by checking the time accounts down correctly. Switching between modes updates the time and theme. Adding and completing tasks works as expected. And we've even got a screenshot here of the final app state.

If we then click on these media artifacts, we'll see the final app state screenshot that was mentioned in the walkthrough plan is accessible here. And then we've also got a screen recording verified Pomodoro app. So if we flick over to that, we can see the actual recording. So if we don't want to rely on just the walk through and the screenshot, we can click on this and view the screen recording and we can see the actions it took. We can see it clicking the start button and the pause button and the short break and testing the task.

So that's a really cool feature as well. Again, the artifact section is a really valuable section to familiarize yourself with when you're building and testing apps. This is where you're going to find all of the artifacts to review the build and verify that the app is working. And again, that's what makes anti-gravity so powerful because you can use agents and sub agents to build and test apps. It saves you so much time because you don't have to go into dev mode and do the testing yourself.

You can let the agents do all of that and then you can actually review the artifacts to confirm and verify that they have actually done the testing that they say they've done. And then you've got a fully working app which we've just done there. We've built a Pomodoro app within a couple of minutes and verified that it works. So it's a pretty cool workflow. If you want to build apps and other cool things like that, this is a great way to do that quickly.

What we'll do now, we'll toggle the sidebar again. So top left, we can open up our sidebar here. What I want to show you now is how you can essentially test and build in your playground workspace here. And then once you're happy with a build, you can then push it to an official workspace. So that's what I'll show you next.

So if we look at the top bar here, we can see this folder with an arrow icon. We can click on that to move your work into a folder. Your conversation file contents will be preserved in the selected folder. So we're happy with the app that's been built in playground mode. We now want to move that into a proper workspace.

If we click that, that will open our directory where we can choose a folder. We'll go and click the Pomodoro test directory. If we select that, that will now move our playground conversation and our app into our Pomodoro test workspace. So, we now have that saved within a proper project directory. Again, that's a really good way if you want to first test a new feature you're building for an existing code base, but you don't want to move it in or build within that existing project directory.

You first want to just test and make sure it works. You can do it that way and then later on move it into your project directory. And we can see here that is now available within our Pomodoro test workspace. And that concludes the setup tutorial for anti-gravity. So, I hope that helped get you started with anti-gravity.

If you're new to the IDE, hopefully you can now set up your workspace and start playing around with the agents within anti-gravity. I'll probably be doing some other videos on anti-gravity and some of the advanced features that are available. I'll also be looking at testing Gemini 3 Pro in more detail and comparing it to some other models such as Codeex and Claude Code. So, if you're interested in seeing that, make sure you subscribe below. If there are any questions you have about anti-gravity or any of the models, let me know in the comments below and I'll work on some other videos around those ideas, too.

Again, make sure you subscribe for more videos and thanks for watching.