Defying Gravity - Kevin Hou, Google DeepMind

All right. Hello. Last one of the day.

Can we get a uh little energy boost?

Who's ready? Who's ready?

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, Anti-gravity came out earlier this week alongside Gemini 3 Pro on Tuesday.

Google Anti-gravity 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.

Anti-gravity is unapologetically agent first. And today, I'm going to

agent first. And today, I'm going to tell you a little bit about what that means and how it manifests in the product. But perhaps maybe a little bit

product. But perhaps maybe a little bit more interestingly, we're going to 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 How. 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 anti-gravity?

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 anti-gravity.

Anti-gravity, notably anti-gravity, not anti-gravity. Anti-gravity. It's an AI

anti-gravity. Anti-gravity. 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

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

expect. Has all the bells and whistles that you would expect. Uh lightning fast autocomplete. This is the part where you

autocomplete. This is the part where you can make your memes about yes, we forked VS Code. And it has an agent sidebar.

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 80% to 100% 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 on under 100

vice versa. And this takes on under 100 milliseconds. It's zippy. And then

milliseconds. It's zippy. And then

finally, something that I love, an agent controlled browser. This is really,

controlled browser. This is really, really cool. And hopefully for the folks

really cool. And hopefully for the folks in the room that have tried anti-gravity, 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

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

retrieval, right? It has the same authentication that you would in your normal Chrome. You can give it access to

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

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 in this way, you get verifiable results. So,

this is what we're very excited about our uh our Chrome browser. And then the agent manager can serve as your control panel. The editor and the browser are

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 going to 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 want to 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

notification. So if there is something that you need, it will sort of let you know. And this kind of solves that

know. And this kind of solves that problem of multi-threading across many tasks at once. And so our team is thrilled to launch this brand new product. It's a brand new product

product. It's a brand new product paradigm. And we did so in conjunction

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.

Um, this has been tormenting me the last couple of days. And so I apologize. On

behalf of the anti-gravity team, I'd like to apologize for our global chip shortage. Um, we're working around the

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, it's 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

product? How did we arrive at this sort of conclusion? You might say, "Oh,

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've 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

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

autocomplete, right? Copilot. And this

this sort of thing was only enabled because models suddenly got good at doing this short form autocomplete. And

then we had chat. We had chat with RHF.

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

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 want to 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 anti-gravity came to be and there are four main categories of improvements powered by a little nano banana artwork the first one is intelligence and reasoning you all

are probably familiar with this you use nano or you used um 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 execute JavaScript. How do you get an agent to

JavaScript. How do you get an agent to understand the nuance of all these tools? It can do longer running tasks.

tools? It can do longer running tasks.

These things now take a bit longer, right? And so you can afford to run

right? And so you can afford to run these things in the background. It

thinks for longer. Just time has gotten stretched out. And then multimodal. I

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 Nano Banana Pro um and you really get something magical. So we have these roughly four

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 got to come up with

something more interesting than whatever this thing is called.

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 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 and 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 have 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 is verification. So, you

things. Browser is 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

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 flight ID and then it'll give you sort of the start and end of of that flight. And this is being done

that flight. And this is being done entirely by a Gemini computer use variant. So it can click, it can scroll,

variant. So it can click, it can scroll, it can retrieve the DOM, it can do all the things. And then what's really cool

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

it did. So it's changed the game. And

the model can take this and because it has 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

experience. Now the second place that we wanted to spend time is on image generation. And we noticed this theme

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

multimodal. And this is really great for consumer use cases, right? Nano Banana 2 was was mindboggling. Um, but also for devs. Devs are inherently this is a multimodal experience. You're not just

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

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 want to give you a quick demo of um mockups. So I have a hunch and you all probably believe this too.

Design is going to change, right? You're

going to spend, you know, maybe some time iterating with an agent to to arrive at a mockup. 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

kind of 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 Nano Banana Pro, you know, we pulled an allnighter for uh for the Gemini launch because that was our first launch. Then

they said, "Do it again. Do it on Thursday." So we made Gemini Pro um or

Thursday." So we made Gemini Pro um or I'm getting all these model names confused. The image Gen one, the Nano

confused. The image Gen one, the Nano Banana one, we made that available on day one. I'm running on very little

