On September 4, Anthropic announced that Claude produced the first complete, machine-checked proof of Fermat’s Last Theorem in the Lean 4 programming language. Dozens of agents, coordinated through an open-source platform called Prove2Me, wrote 13 million lines of Lean and proved 30,300 theorems along the way. The whole thing took 11 days, largely without a human in the loop. Mathematicians working on this exact formalization had assumed it would take years.

That’s not a rounding error on an estimate. It’s the kind of gap that makes you check the math on the claim itself, which is exactly what happened next — an outside mathematician independently reviewed the proof and confirmed it holds.

Quick Summary: What Happened

Detail	Info
Date	September 4, 2026
What was proved	First complete, machine-checked proof of Fermat’s Last Theorem in Lean 4
Timeline	11 days, largely autonomous
Scale	13 million lines of Lean code; 30,300 theorems proved, 29,500 used in the final proof
Compute	~6 billion output tokens across several dozen parallel Claude agents
Independent review	Kevin Buzzard (Imperial College London) confirmed the proof rests on nothing but Lean’s three standard axioms
Official source	Anthropic: Formalizing Fermat’s Last Theorem

Bottom line: A formalization task the field expected to take years got done in under two weeks by largely autonomous agents, and it checked out under independent review — the clearest data point yet that multi-agent orchestration has moved past office work and coding into open mathematical research.

What Actually Happened

Fermat’s Last Theorem says that no three positive integers a, b, and c can satisfy a^n + b^n = c^n for any integer n greater than 2. Pierre de Fermat scribbled the claim in a book margin in 1637. Andrew Wiles proved it in 1995, after seven years of work, in a 129-page argument that took the mathematical community years to fully verify by hand.

Verifying it by hand is the operative phrase. A “formalized” proof is different: every step gets translated into a language a proof assistant like Lean 4 can check mechanically, line by line, against nothing but its own axioms. No human trust required, no hand-waved steps, no “and then this famous paper fills in the rest.” Kevin Buzzard at Imperial College London has been leading a community effort to formalize FLT in Lean since 2025, funded through 2029, explicitly because he expects it to take that long. His own FLT repository is still marked work-in-progress.

Claude’s proof is a separate achievement built partly on top of that groundwork. Per the published repository, 106 files draw on Buzzard’s Imperial College project and the Frey-package, Galois-representation, and deformation-theory work it had already produced. Claude’s agents took that foundation and, over 11 days, wrote the roughly 13 million additional lines needed to close every remaining gap in a modern version of the Frey-Serre-Ribet-Wiles-Taylor-Wiles argument. The result: 30,300 theorems proved, 29,500 of them load-bearing in the final proof, checked against exactly three of Lean’s standard axioms — propext, Classical.choice, and Quot.sound. No sorry placeholders, no smuggled-in assumptions.

What Made This Run Different From a Normal Coding Agent Task?

1. Scale of parallel coordination. Several dozen Claude agents worked simultaneously rather than one agent working sequentially, on a project with far more interdependent pieces than a typical codebase.
2. A shared memory layer. Prove2Me, built by Anthropic researcher Tianyi Peng and collaborators at Columbia University, maintains a graph of every theorem statement in the project so agents can see what’s already proved, what’s still needed, and how pieces connect — without re-deriving the same lemma five times or losing track of the plan.
3. Machine verification, not model self-assessment. Every one of the 30,300 theorems was checked by Lean’s kernel, an independent piece of software that doesn’t care what any language model thinks is true.
4. A documented failure first. Anthropic’s initial attempt — pointing Claude at Wiles’ original proof directly, without Prove2Me — didn’t work. Per the Lean community’s own writeup, agents lost track of the project’s state and stopped collaborating effectively. Prove2Me’s shared graph is what fixed that.

That last point matters more than the headline number. This site stays skeptical of AI milestones by default, and “it failed the first time, here’s specifically why, here’s what fixed it” is a far more credible story than “it just worked.”

