Migrating the past. Shipping the present. Governing the autonomous future.
Christopher Brox.
Building autonomous AI agents and self-shipping software on the Antigravity team at Google DeepMind.
Writing code is no longer the bottleneck.
Orchestrating agents is.
Agents used to autocomplete lines. Now you orchestrate them to migrate monoliths, ship features, and run the night shift.
Where we have been. Where we are. Where we are going.
Every CTO in this room has a system their team is afraid to touch.
When teams first get an agent, they hand it the migration guide and type “port this repository.” It fails every time.
Here is how a real agent migration actually works—step by step, gotcha by gotcha.
Five moves. In this order.
Your wiki is lying. Git isn’t.
Give the agent every source: git history, prior PRs, production code, and the wiki.
Don’t prompt it. Let it grill you.
The agent asks. You answer. Ambiguity dies before code.
Agree on the plan. Zero edits.
Review one page of plan, not ten thousand lines of diff.
“For a payments gateway migration spanning 49 RPC methods, we pointed Antigravity at our migration guide, code generators, and 18 prior pull requests. It first flagged 10 undocumented edge cases in the guide, and then helped us run a repeatable workflow that produced 47 tested pull requests across three microservices over two days.”
Agents grade their own homework. Lock the tests.
Golden master first. The agent can’t touch it.
“Our team used Antigravity to refactor our user intent models from TensorFlow to JAX. We had the agent translate the model layers alongside numerical parity tests for each block, which helped us catch shape and precision differences early in the migration.”
Marathon chats collapse. Slice it.
Pilot one slice. Run /learn. Fan out.
“We used Antigravity to analyze common patterns in our past Go code reviews and codify them into a workspace review skill. Running that pre-review check on new pull requests catches recurring style and error-handling issues early, saving about 30 minutes of review time a day.”
Never trust the agent that wrote the code.
Tests → reviewer agent → recording → you.
Quick pulse. Which of these have you used?
Code parity takes hours. Cutover still takes weeks.
Eliminate the 9-month reverse-engineering bottleneck—and turn a 14-month migration into weeks.
You can build anything in an afternoon.
Which means you can build the wrong thing 10× faster.
Pointing fast agents at a stale Jira backlog doesn’t create velocity. It ships unused software faster.
Tickets tell you what. Analytics tells you where. Neither tells you why.
Don’t start in Jira. Connect the agent to customer reality and test the bet before writing code.
“Before filing engineering requests for a new recommendation ranking model, I used Antigravity over two days to analyze historical benchmark datasets and prototype a candidate scoring rule. Running behavioral replay simulations showed a clear precision improvement, giving us solid data to scope the engineering work.”
From customer evidence to build brief.
Connecting the agent directly to real human feedback via the UserTesting MCP.
Customer words become the tests. Subagents build the rest.
Antigravity takes the UserTesting build brief, audits the data, and ships the working prototype.
“We used Antigravity to analyze production API usage across 400 endpoints to inform our CLI roadmap priorities, and then used it over the next few days to scaffold a multi-surface demo app connecting a mobile view, backend service, and admin console for an upcoming product review.”
Roadmaps exist because
engineering was scarce.
Now your engineers direct swarms
that build 24/7.
engineering was scarce.
that build 24/7.
Three things that used to take a quarter now happen overnight: deal blockers, spec debates, and post-M&A integration.
A 4:00 PM deal blocker becomes an 8:00 AM demo.
Don’t put enterprise blockers on next quarter’s backlog. A swarm builds, tests, and records the working feature before the buyer wakes up.
Stop debating specs. Build all three overnight.
Don’t spend six weeks in PRD committees guessing which architecture will win. Spawn three swarms and let telemetry decide.
Post-M&A integration in days, not 18 months.
Point an integration swarm at both repos on Day 1. Unify identity, billing, and APIs while you sleep—so you cross-sell in week one.
You can’t read 50,000 lines a day. You manage by exception.
Agents police agents inside hard guardrails. Humans only touch product taste, customer commitments, and 100% promotion.
“Through scheduled tasks and CI/CD integration, we run Antigravity jobs to execute combinatorial UI test suites across our analytics platform. Each morning, engineers review the captured browser screenshots, failure summaries, and draft fixes ready for code review.”
knowing what’s worth building.
that ship it while you sleep.