TL;DR
The short version
A review swarm is an orchestrator-plus-fan-out pattern for code review. Slice a change set by domain, hand each slice to a correctness reviewer and a maintainability reviewer, run every pass on two different models, and let a top-level agent aggregate the findings into one actioned report it loops on until the code is clean — all before a human reads the diff.
It's Anthropic's orchestrator-workers pattern pointed at review instead of build. Its power and its cost are the same thing: more agents, more models, more tokens buy coverage a single reviewer misses. The human's job moves upstream — planning becomes the work, and the swarm absorbs the review busywork.
Built on a practitioner demo (2026-07-24): a Notion AI engineer walking through his own review-swarm skill on Every. A single narrated demo, not a benchmark — separate the pattern from the product.
The pattern: orchestrator plus fan-out
Take a change set and slice it by domain — frontend, backend. Delegate two reviewers to each slice: a correctness reviewer that hunts bugs, and a maintainability reviewer that checks reuse, patterns, and whether the code will scale. A top-level agent then aggregates every reviewer's output into one actionable report and loops on it until the code comes back clean.
Slice it into domains… delegate out to a correctness reviewer and then a maintainability reviewer.
Ryan, Notion AI (via Every)
This is not a new framework to adopt — it's the orchestrator-workers pattern Anthropic documents in "Building Effective Agents," instantiated for review. And it's a skill you clone and customize: he built his own by handing an existing review skill to Codex, telling it what he disliked and what to keep, and letting it produce his version.
Two models per pass — and what it costs
Every review slice runs on both GPT and Opus. That's the whole bet: different models miss different bugs, so where one is blind, the other sees. Cross-model ensembling turns review from a single opinion into a quorum.
The coverage isn't free. Multi-agent setups inherit a steep token bill, and a swarm running two models on every slice pays it on every review.
Model count self-reported from the demo; the ~15x figure is Anthropic's own reported range for multi-agent research systems.
The question a swarm forces you to answer is when that coverage pays for itself — below a certain change size, one strong reviewer plus a human is cheaper and just as safe.
Planning is the human's job
The value isn't a magic one-shot. It's front-loading the environment, the changes, the constraints, and the self-verification steps so the agent can absorb the busy work. The whole loop runs against a single surface that holds the spec, the requirements, and a living work journal the agent updates with the problems it hits as it builds — the skill explicitly tells it to take notes.
The payoff he names is consolidation: one source of truth removes the context-management and app-hopping tax that otherwise fragments an agent loop across tools. Kick off a task, close the tab, come back to finished, reviewed work.
The boundary: when a swarm beats a single reviewer
A swarm isn't free of failure modes. Cognition's "Don't Build Multi-Agents" argues the opposite case: parallel agents that don't share full context make conflicting decisions, and a single threaded agent is often more reliable. The line between a swarm that catches more and one that just disagrees with itself is real.
And there's an ownership question the demo glosses. When the swarm auto-fixes CI and opens the PR, and no human reads the diff, who owns the merge — and what class of regression slips through review-by-agent? The pattern moves the human upstream to planning; it doesn't remove the need for someone accountable at the point the code lands.
It's also worth separating two jobs a swarm gets conflated with. A swarm optimizes coverage — more agents and models catch what one reviewer misses, then a human reads the report. A different bottleneck is throughput: the queue of PRs-to-review itself. That's solved by a single agent that risk-scores each diff and auto-approves the low-risk tail, escalating the rest — a move covered in Review Is the Bottleneck. One buys thoroughness; the other clears the queue.
