Defying Gravity

[upbeat electronic music] [audience applauding] All right, hello. Last one of the day. Can we get a, uh, little energy boost? Who's ready? [audience cheering] Who's ready? [audience applauding]

All right, happy Friday. I hope everyone has had a good week, a good conference. Um, and let me tell you, it's been a really bad week if you are gravity.

Wicked 2 is coming out tonight, and then of course, Antigravity came out earlier this week alongside Gemini 3 Pro on Tuesday.

Google Antigravity is a brand-new IDE out of Google DeepMind. It's the first one from a foundational lab, and it is coming right off the press. In fact, um, I probably should be working on the product right now, but I wanted to spend some time to share what we've built here today.

Antigravity is unapologetically agent first, and today I'm gonna tell you a little bit about what that means and how it manifests in the product. But perhaps maybe a little bit more interestingly, we're gonna talk a little bit about how we got here, product principles, direction of the industry, these sorts of things.

Um, so my name is Kevin Hou. I lead our product engineering team at Google Antigravity.

And let's start with the basics. Um, and first, just to get a sense of the room, um, who has used Antigravity?

All right, there you go. Power of Google. Love it.

Um, who's used the Agent Manager? Cool. Nice. Good. Good. All right. So basics of Antigravity.

Antigravity, notably Antegravity, not Antigravity, Antegravity, it's an AI developer platform with three surfaces. The first one is an editor, the second one is a browser, and the third one is the Agent Manager.

So we'll dive into what this means, which one-- what, what each looks like. So a paradigm shift here is that agents are now living outside of your IDE, and they can interact across many different surfaces that your agent or that you as a software developer might spend time in.

And let's start with the Agent Manager, so that's the thing up top. This is your central hub. It's an agent-first view, and it pulls you one level higher than just looking at your code.

So instead of looking at diffs, you'll be kind of a little bit further back. And at any given time, there is one Agent Manager window.

Now, you have an AI editor. This is probably what you've grown to love and expect. Has all the bells and whistles that you would expect. Uh, lightning-fast autocomplete. This is the part where you can make your memes about, "Yes, we forked VS Code."

And it has an agent sidebar, and this is the sort of thing. It's mirrored with the Agent Manager, and this is when you need to dive into your editor to accomplish maybe your eighty percent to a hundred percent of your task.

And at any point, we made it very, very easy because we recognize not everything can be done purely with an agent,

for you to Command + E or Control + E and hop instantly from the editor into the Agent Manager and vice versa, and this takes un- under a hundred milliseconds.

It's zippy. And then finally, something that I love, an agent-controlled browser. This is really, really cool, and hopefully for the folks in the room that have tried Antigravity, you've noticed some of the magic that we've put in behind here.

So we have an agent-controlled Chrome browser, and this gives the agent access to the richness of the web, and I mean that in two ways. The first one, context retrieval, right?

It has the same authentication that you would in your normal Chrome. You can give it access to your Google Docs. You can give it access to, you know, your GitHub dashboards and things like that and interact with a browser like you would as an engineer.

But also, what you're seeing on the screen is that it lets you-- it lets the agent take control of your browser, click and scroll and run JavaScript and do all the things that you would do to test your apps.

So here I put together this, like, random artwork generator. All you do is refresh, and you get a new picture of, um, like a Thomas-- piece of Thomas Cole artwork.

And now we added in a new feature, which is this little, little modal card, and the agent actually went out and said, "Okay, I, I made all the code, but instead of showing you a diff of what I did, let's instead show you a recording of Chrome."

So this is a recording of Chrome where the blue circle is the mouse. It's moving around the screen, and this way, you get verifiable results. So that's what we're very excited about our, uh, our, our Chrome browser.

And then the Agent Manager can serve as your control panel. The editor and the browser are tools for your agent, and we want you to spend time in the Agent Manager.

And as models get better and better, I bet you you're gonna be spending more and more time inside of this Agent Manager. And it has an inbox, and I'll talk a little bit about this and sort of why we did this, but it lets you manage many agents at once.

So you can have things that require your attention. For example, running terminal commands. We don't want it to just kind of go off and just run every terminal command.

There are probably some commands that you wanna make sure you, you hit okay on. So things like this will get surfaced inside of this inbox. One click, you can manage many different things happening at once.

And it has a wonderful OS-level notification, so if there is something that you need, it will sort of let you know, and this kind of solves that problem of multithreading across many tasks at once.

And so our team is thrilled to launch this brand-new product. It's a brand-new product paradigm, and we did so in conjunction with Gemini 3, which was a very exciting week for the team.

