1,000 Claude agents redid the Fermat proof in 28.7 hours

A team of 1,000 agents running an early version of Claude Fable 5.2 rebuilt the Lean proof of Fermat’s Last Theorem in 28.7 hours, coordinating only through Git and a shared Postgres database, with no Prove2Me platform and no researcher steering, Anthropic said in a November 9 post on the Claude blog. What the run tests is whether agents can organize themselves around a known result: they started from 60 target statements, the definitions behind them and 47 lemmas already proved in Anthropic’s September formalization, and Anthropic itself calls it a toy experiment.

What the agents were handed

The 60 statements were the final theorem plus 59 intermediate milestones, each with a one-line informal description. The agents also got a one-sentence sketch of the classical route and a fixed hierarchy of one lead and 999 helpers. Anthropic gave no other guidance on how to prove the theorem or split the work. Each proof had to be written in Lean, a language in which a computer checks every step, built with Lean’s tools and pushed to a shared main branch, where a grader checked it.

The comparison point is the September effort, where a researcher and dozens of agents needed 11 days, roughly 6 billion output tokens and 13 million lines of Lean, all organized through Prove2Me. That platform kept a shared graph linking each statement to the smaller pieces it was split into, so agents could ask which unproved parts were ready, and it kept each statement in its own independently compiling file. Anthropic says its earlier attempts without it failed because agents lost track of the project state. The new team used one-third as many output tokens, which puts it at roughly 2 billion, and wrote a proof one-seventh the length of the original.

The run was not entirely hands-off in mechanics. The harness sent the lead 19 automatic reminders of how much time remained, each encouraging it to keep going, and activity stopped near hour 18, when Anthropic restarted the run from its last save and gave the agents 12 more hours.

Postgres as the coordination layer

Scale forced the architecture. A single shared machine hit its limits at about 100 agents: more than half of Anthropic’s 100-agent runs had to be stopped or restarted because memory, disk or CPU ran out. For this run each agent got its own lightweight virtual machine, connected to the outside only by a pipe to a gateway that called the Claude API and relayed Git and SQL requests.

Anthropic says it picked SQL because it offers general primitives for organizing information, its transactions handle concurrent writes from 1,000 agents, and Claude already knows it. Database calls ran under a shared unprivileged role, each statement had a five-second limit, and writes above 256 MiB were refused. Agents had no messaging tools at all. Each pushed only to its own Git branch and opened merge requests, which a separate job merged unless it hit a conflict or a fault such as unrelated history.

Within the first 10 minutes the lead created five tables: announce for orders to the whole team, assign for who owns which statement, notes as an open board, subtasks as a to-do list where the first helper to claim a task owns it, and landed as a log of finished work. It then wrote 999 rows to the assign table, putting a crew of 16-17 helpers on each statement with one captain per crew to post a plan and split the work.

The split did not stay top-down. By hour 5.6, 73 helpers had written 756 tasks, and only 16 of those helpers were captains. By the third hour the lead was telling free helpers, “do not wait for me.”

The 47 shelved statements

About 27 minutes in, with three statements proved, the lead read the helpers’ difficulty verdicts and set aside the 47 statements most of them had judged infeasible within the run’s budget. Nearly all helpers moved to the remaining 10, and crews grew from about 17 to between 46 and 139. Around 45 minutes in, the lead wrote that “the team’s throughput is far higher than the early ‘infeasible-in-budget’ verdicts assumed.” All 10 were proved within roughly 70 minutes, and the lead moved helpers back to the harder statements, noting “there is no reason to idle.”

The last holdout was Langlands-Tunnell, a classical result Wiles’s proof relies on. Its captain had estimated it would take at least 0.7 to 1 million lines of Lean, with less than a 1% chance of finishing in time. Around hour 18 the lead moved about 750 helpers onto it and wrote, “Honest odds are low.” The team organized the work as a tree: a helper that found a piece too big could split it, and each piece could assume the ones beneath it, so hundreds of helpers worked in parallel before those pieces were proved. The tree reached 2,418 tasks up to 10 levels deep. Langlands-Tunnell fell at hour 28.4 and the final theorem at hour 28.7. Anthropic’s tally ends at 54 of 60 statements, because five alternatives were no longer needed and one statement was dropped.

Anthropic draws its own limits from this. The result doesn’t remove the need for domain-specific harnesses: Prove2Me may still help agents compile Lean faster and search for and reuse human results. And agents tend to give up on hard problems and misjudge their difficulty, so human encouragement at such moments can keep them from stopping too early.

What the monitors saw

Each sandbox had no network access, and the gateway tagged every request with the agent’s identity outside the sandbox so one agent could not pose as another. Commands ran as an unprivileged user with tools like sudo removed, on a kernel built without loadable modules, kexec, raw memory access or kernel probes and run in lockdown mode. A prompted LLM classifier checked every shell command and file edit before it ran, and an offline monitor reviewed the team’s actions afterward with the ability to look up what other agents did.

Anthropic’s standing rule is that a classifier block halts the whole team until a person reviews it. In this run, though, only a block on the lead would have ended it; a block on a helper removed just that helper. The run also used only the action-based monitor, which sees actions but not reasoning. Shortly afterward Anthropic added a parallel monitor that reads chain of thought and interagent communication, after such monitors caught every attempt in its red-team sabotage evaluations. Anthropic notes that it runs experiments like this on models that may not have completed its pre-release alignment assessment.

Across more than a million tool calls, none met the bar to be blocked. Replayed against the chain-of-thought monitor and today’s rubric, one came close: a check for root access.