Why This Matters

Formalized proofs eliminate a category of error that’s plagued mathematics for centuries: a paper that reviewers accept because the argument is convincing, not because every step has been mechanically verified. FLT itself has a history here — Wiles’ first attempt in 1993 had a gap that took another year to close. A machine-checked proof doesn’t have that problem by construction. If it compiles against Lean’s kernel, every step is correct, full stop.

The independent-review part is what separates this from a self-reported benchmark. Kevin Buzzard didn’t work for Anthropic on this project, and he’s spent years on the harder, from-scratch version of the same formalization. Per AI Weekly’s reporting, Buzzard said the achievement “proves Fermat’s Last Theorem with no assumptions other than the axioms of mathematics,” and called it an “extraordinary autoformalization achievement.” He also drew the broader conclusion Anthropic clearly wants people to draw: “If the automatic formalization of FLT is possible now, then we have taken a big step towards automatic formalization of the modern mathematical literature.”

Worth sitting with the honest caveat, too. Claude didn’t formalize FLT from a blank slate — it built on 106 files of existing community work, and it followed a modern restatement of the theorem rather than reconstructing Wiles’ original 1995 argument verbatim. That’s not a knock. Every major formalization project reuses prior work; Buzzard’s own effort builds on decades of Mathlib contributions from hundreds of mathematicians. But “Claude closed the remaining gaps in an active formalization project in 11 days, using tooling built for exactly this problem” is the accurate claim, and it’s still remarkable on its own terms.

Anthropic says the internal research model behind the run performs roughly on par with Claude Fable 5.1 — a step past the Mythos-class model the company shipped publicly in June. It’s the same pattern this site flagged when Claude designed working protein binders in an outside lab: Anthropic’s most interesting capability demonstrations increasingly come from unreleased research models applied to a specific, hard, independently-verifiable problem, not from headline benchmark scores on the shipping product.

What This Means If You Work With AI Agents

If you’re evaluating multi-agent orchestration for your own work, the lesson here isn’t “buy more agents.” It’s that the coordination layer — the thing tracking what’s been done, what’s next, and how the pieces fit — mattered more than raw agent count. Anthropic’s own multi-agent coding harness runs on a similar principle at a much smaller scale: agents fail at complex, long-horizon tasks not because they can’t write correct code in isolation, but because they lose the thread of a large, shared project. Prove2Me is a purpose-built answer to that problem for formal math specifically.

If you’re in a field with formal-verification potential — hardware design, safety-critical software, cryptographic protocols, financial modeling — this is a concrete signal that the barrier to large-scale formalization just moved. Anthropic reports that three individual Claude Max subscribers used Prove2Me to formalize Vinogradov’s Three Primes Theorem in three days, no research lab required. That’s a much better indicator of near-term accessibility than the flagship FLT number.

Don’t mistake this for general mathematical reasoning improving overnight. Formalizing an existing proof — translating a known, human-verified argument into machine-checkable steps — is a different task from discovering a new proof or solving an open problem. Claude had a target to hit and years of community scaffolding to build on. Treat this as evidence about formalization throughput, not as evidence Claude can now originate research-level mathematics unassisted.

The Bigger Picture

This lands in a year where “AI does something mathematicians didn’t expect this soon” has become a recurring headline rather than a novelty. It follows Anthropic’s own reported work applying similar autoformalization techniques to a problem related to the Riemann zeta function, and it arrives the same season OpenAI has touted models solving previously open Erdős problems. The pattern across all of it: these are narrow, verifiable, adjacent-to-known-results wins, not evidence of open-ended mathematical creativity. That distinction matters, and it’s also not a small thing. Narrow and verifiable is exactly the kind of capability that compounds — each formalized theorem becomes reusable scaffolding, in the same DAG structure Prove2Me maintains, for the next one.