But alas, we ran out of capacity. [audience laughing] Um, this has been tormenting me the last couple of days [chuckles], and so I apologize. On behalf of the Antigravity team, I'd like to apologize for our global chip shortage.

Um, we're working around the clock to try and make this work for you. Uh, hopefully we'll have a few less of these sorts of errors. Um, but we've-- What's been really exciting is people who have used the product have seen what the magic of combining these three surfaces can do for your workflows, for your software development.

Um, so let's talk about it. Why did we build the product? How did we arrive at this sort of conclusion? You might say, "Oh, adding in a new window, it's pretty, pretty random," right?

It's this one-to-many relationship between the Agent Manager and many other surfaces.

Um, and it's important to remember, I, I've been at this conference a couple of times, and, and everything, every single time there is this theme: the product is only ever as good as the models that power it.

And this is very important for us as builders, right? Every year there is this sort of new step function. The first, there was a year when it was autocomplete, right?

Copilot, and this, this sort of thing was only enabled because models suddenly got good at doing the short form autocomplete. And then we had chat, we had chat with [REDACTED:username], then we had agents.

So you can see how every single one of these product paradigms is sort of motivated by some change that happens with model capabilities. And it's a blessing that our team is able to work and be embedded inside of DeepMind.

We had access to Gemini for a couple of months, um, earlier, and we were able to work with the research team to basically figure out, you know, what are the strengths that we wanna show off in our product?

What are the things that we can exploit? And then also, what are the gaps, right? This desired experience. Where are the gaps in the model and, and how can we fix that, right?

And so this is, this was a very, very powerful part of why Antigravity came to be. And there are four main categories of improvements powered by a little NanoBanana artwork.

The first one is intelligence and reasoning. You all are probably familiar with this. You used Nano-- Or you used, um, uh, Gemini 3, and you probably thought it was a smarter model.

This is good. It's better at instruction following. It's better at using tools. There's more nuance in the tool use. You can afford things like, you know, there's a browser now.

There's a million things that you could do in a browser. It can literally even j-- execute JavaScript. How do you get an agent to understand the nuance of all these tools?

It can do longer running tasks. These things now take a bit longer, right? And so you can afford to run these things in the background. It thinks for longer.

Just time, time has gotten stretched out. And then multimodal. I really love this property of what Google has been up to. The multimodal functionality of Gemini 3 is off the charts, and you start combining it with all these other models like NanoBanana Pro, um, and you really get something magical.

So we have these roughly four different categories where things have gotten much better.

And if you think about these properties, the question becomes, what do we do about these differences? And from a product perspective, it's like, how do you construct a product that can take advantage of this new wave?

And hopefully, and in my opinion, this is the next step function, autocomplete, chat, agents, and then I probably gotta come up with something more interesting than whatever this thing is called. [chuckles]

So step one is we want to raise the ceiling of capability. We want to aim higher, have higher ambition.

And so a lot of the teams at DeepMind were working on all sorts of cutting-edge research, right? There's-- Google is a big com-- big, big company, and one of my learnings going from a startup to one of these bigger companies is that there is a team of people that is attacking a very, very hard technical problem.

And as a nerd, this is super exciting, right? And then as a product person, it's like, wow, we can start using computer use. So browser use has been one of these huge unlocks.

And this is twofold, right? I mentioned the sort of retrieval aspect of things. Um,

I guess for, for software engineers, there is much more that happens that is beyond the code, right? You can roughly think about it as there's what to build, there's how to build it, and then you actually have to build it.

I would say building it has become more or less, you know, it's reasonable for the model to now, given context, it can generate the code that hopefully functionally works.

And then you've got the what to build. This is the part that is up to you, kind of human imagination. And then there's the how to build it, right?

And there's this richness in context, the richness in institutional knowledge, and these are the sorts of things that having access to a browser, having access to your bug dashboards, having access to your experiments, all these sorts of things that now gives the agent this additional level of context.

And maybe I should've clicked before, but if you saw on the screen... Let's see, how do I do this?

So this is now the other side of things, browser as verification. So you might have seen this video. This is a tutorial video that we put together on just how to use it.

But this is the agent. The blue border indicates that it's being in control by the agent. And so this is a flight tracker. You put in, you know, a, a flight ID, and then it'll give you sort of the start and end of, of that flight.

And this is being done entirely by a Gemini computer use variant. And so it can click, it can scroll, it can retrieve the DOM, it can do all the things.

