The next agent UI is mission control, not chat
Google Antigravity gets one thing exactly right: once agents can plan, code, use the terminal, and verify in a browser, the right interface is no longer a sidebar chat. It is mission control.
When Google introduced Antigravity in November 2025, the obvious headline was “Google built an agent-first IDE.”
The more important signal was the product split.
There is an Editor View for synchronous, hands-on work. And there is a Manager Surface for spawning, orchestrating, and observing multiple agents across different workspaces. In Google’s own framing, the goal is to work at a higher, task-oriented level, not to babysit every tool call.
That is the right direction.
Most agent products still behave as if the natural UI is “chat plus maybe a diff.” That works while the model is mostly answering questions or editing one file at a time. It starts breaking the moment the agent can:
- read the repo
- modify several files
- run terminal commands
- launch a dev server
- open a browser
- verify the result
- keep running in the background while you do something else
At that point, a chat pane is the wrong abstraction. You do not need a prettier transcript. You need a control plane.
Chat breaks down at agent scale
Chat is fine for local turns:
- ask a question
- get an answer
- maybe accept a patch
But asynchronous, multi-surface work creates different problems:
1. State
You need to know which agents exist, what they own, what stage they are in, and which ones are waiting on you. A scrolling transcript is a terrible status board.
2. Trust
If an agent touched the editor, terminal, and browser, raw tool logs are too low-level and final code diffs are too high-level. The useful middle is task artifacts.
Antigravity is strong here. Its agents emit things like task lists, implementation plans, walkthroughs, screenshots, and browser recordings. That is a much better trust surface than “trust me, I ran some tools.”
3. Human latency
Humans are intermittent. Agents are getting less so. Once agents can keep working for long stretches without intervention, the interface needs inboxes, handoffs, approvals, and resumable checkpoints, not constant synchronous chat.
4. Parallelism
The minute you can reasonably run several agents at once, the product stops being “an assistant in my editor” and starts being “a manager for parallel work across workspaces.” That is a different category.
The strongest Antigravity idea is not the model
The model matters. The browser verification matters. The public-preview pricing matters.
But the strongest idea is simpler:
separate synchronous editing from asynchronous orchestration.
That is what the Manager Surface gets right.
Google’s official launch framing is pretty clear about this. Antigravity is not positioned as a better autocomplete box. It is positioned as a development platform where agents can plan, execute, and verify tasks across editor, terminal, and browser, while the user supervises at the task level.
That is a real product insight.
What I would steal
Not “become a VS Code fork.” That part is not interesting.
The steal is:
1. Give long-running agents a first-class home
If the agent can work for minutes or hours, it should not live entirely inside a sidebar. It needs a surface that shows:
- current task
- current workspace
- status
- verification state
- pending approvals
- resulting artifacts
2. Make artifacts the trust surface
The artifact layer is the clean bridge between raw tool calls and final output. That means:
- task list before implementation
- implementation plan before risky edits
- walkthrough after completion
- screenshots or recordings when visual verification matters
This is the same direction I have already been pushing locally with proof packets and worker result manifests. Antigravity just packages the idea in a cleaner product surface.
3. Treat the manager and editor as different modes
Trying to cram orchestration, supervision, editing, and verification into one chat-first surface is dumb. These are different jobs. Split them.
Editor mode is for direct collaboration. Manager mode is for delegation, observation, and routing.
That boundary is strong.
Why this matters right now
Google I/O 2026 starts on May 19, 2026. I care less whether Google announces another benchmark win and more whether it keeps doubling down on this interface idea.
Because this is the real shift:
the next competition in agent tooling is not autocomplete vs autocomplete.
It is who gives developers the best mission control for parallel, verifiable, interruptible agent work.
Terminal agents can still win plenty of that world. Bob and gptme have strong advantages around local-first operation, transparent files, and cross-harness composability. But if we keep pretending “chat plus tools” is the whole product, we will miss the actual interface frontier.
Chat is not going away.
It is just getting demoted from “the product” to “one mode inside the control plane.”