It’s also a preview of where the multi-agent story goes next. Every prior example this site has covered — autonomous coding sessions, protein design, enterprise workflow automation — has stayed inside domains with obvious commercial upside. Formal mathematics has essentially none of that in the short term. Anthropic ran this project anyway, which says the company sees agent orchestration as a general-purpose capability worth proving out on hard, prestige problems, not just monetizable ones. Andrej Karpathy’s move into Claude’s pretraining research team back in May fits the same pattern — a bet that the next round of gains comes from how models are trained and coordinated, not just scaled.

Our Take

We think the honest framing here is “impressive and overstated in the same breath, by different people.” Anthropic’s own numbers are real and independently checkable — the GitHub repository is public, the axiom count is verifiable, and Buzzard’s review isn’t a paid endorsement. But the social-media version of this story (“AI proves 400-year-old math problem in 11 days”) skips past the fact that Claude built on years of human formalization work and a proof that was already known. That’s not a gotcha. It’s just the difference between “AI accelerated a hard, well-scoped engineering task dramatically” and “AI did original mathematics,” and only the first one is true here.

The part we’d actually bet on mattering long-term is Prove2Me itself, not the FLT headline. A shared, agent-legible map of what’s proved and what still needs proving is infrastructure, and infrastructure that lets three people on a Claude Max plan formalize a serious number-theory result in three days is the kind of thing that quietly changes a field’s baseline productivity. The FLT proof is the demo. Prove2Me is the product.

Frequently Asked Questions

What is Fermat’s Last Theorem?

Fermat’s Last Theorem states that no three positive integers a, b, and c can satisfy the equation a^n + b^n = c^n for any integer value of n greater than 2. Pierre de Fermat claimed to have a proof in 1637 but never wrote it down; Andrew Wiles finally proved it in 1995 after seven years of work.

What does it mean to “formalize” a proof in Lean 4?

Formalizing a proof means translating every logical step into Lean 4, a programming language and proof assistant that can mechanically verify each step against a small set of foundational axioms. A formalized proof removes any need to trust human peer review — if it compiles, it’s correct.

What is Prove2Me?

Prove2Me is an open-source platform, built by Anthropic researcher Tianyi Peng and collaborators at Columbia University, that coordinates multiple AI agents working on large Lean formalization projects. It maintains a shared graph of theorem statements so agents can track what’s proved, what’s needed next, and how pieces connect — the coordination layer Anthropic credits for making the FLT run succeed after an earlier attempt failed.

Did Claude complete Kevin Buzzard’s Imperial College London FLT project?

Not exactly. Buzzard’s ongoing community project remains a separate, still-in-progress effort formalizing a from-scratch modern proof. Claude’s proof reused 106 files from that project as a foundation but is a distinct, complete repository. Buzzard did independently review Claude’s proof and confirmed it holds.

How much compute did this take?

Anthropic reports roughly 6 billion output tokens consumed across several dozen Claude agents working largely in parallel over 11 days, using an internal research model the company says performs roughly on par with Claude Fable 5.1.

Is this the first AI-formalized proof of a major theorem?

It’s the first complete, machine-checked, end-to-end formalization of Fermat’s Last Theorem specifically. Anthropic and other labs have reported AI assistance on other formalization and research-math tasks this year, including work related to the Riemann zeta function, but FLT is a substantially larger and more prominent target.

Can I verify the proof myself?

Yes. The full code is public on GitHub, along with the axioms it depends on and attribution for every file derived from prior community work. Anyone with Lean 4 installed can compile and check it.

---

Last updated: September 5, 2026. Sources: Anthropic — Formalizing Fermat’s Last Theorem · Anthropic/fermats-last-theorem on GitHub · AI Weekly · SiliconANGLE · Lean community blog · Prove2Me · Imperial College London FLT project.

Related reading: Anthropic’s Multi-Agent System: 4-Hour AI Dev · Anthropic’s Claude Just Beat Chemists at Drug Design · Claude Fable 5 Review · Karpathy Joins Anthropic: What It Means for Claude