Skip to main content
AI & Engineering16 min read

Google Antigravity Swarm: What /swarm Does and Where Agent Swarms Go Next

R

Raina Rufus, Founder of xSquads

Published

Google Antigravity swarm is the /swarm command in Google Antigravity, in preview. The conversation you are in becomes a coordinator. It names workers, splits the task into pieces that do not collide, and adds verifiers that read diffs and run tests. The agents post on one shared, append-only message board. An idle agent sleeps at zero token cost. The unit of work is a multi-agent swarm in the Antigravity App and CLI: a coordinator, workers, and a verifier on one board.

The changelog dated 9 November 2026 added /swarm so you can coordinate subagents over a message board on long-horizon tasks. The 10 November post rolled that preview out beside Gemini 4 Carbon. Who can run it, and how the team is staffed, is in the swarm docs.

Short answer

Google Antigravity swarm is /swarm in preview. A coordinator names workers, posts a brief for each one, and usually adds one verifier for every two to four workers. They share one message board. Idle agents sleep at zero token cost. It is on Google AI Pro and Ultra in the Antigravity App and CLI, and a swarm uses quota much faster than one conversation.

QuestionAnswer
Where it runsAntigravity App and CLI, on Google AI Pro and Ultra, in preview
Who does the workNamed workers. The coordinator assigns, judges, and reports
Who checks itUsually one verifier for every two to four workers
How they talkOne shared board. Idle members use no tokens
What it costs in quotaMuch faster than a single conversation

What shipped on 9 and 10 November

The App changelog for 9 November 2026 lists /swarm as a way to coordinate multiple subagents over a message board to complete long-horizon tasks. The same page says new versions roll out gradually and may take a few days to reach all users. A separate entry that day added a Knowledge Work layout that hides code changes and developer tools. That layout is a simpler interface for research and writing. It is not /swarm.

On 10 November the Antigravity team published the rollout of Gemini 4 Carbon inside Google Antigravity alongside /swarm in preview. The post pairs the model with native multi-agent orchestration. The changelog calls Carbon Google's strongest model for long-horizon software engineering, knowledge work, scientific discovery, and cybersecurity. The blog says Carbon ranks first on CursorBench 4.0 and on Perplexity's WANDR, and that it uses more tokens because it explores, reasons, and runs extended verification loops. Argon, the blog says, remains an ideal choice for most advanced engineering and knowledge work.

Plan lines differ by product, so they should stay separate. The docs say /swarm is available on Google AI Pro and Google AI Ultra, in the Antigravity App and the Antigravity CLI. The blog says Google AI Ultra subscribers can use Gemini 4 Carbon in the App, the CLI, and Antigravity IDE extensions, and that /swarm is rolling out in preview across the App and CLI. Enterprises can access Gemini 4 Carbon in Gemini for business. Scientists and researchers can apply for a chance to use both Argon and Carbon on Antigravity's highest usage tier, free of charge for 6 months. That sentence in the blog is about the models.

How the Google Antigravity swarm splits a task

The docs describe five steps once you run /swarm.

  1. The coordinator names the swarm and divides the work into pieces that do not collide, for example one worker per file or per package. Each piece gets a named worker, such as @parser, @api-tests, or @docs. A pool of similar workers can be a numbered group, @fix-1 through @fix-4.
  2. Each worker starts with a clean context in its own conversation. Its brief says what it owns, what it must not touch, and what done looks like, and that brief is posted to the board so every member can see it.
  3. The coordinator usually adds a @verifier for every two to four workers. The verifier reads the diffs, runs the tests, and reports problems to the worker that wrote the code, which then fixes them. The blog calls these adversarial verifiers, dedicated to running tests and challenging diffs.
  4. Assignments, questions, diff summaries, and test results go on the shared board, with @name, @group, or @all. Workers do not message each other privately. The blog describes the board as shared and append-only.
  5. A worker with nothing to do, or a coordinator waiting on reports, sleeps on the board without using tokens and wakes when another member mentions it.

The coordinator also adds a @monitor. It stays asleep while the swarm is making progress. It posts only if every member has gone quiet before the work is done, to call on whoever can get it moving again. The coordinator does not do the technical work. It hands out tasks, judges what comes back, and reports to you, so it stays free to respond while the workers run.

Workers share your workspace by default. When several of them edit or build at the same time, the coordinator can give each one its own working copy of the repository. Removing a worker deletes that copy, so the coordinator has the worker land its changes first. The 10 November blog describes the workers as specialised parallel agents in isolated git worktrees, so edits never collide.

Workers run on the same model as your conversation unless your prompt says otherwise. The model you name has to be one you can already choose in the model picker. You can also ask the coordinator to move a waiting worker onto another model later. The worker keeps its conversation and continues. The blog says agents in a swarm can be pinned to different models, and that Carbon fits the coordinator, architecture, cybersecurity auditing, and adversarial verification, while lighter, faster models handle parallel file edits and routine implementation.

