Model: gemini/gemini-3-pro-preview (resolved: gemini-3-pro-preview)
Summary, with detailed notes about what this thing is and how it differs from regular VS Code, then a complete detailed transcript with timestamps
- text/html; charset=utf-8: https://www.youtube.com/watch?v=nTOVIGsqCuY
Here is a summary and detailed breakdown of Google Antigravity, followed by a complete transcript of the video.
Google Antigravity is a new, comprehensive development environment built by Google DeepMind. It reimagines the coding experience by shifting the developer's role from writing every line of code to orchestrating AI agents. It is designed as a unified product service that combines an IDE, a project management system, and an automated web browser.
While VS Code is a text editor with extensions (including AI assistants like Copilot), Antigravity is built as an "Agent-First" environment. Here are the distinct differences:
1. The Three-Surface Architecture Unlike VS Code, which is primarily an editor, Antigravity operates on three distinct surfaces:
- The Agent Manager: A high-level dashboard to create, manage, and monitor multiple AI agents working on different tasks across different workspaces simultaneously.
- The Editor: A familiar coding interface (similar to VS Code with tabs, terminal, and autocomplete) but deeply integrated with the agents. You can switch from Manager to Editor instantly to take over manual control.
- The Browser: A built-in, instrumented version of Chrome. The agents don't just write code; they spawn a browser instance to click, scroll, and visually test the application they just built.
2. Artifact-Based Workflow Instead of just a chat window (like ChatGPT or Copilot Chat), Antigravity agents communicate through structured "Artifacts":
- Task Lists: Real-time tracking of the agent's to-do list.
- Implementation Plans: Detailed specs and research reports generated before coding begins, which the user can review and comment on (similar to Google Docs).
- Walkthroughs: A post-task report including screenshots, screen recordings, and verification steps proving the feature works.
3. "Agent-Assisted" Autonomy Antigravity allows for Agent-Assisted Development. The AI has permission to run terminal commands, install packages, and manage files without constant user approval (unless configured otherwise). It uses "judgment" to decide when to ask for help and when to proceed.
4. Parallel Multitasking You can assign one agent to research documentation, another to generate image assets (using internal models like "Nano Banana"), and a third to write code—all running in parallel while you review their progress in the Inbox.
5. Deep Ecosystem Integration
It creates a feedback loop between Code, Research (via Google Search), and Runtime (via the Browser). For example, it can Google an API's documentation, use curl to test a real API key to verify the data structure, and then write the TypeScript interfaces based on the actual response.
00:00 Kevin: Today I'm going to be giving you the first look at Antigravity. A brand new product by Google DeepMind, built for developers, and it combines the best of all worlds. It's both an editor, an agent manager orchestration system, and a browser, all in one product service.
00:17 [Onboarding] Kevin: So to start, we're going to open up the Antigravity app, and we're going to go through the onboarding. So let's click Next. Personally, I'm a light mode guy, so let's head over to Default Light Mode, and click that Sign in with Google button. So, you'll just use your normal Gmail account. Click Sign In. And this will pop us back into Antigravity.
00:42 Kevin: All right, so now we're logged in. We're going to introduce you to a key concept of Antigravity, which is that there are three main surfaces on which you can get your work done. The first one is called the Agent Manager. This is a place for you to manage and create agents across all of your workspaces. There is one Agent Manager window.
00:59 Kevin: Now, if you want to get into the code, if you want to take over from the agent—for example, and bring that task from 90% to 100%—you can at any point press Command-E or press the Open in Editor button. And this will take you into the Antigravity Editor, which has things like Tab, autocomplete, the agent sidebar—everything you've come to know and love inside of your editor products.
01:20 Kevin: And finally, there is a Browser. This is a brand new offering that incorporates an agent directly inside of Chrome. So, you can ask questions like "Test my feature," and the Agent Manager or the Editor will spawn a browser and click on the screen, scroll on the screen to basically test the products that you're building. So this is a really, really powerful way to bring all that context—that rich context of applications and docs—directly into the agent.
01:46 Kevin: So we're going to go with Agent-Assisted Development. What this means is the LLM will automatically decide if something is worth our attention. If something is very, very easy, the agent will just go off and implement it and come back at the end. But for some things that are more complicated, or if it has questions, it might ask us, "Hey, why don't you take a look at this, answer a few questions about your codebase that I couldn't figure out," and then go off and execute. So, it's a different way of working; this is my preferred way.
02:11 Kevin: So now that we finished onboarding, let's go ahead and get started on our first project.
02:14
[Initial prompt and implementation]
Kevin: You'll notice on the left side there is a sidebar, and we're going to go ahead and add a new workspace. We're going to be working locally instead of in SSH, so we'll press Open Folder. And let's create a new folder. We'll just call it flight-tracker.
02:32 Kevin: And today we're going to be building a flight tracker app where a user can add their flight number and it will directly integrate with your Google Calendar to basically add that flight information to your calendar directly.
02:41 Kevin: [Typing Prompt] Build me a flight lookup Next.js web app where the user can put in a flight number and the app gives you the start time, end time, time zones, start location, and end location of the flight. For now, use a mock API that returns a list of matching flights. Display the search results under the form input.
02:58 Kevin: So it's going to start. And remember the setting that we chose for the agent to be making decisions on the user's behalf? Because we chose that Auto setting, this means that the agent is capable of running terminal commands on our behalf without our approval. Now, if this command was something a bit more sophisticated, we want to build that trust with you as the user, and so we'll obviously notify you to approve or deny that specific request.
03:22
Kevin: So we'll go off. It looks like we want to run create-next-app. And the agent will now start doing work on your behalf in the background. But you can always check in on its progress. And one of the really, really cool features for Antigravity is this notion of Artifacts.
03:36 Kevin: So if you click the right sidebar—and this is available both in the Editor and the Agent Manager—you'll notice that the agent is putting together Artifacts. These are markdown files for the agent to sort of track its own progress, do research, and even generate findings. We see that the agent is keeping its own Task List to keep track of its progress. And this is something that you can also follow along with.
03:57 Kevin: We have instrumented the Antigravity agent to work with three main artifacts. The first one is the Task List, which you saw. And the other two are important for users to observe and approve. The first one is called an Implementation Plan. And this basically specs out some of the research the agent did, and it will give you a report of what it's going to do prior to actually going off and making changes to your codebase.
04:19 Kevin: And finally, there is a Walkthrough, which happens at the end of an agent's task. And it will communicate what it did, as well as some of the verification steps it took to sort of prove that it completed it. This might take the form of screenshots, or terminal commands that it ran, or unit tests, or heck, maybe even a PR description—things of that nature.
04:37 Kevin: And so it looks like our agent has done some research. And we're now going to open up our Implementation Plan. And you'll see this looks pretty good. It's putting together some components, it's telling me a bit about the styling, some of the ways that it's going to verify that it did the work correctly. This all looks pretty good to me.
04:51 Kevin: So now it's going to go off and start implementing all these files. It'll keep track of its progress in the Task List, and you can follow along, or you could even go get a coffee and come back.
05:01 Kevin: It looks like the agent finished the code generation part. So now it's going to actually run the dev server so that we can check this out locally. And it wants to launch the browser. So let's go ahead and press Setup. You'll press Install Extension. So let's go ahead and add this to Chrome.
05:20 Kevin: So what's really cool about Antigravity is that because of this browser integration, it can actually test the code that it just wrote, all on its own.
05:28 Kevin: So here, we just generated a flight tracker, and now with that blue little cursor, it's moving its cursor around the screen to actually test our application. And in this case it's adding in American Airlines flight 123. It's testing some invalid states. And it's basically going to deliver us a couple of screen recordings and a screenshot in our Walkthrough report.
05:50 Kevin: So let's click Review and we can see what it put together. It tells us a bit about the features that it implemented, and importantly, how it verified that the results were actually correct.
06:00 Kevin: So let's head back to our Home. We call this the Inbox. This is where you can spin up new conversations and check in on your progress across all your different agents across all your different workspaces.
06:10 [Parallel Tasks] Kevin: And so now we're going to start two parallel tasks. And the beauty of Antigravity is that you can have the agent do work for you in the background while you focus on maybe a more complex task in the foreground. Let's have it do some research. So we want to hook this up to live flight data. So let's ask it to look up the Aviation Stack API.
06:26 Kevin: [Typing Prompt] Research the aviation stack flights API. I already have an API key if you want to test with curls. Look up the documentation and make sure you use the curl responses to get the interface.
06:36 Kevin: Let's make this app look a little bit more polished by giving it a logo. The beautiful part about being part of the Google DeepMind ecosystem is that we have direct access to "Nano Banana" and the latest image generation models directly inside of the product.
06:50 Kevin: [Typing Prompt] Design a few different mockups for a logo for our app. I want one that's minimalist, one that's more classic, one that's clearly a calendar, and any others that you think might fit. I want to use this as the favicon for our app.
07:05 Kevin: So let's head back home. Oh wow, it already looks like it's done with the logos. That was very, very quick. And you'll see that it generated, let's see... four different types of logos. I really do like the look of this classic aviation style one. So let's tell the agent to implement this one inside of our project.
07:25 Kevin: [Typing Prompt] I like the global flight tracker with aviation theme. Add this as my favicon.
07:31 Kevin: And I actually should probably tell it to update my site title as well... so let's go ahead and tell it to do that as well.
07:38 Kevin: [Typing] Oh and also update my site title to 'Flight Tracker'
07:40 Kevin: And you'll see that we are sending it as a pending comment. Which basically means the agent can take into consideration at some good stopping point in the conversation. So here, it already got started working on the favicon, but now it's also going to take into account that we want to change the site title. And we didn't even need to babysit the agent. We could just leave it, and leave some comments, and come back and it takes it into account. It's smart enough to know when and how to inject this into our conversation.
08:04 [Artifact Review] Kevin: So we'll head back home. And it looks like now our Aviation Stack API research is already done. And it's written an artifact for us to review. And it's done all this research on what the Aviation Stack API can do and what data it returns.
08:23 Kevin: And what's really cool is you can scroll through the conversation if you want more detail on how it arrived at this conclusion. And it did a Google Search to basically figure out what is the Aviation Stack API, what is the docs URL for this, and it went out and actually read those pages to put together this research.
08:38 Kevin: And I also love that because we gave it an API key, it's able to literally run the curl requests and get sample data so that we know with very, very high confidence and very high trust that this is correct.
08:51 Kevin: So this Implementation Plan looks pretty good. Let's actually tell it and leave it some comments. So just like a Google Doc, you can highlight text, leave comments.
08:59 Kevin: [Commenting on Artifact] Use the key I gave you in the .env.local
09:08 Kevin: We'll scroll through the rest. And looks good to me.
09:12 Kevin: [Typing Prompt] LGTM. Implement this in a util folder so that I can apply it to the route. Don't change the route yet.
09:25 Kevin: Just submit. Great. Now let's hop back over to Home.
09:28 Kevin: And now we're going to go check in on our design of the favicons. It looks like it's updated our favicon. You'll see it now in the tab. We should probably remove the white background at some point, but you kind of get the idea. It's able to do this work in parallel.
09:41 Kevin: So now we're sort of multi-threading our brain across these two different projects. And you'll see that this Aviation Stack API util is almost done.
09:50
Kevin: Great. So our agent has notified us that it's ready for review. And it looks like it created this new file aviationStack.ts in our utils folder. And it looks like it used a lot of the research that it did before to make sure that this is correct.
10:04 Kevin: And let's now hop into the Editor so that we can really, really use this new util. We could ask the agent to do this, but I want to show you some of the features inside of the Editor.
10:12 Kevin: We'll head over to where I think the route is. And you'll see all this logic for mock flights that came out of the original generation. And we can go ahead and delete all this.
10:23 Kevin: The Editor is already suggesting that we replace our mock data with our live data. So let's go ahead and press Tab to accept this suggestion. We're going to press Tab again, include the import. And now let's just make sure that the rest of our UI is using these new type declarations from the API as opposed to the mock data.
10:40
Kevin: So we'll go into page.tsx. And we'll sort of start poking around. Looks like we'll need to change the shape of the data. So instead of Flight, which is the mock API schema, we are going to use the one from the API itself. And it's called AviationStackFlightData.
10:58 Kevin: Because the agent has context over all the files in your codebase, as well as the internet documentation that we retrieved earlier, we can just Tab, Tab, Tab, and change all the instances in our UI of using the mock data to using the API data.
11:12 Kevin: Now that this migration is complete, let's head back over to the Browser and just make sure that the app actually works with this new live data.
11:16 [Testing application] Kevin: So we'll type in a real flight. Looks like American Airlines Flight 100 is taking off from JFK and landing in Heathrow. So our app seems to be working.
11:28 Kevin: Now, let's put a bow on it. We want to be able to add this flight into our Google Calendar. Let's ask the agent to do this for us.
11:36 Kevin: [Typing Prompt] For each flight result, make the entire card clickable to open a Google calendar link with the flight information (notably the times and locations). Test this with the browser and show me a walkthrough when you're done.
11:48 Kevin: Again, we could let this task run in the background, but this product is really, really mind-blowing sometimes, so let's actually watch it side-by-side.
11:56 Kevin: The agent will also show you what it's thinking about while it's doing its work. So here it's saying "Reviewing clickable items," it's starting to map some of the flight data. And now it's going to go off and read some of the files that are relevant for this conversation.
12:09 Kevin: It looks like it's implementing the Google Calendar integration. And the agent divides things into sections so it's a bit easier for the user to follow along. Of course, you can always get into the nitty-gritty by going to the Editor and showing all the steps.
12:20 Kevin: So it looks like it's done, and it's now going to the Browser and actually testing this feature. So when the blue border is visible, this means that the browser is under the agent's control. And here it's testing out American Airlines Flight 100, and can move the cursor to click. And now you can see we are able to add this flight to our calendar.
12:39 Kevin: And now that the agent is done using the browser, it's going to put together a Walkthrough. This is the third and final artifact to show us that it is indeed done with the task that we requested.
12:49 Kevin: And here you can see sort of some of the features that it implemented here—the Google Calendar integration—and that it verified using American Airlines Flight 100.
12:57 Kevin: And let's head back over to a browser, we can try this feature ourselves. We'll come in here, put in American Airlines Flight 100. Looks like data is flowing correctly. And hey, looks like it generated a calendar event for us.
13:14 Kevin: So let's head back over to our Editor, and let's commit this code. And there's a nice little button here to just generate a commit message. Again, this is context-aware, so it's using your conversation history in addition to the files to come up with this commit message. This looks pretty good. Let's commit it.
13:30 Kevin: There you have it. We just built a new app from scratch in just a few minutes. And we believe that this is the new way for devs to get work done. Reviewing artifacts, managing multiple agents, and getting tasks over the finish line with an AI-powered editor.
13:43 Kevin: The Antigravity team is already hard at work on what's next. So, stay tuned for future updates. I'll catch you all on the next one.
75,855 input, 6,464 output, {"candidatesTokenCount": 4903, "promptTokensDetails": [{"modality": "VIDEO", "tokenCount": 75828}, {"modality": "TEXT", "tokenCount": 27}], "thoughtsTokenCount": 1561}