Gemini 4 Carbon Is Live. /swarm Burned My Quota in One Afternoon

The short version

On November 10, 2026, Google made Gemini 4 Carbon generally available to developers, enterprises, researchers, and consumers, two weeks after seeding it to cybersecurity defenders through the Fairwind Program. Alongside it, Google Antigravity began previewing /swarm, a multi-agent orchestration command that turns a single prompt into a named team of agents working against a shared message board.

Google's own guidance is the part most coverage skips: Argon remains the ideal choice for the majority of software engineering and knowledge work. Carbon is built for tasks that test the limits of the model — multi-step debugging across large codebases, open-ended scientific research, and cybersecurity defense. It is not the default. It is the ceiling-raiser.

And buried in the Antigravity launch post is the sentence that matters most for anyone paying the bill: after five weeks of internal dogfooding, Google warns that "parallel multi-agent systems consume quota much faster than a standard chat" — even with zero-token idle waits and dynamic model hot-swapping.

What actually changed: the numbers

Pricing is identical to Argon during the introductory window: $2 per million input tokens and $10 per million output tokens, with cached input at 95% off the input price. That window closes November 30, 2026. After that, Carbon moves to $4 input / $20 output — a straight doubling.

The benchmark story is stronger than most launches because the marquee results come from third parties, not from Google's own harness:

CursorBench 4.0 — first place
Perplexity's WANDR (wide-and-deep research) — first place
Zapier's AutomationBench — first place
Above the next-best external model on all three, at more than 2x lower cost per task
Artificial Analysis Intelligence Index v5.0 — first at 59
WebDev Arena — up 89 elo to 1769, ranked #4
Multimodal Knowledge Agent (built with Artificial Analysis) — #2, at more than 6x lower average cost per task than the leader

Security benchmarks are where Carbon opens the largest gap: SEC-bench Pro 88.2% for finding real vulnerabilities, ExploitGym 54.8% for proving exploitability, CWE-bench 71.0% for root-cause patching. In Google's Project Fortify internal benchmark, Carbon hit 100% recall on scanning and 95% precision on triage, with a 25% relative improvement over Argon's recall on open-source repositories. Wiz's Scan for Good team reported finding 0-days in two major SaaS providers in under two hours.

The honesty metrics matter more than the accuracy ones

For production work, "does it lie" beats "does it score well." Carbon passes 92% of Google's 375-task agentic honesty benchmark versus 70% for Argon. It declines to invent missing experimental data 98% of the time and flags methodological flaws 68% of the time. On Terminal-Bench 4.0, successful cheating dropped to 0.0% with attempts at 0.4%. High-severity misalignment alerts in internal live coding environments fell by nearly 80%. Unsupported claims were cut roughly in half.

Indirect prompt injection is the headline safety number: 0.0% attack success rate on Gray Swan's IPI benchmark, the first time any model has reached that, down from Argon's already-low 0.7%. Google's own caveat is worth quoting in spirit: automated red teaming shows models could still be improved against sophisticated attacks in some distributions. Zero on a benchmark is zero on that benchmark's attack set, not zero in the world.

How `/swarm` actually works

Running /swarm promotes your current conversation into the coordinator, which then:

Splits the work into non-colliding pieces and names a worker for each — @parser, @api-tests, @docs, or a numbered group like @fix-1 through @fix-4 for homogeneous pools.

Gives each worker a public brief — what it owns, what it must not touch, what "done" looks like — posted to the board. Workers start with clean context.

Adds one @verifier per two to four workers. The verifier reads diffs, runs tests, and reports failures back to the worker that wrote the code.

Forces all coordination onto the shared board via @name, @group, or @all. Workers never message each other privately, so the whole team conversation stays in one ordered place.

Puts idle members to sleep at zero token cost, waking them the instant a post mentions them.

Adds a @monitor that stays silent unless every member has gone quiet before the work is done.

The coordinator does no technical work itself. It allocates, judges, and reports — which keeps it responsive while workers run.

Four behaviors that will bite you

These are documented, not folklore, and they are the difference between a swarm that pays for itself and one that doesn't:

Workers default to the same model as your conversation. You can specify a different model per worker or for the whole team in your prompt, and the coordinator can hot-swap a waiting worker mid-task while preserving its conversation. Pinning the verifier to a different model than the implementers is the highest-value configuration and costs one sentence to set up.
Workers share your workspace by default. When several edit or build simultaneously, the coordinator can give each its own working copy. Removing a worker deletes that copy, so the coordinator lands changes first. Kill a worker at the wrong moment and you lose its uncommitted work.
Killed is permanent. A removed worker cannot be revived; the coordinator adds a new one instead.
Quota exhaustion pauses, it does not retry. A member that runs out of quota stops and stays stopped until there is a new board post, its model is switched, or you message it — it will not resume on its own when your quota refreshes.

That last one is the operational trap. A long /swarm run that hits a limit overnight does not heal itself by morning.

Picking between the four Antigravity multi-agent modes

Antigravity now ships four distinct ways to put more than one agent on a problem, and they are not interchangeable:

Subagents — one delegated side task, seconds to minutes
/boost — hard problems that need several lines of reasoning cross-checked, seconds to hours
/swarm — large work that divides cleanly across files, packages, or questions, minutes to hours
/teamwork — repository-scale migrations and long simulations, hours to days

/swarm is for large and divisible, not large and hard. If the task doesn't split cleanly, you get coordination overhead and parallel token burn with nothing to show.

The decision framework

Three rules, in order:

Before October's end, the price argument is neutral. Carbon costs the same as Argon until November 30, so benchmark it against your own workloads now rather than arguing about list prices. After December 1, the doubling means every workflow needs re-justifying.

Carbon earns its place on ceiling tasks only. Google's "2x lower cost per task" claim comes from their measurement conditions. Reproduce it on one of your own repos before you standardize on it.

Measure /swarm on a small task first. Run a two-to-four-worker job, record actual tokens consumed, and extrapolate. Google explicitly says quota drains faster in parallel. One afternoon of measurement beats a multi-package migration that stalls halfway through.

One more calibration point: Perplexity's own WANDR paper reports the strongest system at 0.363 soft F1 and 0.133 hard F1 — meaning even the leader earns full credit for roughly one in seven records it submits. Carbon ranking first on WANDR is real, and wide-and-deep research remains far from solved. First place on a benchmark that nobody has passed is not the same as a tool that finishes the job.

Bottom line

Carbon is a genuine frontier model with third-party-validated wins and a pricing window that makes experimenting cheap until November 30. /swarm is a well-designed coordination layer — shared board, named ownership, adversarial verifiers, free idling — wrapped around a cost curve Google itself tells you is steep. Use Carbon for the tasks Argon fails, and measure /swarm before you trust it with anything that matters.