A member is in one of three states:

StateMeaning in the docs
ActiveRunning a turn: thinking, using a tool, or waiting on the model
WaitingAsleep on the board, using no tokens until a post mentions it
KilledRemoved. It cannot be revived. The coordinator adds a new worker

If a member runs out of quota, it pauses instead of retrying. You see the quota error once. It stays paused until there is a new post on the board, its model is switched, or you message it. It does not restart on its own when your quota refreshes.

This is the split where a separate agent still earns its place: parallel work with a fresh context, and a check that is not the agent that wrote the change. The longer argument, including when one agent is the better design, is single agent vs multi-agent. The general shape of a coordinated team is agent swarms. /swarm is Google's implementation of that split. This page does not restate either post.

What you see while it runs

The blog says the Swarm UI exists so the team is not a black box. In the App, the side pane has a live Board, a Members roster, and a Graph you can replay. You watch posts as they land, open any member's conversation from the roster, and scrub the graph from the first post to the latest. The docs add search and filters on the Board, and Active, Standing by, and Retired groups on Members. The coordinator's reply ends with a link that opens the pane. You can also open it later from Overview, then Extensions, then Swarm.

In the CLI, /swarm board or Alt+S opens the live board full screen: a Roster, a Posts feed, and the selected message. On macOS, Alt+S works only if the terminal sends Option as Alt. /swarm board works in every terminal. A status row under the prompt shows the latest post while the swarm is active.

You keep talking to the coordinator in the main conversation. Ask it for status, or change the scope, and it posts the new instructions to the right workers. To reach one worker, open its conversation in the App, or start a CLI message with @ and the worker's name. That message goes to the worker only, not to the board. When the work is finished, the coordinator reports the result. Waiting workers use no tokens, so you do not have to stop them. You can ask the coordinator to remove workers that have nothing left to do. Removing a worker is permanent.

On 10 November, RJ Skerry-Ryan wrote: "The /swarm UI in antigravity is really well done." Zviad Kardava called /swarm mode "amazing" and wrote that it "turns your single prompt into a coordinated multi-agent workflow where agents plan & work together using best model for the task." Kazunori Sato posted "Antigravity の /swarm" and a link. Those are reactions from that evening. The staffing rules are the docs and the blog, not the posts.

When to run /swarm, and what it spends

Google's docs compare four ways to put more than one agent on a task. The horizon column is the range the docs name, not a promise about your repo.

CommandUse it whenHow the agents coordinateHorizon in the docs
SubagentsOne side task, such as research or a test runEach one reports back to the agent that started itSeconds to minutes
/boostA hard bug, algorithm, or refactorA hierarchy explores hypotheses and checks solutionsSeconds to hours
/swarmWork that splits across files, packages, or questionsNamed workers and a verifier share one boardMinutes to hours
/teamworkMigrations, long simulations, research projectsRoles follow a milestone plan with audit gatesHours to days
/swarm is the one for a task that is large and still divides cleanly, when you want to watch and steer. You describe what you want built or answered, and how to check it. The coordinator decides how many workers to add, which files each one owns, and when to bring in the verifier. /boost is for a problem that is hard rather than large. /teamwork starts with a scoping interview and an upfront specification. Subagents are for one side task in the background.

The documented examples are coding jobs of that shape: tests for two utility files, validation on three API handlers with one worker each, a retry change with the verifier on a different model and a race detector, a read-only investigation of a slow CLI start split across three questions, and a pytest repair grouped by package with a verifier re-running the suite. The blog says that inside Google, five weeks of dogfooding used swarms for multi-package migrations, cross-subsystem root-cause investigations, and complex architectural redesigns. The post does not give a headcount, a pull-request count, or a speed figure.

The quota warning is in both places. The docs say every worker is its own agent, so a swarm uses quota much faster than a single conversation. The blog says the same even with zero-token idle waits and dynamic model hot-swapping: parallel multi-agent systems consume quota much faster than a standard chat.

What the verifier changes

A single chat writes the change and then waits. /swarm puts a named verifier in the team while the workers are still going. The verifier has its own brief: read the diffs, run the tests, report problems back to the author of the change. The blog adds that the verifiers challenge diffs. That is the part of a multi-agent setup that is worth a second context. Turn review on before you scale the agents is the case for making the check a gate.

The docs do not say the verifier scores the diff against a user story that lives outside the session. They do not say a lesson from this swarm is loaded into the next one. The coordinator reports, and the session is the unit of work. The horizon in the comparison table is minutes to hours.

From one Antigravity session to a software factory