And then what's really cool is you end up with not just a diff, you end up with a screen recording of what it did. So it's changed the game, and the model can take this, and because it has a, the ability to understand images, it can take this and iterate from there.

So that was the first category, browser use. Just an insane, insane magical experience. Now, the second place that we wanted to spend time is on image generation. And we noticed this theme when we, you know, when I, when I first started at, at Google, we noticed, okay, Gemini is spending a lot of time on multimodal.

And this is really great for consumer use cases, right? NanoBanana 2 was, was mind-boggling. Um, but also for devs. Devs are inherently-- This is a multimodal experience. You're not just looking at text.

You're looking at the output of websites. You're looking at architecture diagrams. There's so much more to coding than just text. And so there's image understanding. This is verifying screenshots, verifying recordings, all these sorts of things.

And then the beautiful part about Google is that you have this synergistic nature. This product takes into account not just Gemini 3 Pro, but also takes into account the image side of things.

And so here I wanna give you a quick demo of, um, mock-ups. So I have a hunch, and you all probably believe this too, design is gonna change, right?

You're gonna spend, you know, maybe some time iterating with an agent to, to arrive at a mock-up. But for something like, "Oh, let's build this website," we can start in image space.

And what's really cool about image space is it lets you do really cool things like this. We can add comments. And so you end up commenting and leaving a bunch of, a bunch of queued-up responses, and it's kinda like GitHub.

You'll just say, "All right, now update the design." And then it'll put it in here. The agent is smart enough to know when and how to apply those comments.

And now we're iterating with the agent in image space. So really, really cool new capability. And what was awesome is that, um, we had NanoBanana Pro, you know, we pulled an all-nighter for, uh, for the Gemini launch 'cause that was our first launch.

Then they said, "Do it again. Do it on Thursday." So we made Gemini Pro, um... Or I'm getting all these model names confused.

The image gen one, the nano banana one, we made that available on day one. I'm running on very little sleep [laughs] on day one inside of the Antigravity Editor. And our hope is that the Antigravity Editor is this place where any sort of new capability can be represented inside of our product.

And so step two was, all right, we have this new capability. We've pushed the ceiling higher. Agents can do longer running tasks. They can do more complicated things. They can interact on other surfaces.

And so this necessitates a new interaction pattern, and we're calling this Artifacts.

This is a new way to work with an agent, and this is one of my favorite parts about the product, and at its core is this Agent Manager.

So let's start by defining an artifact. An artifact is a dynamic representation of something that the agent generates. Sorry, it's a-- An artifact is something that the agent generates that is a dynamic representation of information for you and your use case, and the key here is that it's dynamic.

Artifacts are used to keep the agent organized. They can use-used for, uh, kind of like self-reflection and, and, and self-organization. It can be used to communicate with the user to maybe give you a screenshot, to maybe give you a screen recording like we described.

And it can also be used across agents, whether this be with our browser sub-agent or with other conversations or as memory. And this is what you see on the right side of this Agent Manager.

We've dedicated sort of half the screen and, and your sidebar to this concept of artifacts.

And so we've all tried to follow along chain of thought, and I would say this, you know, we did some fanciness here inside of the Agent Manager to make sure conversations are broken up into, like, chunks.

So in theory, you could follow along a little bit better in the conversation view, but ultimately you're looking at a lot, a lot of strings, a lot of tokens.

This is, like, very hard to follow. And then th-this is actually, like, there's like ten of these, right? So you just scroll and scroll and scroll, and you're like, "What the heck did this agent do?"

And, and this, this has been traditionally the way that people review and sort of supervise agents. They're kind of just looking at the thought patterns.

But isn't it much easier to understand what is going on inside of this visual representation? And that is what an artifact is. The whole point, and the reason why I'm not just standing up here and giving you this long, you know, stream of consciousness, is because I have a PowerPoint.

The PowerPoint is my artifact. And so Gemini 3 i-is really, really strong with this sort of visual representation. It's really strong with multimodal. And so instead of showing this, which of course we always let you show, we alway- we will always show you this, but we wanna focus on this, and I think this is the game-changing part

about Antigravity. And the theme is this dynamicism. The model can decide if it wants to generate an artifact. And let's remember there are some tasks, we're changing a title, we're changing something small, it doesn't really need to, to produce an artifact for this.

So it will decide if it needs an artifact. And then second, what type of artifact? And this is where it's really cool. There, there are many potential in- potentially infinite ways that it can represent information.

