[music]

All right. Hello. Last one of the day.

Can we get a uh little energy boost?

Who's ready? Who's ready? [applause]

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

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

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

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

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

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

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

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

that you need, it will sort of let you

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

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.

[laughter]

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

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

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

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

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

understand the nuance of all these

tools? It can do longer [clears throat]

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

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

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 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. 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 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? Nano Banana 2

was was mindboggling. 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 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

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 on day one inside of the

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

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

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

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

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

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

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

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

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

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 agents

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

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

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

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,

"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 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 ma 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,

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

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

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.

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

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

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

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

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

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

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

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

will defy gravity. We've got pushing the

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.

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

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

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

listening. Enjoy the rest of the

conference. [applause]

[music]