Agent-First AI Development Platform with Multi-Surface Orchestration

google_deepmind · Tech · 2025 · source Agentic: yes · promotional bias: med · source-backed · extracted with prompt 0.5.2 (schema v2)

Generated from extraction.json — do not edit by hand. Every claim cites verbatim source evidence; stated means the quote directly asserts the claim, implied means it supports it indirectly.

Problem

Domain: AI development environment

Google DeepMind needed an agent-first development platform for long-running software tasks across editor, browser, and agent manager surfaces.

Constraints:

Multi-surface agent work
Asynchronous feedback
Capacity constraints at launch

Architecture

Google Anti-gravity is an agent-first developer platform with three coordinated surfaces: an editor, an agent-controlled Chrome browser, and an agent manager. Gemini 3 Pro powers agents that work outside the IDE across code, authenticated web context, browser actions, and long-running task execution. The agent manager organizes work through dynamic artifacts such as plans, walkthroughs, diagrams, screen recordings, research reports, open questions, task lists, and memory items, so users supervise progress through structured outputs rather than raw token streams.

Diagram confidence: explicit (topology described by the source).

flowchart LR
  editor-surface[Editor surface] --> agent-manager[Agent manager]
  editor-surface --> gemini-agent[Gemini agent]
  agent-manager --> artifact-system[Artifact system]
  gemini-agent --> agent-manager
  gemini-agent --> agent-controlled-browser[Agent-controlled browser]
  agent-controlled-browser --> artifact-system
  gemini-agent --> artifact-system
  artifact-system --> memory-bank[Memory bank]
  agent-manager --> user-feedback-loop[User feedback loop]
  artifact-system --> user-feedback-loop

Drag to pan · scroll or use +/− to zoom · reconstructed from the source's described component topology

Components

Component	Role	Interacts with
`Editor surface`	VS Code-like coding surface with agent sidebar and fast handoff to the agent manager.	`Agent manager`, `Gemini agent`
`Agent manager`	Central control panel for supervising long-running agent tasks and artifacts.	`Editor surface`, `Artifact system`, `Gemini agent`
`Agent-controlled browser`	Chrome browser the agent can use for authenticated context retrieval and browser actions.	`Gemini agent`, `Artifact system`
`Gemini agent`	Gemini 3-powered development agent that executes tasks across surfaces.	`Editor surface`, `Agent manager`, `Agent-controlled browser`, `Artifact system`
`Artifact system`	Dynamic representations of plans, walkthroughs, research, diagrams, recordings, tasks, and memory.	`Agent manager`, `Gemini agent`, `Memory bank`
`Memory bank`	Stores reusable artifacts or derived knowledge for future tasks.	`Artifact system`
`User feedback loop`	Human review and feedback during task execution.	`Agent manager`, `Artifact system`

Data flow

A developer starts from the editor or agent manager. The agent can move between editor work, browser research/control, and agent-manager supervision; Gemini decides whether to produce artifacts; artifacts expose plans, questions, task progress, proofs, and memory; the user can provide feedback during execution or jump back to the editor with the same files, artifacts, and conversation.

3 supporting quotes

“Anti-gravity. It's an AI developer platform with three surfaces. The first one is an editor. The second one is a browser and the third one is the agent manager.”transcript, stated

“So, we have an agent controlled Chrome browser. And this gives the agent access to the richness of the web. And I mean that in two ways.”transcript, stated

“And the artifact system lets you iterate with the model more fluidly during this process of execution. And so, not to sound like a complete Google shell, but I love Google Docs, right?”transcript, stated

Why this architecture

Anti-gravity uses multiple surfaces and artifacts because long-running agent work no longer fits inside a single IDE chat. The browser gives the agent web context and interaction, the editor remains available for direct developer control, and artifacts make task supervision less dependent on scrolling through strings and chain-of-thought-like logs.

3 supporting quotes

“So a paradigm shift here is that agents are now living outside of your IDE and they can interact across many different surfaces that your agent or that you as a software developer might spend time in.”transcript, stated

“And at any point, we made it very very easy because we recognize not everything can be done purely with an agent for you to command E or control E and hop instantly from the editor into the agent manager and vice versa.”transcript, stated

“So in theory, you could follow along a little bit better in the conversation view, but ultimately you're looking at a lot a lot of strings, a lot of tokens. This is like very hard to follow. And then this is actually like there's like 10 of these, right?”transcript, stated

Models used: Gemini 3 Pro

Scale

The product launched alongside Gemini 3 Pro and initially hit capacity limits.
“And then, of course, Anti-gravity came out earlier this week alongside Gemini 3 Pro on Tuesday.”transcript, stated
Artifacts are designed to scale into new representation types as the model decides what a task needs.
“because it's dynamic the agent will decide this over time so suddenly there's maybe a new type of artifact that we maybe we missed Right?”transcript, implied

Alternatives considered (roads not taken)

Keep agents inside the IDE/chat surface

Rejected because: The platform treats agent work as spanning editor, browser, and manager surfaces.

“The first one is an editor. The second one is a browser and the third one is the agent manager. So we'll dive into what this means, which one what what each looks like.”transcript, stated

Supervise agents through conversation logs

Rejected because: Raw token streams are hard to follow for many concurrent or long-running tasks.

“You're like, "What the heck did this agent do?" And and this this has been traditionally the way that people review and sort of supervise agents.”transcript, implied

Patterns

`multi-agent-orchestration` (developer-platform)

The platform manages agent work across multiple surfaces.

“each looks like. So a paradigm shift here is that agents are now living outside of your IDE and they can”transcript, implied

`tool-use-orchestration` (browser-use)

The agent can operate an agent-controlled Chrome browser.

“agent controlled Chrome browser”transcript, stated

Tradeoffs

Keep an editor escape hatch inside an agent-first product.

Chose Fast handoff from agent manager back into the editor with files, artifacts, and conversation preserved over Forcing every task to remain fully delegated to the agent.

Rationale: The product recognized that some tasks still required direct developer control because trust in models was not universal.

“There are tasks that you know you maybe don't trust the agent yet. We don't trust the models yet. And so you can command E and you can command E and it'll open inside the editor”transcript, stated

How to supervise long-running coding agents.

Chose artifact-centered agent manager over raw conversation and token streams.

Rationale: Artifacts present plans, progress, diagrams, and proof of work in forms that humans can review more easily than raw logs.

“The whole point and the reason why I'm not just standing up here and giving you this long, you know, stream of consciousness is because I have a PowerPoint.”transcript, stated

Gotchas (what bit them)

Raw agent conversation logs did not scale as the main supervision interface.

Root cause: Long-running multi-agent work generated too many token strings and intermediate steps for users to follow.

Resolution: Antigravity introduced artifacts and an agent manager so users could supervise progress through structured outputs rather than raw traces.

“ultimately you're looking at a lot a lot of strings, a lot of tokens. This is like very hard to follow. And then this is actually like there's like 10 of these, right?”transcript, stated

Evaluation

The summary emphasizes dogfooding and feedback loops rather than numeric benchmark metrics.

Metrics: internal dogfooding · user feedback

“The solution emerged from close collaboration between product and research teams at DeepMind, creating a feedback loop where internal dogfooding identified model gaps and drove improvements.”summary, stated

Outcomes

Early users reported workflow improvements, while launch demand caused capacity constraints.

The product was launched as an agent-first AI development platform.

“Initial launch experienced capacity constraints due to high demand, but users who accessed the product reported significant workflow improvements from the multi-surface agent orchestration approach.”summary, stated