/swarm is a session one developer starts in the Antigravity App or CLI. The backlog, the pull request, and the next run sit outside that conversation. xSquads Software Factory is the line around that kind of work. Engineers run coding agents in the cloud that raise pull requests from user stories. Review agents check each pull request against the story's intent, not only against passing CI, and they request fixes. Self-improving loops feed lessons from those reviews into the next run. A software factory is that repeatable path. /swarm is one coding session on a laptop conversation. The factory starts from the story, keeps the intent check, and carries the lesson into the next story. The product is at xsquads.ai.

The same pattern, outside the coding session

/swarm runs in the Antigravity App and CLI, and Google's examples are coding tasks that split across files, packages, or questions. Carbon is also positioned for knowledge work. The Knowledge Work layout from the same week's changelog is a different switch: it hides the code tools. It does not staff a swarm. xSquads for Work gives every knowledge worker their own squad of specialised agents working together as a swarm, as an alternative to chatting with ChatGPT or Copilot. /swarm is the coding session inside Antigravity. xSquads for Work brings that swarm model to everyday knowledge work, on the files you already have. The desktop app is live on Mac and Windows and is free with Pro agents. The product note is give every knowledge worker their own xSquad.

Frequently asked questions

What is the Google Antigravity swarm?

Google Antigravity swarm is the /swarm command in preview. Your conversation becomes a coordinator that names workers, splits the task so the pieces do not collide, and adds verifiers that read diffs and run tests. The agents post on one shared message board, and an idle agent sleeps without using tokens.

Who can use /swarm in Google Antigravity?

The docs say /swarm is on Google AI Pro and Google AI Ultra, in the Antigravity App and CLI, and that preview swarms spend quota faster than one chat. The 10 November blog says Gemini 4 Carbon is for Ultra subscribers in the App, the CLI, and IDE extensions.

How does the /swarm verifier work?

The coordinator usually adds one @verifier for every two to four workers. It reads the diffs, runs the tests, and reports problems to the worker that wrote the code, which then fixes them. The blog calls these verifiers adversarial and says they challenge diffs. A @monitor posts only if every member goes quiet before the work is done.

Does /swarm use more quota than one conversation?

Yes. The docs say every worker is its own agent, so a swarm uses quota much faster than a single conversation. The blog repeats that warning even when idle agents wait at zero token cost. A member that runs out of quota pauses and does not restart on its own when quota refreshes.

When should you pick /swarm over /boost or /teamwork?

Pick /swarm when the task splits across independent files, packages, or questions and you want a named team on one board. Pick /boost when the problem is hard rather than large. Pick /teamwork for repository-scale work that needs a scoping interview, a milestone plan, and audit gates. Subagents cover one side task.

How is /swarm different from xSquads?

/swarm is one session in the Antigravity App or CLI, on a minutes-to-hours horizon. xSquads for Work is a desktop squad for knowledge work on your own files, live on Mac and Windows, free with Pro agents. xSquads Software Factory raises pull requests from user stories in the cloud, and review agents check intent.

Where these facts come from

Read on 11 November 2026.

  • Gemini 4 Carbon and /swarm, the Antigravity team, 10 November 2026: the preview beside Carbon, isolated git worktrees, adversarial verifiers, the append-only board, zero-token idle, the Swarm UI, model pinning, CursorBench 4.0 and WANDR, five weeks of dogfooding, the quota warning, Ultra access, IDE extensions, Gemini for business, and the research tier.
  • Swarm (/swarm): Pro and Ultra, the coordinator loop, the verifier ratio, the monitor, the board, working copies, models, member states, the quota pause, App and CLI controls, the examples, and the comparison with subagents, /boost, and /teamwork.
  • Changelog, 9 November 2026: /swarm for coordinating subagents over a message board on long-horizon tasks, the note that new versions roll out gradually, and the Knowledge Work layout in the other entry from that day.
  • X, 10 November 2026: RJ Skerry-Ryan, Zviad Kardava, Kazunori Sato.

Related reading

Conclusion

Google Antigravity swarm is a coordinator, named workers, and a verifier on one board, in preview, in the Antigravity App and CLI. The 10 November post says a single agent breaks down when a change spans many files and test suites. /swarm is Google's answer for that session: parallel workers, a separate check, and a board you can read. The session ends when the coordinator reports. A software factory is the path that starts from a user story, raises a pull request, checks it against intent, and keeps the lesson. That path is at xsquads.ai.

Raina Rufus, Founder of xSquads

Start at xsquads.ai. xSquads for Work is the desktop squad for knowledge work, live on Mac and Windows and free with Pro agents. xSquads Software Factory is the cloud line where coding agents raise pull requests from user stories.

Give yourself a squad of AI teammates

Your own squad of specialised agents to delegate to and review. The app is live on Mac and Windows. xSquads for Work is free with Pro agents.