Google is expanding the capabilities of its Antigravity AI development platform with a new multi-agent feature called Agent Swarm. Activated through the /swarm command, the feature allows developers to coordinate multiple AI agents that divide a large task, work on separate parts simultaneously and verify one another’s results. Instead of relying on a single AI assistant to complete an entire project, developers can now organise a team of specialised agents around a shared objective.
Google announced the preview rollout of /swarm on November 10, 2026, alongside Gemini 4 Carbon, its new model designed for demanding software engineering and other long-running tasks. The feature is intended for projects that involve multiple files, packages or complex investigations. It introduces a central coordinator, parallel workers, verification agents and a shared communication board that makes the team’s activities visible to developers.
Key Takeaways
- New command: Developers can start a coordinated AI team by entering
/swarmin Antigravity. - Multiple agents: A coordinator divides work among specialised agents that operate in parallel.
- Shared message board: Agents communicate through a common board where assignments, progress and test results are visible.
- Built-in verification: Dedicated verifier agents review code changes and run tests to identify problems.
- Visual dashboard: Antigravity provides Board, Members and Graph views to monitor agent activity.
- Availability: Swarm is in preview in the Antigravity App and CLI. Google’s documentation lists Google AI Pro and Ultra plan availability.
- Higher usage: Running multiple agents can consume significantly more quota than a standard AI conversation.
- Gemini 4 Carbon: Google’s new model can be assigned to demanding coordination, architecture and verification roles.
What Is Google Antigravity Agent Swarm?
Agent Swarm is a multi-agent orchestration feature built into Google Antigravity.
Antigravity is Google’s AI-powered development environment designed to help developers plan, build and test software using AI agents. Its existing capabilities include agent-assisted coding, browser interactions and software development workflows.
The new Swarm feature expands this approach by allowing several agents to collaborate on one project.
In a conventional AI coding workflow, a developer gives one assistant a task. That assistant analyses the request, writes code, makes changes and runs tests.
This approach works well for smaller tasks. However, complicated projects can become difficult when the assistant must understand dozens of files, coordinate different development activities and verify a large number of changes.
Swarm addresses this limitation by distributing work among multiple agents.
For example, if a developer wants to improve a large application, the coordinator could assign one agent to the API, another to the user interface, a third to documentation and a separate verifier to review the changes.
Each agent receives its own responsibilities and works toward the same overall objective.
The coordinator then combines their findings and reports the completed work to the developer.
How Agent Swarm Works
Google describes Swarm as a system built around a coordinator, specialised workers and verification agents.
The process generally follows five stages.
1. The Coordinator Divides the Task
The first agent becomes the coordinator when a developer starts a Swarm task.
It analyses the request, identifies independent pieces of work and determines how many agents are required.
For example, a developer building an e-commerce application might ask Swarm to improve product search, checkout functionality and automated testing.
The coordinator can divide the assignment into separate responsibilities rather than attempting to complete everything sequentially.
2. Specialised Agents Work in Parallel
The coordinator creates named workers with specific responsibilities.
Google’s documentation gives examples such as:
@parserfor parsing-related changes@api-testsfor API testing@docsfor documentation@fix-1and@fix-2for parallel groups of similar tasks
Each worker receives a brief explaining what it should do, which files or areas it owns, what it must avoid changing and what constitutes completion.
Workers can operate in separate conversations with their own context.
When multiple agents need to edit different parts of a repository, Antigravity can provide separate working copies through Git worktrees to reduce conflicts.
3. Agents Communicate Through a Shared Board
One of Swarm’s central features is its shared message board.
Instead of communicating privately and leaving the developer unaware of what is happening, agents post their assignments, questions, progress reports and findings to a common board.
They can address messages to individual agents, groups or the entire team.
This makes it possible for developers to understand how work is progressing and where coordination is required.
The board also provides a record of the team’s communication, making it easier to inspect why a particular decision was made.
4. A Verifier Checks the Work
Swarm does not rely only on the agents that write the code.
The coordinator usually creates a verifier for every two to four workers.
The verifier reviews the changes, examines code differences and runs relevant tests. If it identifies a problem, it reports the issue to the worker responsible for the change.
That worker can then correct the implementation and submit it for another review.
This process is particularly useful for projects where changes made in one part of an application could break another component.
However, verification does not guarantee error-free software. Developers should still review important changes and run their own checks before deploying code.
5. The Coordinator Combines the Results
Once the workers complete their assignments and the verification process finishes, the coordinator collects their reports.
It then presents the results to the developer, including the work completed and any remaining issues.
The developer can continue interacting with the coordinator while the other agents work.
This allows the human developer to provide additional instructions, change priorities or ask questions without manually managing every worker.
Swarm Dashboard: Monitor Every AI Agent
Google has introduced a visual interface to make the multi-agent process easier to understand.
The Swarm interface includes three main sections.
| Dashboard section | What it does |
|---|---|
| Board | Displays agent messages, assignments, progress and test results |
| Members | Shows the coordinator, workers, models and current status |
| Graph | Visualises communication between agents and how the team progresses |
Board: Developers can follow the conversation between agents, inspect reports and filter messages by sender or recipient.
Members: The roster displays which agents are active, waiting or removed. Users can also open individual agent conversations and inspect what each worker is doing.
Graph: This view shows how agents communicate through mentions and messages. Developers can replay the team’s activity to understand how the project moved from the original request to the final result.
The interface is important because multi-agent systems can become difficult to manage when several AI assistants are working simultaneously.
By exposing the communication process, Google is attempting to make agent coordination more transparent.
How to Use Agent Swarm in Google Antigravity
Developers can start a Swarm directly from the Antigravity application or command-line interface.
The basic process is straightforward.
Step 1: Open a project in Google Antigravity.
Step 2: Start a conversation and enter the /swarm command.
Step 3: Describe the task, including what needs to be completed and how the results should be verified.
Step 4: Allow the coordinator to divide the work and create specialised agents.
Step 5: Open the Swarm interface to monitor the workers and verifier.
A sample prompt could look like this:
/swarm Build unit tests for the date utilities and currency formatter in my project. Assign separate workers to each file, add tests without changing existing functionality, and have a verifier run the complete test suite.
The coordinator can create separate workers for the date utilities and currency formatter, while another agent checks the implementation and runs the tests.
Developers can also ask the coordinator to use a different available AI model for the verifier.
For the command-line version, developers can use /swarm board to open the live board. The Alt + S shortcut can also open the board in supported terminal configurations.
Google Introduces Different Roles for Multi-Agent Development
Swarm is not simply a feature that launches several copies of the same AI assistant.
Google has designed the system around different responsibilities.
| Agent role | Responsibility |
|---|---|
| Coordinator | Plans the task and manages the team |
| Worker | Completes a specific part of the project |
| Verifier | Reviews code changes and runs tests |
| Monitor | Checks whether the team has stopped making progress |
The coordinator generally avoids doing the technical work itself. Instead, it focuses on delegation, communication and combining results.
The monitor is designed to intervene when the team becomes inactive before completing its work.
Google also explains that workers can enter a waiting state when they have nothing to do. They can wake automatically when another agent sends them a relevant message.
According to the documentation, waiting agents consume no tokens while idle.
This approach is intended to make coordination more efficient without requiring every agent to remain continuously active.
Gemini 4 Carbon Adds More Reasoning Power to Swarm
Google introduced Agent Swarm alongside Gemini 4 Carbon, its new AI model designed for long-horizon tasks.
The company says Carbon is suited to complex software engineering, scientific discovery, cybersecurity and knowledge work that requires extended reasoning and verification.
The combination is significant because a multi-agent system needs more than the ability to run several models simultaneously. It also needs agents capable of planning tasks, understanding dependencies and evaluating one another’s work.
Google says developers can assign different models to different agents, depending on the task and the models available in their account.
For example:
- A coordinator could use Gemini 4 Carbon for complex planning.
- Workers could use a faster model for routine code changes.
- A verifier could use a stronger reasoning model to inspect the implementation.
This allows developers to distribute model capabilities according to the importance of each responsibility.
Google says Gemini 4 Carbon is available through Antigravity for eligible subscribers, while the Swarm feature is rolling out in preview through the Antigravity App and CLI.
Swarm, Boost and Teamwork: What Is the Difference?
Google Antigravity now offers different ways to use multiple agents, depending on the type of problem.
The company’s documentation distinguishes Swarm from other approaches such as subagents, Boost and Teamwork.
| Feature | Best suited for |
|---|---|
| Subagents | Delegating one focused task to a helper agent |
/boost | Difficult problems requiring multiple reasoning approaches |
/swarm | Large tasks that can be divided into independent pieces |
/teamwork | Long-running projects with multiple milestones and formal verification |
The distinction is important.
A developer investigating a difficult algorithm might benefit from Boost, where multiple reasoning approaches can examine the same problem.
A project involving changes across multiple packages may be better suited to Swarm because different workers can handle separate components.
Teamwork is intended for larger projects that require an upfront planning process, milestones and structured verification.
This gives developers more control over how AI agents are organised.
The Biggest Challenge: Higher AI Usage and Costs
Although Agent Swarm can speed up development by distributing work, it introduces an important trade-off: resource consumption.
Every active worker is an AI agent that requires model inference and can consume usage quota.
A single conversation may involve one model handling a task from beginning to end. A Swarm can involve a coordinator, several workers, a verifier and a monitor.
As a result, the total consumption can increase substantially.
Google explicitly warns that preview Swarm usage can consume quota much faster than a standard conversation.
Waiting agents use no tokens while idle, but active agents still require resources to reason, use tools and complete their assignments.
For developers, this means Swarm may be most useful for complex tasks where parallel execution provides enough value to justify the additional usage.
It may be unnecessary for small changes such as correcting a typo, updating a button or writing a short function.
What Agent Swarm Means for the Future of AI Coding
The introduction of Swarm reflects a broader shift in software development.
AI coding tools initially focused on helping developers write individual lines of code, explain functions and generate small applications.
More recent systems are moving toward autonomous agents that can understand entire repositories, execute commands, use development tools and manage longer workflows.
Multi-agent coordination takes this idea further.
Instead of relying on one AI system to handle every responsibility, developers can organise specialised agents around different parts of a project.
This could be particularly valuable for enterprise software, where projects often involve several programming languages, large codebases, testing requirements and multiple development teams.
However, parallel execution also introduces new challenges. Agents may misunderstand instructions, produce conflicting changes or incorrectly interpret one another’s work. Verification and human oversight will therefore remain important.
Google’s approach attempts to address these challenges through specialised roles, isolated workspaces, shared communication and dedicated verification.
The Bigger Picture
Google’s Agent Swarm feature shows how competition in AI development tools is moving beyond the quality of individual models. The next stage involves coordinating multiple AI agents that can divide responsibilities, communicate, execute work and verify results. By integrating this capability directly into Antigravity, Google is positioning its development platform as an environment for managing teams of AI workers rather than simply using a single coding assistant.
The approach could make complex software development faster and more accessible, particularly for tasks that can be divided across independent files, packages or investigations. However, the additional model usage, coordination overhead and possibility of errors will determine where Swarm delivers genuine productivity improvements. Its preview rollout gives developers an early opportunity to test whether coordinated AI teams can deliver better results than a single agent working alone.
Frequently Asked Questions
1. What is Google Antigravity Agent Swarm?
Agent Swarm is a multi-agent feature in Google Antigravity that allows several AI agents to work on different parts of a task simultaneously. A coordinator manages the workers, while verifier agents review their results.
2. How do I activate Agent Swarm?
Open a project in Antigravity, start a conversation and enter /swarm, followed by a description of the task you want the agents to complete.
3. Is Google Agent Swarm available now?
Google announced a preview rollout on November 10, 2026. Its documentation lists availability through the Antigravity App and CLI for Google AI Pro and Google AI Ultra plans.
4. Does Agent Swarm use multiple AI models?
Yes. Developers can use the same model across the team or request different available models for specific workers, such as a more capable model for verification.
5. What is the Swarm dashboard?
The Swarm dashboard is a monitoring interface with Board, Members and Graph views. It lets developers inspect agent conversations, activity, assignments and communication patterns.
6. Does Agent Swarm increase AI usage?
Yes. Google warns that Swarm can consume quota much faster than a standard AI conversation because multiple agents may be active simultaneously.
7. Can Agent Swarm test and verify code?
Yes. The coordinator can assign verifier agents to inspect code changes, run tests and report problems to the workers responsible for fixing them.
8. Is Agent Swarm useful for beginners?
Beginners can experiment with it, but understanding basic programming concepts and reviewing generated code remain important. Swarm is particularly useful when a task is large enough to benefit from parallel work.
Looking Ahead
Google’s next challenge will be demonstrating that Agent Swarm can consistently improve development speed and software quality. The preview will give developers an opportunity to evaluate how well agents coordinate, whether isolated workspaces reduce conflicts and how effectively verification catches problems. Usage limits and the cost of running several agents will also influence adoption.
The larger opportunity is a future in which developers describe a software objective and supervise a team of specialised AI agents that handles implementation, testing and documentation. Google’s Antigravity Swarm is an important step in that direction. However, the strongest development platforms will not simply launch more agents; they will need to ensure those agents work reliably, communicate effectively and produce code that humans can trust.
Get the day’s top stories in your inbox
One concise email. No spam, unsubscribe anytime.
