Seven Agents and $0: How OpenAI's Dots Broke a 47-Year-Old Math Record

On October 3, a covering number that had stood since the era of slide rules finally moved. An independent researcher, writing under the pen name “unexcitedneurons,” announced a Lean-verified proof that C(24,14,4) ≥ 20 — improving the previous lower bound of 19, which traces back to Schönheim in 1964 and Mills in 1979. What makes the result remarkable is not just the mathematics. It is the bill: $0. The proof was produced by a swarm of seven AI agents running on OpenAI’s Dots platform, on hardware the researcher described as “9 cores of an AMD Epyc CPU, 10GB of RAM, and 32GB of allocated storage space.”

The Lottery That Nobody Could Settle

Covering numbers are easy to state and brutal to compute. The researcher’s own framing, borrowed from a Claude explanation that has since made the rounds, describes it as a lottery: suppose the draw picks 4 numbers out of 24, and each ticket lets you pick 14 numbers. How many tickets do you need so that, whatever is drawn, one of your tickets contains all four drawn numbers? That minimum is the covering number C(24,14,4). Mathematicians have boxed it between lower and upper bounds for decades without pinning it down exactly. The old lower fence said at least 19 tickets are necessary; there are 10,626 possible four-element draws, and the swarm’s companion website even offers an interactive grid where you can try to cover all of them with 19 tickets yourself. You cannot. Now there is a machine-checked proof that you never will.

The result does not live in isolation. Covering numbers feed into each other, and the same argument lifts the next case up, C(25,15,5), from a lower bound of 32 to 34. If the proof survives review, the author notes that further entries in the covering tables would move with it: C(26,16,6) to 56, C(27,17,7) to 89, and C(28,18,8) to 139.

The Swarm That Did It

The computational setup sounds almost comically modest against the result. Dots, OpenAI’s recently released personal assistant product, gives each user a virtual machine and a small stable of subagents — seven slots in total, including the primary agent, for six subagents. Critically, each agent runs with free, unlimited access to GPT-6 Astra, OpenAI’s most capable model, with reasoning effort configurable from low up to ultra. The researcher was, by their own account, simply waiting for a Codex usage reset and decided to see what the platform could do.

The orchestration is the genuinely novel part. The swarm was divided into roles: mathematical research, Lean formalization, construction and computational search, adversarial review, and coordination. Crucially, no single agent’s output was ever trusted. A proof sketch from one agent was treated as merely a “plausible argument” until it had been checked by other agents and translated into a formal Lean proof. The review agent additionally verified that the formal Lean statement actually described a real covering design, and that intermediate lemmas applied to the same blocks and points used by the final theorem — a failure mode where a formally correct proof proves the wrong thing.

The architecture itself evolved mid-run. The initial fixed role assignments left most agents idle while waiting on colleagues, and the author — limited not by compute but by the number of agents — migrated the swarm to a shared task pool. Agents could propose follow-up tasks; the primary Dots agent acted as coordinator, checking scope, dependencies, and priority before making tasks available to claim. The pool was deliberately not a strict queue: agents were allowed to pick work related to what they had just been doing, keeping similar tasks within the warm KV cache of a single agent’s context, while proof development, independent review, formalization, and computational checks were forced to land on different agents.

Trust the Process, Not the Agent

The writeup’s lessons section reads like a field manual for agentic mathematics. Agents, the author found, are “good at grinding and bad at knowing when to stop” — left alone, they would happily spend hours hunting for an elegant argument about a case a laptop could exhaustively check in under a second. The fix was to add a dedicated brute-forcing role, with a simple policy: searches under five minutes run without asking permission, anything larger needs stronger reductions or a better plan. Successful brute-force results were then reproduced with direct Lean kernel checking, so the machine-checked proof does not rest on trust in any script’s output.

The most quotable line is about epistemics: “Verification is the whole game.” Every agent was confident, and some were confidently wrong. Raw logs show plenty of dead ends. The only thing trusted was the stack of checks, with Lean at the bottom refusing to accept bad arguments.

There is an operational lesson for anyone running long-lived agent swarms, too. Partway through the three-day run, the agents’ shared workspace was deleted out from under them — the VM was wiped. Rather than collapsing, the agents rebuilt the missing files from what survived and from their own message history. Anyone who has lost a week of work to a dead disk will feel that one.

Small Proof, Enormous Footprint

The asymmetry between the human-readable argument and its verification is telling. The mathematical proof itself is short — a few pages involving counting, a rank argument, a rigid design, and the Petersen graph. The Lean formalization, by contrast, spans 80 files and roughly 8,800 lines. The author admits to not reading all of it; nobody is expected to. That is the point of machine verification. The proof has passed the mechanical checks of the Palomar registry, an independent registry of Lean-verified results, under entry PALOMAR-2026-10-04-000003, and the code is public on GitHub alongside a companion website that breaks the argument into eight steps with interactive figures.

Appropriate humility is applied. The author is explicit that this is not yet peer reviewed and has deliberately kept it off arXiv until mathematicians from the Covering Repository, who are helping shepherd the review, confirm the result. The swarm, meanwhile, is still running — it is still free, after all.

Why This Matters Beyond Combinatorics

Two bigger signals are worth pulling out of this story. First, it is now possible for an individual, spending nothing, to orchestrate frontier-model agents on a sustained multi-day mathematical research campaign that produces a formally verified improvement to a 47-year-old bound. The era in which meaningful mathematical records required institutional compute, a university affiliation, or deep pockets is, for this class of problem, effectively over. Second, the verification-first workflow demonstrated here — plausible arguments demoted to guesses until independent agents and a proof kernel sign off — is a template that generalizes far beyond covering designs. As agent swarms get cheaper and more capable, the scarce resource stops being intelligence and becomes verification and taste: knowing which problems are worth attacking, and refusing to trust any single confident voice in the swarm.

The author compared the effort, self-deprecatingly, to OpenAI’s reported 10,000-agent swarm that attacked Navier-Stokes — “a far cry,” they wrote. Perhaps. But seven agents, three days, zero dollars, and a 47-year-old record that finally fell is its own kind of milestone.