Claude Ran Unsupervised for 11 Days. Here's the One Thing That Made 13 Million Unread Lines Safe to Trust.

Note: Anthropic announced this on September 4, 2026 — three days old as of this writing.

On September 4, Anthropic announced that Claude had produced the first complete, computer-checked proof of Fermat’s Last Theorem written in Lean, a formal proof language whose compiler either accepts a proof as mathematically valid or rejects it — no partial credit, no “looks plausible,” no human grader who might miss something. The formalization runs 13 million lines of Lean code, more than five times the size of Mathlib (Lean’s entire existing mathematics library), and proves 29,500 intermediate theorems along the way. Dozens of Claude agents worked on it in parallel, largely autonomously, for 11 days, with human input from Anthropic’s team limited to occasional high-level nudges like “the Jacobian as a scheme sounds high priority” — not line-by-line review, not even close.

Nobody read 13 million lines of that code by hand before trusting the result. That’s not a gap in the story — it’s the actual point. And it’s worth sitting with why that’s true here and almost nowhere else an AI agent runs unsupervised for days at a time, because the answer is the single most useful thing a small shop running its own long autonomous agent jobs can take from this.

What actually happened, and what it doesn’t mean

Fermat’s Last Theorem — no three positive integers a, b, c satisfy aⁿ + bⁿ = cⁿ for any integer n greater than 2 — was proven by Andrew Wiles in 1995, one of the most celebrated results in modern mathematics. What Claude did was not discover new mathematics. It took an existing, already-trusted proof (specifically the Darmon–Diamond–Taylor exposition of Wiles’s argument) and translated the entire multi-hundred-page argument into a form a machine can check step by step, using only Lean’s basic axioms — no human “trust me, this step is fine” anywhere in the chain.

What it is	What it isn’t
A machine-verified formalization of an already-proven theorem	A new mathematical discovery
13 million lines of Lean code checked by Lean’s compiler	13 million lines reviewed by a human mathematician
Confirmation that Wiles’s proof holds with zero unstated assumptions	Evidence that Claude can do original mathematical research at this level
Built on Prove2Me, an open collaborative formalization platform	A fully novel Anthropic tool with no external dependencies

Sources: Anthropic’s own research writeup, SiliconANGLE’s independent reporting, Kevin Buzzard’s own blog post reacting to the announcement.

Kevin Buzzard, the Imperial College London mathematician who has spent years on a publicly funded project to formalize the modern proof of FLT himself, put the scale of the achievement plainly: “extraordinary autoformalization achievement” — and then, in the same post, the caveat that actually matters for this piece: he was already “99.9% sure” the proof was correct before any of this started, and most number theorists were effectively 100% sure. The formalization didn’t resolve mathematical doubt, because there wasn’t meaningful doubt to resolve. What it did was execute, in 11 days, a formalization workload Buzzard’s own funded project expected to take years.

How dozens of agents avoided just duplicating each other’s work

The other underreported piece of infrastructure here isn’t Claude — it’s Prove2Me, the open collaborative formalization platform the whole effort ran on, built by Tianyi Peng and collaborators at Columbia University, not by Anthropic itself. Prove2Me maintains a directed acyclic graph of every theorem statement in the proof, so any agent picking up work can see exactly what’s already been proven, what’s still open, and what depends on what — instead of dozens of independent Claude instances guessing at random which piece to tackle next and colliding with each other’s half-finished work. It also splits each statement and its proof into separate files specifically to keep individual compilation jobs fast, and it keeps a plain-language description attached to every formal statement so a human — or another agent — can find and reuse prior work without re-deriving it from raw Lean syntax.

That’s worth calling out because it’s a second, quieter instance of the same pattern as the compiler itself: the reason “dozens of agents working largely autonomously for 11 days” didn’t collapse into chaos wasn’t better prompting or a smarter model alone — it was a coordination structure external to any single agent that made progress checkable and conflicts visible as they happened, rather than discovered at the end. Anthropic’s own writeup puts a number on the raw compute behind this: roughly six billion output tokens, generated by a general-purpose internal research model comparable to Claude Fable 5.1 — notably not a specialized math model built for this task. The achievement leaned more on the scaffolding (Lean’s compiler for correctness, Prove2Me’s task graph for coordination) than on any single model being uniquely gifted at mathematics, which is the same lesson small-shop operators should take from the structure, not just the headline result.

The detail that should actually change how you think about your own agent jobs

Here’s the part of Buzzard’s reaction that’s more useful to a small-shop reader than the headline achievement: the resulting codebase is, in his words, “gigantic” — over 13.4 million lines — and takes nearly 20 times as long to compile as Lean’s entire existing mathematics library. Claude also formalized only the 1995-era exposition of the proof, which works for primes p ≥ 17, not the tighter modern version Buzzard was pursuing (the gap for smaller primes was already covered separately by prior work, so the result is complete — just not the most elegant version of complete).