And so the common ones are marked down in the concept of a, of a plan and a walkthrough. So this is probably what you've used most, most often. When you start a task, it will do some research.

It will put together a plan. This is much-- very similar to like a PRD. It will even list out open questions. So you can see in this feedback section it'll surface, "Hey, you should probably answer these three questions before I get going."

And what's really awesome, and we're betting on the models here, what's really awesome is that the model will decide whether or not it can auto-continue. If it has no questions, why should it wait?

It should just go off. But more often than not, there are probably areas where you may be under-specified or maybe it did something during research, right? Everyone has gone through and, and started a big refactor, then realized they actually don't have all the information ahead of them.

They gotta go back to the drawing board, maybe talk to some people. Same idea. So it'll surface, um, it'll surface open questions for you, and so that's-- you'll start with that implementation plan, and then you'll say, "All right, LGTM.

Let's, like, send it." You'll go all the way down. It might produce other artifacts. You know, we've got a task list here. This is the way that you can monitor the, the progress of the agent instead of looking at the conversation.

Might put together some architecture diagrams, and then you'll get a, you'll get a walkthrough at the end, and this walkthrough, you kind of saw a glimpse of this before, but it is, "Hey, how do I prove to you, agent to human, that I did the correct thing and I did it well?"

And then this is the part that you'll end with. It's kind of like a PR description. And then there's a whole host of other types, right? Images, screen recordings, these mermaid diagrams.

And really, what's, what's, what's quite cool is that because it's dynamic, the agent will decide this over time. So suddenly there's maybe a new type of artifact that we maybe we missed, right?

And then it'll figure that out. It'll just become part of the experience. So it's very scalable. But this artifact primitive is something that's very, very powerful that I'm pretty excited about.

And then I guess another question is why is it needed? So we'll always explain to the user what the purpose of this artifact is. Um, and then interestingly, like, who should see it?

So should the sub-agent see it? Should the other agents see it? Should other conversations see this? Should this be stored in my memory bank? Right? If this is something that I derived, one of the cool examples, um, that I like is, like, if you give it a, a piece of documentation and you have your API key, it'll,

like, go off and run curl requests to basically figure out the exact schema of, like, what the types of APIs you're using. And it'll do this, like, deep research, um, for quite a while, and then it'll give you a report and basically, like, deeply understand, uh, this sort of, uh, this sort of API.

You wouldn't wanna just throw that away and have to rederive it the second time you did this. So it'll store it in your memory, and then all of a sudden, that's just a part of your knowledge base.

So and then there's also this idea of, like, notifications, right? So if there's an open question, you want the agent to be proactive with you. And that's another very cool property of this artifact system.

We wanna be able to provide feedback along this cycle. So from task start to task end, we wanna be able to provide feedback and inform the agent on what to change.

And the artifact system lets you iterate with the model more fluidly during this process of execution. And so not to sound like a complete Google shill, but I love Google Docs, right?

Google Docs is a great pattern. It's awesome. The comments are great, and this is how you might interact with a colleague, right? You're collaborating on a document, then all of a sudden you wanna leave a text-based comment.

So we took inspiration from that, we took inspiration from GitHub. But you leave comments, you highlight text, you say, "Hey, maybe this part needs to get ironed out a bit more.

Maybe there's a part that you missed, or actually don't use Tailwind, use vanilla CSS." So these are the sorts of comments that you would leave. You'd batch them up, and then you'd go off and send.

And then in image space, this is very cool, we now have this like Figma style, drag and drop like... or not drag, you know, highlight to select. And now you're leaving comments in a, in a completely different modality, right?

And we've done this and instrumented the agent to na- naturally take your comments into consideration without interrupting that task execution loop. So at any point during your conversation, you could just say, "Oh, actually, you know, mid, mid-browser actuation, I actually really don't like the way that that turned out."

Let me just highlight that tell you, u- uh, send it off, and then I'll just get notified when you're done taking into consideration those comments. And so it's a whole new way of working, and this is really at the center of what we're trying to build with Antigravity.

It's pulling you out into this higher level view. And the Agent Manager really is built to optimize the UI of artifacts. So we have a beautiful, beautiful artifact review system.

We're very proud of this. And it can also handle sort of the property that is like parallelism and orchestration. So whether this be many different projects, whether this be the same project and you just wanna execute maybe a design mockup iteration at the same time you're doing research on an API, at the same time you're iterating and,

and, and actually building out your app, you can do all these things in parallel. And the artifacts are the way that you provide that feedback, the notifications are the way that you know that something requires your attention.

