← All posts

A swarm still needs someone to say yes

14 November 2026 · Deliverd Engineering Team · 4 min read

A coordinator card fans out to four worker cards and a dashed verifier card with ticks; every line converges on one amber pause before a production block, and a dotted blue line runs to a person with a blue tick and back.

This week Google put Gemini 4 Carbon into Antigravity, and with it a preview of /swarm. Antigravity is Google's agent platform for software work: a desktop app, the agy command line, extensions for six editors and a Python SDK. /swarm changes how much of it can run at once.

You give a task to one conversation and it becomes the coordinator. It splits the work into pieces that won't collide and hands each to a worker, with a brief that says what it owns, what it must not touch and what "done" means. Workers can each have their own copy of the repository. For every few workers there's a verifier, an agent whose job is to read the diffs, run the tests and send problems back. They all talk on a shared board, and an idle agent sleeps without using tokens until someone mentions it.

Google says its own engineers used swarms for multi-package migrations and cross-system investigations. It's an impressive way to get a lot done quickly.

The verifier is not a sign-off

The verifiers are the part worth looking at closely. They're adversarial on purpose: they challenge the work and run the tests, which is exactly what you want. They're also agents. A verifier can tell you the tests pass. It can't be the person your organisation has agreed owns a production change, and it can't be accountable for one.

Antigravity has its own approvals, and they're good ones. Permission presets decide how freely the agent can run commands. Rules can allow, deny or ask before a command, a file write, a URL or an MCP tool. When a rule says ask, a card appears and you click Allow. You can step into any worker's conversation and steer it.

All of that asks one person: whoever is at the keyboard. With one agent, that's usually fine. With a coordinator and eight workers running in parallel, the person at the keyboard is clicking Allow on things that belong to other people. The release that the release manager owns. The infrastructure change that the platform lead owns. The refund through a payments server that Finance owns. And when the session ends, the record of who allowed what is in a scrollback buffer.

Where Deliverd fits

Deliverd is where the yes comes from the person who owns it, and where it's kept. We've made it work with Antigravity in three ways, and they work together.

The agent asks for itself. Add the Deliverd MCP server, or install the plugin with its skills:

agy plugin install https://github.com/deliverd-dev/deliverd-skills

Antigravity signs in with OAuth, so there's no key to paste. Now the agent can call request_approval before it acts and wait for the answer, which arrives from the approver's email, Slack or Teams.

A hook checks the calls the agent didn't ask about. An agent that isn't told to ask may not. Antigravity runs hooks before every tool call, and our hook pack now speaks Antigravity's format. Before a run_command or an MCP tool your rules name, such as a publish, a deploy, terraform apply, a force push or a merge, it asks your policy in Deliverd. The policy allows it, refuses it or asks a named person. A refusal goes back to the agent with the reason. Anything else is handed back to Antigravity's own rules, so its prompts still apply. It never auto-approves. If Deliverd can't be reached, the call doesn't go ahead.

For a swarm, put the hook in your global Antigravity hooks file, or commit it with the repository, so every worker's copy carries it.

Agents you build get a hook too. If you're building on the Antigravity SDK, deliverd_hook from our Python SDK (0.27.0) is a pre-tool-call hook that holds the calls you pick until a person decides. A no reaches the agent with the person's reason, so it changes course rather than trying again.

from deliverd.aio import AsyncDeliverd
from deliverd.adapters.antigravity import deliverd_hook

hooks = [deliverd_hook(AsyncDeliverd(), approvers=["platform-leads"],
                       when=lambda tool, args: tool == "run_command")]

Two approvals, two jobs

None of this replaces Antigravity's permissions. They decide what the agent may do on your machine. Deliverd decides what your organisation has agreed to, who agreed and why, and keeps that record in one place, whichever agent platform did the work. A yes from Deliverd never switches off an Antigravity prompt.

The faster agents get, the more this matters. A swarm can do a week's work in an afternoon. The approval for the one step that goes to production should still take a person a minute, and it should be the right person.

The setup guide covers all three routes. We haven't tried every corner of a real swarm yet, so if you're running one, we'd like to hear how it goes. Start free, or read the guide first.

Give your agent a way to ask.

Give any AI agent a way to ask a person — for approval, a decision, an answer or a review.