# Defying Gravity

Kevin Hou, Google DeepMind | AI Engineer CODE 2025 | 25:10

Source: https://www.youtube.com/watch?v=HN-F-OQe6j0
Channel: AI Engineer (https://www.youtube.com/@aiDotEngineer). Summarised by AIE Talks.
Page: https://aietalks.com/talks/defying-gravity
Published: 2025-12-02
Tags: agents, coding-agents, computer-use, human-in-the-loop, multimodal

## TL;DR
- Google Antigravity puts an agent manager, an editor, and an agent-controlled browser into one developer platform.
- Artifacts give agents a visual way to present plans, task progress, screenshots, recordings, diagrams, and walkthroughs.
- Google DeepMind uses Antigravity internally so product use exposes model and tooling problems that evaluations may miss.

## Summary
Kevin Hou introduces Google Antigravity, an AI developer platform built around three surfaces: an editor, an agent-controlled Chrome browser, and an agent manager. The manager gives developers a higher-level view of work across multiple agents, while the editor remains available for detailed coding and the browser supplies web context and visual verification. Hou explains that changes in model abilities have repeatedly produced new product patterns, from autocomplete to chat and agents. Gemini 3 adds stronger reasoning, tool use, long-running work, and multimodal abilities, so Antigravity uses artifacts to help agents communicate plans, questions, progress, screenshots, recordings, diagrams, and final walkthroughs. Users can comment on artifacts during execution, and agents can store useful reports as memory. Hou is direct that developers still need an editor escape hatch when they do not trust an agent. He also describes an internal research-product loop in which Google engineers use Antigravity to find gaps in models, tools, infrastructure, and interaction design.

## Key ideas
### Antigravity combines three surfaces around an agent manager
[01:40](https://www.youtube.com/watch?v=HN-F-OQe6j0&t=100s)
Kevin Hou describes Google Antigravity as an AI developer platform with an editor, a browser, and an agent manager. The manager is the central hub, pulling developers one level above code and diffs so they can supervise work across agents. The editor provides autocomplete, an agent sidebar, and the detailed environment needed to take a task from roughly 80% to 100%. The browser is an agent-controlled Chrome instance that can access authenticated web resources and interact with applications. Developers can move between the editor and manager with Command-E or Control-E in under 100 milliseconds. The manager also includes an inbox for approvals, such as terminal commands, plus operating-system notifications.

### The browser gives agents both context and a way to prove their work
[03:13](https://www.youtube.com/watch?v=HN-F-OQe6j0&t=193s)
The agent-controlled Chrome browser gives Antigravity access to the web through the developer's existing authentication. Hou mentions Google Docs, GitHub dashboards, and other resources an engineer might use. The agent can click, scroll, execute JavaScript, retrieve the DOM, and test applications. Rather than only presenting a code diff, it can record the browser session, with a blue circle showing the mouse movement. Hou calls this a way to get verifiable results. In a flight tracker example, a Gemini computer-use variant enters a flight ID and returns the start and end of the flight. The model can inspect the recording as an image and use it to iterate.

### Product patterns change when model capabilities take a step forward
[05:51](https://www.youtube.com/watch?v=HN-F-OQe6j0&t=351s)
Hou argues that developer products follow model capabilities. Autocomplete became possible when models got good at short-form completion, followed by chat and then agents. Google DeepMind's product team could work with Gemini before launch to identify strengths worth exposing and gaps that needed product or model work. He groups the newer capabilities into intelligence and reasoning, richer tool use, longer-running tasks, and multimodality. Better instruction following supports more nuanced tool interactions. Longer tasks can run in the background while the model thinks for more time. Multimodal abilities let an agent understand screenshots, recordings, and other visual outputs.

### Browser use expands the agent's context beyond source code
[08:43](https://www.youtube.com/watch?v=HN-F-OQe6j0&t=523s)
Hou separates software development into what to build, how to build it, and the act of building it. Code generation can handle more of the building step when the model has enough context, while the developer still supplies much of the product direction. Browser access gives the agent institutional and operational context, including bug dashboards, experiments, and other systems around the code. The browser also supports verification after implementation. An agent can operate an application, capture what happened, and inspect the result visually. Hou presents this as a way for the model to use its image understanding to continue iterating instead of stopping at a textual diff.

### Image-space design lets developers review and revise before coding
[10:38](https://www.youtube.com/watch?v=HN-F-OQe6j0&t=638s)
Hou says development is a multimodal activity because developers work with website output, architecture diagrams, screenshots, and recordings as well as text. Antigravity uses image generation and understanding to support design iteration. A developer can start with a mockup, add comments, and queue several requested changes. The agent can interpret those comments and update the design in image space. Hou compares the interaction to GitHub review and later describes a Figma-style way to select parts of an image before commenting. The product team wanted the editor to provide a place where new model capabilities, including image generation, could appear alongside ordinary development work.

### Artifacts turn agent output into inspectable working objects
[12:26](https://www.youtube.com/watch?v=HN-F-OQe6j0&t=746s)
Hou defines an artifact as a dynamic representation of information generated for a user's task. Artifacts help agents organize themselves, communicate with users, coordinate across sub-agents, and preserve memory. Instead of making users follow long streams of tokens and reasoning, the agent manager can show a plan, task list, architecture diagram, screenshot, screen recording, or walkthrough. A plan can include research findings and open questions before implementation begins. If there are no questions, the model may continue automatically. If the task is underspecified, it can stop and ask for input. At the end, a walkthrough can explain what changed and provide evidence that the work was completed correctly.

### Comments and memory keep collaboration active during long tasks
[16:51](https://www.youtube.com/watch?v=HN-F-OQe6j0&t=1011s)
Artifacts support feedback while an agent is still working. Users can leave text comments, highlight passages, and batch changes before sending them, much like comments in Google Docs or GitHub. In image space, they can select a region and describe what should change. Hou says the agent can take these comments into account without interrupting its execution loop, then notify the user when the work is done. Artifacts can also become memory. For example, an agent can read documentation and an API key, run curl requests, determine the API schema, and produce a report. Saving that report means the agent does not have to derive the same information again.

### Internal use creates a research-product feedback loop
[20:34](https://www.youtube.com/watch?v=HN-F-OQe6j0&t=1234s)
Hou says the team builds Antigravity for itself and gives Google engineers and DeepMind researchers access to it. Their daily use exposes issues in computer use, image generation, instruction following, infrastructure, and the agent manager. A real user may notice that a page is slow, or that an agent harness needs better tools, in ways that an evaluation does not reveal. Hou describes working directly with the computer-use team to find mismatches between model data and the product's tools. Artifacts also needed changes because model training did not naturally include the product's review pattern. The teams improved the model and surrounding plumbing together, then shipped stronger artifact handling with Gemini 3 Pro.

## Notable quotes
- "Anti-gravity is unapologetically agent first." (00:59)
- "The product is only ever as good as the models that power it." (05:58)
- "An artifact is something that the agent generates that is a dynamic representation of information for you and your use case." (12:56)
- "The secret here is a lesson that we've just learned over the past three years in codegen, it's just to be your biggest user." (20:45)
- "It gives you this level of insight that eval just simply can't give you." (21:46)

## Tools & references mentioned
- Google Antigravity
- Google DeepMind
- Gemini 3 Pro
- Gemini 3
- Google Chrome
- VS Code
- GitHub
- Google Docs
- Nano Banana Pro
- AI Studio
- Figma
- Tailwind CSS
- Google TPU

## Who should watch
- You are building coding agents and need product ideas for supervising work across editors, browsers, and background tasks.
- You want agents to provide visual evidence, plans, progress reports, or reviewable design output instead of returning only text and diffs.
- Your team is deciding how internal use of an agent product can expose model, tool, and infrastructure problems.

## Related talks

- [How Google DeepMind Runs Agents at Scale](https://aietalks.com/talks/how-google-deepmind-runs-agents-at-scale) (KP Sawhney & Ian Ballantyne, Google DeepMind, 25:13)
- [The New Primitives: Building AI Native Software](https://aietalks.com/talks/the-new-primitives-building-ai-native-software) (Kwindla Kramer, Daily, 21:14)
- [Navigating AI's Frontier in 2025](https://aietalks.com/talks/navigating-ais-frontier-in-2025) (Grace Isford, Lux Capital, 17:55)
- [How Anthropic Builds: Lessons from Labs](https://aietalks.com/talks/how-anthropic-builds-lessons-from-labs) (Mike Krieger, Anthropic, 26:11)
- [Agents for Everything Else](https://aietalks.com/talks/agents-for-everything-else) (swyx, AI Engineer, 14:10)