← All speakers

Kevin Hou leads product engineering for Google Antigravity at Google DeepMind, building software-development environments where AI agents can write code, operate browsers, verify applications, and coordinate parallel tasks. Previously, he led product engineering at Codeium and Windsurf, helping move coding assistants beyond autocomplete toward sustained participation in the wider engineering workflow.

From autonomous vehicles to agent-first development

Hou studied computer science at Princeton University and worked on autonomous vehicles at Nuro before joining Codeium, the AI developer-tools business that emerged from Exafunction. His programming portfolio reflects a broader interest in full-stack software, product design, and machine learning; he also works in photography and woodworking. Earlier projects include async-post-message and Handwriting Font App, which converts handwritten characters into text suitable for physical reproduction.

At Codeium, Hou tackled a basic weakness of AI coding tools: useful changes usually depend on several related files, project-specific conventions, and external documentation, while conventional retrieval benchmarks often reward finding one relevant document. The team developed M-Query, which uses models to assess candidate codebase items and assemble richer context. Its evaluations paired pull requests and commits with the files they changed, measuring retrieval against realistic engineering work while accounting for latency and infrastructure costs. His account of repository-aware retrieval also explains why larger context windows and ordinary vector embeddings do not automatically solve the problem.

As Codeium evolved into Windsurf, Hou helped develop an agent-oriented editor organized around a shared human-agent timeline. File edits, searches, terminal commands, and agent actions contribute to the same working context, enabling an agent to continue unfinished tasks, infer dependencies, and remember project conventions. Potentially dangerous commands require approval. His Windsurf product architecture discussion frames persistent context as a prerequisite for collaboration, not merely a convenience.

Windsurf subsequently expanded into browser previews, GitHub pull requests, background agents, and integrations with tools including Notion, Linear, and Stripe. Hou introduced Windsurf Previews as a way to modify applications through direct interaction with their running interfaces. Windsurf’s SWE-1 model extended that approach to evaluation: assess complete engineering tasks and partially finished conversations, not code generation in isolation.

Hou helped launch Google Antigravity in November 2025, combining an AI editor, an agent-controlled browser, and Agent Manager for supervising concurrent work. The browser can retrieve authenticated context and test applications directly; implementation plans, diagrams, screenshots, recordings, and walkthroughs make an agent’s decisions and results reviewable.

  • Repository-aware retrieval: Coding agents need multiple interconnected sources of context, evaluated against actual code changes rather than simplified search exercises.
  • Shared human-agent context: Agents should track evolving files, terminal activity, documentation, and project preferences so they can continue work without repeatedly requesting the same information.
  • Browser-based verification: A useful agent should inspect and interact with the running application, producing visible evidence of whether its changes work.
  • Artifacts as an agent interface: Plans, task lists, diagrams, screenshots, and walkthroughs give developers practical checkpoints for reviewing, redirecting, and approving autonomous work. Hou’s explanation of Antigravity’s design connects these interfaces to parallel orchestration and collaboration between product engineers and model researchers.

Read the topics behind these talks

4 conference talks

Key ideas

Scroll to read ↓

Windsurf’s early demos show how shared activity history, persistent context, and model-directed research turn code generation into a coordinated development workflow.

  • What comes after completing the next function?
    0:38 ↗
  • Build the crawler where the developer works
    3:17 ↗
  • Less explicit input, more operational responsibility
    4:19 ↗
  • A shared timeline supplies the missing intent
    6:49 ↗
  • Observe and act in the same environment
    9:56 ↗
  • Remember what the current task cannot tell you
    11:49 ↗
  • Let better models remove interaction costs
    15:20 ↗
  • From suggesting code to doing more of the work
    19:14 ↗

Key ideas

Scroll to read ↓

Google Antigravity combines an editor, a browser and an Agent Manager to make longer agent tasks easier to direct, inspect and improve.

  • Where do you work when the agent leaves the editor?
    0:29 ↗
  • Show the feature working, then ask for attention
    3:10 ↗
  • New model capabilities change the product shape
    5:49 ↗
  • Raise the ceiling with context and browser feedback
    8:22 ↗
  • Iterate on the design before writing the website
    10:26 ↗
  • Artifacts make long tasks reviewable
    12:24 ↗
  • Keep discoveries that the next task will need
    16:48 ↗
  • Steer running work through the artifact
    17:45 ↗
  • Improve the model and the harness together
    20:27 ↗
  • Build for a higher capability ceiling
    23:34 ↗

Key ideas

Scroll to read ↓

A React contact form exposes the limits of similarity search: useful generation needs several complementary sources, an evaluation that measures their recovery, and affordable compute to rank them.

  • A contact form that belongs in the repository
    0:29 ↗
  • Three ways to supply repository knowledge
    2:59 ↗
  • Similarity is not the same as task relevance
    4:31 ↗
  • Measure recovery of the whole relevant set
    6:01 ↗
  • Turn commits into retrieval tasks
    6:57 ↗
  • Make more retrieval computation affordable
    8:45 ↗
  • M-Query judges candidate items in parallel
    10:13 ↗
  • Test retrieval in the interaction it serves
    11:43 ↗
  • A context engine and a production feedback loop
    13:38 ↗
  • Let shipped products test the compute argument
    15:44 ↗

Key ideas

Scroll to read ↓

A coding agent needs more than repository context: it must follow work across tools, join partially completed tasks, and learn when to act or ask for approval.

  • Why does an editor feel like it understands your work?
    0:50 ↗
  • A shared timeline of human and AI actions
    2:30 ↗
  • The context behind a correct change
    3:55 ↗
  • A dashboard page begins before anyone writes code
    5:02 ↗
  • From reading the workflow to acting within it
    6:19 ↗
  • From synchronous assistance to background work
    8:37 ↗
  • Engineering tasks do not always start at the beginning
    10:02 ↗
  • SWE-1: evaluate completion and continuation
    11:21 ↗
  • Product use reveals what the model and tools are missing
    12:51 ↗
  • Align the application with the behavior the model should learn
    14:25 ↗

References