Put together, that’s the honest shape of what “11 days, largely autonomous” actually produced: a working, fully verified, genuinely impressive result that is also bloated, inefficient, and not the version a human expert building for long-term maintainability would have chosen to write. That combination — correct, verified, and simultaneously wasteful in a way only a domain expert would catch and care about — is exactly the pattern worth expecting from your own long unsupervised agent runs, not the exception to watch for.

Why “nobody reviewed it line by line” was fine here and usually isn’t

This is the crux, and it’s worth being precise about it instead of hand-waving toward “AI is trustworthy now.” The reason nobody needed to read 13 million lines of Lean code is that Lean’s compiler is a total, mechanical arbiter of correctness for the specific class of claims it checks. Feed it a proof; it either verifies every logical step against a small set of foundational axioms, or it rejects the file. There’s no partial credit, no benefit of the doubt, no plausible-sounding argument that slides through because a reviewer was tired or rushed. SiliconANGLE’s coverage of the story makes the same point independently: this is one of the rare AI achievements that can’t be inflated by benchmark contamination or generous grading, because the grader is a compiler with zero social incentive to be generous.

That’s an extraordinarily rare property. Almost nothing else an AI agent produces during a long unsupervised run has an equivalent — no compiler exists that mechanically verifies “this refactor didn’t change business logic,” “this scraped dataset is accurate,” “this customer email is appropriate to send,” or “this multi-day coding session didn’t introduce a subtle bug that passes the existing test suite but breaks an edge case nobody wrote a test for.” The Claude Fable 5.1 piece from earlier this month covered Anthropic’s own admission that refusal rates on that model are “materially higher” than previous versions — a vendor volunteering a real limitation, which is a good sign of honesty, but also a reminder that even the newest models running for days at a stretch produce output with rough edges a human eventually has to catch.

It’s the same finding the HANDBOOK.md benchmark piece from last month turned up from the other direction: agents dropped into mock companies with real SOPs followed the rules in only 36% of trials at best, even when the rules were right there in the context window. Reading the instructions and following them reliably are two different skills, and neither one is a compiler. That’s exactly why “the agent said it followed the process” and “the agent said the migration worked” deserve the same level of skepticism — both are self-reports from the system under test.

The verification gap, mapped to what small shops actually run unsupervised

Task type	Does it have a “Lean compiler” equivalent?	What actually catches errors
Formal math / Lean proofs	Yes — the compiler either accepts or rejects	Nothing else needed
Code with a comprehensive test suite	Partial — tests catch what they’re written to catch	Test coverage gaps, which are usually large and invisible until they matter
Scraped/aggregated data pipelines	No	Manual spot-checks, downstream error reports
Customer-facing content generation	No	Human review before publish, or nothing
Multi-step business process automation (invoicing, reconciliation, inventory sync)	No	Whoever notices the output looks wrong, eventually

The further down that table your unsupervised agent job sits, the more “it ran for days without anyone checking in” should worry you rather than impress you — because the thing that made Claude’s 11-day math run trustworthy without human review wasn’t the length of the run or the sophistication of the agents. It was the existence of an external, mechanical, un-gameable judge sitting at the end of the process. Most small-shop automation doesn’t have one, which means the human review step the math proof genuinely didn’t need is exactly the step a business process automation still does.

Building your own version of “the compiler,” even an imperfect one

You’re not going to get a Lean-grade formal verifier for your invoicing workflow, but the underlying idea — an independent, mechanical check that doesn’t trust the agent’s own report of its work — scales down further than it first appears:

1. Attach a real assertion, not a vibe check, to the end of any multi-step job. “Does the total on the generated invoice match the sum of line items, exactly, to the cent” is a one-line check a script can run with zero AI involvement, and it catches a meaningful share of the errors that actually occur in automated billing.
2. Use existing structured data as your compiler where you can. If an agent is syncing inventory across platforms, the three platforms’ reported stock counts either match after the sync or they don’t — that comparison is mechanical, doesn’t require a human to read anything, and can run automatically after every job.
3. Treat test coverage as the closest real substitute for a compiler on code. Not “we have tests,” but “we have tests for the specific thing this agent just changed” — a distinction that matters enormously and that most shops don’t actually verify before trusting a multi-day coding session’s output.
4. Where no mechanical check is possible, shrink the unsupervised window instead of accepting the risk. The smart-plug kill-switch piece covered the physical version of stopping a runaway session; the same logic applies to review cadence — a job with no compiler-equivalent shouldn’t run for 11 days between check-ins just because the technology now makes that technically possible.
5. Log everything the agent actually did, not just what it reports doing. A model’s own summary of its work is not an independent record — it’s the thing under test reporting on itself. A separate, append-only log of actions taken is the closest small-shop equivalent to “an outside compiler checked this,” even if a human still has to read the log eventually.

A worked scenario: the multi-day migration job without a Lean compiler

Concrete version, because the abstract framework above is only useful if it changes a real decision. A four-person e-commerce shop kicks off a multi-day agent job to migrate product data from a legacy platform into a new one — thousands of SKUs, descriptions, images, and pricing rules, explicitly framed as a “just let it run over the weekend” job because the new agent harnesses make that technically feasible now.

