Antigravity's Agent Manager: mission control for parallel agents

The one feature people will remember from Antigravity isn't the editor, and it isn't even the browser trick. It's the Agent Manager: a mission-control surface where you launch several agents, name each one, and watch them run at the same time. Google clearly wants you to stop babysitting one agent and start supervising a small team of them.

For about two days it felt like the best unlock I'd touched in a year. Then it bit me.

from one agent to a board of them

My old rhythm with any coding agent was strictly linear. Hand it a task, watch the diff scroll past, review, accept or throw it back, repeat. One thing at a time, my whole attention pinned to it. The Agent Manager breaks that habit on purpose. On the dispatch-board project I had one agent renaming database columns, a second writing tests for a billing edge case, and a third chasing a flaky timezone bug, all in flight while I read the first one's output.

That's a real change in how the work feels, and it lines up with how the async agent architectures I've written about actually want you to operate. You stop being a driver. You become a dispatcher, which, given what the client's app does, was a joke that landed a little too close to home.

the artifacts are the point

What makes the parallel view survivable at all is the evidence each agent leaves behind. Antigravity calls them artifacts: a written plan up front, screenshots from the browser checks, a short walkthrough of what changed and why. When you're triaging four agents, you can't rebuild each one's reasoning from memory. The artifact is the thing you sit down and review.

The Agent Manager doesn't save you the review work. It just stacks up more of it, faster, and dares you to keep pace.

the morning I launched five

Here's the part I got wrong, told plainly. One morning I got greedy. Five agents, five tasks, all fired off inside about ten minutes, because starting them was so cheap I couldn't feel the cost. It felt tremendous for exactly as long as it took the first three to finish.

Then I had five sets of diffs, five plans, and five browser walkthroughs landing on me at once, and I could not hold five mental models of a 400k-line codebase in my head simultaneously. I approved one change I shouldn't have, a test that passed for the wrong reason, purely because I was skimming. I caught it that afternoon, but only because the flaky bug I'd meant to kill came back to visit. In the end I shut down two of the five just to get my own attention back.

review is the scarce resource

The lesson stuck. The bottleneck in agent-heavy work isn't how fast the agents produce. It's how fast a competent human can actually review what they produce and mean the approval. Antigravity pushed the ceiling on production way up and left the ceiling on my review sitting exactly where it always was.

So I've settled on a cap. Two agents at once, three if the tasks are small and genuinely unrelated. Past that I'm not supervising anymore, I'm rubber-stamping, and rubber-stamping is how bad code ships with my name on the commit. It's the same wall people run into with Claude Code subagents, and the answer rhymes: the tool scales the work, not your judgment.

Mission control is the right metaphor for it. Just remember that in an actual mission control, the screens don't fly the spacecraft. The people do, and there are only ever so many of them.