The 30 hours came with a head start, and they didn’t produce a new proof. Anthropic says 1,000 Claude Fable 5.2 agents, AI workers that each carry out steps on their own, formalized Fermat’s Last Theorem in 30 hours. That means they rewrote the proof Andrew Wiles published in 1995 so a computer could check every step. They also began with 60 target statements and 47 lemmas, smaller results the proof leans on, already proved by an earlier run. Keep both in mind before you repeat the headline.
Our read: this run shows an AI team working on one job for more than a day, with a strict checker on every statement. It isn’t a reason to upgrade your Claude plan. The files for the 30-hour proof aren’t public, and we found no outside mathematician commenting on them.
Quick Navigation
What did Claude actually do to Fermat’s Last Theorem?
The theorem says no positive whole numbers a, b and c fit aⁿ + bⁿ = cⁿ when n is greater than 2. With squares it does work: 3² + 4² is 9 + 16, which is 25, or 5². So you can find whole numbers that fit for squares, but never for cubes or any higher power. Fermat wrote the claim in the margin of a book around 1637, and it stayed unproven for more than 350 years.
Wiles solved it in the 1990s. His first version had a gap that a reviewer spotted, and he spent a year fixing it, partly with his former student Richard Taylor. The corrected proof ran in the Annals of Mathematics in 1995. If a proof that famous needed a year of repair, you can see why mathematicians want a machine to check every step.
So Claude didn’t find a proof. It formalized one: it translated the proof “into a language that a computer can check step by step”. Anthropic’s own September write-up says the new part is the verification, not the mathematics.
Think of a human proof as a flat-pack manual. It says “attach the doors” and trusts you with the rest. Lean, a programming language in which a computer checks every step of a proof, is the pickiest builder you could hire. It needs to see every step, no matter how trivial.
Formalizing means rewriting the manual screw by screw until Lean builds the whole thing without one complaint. It’s a comparison, not a description of how Lean works inside. That rewriting is no small job: Anthropic’s first finished formalization, published in September, ran to 13 million lines of Lean. So when a headline says Claude did Fermat, read it as Claude rewriting a known proof so a machine could check every line.
Was it really 30 hours, and how much help did it get?
A thousand agents on one job sounds like chaos. It ran more like a restaurant kitchen you’d recognise: one head chef, the lead agent, and 999 cooks, its helpers. Each worked in its own sandbox with no internet access, a sealed computer you can picture as a locked office. Instead of shouting across the kitchen, they shared orders and notes through a SQL database, a shared set of tables they could all read and write.
Finished proofs went to Git, the tool programmers use to track changes to shared code.
They didn’t start from a blank page. The agents got 60 statements to prove, a one-sentence sketch of the classical route, the definitions those statements use, and 47 proved lemmas from the September run. Lean’s tools and Mathlib, the main community library of proofs already written in Lean, were built in. It’s like setting off with the waypoints marked and some of the road already laid.
The lead triaged fast, the way you might clear the easy jobs first. Early on, it set aside 47 of the 60 target statements, a different 47 from the lemmas, because most helpers judged them infeasible. Once the first 10 were proved, it sent helpers back to them. If you’ve ever shelved a hard task and come back to it once the easy ones were done, it’s the same move.
With nearly everything else proved, it moved about 750 helpers onto the biggest remaining piece, Langlands-Tunnell, a classical result that Wiles’s proof relies on. The helper leading that piece had given it less than a 1% chance of finishing in time. It was proved at hour 28.4, and the final theorem followed at hour 28.7. In this run, at least, the team wrote off its biggest piece early and came back to it only when little else was left.
The 30 hours weren’t one straight stretch, though. Activity stopped near hour 18, and Anthropic restarted the run from its last save with 12 more hours. It’s like reloading a game from a save point.
So 30 hours is 18 plus 12, and the finish came 1.3 hours before the budget ran out. Neither Anthropic post says why it stopped or how long the pause lasted. If you picture 30 nonstop hours, adjust the picture.
“Minimal human intervention” isn’t none, either. Anthropic restarted the run once, and its harness, the software that ran the agents and kept time, sent the lead 19 automatic reminders of the time left, each nudging it to keep going. Anthropic’s own conclusion is that agents tend to give up on hard problems and misjudge their difficulty, and that human encouragement can keep them from stopping too early.
What you can take from it is about long jobs, not maths: this run kept an AI team on one task for more than a day, with a strict checker deciding what counted as done.
“No mathematical references”, plus a starter kit
The launch post: Fable 5.2 “used no mathematical references, only a list of intermediate theorem statements to score progress”
The engineering post: the agents also had a route sketch, the definitions, 47 proved lemmas from the September run, and Mathlib.
For you: if you quote the launch post’s line, quote the starter kit with it.
Is 30 hours really faster than 11 days?
Anthropic sets its first run’s 11 days against the new 30 hours. In hours that’s 264 against 30, about 8.8 times longer. But the two runs differ in nearly everything except the theorem, so this isn’t a clean race between two models, the AI systems behind the answers. If you see “nine times faster” in a headline, that’s the gap it skips.
| First run (September) | New run (November) | |
|---|---|---|
| Model | An internal research model roughly comparable to Claude Fable 5.1 | An early version of Claude Fable 5.2 |
| Agents | Dozens, plus a researcher | 1,000: one lead, 999 helpers |
| Time | 11 days | 28.7 hours to the final theorem, inside a 30-hour budget |
| Human help | Occasional high-level instructions from a researcher | No researcher steering; one restart; 19 automatic reminders |
| How they coordinated | Prove2Me, a platform with a shared graph of statements to prove | Git and a shared SQL database |
| Starting point | A simplified version of Wiles’s proof as the route | 60 statements, a route sketch, definitions, 47 proved lemmas from run one |
| Size and tokens (chunks of text) | 13 million lines of Lean, roughly 6 billion output tokens | A proof seven times shorter, one-third the tokens |
| Checks Anthropic names | Lean, three standard axioms, a comparator, a second kernel, a mathematician’s review | Lean’s checker had to accept each proof before it counted; a grader on the main branch |
| Public files | Yes, on GitHub | None published |
Tokens are the small chunks of text an AI model reads and writes, so one-third the tokens means far less writing for a proof one-seventh the length. The launch chart adds a second team: Opus 5.5 with the same 1,000-agent setup completed 26% of the formalization at 18 hours and barely moved by 30. That’s a single run per model on one task, so it isn’t a ranking of Claude models. If you’re choosing between the models you can use today, our Opus 5.5 vs Sonnet 5.5 guide is the better place to decide.
From Fermat’s margin to the 30-hour run
| When | What happened |
|---|---|
| Around 1637 | Fermat writes the claim in the margin of a book |
| June 1993 | Wiles presents a proof; a reviewer later finds a gap |
| May 1995 | The corrected proof is published |
| Aug 18, 2026 | Anthropic’s first run marks the theorem proved |
| Sep 4, 2026 | Anthropic publishes the first run |
| Sep 24, 2026 | Last change to the first proof’s public code on GitHub |
| Nov 9, 2026 | Anthropic describes the 30-hour run with the Fable 5.2 launch |
| Nov 11, 2026 | No public files for the 30-hour proof; no outside comment found |
Who checked the 30-hour proof?
One run has been opened to outsiders; the other hasn’t. That difference decides how much you can lean on each.
The September proof got several locks on the door, the kind you’d want on any claim this big. Lean checked it, and it rests only on Lean’s three standard axioms, the starting rules you have to accept in any Lean proof. A comparator, a tool that confirms the proof answers the question that was asked, matched its statement to Mathlib’s statement of the theorem.
Its public repository, the online folder where the code lives, adds a second kernel, a separately written copy of Lean’s core checker, and that one accepted the proof too. Mathematician Kevin Buzzard reviewed it and said it “proves Fermat’s Last Theorem with no assumptions other than the axioms of mathematics”. If you want a proof you have to take far less on trust, that’s what it looks like.
For the 30-hour proof, the evidence so far is Anthropic’s own account. A statement counted as proved only once Lean’s checker accepted a finished proof. The lead agent signed off with “kernel-checked by the official checker”. The count ends at 54 of 60 statements: five were backup routes that were no longer needed, and one was dropped. If you expected 60 out of 60, that’s why the count stops short.
What Anthropic hasn’t described is the rest of September’s locks. The engineering post doesn’t mention a comparator, a second kernel or an outside review. The only Fermat repository on Anthropic’s GitHub is the September one. We found no outside mathematician commenting on the new run, and Tech Times found no independent review either.
Even a fully checked proof has a limit. The September repository says what no tool can check: that each intermediate theorem means what its name suggests. So a checker proves the logic holds, and people still judge whether each label means what it says.
For now, you’re taking the 30-hour proof’s checks on Anthropic’s word. For more on why that difference matters, our explainer on trusting AI math proofs walks through the same checks on other claims.
Can you use the model behind the Fermat run?
Yes, though not the exact version. The run used an early version of Fable 5.2, and the released Fable 5.2 is on Pro, Max, Ultra, Team and Enterprise. Max costs $100 a month and includes Fable for up to half your weekly limit.
Pro costs $20 billed monthly, and on Pro, Fable normally runs on usage credits. That means you pay as you go at the rates developers pay through the API, the builders’ entrance round the back. Until November 16, 2026, a launch offer lets Pro use Fable inside its weekly limit, up to half of it, at no extra cost.
If you pay for Pro monthly and this story has you eyeing Max, that’s $80 a month more, or $960 a year. Nothing in the Fermat run tells you what that buys for your own work. It was a toy experiment, in Anthropic’s words, run as 1,000 sandboxed agents in Anthropic’s own harness.
Here’s a rule you can use: if you hit Pro’s weekly limit most weeks, Max deserves a look on its own merits. If you rarely do, this headline changes nothing for you.
Our Claude plan guide sets out what each tier includes, and our Claude Fable review covers the model itself. Fable is the same underlying model as Claude Mythos, which organizations in cybersecurity or biomedical research can apply for; our Mythos piece covers that side. Our Claude Agent Teams review covers running several agents at once yourself.
What would make the 30-hour proof trustworthy
Our answer today: a known proof, rewritten for a machine in 30 hours of run time, that only Anthropic has checked so far. Three things would move it.
- Anthropic publishes the Lean files. Then outsiders could run the same checks the September proof got: the axioms, the comparator, a second kernel.
- A mathematician outside Anthropic reviews them, as one did for the first run.
- Another run, on this theorem or a new one. One run per model is a sample of one; a repeat would show you whether this was typical or a good day.
Until one of those happens, take the 30 hours as a sign of where AI teams are going, not as a result outsiders have checked. We’ll update this page when the files or a review appear.
Sources and how we checked: the Claude Fable 5.2 launch post (Mathematics section), Anthropic’s engineering post on the 1,000-agent run, its September post on the first formalization, the first proof’s GitHub repository and commit history, Anthropic’s GitHub repository list, Claude’s pricing page, Fable page and help article on the Fable launch offer, the Annals of Mathematics page for Wiles’s paper, and Tech Times’ report, all read on November 11, 2026. We searched for outside comment on the 30-hour run the same day and found none. Prices are US dollars. We did not build or check either proof ourselves; this post shares its research with our video on the same run.
Founder of AI Tool Analysis. Every price and limit here is checked against the vendor’s own pages. How we research
Stay Updated on AI Plans and Prices
Get an email when a plan we cover changes its price or limits.
Free, unsubscribe anytime.
Related Reading
- Can You Trust an AI Math Proof? Why Lean Matters (2026)
- Claude Fable Review
- Claude Subscription 2026: Free vs Pro vs Max vs Ultra
- Claude Mythos Preview
- GPT-6 Astra: Did It Really Solve Chess?
- Claude Agent Teams Review
Last Updated: November 11, 2026
Next Review Update: December 11, 2026