Applying the framework: step one, there is no compiler-equivalent for “did this migration preserve the correct price for every SKU” in any general sense — but there is a mechanical check available: compare the total SKU count, and a checksum of prices, between source and destination before and after. That’s minutes of setup for a assertion that would have caught, say, a currency-formatting bug that silently dropped decimal points on a subset of products. Step two, the shop shrinks the unsupervised window from “the whole weekend” to “four hours, then a check-in,” specifically because product pricing errors are the kind of mistake that costs real money fast and has no equivalent to Lean’s zero-tolerance compiler catching it before it goes live. Step three, the migration agent’s own end-of-run summary says “migration completed successfully, all SKUs transferred” — and the shop treats that claim as unverified until the independent SKU-count and price-checksum comparison confirms it, rather than as the actual verification.

None of this requires exotic tooling. It requires treating “the agent said it worked” as categorically different from “an independent check confirmed it worked” — which is the entire distinction Claude’s Fermat proof makes obvious in the one domain where that independent check already exists for free.

When running something unsupervised for days is genuinely fine

When there’s a real mechanical verifier at the end, even an approximate one — automated tests with meaningful coverage, a checksum, a reconciliation against a source of truth. This is the actual green light, not “the agent seems capable.”

When the failure mode is cheap and reversible. A multi-day job generating draft content that a human reviews before anything goes live has a low-stakes failure mode regardless of how long it ran unsupervised, because nothing happens until the review step anyway.

When you’ve already run the same job pattern successfully several times and have a track record of what “normal” output looks like, making anomalies easier to spot on the eventual check-in even without a formal verifier.

When it isn’t, no matter how capable the model is

When the output touches money, customer data, or anything irreversible, and there’s no independent check beyond the agent’s own report. This is where “it ran fine for 11 days on a math proof” is the wrong precedent to reach for — the math proof had a compiler; your reconciliation job almost certainly doesn’t.

When “largely autonomous” is doing more work in the sentence than you’ve actually verified. Anthropic’s own writeup is honest that human guidance happened throughout — high-level nudges, not zero involvement. A small shop reading “AI worked autonomously for 11 days” as “zero oversight needed” is reading past the actual claim being made.

When the job pattern is new enough that you don’t have a track record of what correct output looks like. Novelty and long unsupervised windows are a bad combination regardless of the underlying model’s benchmark scores.

Quick answers

Does this mean AI can now do original mathematical research? No — this was formalizing an already-proven, already-trusted result, not discovering new mathematics. Kevin Buzzard’s own reaction is explicit that this “tells us essentially nothing” new mathematically, even while calling the formalization achievement itself extraordinary.

Why did this work without human review when most AI agent output needs it? Because Lean’s compiler provides a mechanical, un-gameable check that either accepts or rejects the proof — a property almost no other class of AI-agent output has. The lesson is to look for (or build) an equivalent check for your own use case, not to assume the same trust level transfers automatically.

Is 11 days of autonomous agent work now normal or expected? It’s evidence of what’s technically possible in a domain with strong external verification. It says less than it appears to about what’s safe in domains without one — which is most small-business automation.

What’s the one thing to actually change after reading this? Before your next multi-day unsupervised agent job, write down what your equivalent of “the compiler” is — the independent, mechanical check that confirms the work, not the agent’s own summary of it. If you can’t name one, that’s the signal to shrink the unsupervised window, not extend it.

Bottom line

Claude formalizing Fermat’s Last Theorem in 11 days, largely autonomously, across dozens of parallel agents, is a genuinely impressive demonstration of what long-running multi-agent systems can now do — and it’s also the cleanest possible illustration of exactly why that capability is safe in one narrow domain and not automatically safe everywhere else. The proof didn’t get trusted because Claude ran for 11 days without anyone checking in. It got trusted because Lean’s compiler checked every one of the 13 million lines mechanically, the moment they were written, with zero benefit of the doubt. Before you let your own agent run unsupervised for days at a stretch, ask what’s playing the compiler’s role in your setup. If the honest answer is “nothing, we just trust the summary,” that’s the gap worth closing before the run length, not after.

Sources

All facts accessed September 7, 2026.

• Full technical details of the formalization, timeline, and methodology — Anthropic, “Formalizing Fermat’s Last Theorem”
• Independent reporting and context on the announcement — SiliconANGLE, “Anthropic uses Claude to formalize proof of Fermat’s Last Theorem,” September 4, 2026
• Kevin Buzzard’s own reaction, including caveats on compile time, proof version (p ≥ 17), and mathematical significance — Xena Project blog, “FLT: Anthropic has beaten me to it,” September 4, 2026
• Claude Fable 5.1’s disclosed refusal-rate increase, cited for context on unsupervised-run limitations — Anthropic, “Introducing Claude Fable 5.1 and Claude Mythos 5.1”
• Prove2Me platform design (DAG task coordination, per-file compilation, plain-language descriptions), compute figures (~6 billion output tokens), and model used — AI Weekly, “Claude formalized Fermat’s Last Theorem in 11 days: Anthropic”