Claude Just Formalized Fermat's Last Theorem in Lean

What Anthropic Actually Announced

On September 4, Anthropic published a research page describing what it calls the first end to end, computer-checked formalization of Fermat's Last Theorem in the Lean 4 proof assistant. The theorem itself is old news. Pierre de Fermat scribbled the claim in a margin in 1637, and Andrew Wiles finally proved it in 1995 after years of work, in a proof that runs 129 pages and took the mathematical community months to fully verify by hand. What Anthropic did in September 2026 was different. It turned Wiles' proof into a form a computer can check line by line, with no human trust required at any step.

The model behind the work is described as an internal general purpose research model with capabilities roughly comparable to Claude, not a publicly available one. That distinction matters and I will come back to it, because a fair amount of the coverage I read this week blurred it. According to Anthropic, the model worked largely autonomously across 11 days, spinning up dozens of agents in parallel against a shared coordination tool called Prove2Me. Human input was limited to occasional high level nudges, the kind of thing a supervisor might say in passing rather than a line by line collaborator. One quoted example: "Jacobian as a scheme sounds high priority."

I've been tracking Anthropic's model releases closely since Fable 5.1 and Mythos 5.1 shipped on September 1, and this result landed just three days later, which is part of why it caught my attention. Two very different kinds of announcements in the same week, one about a model everyone building on Claude Code can use today, one about a research result nobody outside Anthropic can reproduce yet. Both are worth understanding, but only one of them changes what I can build with tomorrow.

Lean itself is worth a sentence for anyone who has not touched a proof assistant. It is a programming language and an interactive theorem prover at once. You state a claim in Lean's own strict syntax, then you write a sequence of tactics that the language's kernel either accepts as a valid logical chain to the claim or rejects outright. There is no partial credit and no benefit of the doubt. A Lean proof either type-checks or it does not, which is exactly why a machine-checked Fermat's Last Theorem carries more weight than a plain English summary of one, however well written.

The Numbers Behind the Claim

The scale here is what makes this worth a second look instead of a skim. The final Lean file runs approximately 13 million lines, which multiple outlets covering the release describe as the largest Lean proof ever written. Getting there required proving 30300 intermediate theorems, of which about 29500 ended up used in the completed proof. The run consumed close to 6 billion output tokens across the full 11 days.

Numbers that size are easy to state and hard to picture, so here is the comparison that made it click for me. A single, well scoped feature I ship for a RAXXO tool might touch a few hundred lines of code across a handful of files, reviewed and tested inside a day or two. This run produced roughly the equivalent of building and internally verifying tens of thousands of small, interlocking proofs, continuously, for eleven straight days, without a human checking each one as it landed. The checking happened after the fact, by Lean's own type checker, which is the part that actually earns the claim of being computer-checked rather than just computer-assisted.

Kevin Buzzard, a mathematician whose published work the model drew on while building the formalization, gave one of the more grounded reactions I found: the result shows autoformalization tools spanning algebra, harmonic analysis, geometry, and number theory are now robust enough to be built upon, and the proof itself is multi-layered rather than a single trick repeated at scale. That is a mathematician's way of saying the tooling crossed a real threshold, not just a headline number. If formalizing something on the scale of Fermat's Last Theorem is possible now, the next target for this kind of work is checking the modern mathematical literature itself for the errors that inevitably creep into decades of published proofs nobody has re-verified by machine.

The timestamp detail I keep coming back to is a small one. According to Anthropic's own writeup, the moment the root theorem flipped to proved on the Prove2Me dashboard was logged automatically, in the middle of the night US time, with no one watching it happen live. That is a different picture than the usual framing of a research breakthrough, a team huddled around a screen at the moment of discovery. Here the discovery moment was a log line an agent wrote for other agents to read, and a human found out later. I think that detail says more about where long horizon agent work is heading than the theorem itself does.

What This Result Is Not

I want to be as precise here as I was excited reading the original announcement, because the two pull in different directions. This is not Claude discovering a new proof of Fermat's Last Theorem. Wiles did that work in 1995, and nothing about a formalization changes who found the mathematics or when. What the model did was translate an already-accepted, already-published proof into a form where a machine, rather than a community of expert reviewers over months, can confirm every logical step holds together with no gaps.

That distinction is not a knock on the achievement, it is the whole point of formalization as a field. Verification at this scale used to be a job for a small number of specialists working for years. Compressing that into 11 days is genuinely new, and it is a fair test of whether large models can hold a long, structurally complex task together without losing the thread, which is a much harder problem than answering a single hard question correctly.

The second caveat is the one I think matters more for anyone reading this as a signal about what they can build today. The model that did this work is not Fable 5.1, not Mythos 5.1, and not anything currently sitting behind an API key. It is described as an internal research model with capabilities in the same range as Claude, built and tuned specifically for this kind of long horizon formal reasoning task. I read the earlier Mythos result on cipher weaknesses the same way when it came out. Anthropic has a real pattern of testing frontier capability on hard, narrow, verifiable problems well before anything resembling that capability reaches a product a developer can actually call.

Why Prove2Me Is the Part Worth Studying

The model getting most of the attention this week is, in my opinion, the less interesting half of the story. The coordination tool underneath it, Prove2Me, is the part with something concrete to learn from if you build with agents rather than just chat with one.

Prove2Me maintains a directed acyclic graph of theorem statements, essentially a map of which claims depend on which other claims, and multiple agents pull from that shared graph to decide what to attempt next. That structure solves two problems at once. It lets many agents work in parallel without duplicating effort on the same subgoal, and it gives each agent a persistent, external memory of the overall task that does not degrade the way an agent's own context window does over a long run. Anthropic specifically credits this graph structure with mitigating memory degradation across the 11 day run, which lines up with the single biggest failure mode I have hit running any multi-step agent task longer than an afternoon.

I do not run anything close to an 11 day autonomous agent campaign for RAXXO tools, and I am not going to pretend the comparison is close. But the underlying pattern, a shared, external, structured record of subgoals that multiple agent runs read from and write to instead of each one trying to hold the whole task in its own head, is exactly the kind of thing worth stealing at any scale. It is a cleaner answer to "how do I keep several agent runs from stepping on each other or forgetting what already got done" than most of what I see written about multi-agent workflows.

There is also a quieter design choice in Prove2Me worth naming, which is that it is a dependency graph rather than a checklist. A checklist assumes tasks are mostly independent and just need dividing up. A dependency graph assumes the opposite, that most tasks only make sense once something else is already done, and it makes that ordering explicit instead of leaving it for each agent to rediscover on its own. Anthropic reports the platform was released as an open tool rather than kept internal, which means the coordination layer, not just the paper describing it, is something a developer can go read today even though the research model behind this specific run is not available to anyone outside the company.

Bottom Line

I read a lot of AI announcements that claim a new benchmark or a marginally better score, and most of them do not change anything about how I work the next morning. This one is different, not because I am about to formalize theorems, but because it is the clearest public evidence I have seen of a model holding together a genuinely long, structurally demanding task without a human checking in every hour.

The honest version of this story has two halves, and I think both deserve equal weight. Half one: an internal research model, not a product I can use, spent 11 days and roughly 6 billion tokens formalizing an already-proven theorem, which is a real and specific kind of progress, not a vague one. Half two: the coordination pattern that made it possible, a shared graph of subgoals instead of one long conversation, is something I can actually learn from today regardless of which model I am running it on. I will take the second half over the headline every time. That is usually where the durable lesson in these announcements actually lives.