Agent Swarm vs Single Model vs Human+AI Team 2026
The Short Answer
Three ways to point AI at a genuinely hard problem existed in September 2026, and the same week produced a live example of each:
| Approach | Example (September 2026) | Cost | Wins when |
|---|---|---|---|
| Agent swarm | OpenAI: ~10,000 agents, 88 hours, Navier-Stokes | ”Millions of dollars” (OpenAI) | A verifier exists and compute is cheap relative to the prize |
| Single frontier model | GPT-6 Astra formalising the proof in Lean, 17 hours | Standard API rates ($10/$50 per MTok for Astra) | Task is well-specified; you need auditability |
| Human + AI team | Alpöge & Buckmaster with Claude + Codex on Euler/Boussinesq/IPM | Subscription/API spend | Expertise is the bottleneck, not search |
Default to the single model. Escalate to human+AI when the problem needs judgment. Reach for a swarm only when you have a mechanical checker and a budget that makes 130 billion output tokens rational.
Agent Swarm: Breadth of Search, Paid in Compute
OpenAI’s Navier-Stokes run is the clearest public description of a swarm to date. Agents were split into groups that could message each other, each group was prompted with a different variant of the problem, and Codex periodically consolidated the most useful intermediate findings and re-seeded the groups. Across all problems attempted the system sent 4.9 million messages and used ~300 billion output tokens; the Navier-Stokes group alone used 2.7 million messages and ~130 billion output tokens.
Two design choices carry most of the value. First, diversity by prompt variant — proof and disproof groups ran in parallel, so the swarm did not commit to one direction. Second, staged escalation — a ~100-agent group solved the easier unforced Euler problem in ~50 hours, and that result was fed into the larger Navier-Stokes effort.
⚠️ The failure mode is confident nonsense at scale. A swarm generates orders of magnitude more candidate arguments than a human can read. OpenAI closed the loop with a Lean formalization; without one, you would be picking the most persuasive of 10,000 wrong proofs.
Choose a swarm when: the problem is open-ended search, a formal or test-based checker can reject bad candidates automatically, and the prize justifies seven-figure compute.
Single Frontier Model: The Auditable Default
GPT-6 Astra did the Lean formalization of OpenAI’s proof in 17 hours — a well-specified task with a binary outcome (the build passes or it does not). That is the shape of work where one model at high effort beats a swarm: bounded, checkable, and something you want a clean audit trail for.
Cost is predictable. Astra lists at $10 input / $50 output per MTok (September 2026), and Artificial Analysis measured $1.41–$4.72 per coding task depending on effort level. Claude Fable 5.1 sits at the same headline price with cache reads cut to $0.25. Either is a rounding error next to a swarm.
Choose a single model when: the task can be stated precisely, you need to explain the output to a reviewer, or you are not sure a verifier exists — because then you are the verifier, and one model’s reasoning is readable.
Human + AI Team: Expertise as the Multiplier
The Alpöge–Buckmaster preprints are the counter-example to “AI did it alone.” Their IPM paper describes using Claude to work through prior literature and Claude and Codex for drafting and bookkeeping of constants and inductions, under human direction, with their own simplifications layered on top. The Euler formalization README says Claude wrote the Lean code under Alpöge’s direction, with a separate statement file and comparator to confirm the proof establishes the intended theorem.
This is a working mathematician using models the way an engineering team uses them: for the parts that are tedious, searchable, or mechanical, while the human chooses the direction. It runs on ordinary spend and produces artefacts a referee can follow.
Choose human+AI when: the hard part is knowing which problem to attack or which construction might work — judgment the swarm had to brute-force with 10,000 parallel guesses.
The Rule That Cuts Across All Three
The checker decides the architecture. If you have a formal verifier (Lean, a type checker, a test suite), a swarm can be worth it. If you have a benchmark, a single model at high effort is usually enough. If you have neither, the human is the verifier, and the human+AI team is the only approach whose output you can actually trust — because a model-written argument is only as good as whatever rejects it when it is wrong.