A thousand Claude Fable 5.2 agents formalized Fermat’s Last Theorem in Lean in 30 hours

Formal verification was long considered the domain of specialists. Now Anthropic is showing that a team of a thousand agents can encode in Lean a proof that once took mathematicians years to develop. For practitioners, the point is how far models can go working autonomously.

What the agents actually did

Fermat’s Last Theorem states that, for an integer n > 2, the equation aⁿ + bⁿ = cⁿ has no solutions in positive integers. Andrew Wiles’s proof was published in 1995 after he repaired a gap with Richard Taylor. The agents had a different task: express that argument in a form a machine could verify.

In Lean, a proposition is represented by a type, and its proof is a term of that type. Tactics construct the term, and the kernel checks that it matches the type. If a required lemma is missing from the library, the agents have to state and prove it themselves. It resembles building a large software project in which every missing dependency becomes a separate task.

In September, Anthropic tackled the same task using the Prove2Me platform, which maintained a dependency graph linking propositions. That run took 11 days, and the final proof included 29,500 intermediate theorems. The final statement was separately checked against Mathlib.

What changed in the new run

Fable 5.2 received brief initial instructions and a list of intermediate propositions for measuring progress. According to Anthropic, the agents allocated work themselves and operated without mathematical reference materials, with humans intervening only rarely. Token consumption for actions fell threefold, and the formal proof text was seven times shorter.

Opus 5.5 ran in the same configuration with roughly a thousand agents. It completed 26% in the first 18 hours, then made almost no progress during the remaining 12. Both teams resumed work from a saved state at the 18-hour mark. An important caveat: the chart shows only one run per model, while the September experiment used a different model and a different coordination setup. This is a demonstration, rather than a rigorous benchmark.

Other results from the announcement

A team of agents running an early version of Fable 5.2 migrated a critical internal service from Python to Rust, cutting startup time by roughly a factor of 26. In another experiment, the model spent eight days coordinating more than a thousand subagents working on an operating system prototype. Starting with an empty folder, they produced a system with a kernel, disk, keyboard and network drivers, file storage, a windowed interface and an installer that boots on a laptop.

On FrontierCode 2.0, Fable 5.2 scored 49.1% at the Xhigh effort level, compared with 32.4% for Fable 5.1. At High, it matched Opus 5.5 running at Max, while the cost per task was roughly half as much.

Fable 5.2 and Mythos 5.2 share the same base model. Fable is restricted in high-risk cybersecurity and biology tasks, while Mythos is available to vetted organizations. On the internal CVE Rediscovery test, Mythos 5.2 found 89.6% of 1829 published vulnerabilities, compared with 78.3% for Mythos 5.1 and 81.3% for Opus 5.5 without safety restrictions.

Pricing and practical takeaways

The model is available through the API as claude-fable-5-2, as well as through AWS, Google Cloud and Microsoft Azure. Pricing is $8 per million input tokens and $40 per million output tokens. Generation speed has increased by up to 30%. In Fast Mode, tokens are generated up to 2.5 times faster, but prices double to $16 and $80.

What developers should do. First, if you build agent systems, check where they hit a ceiling on long-running tasks: that is where differences between model generations become most apparent. Second, give agents an explicit list of intermediate goals, as in this experiment: measurable progress helps both the model and you. Third, build state saving and resumption into the architecture from the outset.

The limitations are clear: all figures come from Anthropic itself, there is no independent verification yet, and the comparison rests on a single run per model. But the direction is clear: long-running autonomous tasks involving thousands of agents are moving from laboratory demos into engineering practice.