It's a completely different pattern. And what's really nice is that you can, you can take a step back, and of course, you can always go into the editor. I'm not gonna lie to you, there are tasks that, you know, you maybe don't trust the agent yet, you don't trust the models yet.

And so you can Command + E, and you can Command + E, and it'll open inside the editor within a split second with the exact files, the exact artifacts, and that exact conversation open, ready for you to autocomplete away, to continue chatting synchronously, to get you from eighty percent to a hundred percent.

So we always wanna give devs that escape hatch. But in the future world, we're building for the future, you'll spend a lot of time in this Agent Manager working with parallel sub-agents, right?

It's a very, very exciting concept. Okay, so now that you've seen we've got new capabilities, multitude of new capabilities, we've got a new form factor. Now the question is like, what is going on under the hood at DeepMind?

And the secret here is a lesson that I guess we've just learned over the past, I don't know, we've spent like, or I, I've personally spent like three years in, in codegen, is just to be your, your biggest user, right?

And that creates this research and product flywheel.

And so I will tell you, Antigravity will be the most advanced product on the market because we are building it for ourselves. We are our own users. And so in the day-to-day,

we were able to give Google engineers, DeepMind researchers, we were able to give them an early access, and now an official access, to Antigravity internally. And so now all of a sudden, the actual experience of the models that people are improving, the actual experience of, of using the Agent Manager and touching artifacts, is letting them see at

a very, very real level, what are the gaps in the model?

And whether it be computer use, whether it be image generation, whether it be instruction following, right? Every single one of these teams, and there are many teams at Google, has some hand inside of this very, very full stack product.

And so you might notice as an infrastructure engineer, you might say, "Oh, this is a bit slow." Well, build it for yourself. Make it faster. Image gen, all of a sudden computer use isn't going well.

It can't click this button. It's really bad at, at scrolling, really bad at finding text on the page. Well, go off and, and make that better, right? So it gives you this level of insight that evals just simply can't give you.

And I think that's what's really cool about being at DeepMind. You are able to integrate product and research in a way that creates this flywheel and pushes that frontier.

And I guarantee you that whatever that frontier provides, we will provide in Antigravity for the rest of the world. These are the same product. And so I'll give you two examples of how this is, has worked.

The first one was that computer use example, right?

In collaboration with the computer use team, which we sit, you know, a couple, couple tens of feet away from, we identified gaps on both sides, right? So we're not just using an API, we are interacting across teams to basically say, "Oh, like the capability is kind of off here.

Can, can we go off and figure out what's going on here? Maybe there's a, there's a mismatch in data distribution." And then on the other side, it's like, "Yo, your like agent harness is like pretty screwed up.

You gotta fix your tools," right? And so then we'll go off and we'll fix our side. But it's this harmony, it's, it's both sides talking to each other that really makes this type of thing possible.

Similarly, you come up with a new product paradigm, artifacts. Artifacts were not good on the initial, on the initial, uh, versions, right? What part of training, what part of data distribution includes this like weird concept of reviews?

And so it took a little bit of plumbing, a little bit of work with the research team to figure out, all right, let's steadily improve this ability. Let's give you a hill to climb.

And then now we were able to launch Gemini 3 Pro with a very good ability to handle these sorts of artifacts. And so it's this cyclic nature that I'm really, really betting on.

And this, this is really how Antigravity will defy gravity. We've got pushing the ceiling. We're gonna have an agent with very, very high level of ambition. We're gonna try and do as much as we can.

And this includes vibe coding, though I will say there are some excellent products out there by Google. AI Studio is an excellent product.

We are in the business of increasing the ceiling.

Second, we built this agent-first experience, Artifacts, Agent Manager. And then finally, we have this research product flywheel. And this is the magic, and this is the three-step process that we used in building Antigravity.

So it's been a blast. I mean, I've, I've been back at, um, AI Engineer Summit. Thank you again, Swix and Ben, for having me. It's been awesome to come back every year.

And so on behalf of the Antigravity team, I just wanna thank you for your time, for your patience as you use the product, um, and your support. And of course- [laughing]

You too can adopt a TPU and help us, uh, turn off PagerDuty a bit more. Um, and then of course, you know, you could also yell at me on Twitter.

That's another way of doing it. Maybe do it in DMs instead. Um, but we've got a lot of exciting things, and I'm really, really excited to bring Antigravity to market.

The team is thrilled that this is now out in the wild, so we welcome your feedback. Um, and thank you again for listening. Enjoy the rest of the conference. [clapping] [upbeat music]