AI Engineer Code 2025
Defying Gravity
Loading slides…
Read the talk
Defying Gravity: Building an IDE Around Agent Work
Google Antigravity combines an editor, a browser and an Agent Manager to make longer agent tasks easier to direct, inspect and improve.
From a talk by Kevin Hou
Before you start: Familiarity with code editors, pull requests and basic agent tool use will help you follow the examples.
Where do you work when the agent leaves the editor?
If an agent can do more than edit code, where should a developer supervise its work? Google Antigravity begins with that product question. Kevin Hou introduces it during launch week, joking that the arrival of Wicked 2 and Antigravity alongside Gemini 3 Pro has made it a bad week for gravity. Hou, who introduces himself as the product engineering lead, describes the Google DeepMind IDE as the first from a foundational lab. Its central commitment is to put agents first in the developer experience.
The platform has three surfaces: an Editor, a Browser and an Agent Manager. Agents can work across those surfaces instead of remaining inside an IDE sidebar. The Agent Manager is the central hub: one window that lets the developer step back from individual diffs and look at the work being delegated.
The editor remains a familiar VS Code fork, with autocomplete and an agent sidebar mirrored with the Agent Manager. It is where developers can take over when agent-only work is insufficient—what Hou calls getting from eighty percent to one hundred percent of a task. That is a description of the handoff, not a measured completion rate. Hou reports that Command + E or Control + E switches between the editor and Agent Manager in under 100 milliseconds. He gives no measurement setup for that switching latency.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Show the feature working, then ask for attention
Agent-controlled Chrome has two jobs. First, it retrieves context from the web, including authenticated documents and dashboards that the developer grants access to. Hou describes access to Google Docs and GitHub dashboards in terms of the authentication available in normal Chrome. For present-day setup, the browser-profile documentation specifies a separate profile: normal-profile cookies and sign-ins are not shared, but sign-ins made within the agent profile persist. Access to authenticated sites should therefore not be confused with automatic reuse of an existing Chrome session.
Second, the browser lets the agent inspect an application by clicking, scrolling and executing JavaScript. Hou demonstrates a random artwork generator: refreshing the page produces another Thomas Cole picture. After adding a small modal card, the agent supplies a Chrome recording showing the interaction, with a blue circle marking the mouse. The developer can inspect the feature as it appears in the browser, alongside the code changes. The recording is evidence of those interactions, rather than a guarantee that every application behavior is correct.
With the editor and browser serving as agent tools, the Agent Manager becomes a control panel for several tasks. Its inbox collects requests that need intervention, such as approval for a terminal command. OS-level notifications tell the developer when attention is needed, reducing the need to keep checking each conversation.
That launch also exposed an immediate operational limit: capacity. Hou reports that the service ran out and that the team was working through errors. His apology for a global chip shortage is a joke about that pressure; the launch-era changelog separately distinguishes individual quota exhaustion from global capacity limits.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
New model capabilities change the product shape
Why introduce another window? The Agent Manager creates a one-to-many relationship with the other work surfaces. Hou connects that decision to earlier changes in coding tools: models became good at short-form completion, making Copilot-style autocomplete possible; chat and then agents followed. He presents these product paradigms as responses to changes in model capabilities. A product can only expose the capabilities its models can sustain.
Working inside DeepMind gave the Antigravity team access to Gemini a couple of months early. Product engineers and researchers could explore both directions: which model strengths deserved a new interface, and which gaps prevented the intended experience. Hou groups the changes into four categories, illustrated on his slides with Nano Banana artwork.
| Capability | Product consequence |
|---|---|
| Intelligence and reasoning | More demanding instructions become practical. |
| Nuanced tool use | A browser can expose clicks, navigation and JavaScript execution. |
| Longer-running work | Tasks can continue in the background while the developer does something else. |
| Multimodality | Images and visual outputs become part of the work loop. |
The browser makes tool choice particularly consequential: executing JavaScript is a much broader action space than selecting a simple editor command. Longer thinking also stretches the time between a request and its result. Hou pairs Gemini 3 with Nano Banana Pro as an example of combining reasoning with image capabilities. His proposed next step beyond existing agents is a product hypothesis about how to use these changes together.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Raise the ceiling with context and browser feedback
The first design step is to raise the ceiling of what an agent can accomplish. Specialist research teams make capabilities such as computer use available, but the product still needs to connect them to engineering work. Hou divides that work into deciding what to build, deciding how to build it and actually building it. Code generation increasingly addresses the last part, provided the model has sufficient context and produces functioning code. Human imagination supplies the direction; institutional knowledge helps determine the implementation. Bug dashboards, experiments and other browser-accessible material make that knowledge available to the agent.
The flight-tracker demonstration shows the other half of browser use: verification. A user enters a flight ID and the application returns the flight's start and end. A blue border indicates that the browser is under agent control. Hou says a Gemini computer-use variant performs the interaction, with access to clicking, scrolling and DOM retrieval.
The result includes both a diff and a screen recording. That adds a feedback path: an image-capable model can inspect the visible result and iterate from it. The same browser interaction therefore supplies material for human review and observations for another agent step.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Iterate on the design before writing the website
Software development is already multimodal: developers inspect rendered websites, architecture diagrams, screenshots and recordings. Image understanding helps with verification; image generation adds another way to create and revise the intended result. Antigravity combines Gemini 3 Pro with the image side of the model family rather than treating coding as exclusively a text task.
The mockup demonstration starts in image space. A developer can work toward a website design, attach comments to the image and queue several pieces of feedback before asking the agent to update it. The interaction resembles a GitHub review: collect the comments, submit them together and let the agent decide how to apply them. The displayed plant-site design is the visual object being iterated on before implementation.
Hou describes consecutive launch pushes for Gemini and then the image model, with image generation available in the editor on its launch day. The Antigravity image-model announcement identifies that release as Nano Banana Pro, also called Gemini 3 Pro Image, and specifies an incremental rollout; users without Pro access continued using the original Nano Banana. The product ambition is an editor where new model capabilities can become usable development tools as they arrive.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Artifacts make long tasks reviewable
More capable agents create a second design problem. When tasks take longer, become more complex and cross several surfaces, the user needs a way to understand the work without reading every message. Antigravity calls that interaction primitive an artifact: an agent-generated, dynamic representation of information suited to the user and the task.
Artifacts serve several audiences. They help an agent organize and reflect on its own work; communicate screenshots or recordings to the user; and share information with a browser sub-agent, another conversation or memory. The Agent Manager dedicates roughly half its screen, plus sidebar space, to these objects.
Chunking the conversation makes a long run somewhat easier to follow, but it still leaves the developer scrolling through strings and tokens to discover what happened. A visual representation can communicate the relevant structure more directly. Hou uses his own PowerPoint as the analogy: the slides are his artifact, making a spoken explanation easier to follow. The underlying agent conversation remains available, but it no longer has to carry the entire burden of review.
Dynamic means that the agent chooses whether an artifact is useful and what form it should take. A title change may not need one. For a larger task, the lifecycle can look like this:
- Research and plan. Produce a Markdown implementation plan resembling a product requirements document, including open questions. Hou's example surfaces three questions before work begins.
- Decide whether to continue. If there are no unresolved questions, the model may proceed automatically. An underspecified request or a discovery during refactoring can instead require clarification.
- Track execution. After approval where needed, use a task list to expose progress and architecture diagrams to explain structure.
- Present the result. Finish with a walkthrough resembling a pull-request description: explain what changed and provide evidence that it works.
Images, screen recordings and Mermaid diagrams are other possible representations. Hou expects the set to expand as agents discover useful ways to present information.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Keep discoveries that the next task will need
An artifact also needs a purpose and an audience. Why was it created? Should a sub-agent see it? Should it be available to another conversation or stored in memory? Hou illustrates those choices with API research: give the agent documentation and an API key, and it can issue curl requests to investigate response schemas and types, then produce a report.
For an API that uses bearer authentication, a minimal inspection request can take this form, with API_URL set to a documented read endpoint:
bash
curl --fail-with-body --silent --show-error \
--header "Authorization: Bearer ${API_KEY}" \
--header "Accept: application/json" \
"${API_URL}"
The returned response is an observation for the research report; one request does not establish every possible response shape. The reusable artifact is the accumulated understanding of the API, not merely the command used to inspect it.
Hou's example preserves that report in memory so the next task does not have to repeat the same investigation. If the research instead produces an open question, a proactive notification brings it back to the user. Artifacts can therefore carry knowledge forward as well as request the attention needed to continue.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Steer running work through the artifact
Review is not confined to the beginning or end of a task. Antigravity borrows from Google Docs and GitHub: highlight text, attach comments, batch them and send them together. A comment can clarify an incomplete part of a plan or change an implementation choice—for example, asking the agent to use vanilla CSS instead of Tailwind.
Images use a Figma-like selection pattern: select a region and leave feedback on that part of the design. Hou says the agent is instrumented to incorporate these comments without interrupting its task execution loop. A user can object to a result while browser interaction is underway, submit the comment and receive a notification after it has been addressed. Submitting feedback is a request for a change; incorporation happens subsequently.
That interaction supports parallel work. The Agent Manager can coordinate different projects, or separate activities within one project: design mockup iteration, API research and application implementation. Artifacts are where the developer reviews and directs each activity; notifications indicate which one needs attention.
Direct control remains available when the model is not capable enough or the developer does not trust a particular task to it. Command + E opens the editor with the exact files, artifacts and conversation associated with the work. Autocomplete and synchronous chat let the developer finish from there. Hou expects more time to shift toward the Agent Manager and parallel sub-agents as capabilities improve, but the editor remains an intentional escape hatch.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Improve the model and the harness together
The third part of the design is organizational: use the product heavily enough to discover what needs to improve. Drawing on roughly three years in code generation, Hou describes internal use as the basis for a research–product feedback loop. Google engineers and DeepMind researchers received early access and then official internal access, putting the people improving the models in contact with the Agent Manager and its artifacts.
That experience gives different teams concrete problems to work on. An infrastructure engineer encounters slow responses; a computer-use researcher sees a failed button click, poor scrolling or difficulty locating text. Image generation and instruction-following teams also encounter their capabilities within the complete application. Hou argues that this exposes gaps evaluations alone miss. His prediction of market leadership rests on this internal use, alongside a commitment to bring frontier capabilities to external users through the same product.
The computer-use collaboration illustrates why the loop has to run in both directions. Nearby researchers and product engineers can investigate whether a failure comes from a model capability gap or a mismatch in data distribution. They can also discover that the agent harness exposes faulty tools. In the latter case, the product team has to repair its side of the interaction. Calling a model API is only one part of making the full system work.
Artifacts supplied a second example. Hou reports that early model versions handled them poorly: the new review interaction did not fit familiar training patterns. Product plumbing and collaboration with researchers created a concrete target for improvement, leading to better artifact handling by the Gemini 3 Pro launch. The product introduced a new behavior to support; research and engineering then worked together to make it dependable enough to expose.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Build for a higher capability ceiling
The ambition includes vibe coding, and Hou acknowledges AI Studio as another strong Google product. Antigravity's emphasis is on increasing the ceiling: enabling more demanding agent work, making it manageable through artifacts and the Agent Manager, and using the research–product loop to improve what the system can actually accomplish. These are connected design choices. Greater capability creates harder supervision problems; a new interaction pattern creates new demands on the model.
The closing returns to the realities of shipping. Hou jokes that users can adopt a TPU to help quiet PagerDuty, invites feedback on Twitter—preferably through DMs—and welcomes reports from people using the released product. The next round of improvement depends on that contact with real work, including the operational pressure it creates.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Resources
From the talk
The original launch explanation of Antigravity's agent-first development platform and artifact-based collaboration.
How image generation supports UI mockups, visual design feedback, architecture diagrams and application assets.
Further reading
Launch-era examples of asynchronous agent work, browser verification, artifact feedback and reusable knowledge.
Updates since the talk
Explains browser-profile isolation, persistent sign-ins and profile-location settings.
Full transcript
Loading transcript…