day one. I'm running on very little sleep on day one inside of the anti-gravity editor. And our hope is

anti-gravity editor. And our hope is that the anti-gravity 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

ceiling higher. Agents can do longer running tasks. They can do more

running tasks. They can do more complicated things. They can interact on

complicated things. They can interact on other surfaces. And so this necessitates

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

organized. They can use used for uh kind of like self-reflection and and self-organization. It can be used to

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

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

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

of tokens. This is like very hard to follow. And then this is actually like

follow. And then this is actually like there's like 10 of these, right? So you

just scroll and scroll and scroll.

You're like, "What the heck did this agent do?" And and this this has been

agent do?" And and this this has been traditionally the way that people review and sort of supervise agents. You'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

representation? And that is what an artifact is. The whole point and the

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 is really

artifact. And so Gemini 3 is really really strong with this sort of visual representation. It's really strong with

representation. It's really strong with multimodal. And so instead of showing

multimodal. And so instead of showing this, which of course we always let you show, we always we will always show you this, but we want to focus on this. And

I think this is the game-changing part about anti-gravity.

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.

title. We're changing something small.

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 markdown in the concept of a of a plan and a walkthrough. So, this is probably what

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 much 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 underspecified 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 got to 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

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 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

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

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

needed? So we'll always explain to the user what the purpose of this artifact is. Um and then interestingly like who

is. Um and then interestingly like who should see it? So should the sub agents see it? Should the other agents see it?

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 give it 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 want to 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

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 want to be able to provide

system. We want to be able to provide feedback along this cycle. So, from task start to task end, we want to 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 shell, 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

colleague, right? You're collaborating on a document. Then all of a sudden, you want to leave a textbased comment. So,

we took inspiration from that. We took

inspiration from GitHub. But you leave comments. You highlight text. You say,

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,

use Tailwind. Use vanilla CSS." So,

these are the sorts of comments that you would leave. You'd batch them up and

would leave. You'd batch them up and then you 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

select. And now you're leaving comments in a in a completely different modality, right? And we've done this and

right? And we've done this and instrumented the agent to ma naturally take your comments into consideration without interrupting that task execution loop. So at any point during your

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, 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 anti-gravity.

It's pulling you out into this higher level view. And the agent manager really

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

of this. And it can also handle sort of the property that is like parallelism and orchestration. So whether this be many

orchestration. So whether this be many different projects, whether this be the same project and you just want to 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

attention. It's a completely different pattern. And what's really nice is that

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 going to lie to you.

editor. I'm not going to lie to you.

There are tasks that you know you maybe don't trust the agent yet. We 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 80% to 100%. So we always want to give devs

100%. So we always want to 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

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

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. It's just to be your your

codegen. It's just to be your your biggest user, right? And that creates this research and product flywheel.

And so I will tell you anti-gravity will be the most advanced product on the market because we are building it for ourselves. We are our own users. And so

ourselves. We are our own users. And so

in the dayto-day we were able to give Google engineers, deep mind researchers, we were able to give them an early access and now an official access to anti-gravity

internally. And so now all of a sudden

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.

page. Well, go off and and make that better, right? So, it gives you this

better, right? So, it gives you this level of insight that eval just simply can't give you. And I think that's what's really cool about being a deep mind. You are able to integrate product

mind. 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 an anti-gravity 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

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 identify 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 got to 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

artifacts. Artifacts were not good on the initial on the initial uh versions, right? What part of training, what part

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

artifacts. And so it's this cyclic nature that I'm really really betting on.

And this this is really how anti-gravity will defy gravity. We've got pushing the ceiling. We're going to have an agent

ceiling. We're going to have an agent with very very high level of ambition.

We're going to try and do as much as we can. And this includes vibe coding.

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.

product flywheel. And this is the magic.

And this is the three-step process that we used in building anti-gravity.

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

having me. It's been awesome to come back every year. And so on behalf of the anti-gravity team, I just want to thank you for your time, for your patience as you use the product um and your support.

And of course, you too can adopt a TPU and help us uh turn off pager duty 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

instead. Um but we've got a lot of exciting things and I'm really really excited to bring anti-gravity 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

feedback. Um, and thank you again for listening. Enjoy the rest of the

listening. Enjoy the rest of the conference.