Claude Proved Fermat's Theorem in 11 Days

An AI Agent Just Did What Mathematicians Said Would Take Years

In 11 days, a team of Claude agents wrote 13 million lines of Lean code, proved 29,500 intermediate theorems, and produced the first fully computer-verified proof of Fermat's Last Theorem — a problem that sat unsolved for 358 years and whose human proof took Andrew Wiles nearly a decade to construct. The entire run consumed roughly six billion output tokens. Human input was limited to a handful of high-level priority nudges.

For a business owner, the headline number is not the theorem. It's the operating model behind it: dozens of autonomous agents, coordinated by a platform, working a problem of staggering complexity with almost no human intervention — and finishing ahead of every expert estimate. What that architecture looks like, what made it work where earlier attempts failed, and what it signals about where autonomous AI agents are headed in enterprise operations — that's what the rest of this article is about.

The Proof Nobody Expected This Fast

Fermat's Last Theorem states that no three positive integers can satisfy the equation xⁿ + yⁿ = zⁿ for any integer n greater than 2. Pierre de Fermat scribbled it in a margin in 1637. Andrew Wiles finally proved it in 1995 — a 129-page proof that took months just to verify for errors. Formalizing that proof, meaning converting it into machine-checkable Lean code that a computer can verify step by step, was considered a multi-year undertaking. The mathematical community had an active blueprint project running toward that goal.

According to Anthropic's research publication, Claude completed the task in 11 days, starting in early August 2026. The run was launched on the Prove2Me platform, developed by Anthropic researcher Tianyi Peng and his group at Columbia University. Dozens of Claude agents collaborated in parallel — defining concepts, proving intermediate theorems, and stacking those results into progressively harder statements. The finished artifact, at 13 million lines of Lean code, is more than five times the size of Mathlib, the principal community library of mathematical proofs. Lean's kernel and an independent second checker each accepted every declaration.

Kevin Buzzard, the Imperial College London mathematician who has led a community effort to formalize the same theorem, reviewed the result and called it "an extraordinary autoformalization achievement" — adding that it proves Fermat's Last Theorem "with no assumptions other than the axioms of mathematics." He noted that the technique points toward automatic formalization of the broader modern mathematical literature.

This is also, according to the Xena Project blog, the final theorem to be formalized on Freek Wiedijk's famous list of 100 formalization challenges — a benchmark that had been open for twenty years.

The proof is not the point. The operating model is. Dozens of agents, a structured coordination platform, a dependency graph of 30,000 tasks — and eleven days to close what experts estimated would take years. That architecture is not unique to mathematics.

What Actually Made It Work

Anthropic's first attempt to formalize Wiles' proof failed. Early multi-agent runs collapsed because agents accumulated too much local context, lost track of already-proved results, and duplicated work across the dependency graph. The breakthrough came when the team introduced Prove2Me as the coordination layer.

Prove2Me maintains a directed acyclic graph of theorem statements — essentially a structured map of every sub-problem and its dependencies. Agents can see what has already been proved, what remains open, and what the logical prerequisites are for each next step. This prevented the redundancy and context-loss that killed the first attempt. The platform also separated theorem statements from proof files and maintained natural-language descriptions of each theorem, making search and reuse across agents practical at scale.

The result was a system where human oversight was genuinely minimal. According to Anthropic's research post, mathematical input from humans was limited to occasional high-level comments — things like flagging which sub-theorem to prioritize next. The agents handled everything else: decomposing the problem, allocating work, verifying intermediate results, and building upward through the dependency tree.

Three architectural decisions drove the outcome:

• Structured task decomposition — the problem was broken into ~30,000 discrete, verifiable sub-tasks with explicit dependencies, not handed to a single agent as one monolithic prompt
• Shared state and memory — Prove2Me gave every agent visibility into the global proof state, eliminating redundant work
• Continuous machine verification — Lean checked each sub-proof as it was completed, catching errors before they propagated

This is not a research curiosity. It is a blueprint for how complex, multi-step processes get automated at scale — and it maps directly onto the kind of operational problems that consume executive attention in real businesses.

Why the First Attempt Failed — and What That Teaches

The failure mode of the first run is instructive: agents working in isolation, without shared state, without a dependency map, duplicating effort and losing context. This is exactly what happens when companies deploy AI agents as isolated point solutions — one agent for procurement, another for compliance, another for approvals — with no coordination layer between them. The agents don't fail dramatically. They just quietly underperform, and nobody can tell why.

The fix in the Fermat case was architectural, not model-level. The underlying model didn't change. The coordination infrastructure did. That distinction matters enormously for how businesses should think about AI agent deployment.

What This Means for Business Operations

The Fermat proof is a stress test at the outer edge of what autonomous AI agents can do. The problem is maximally complex, the error tolerance is zero (one wrong line of Lean code invalidates everything downstream), and the dependency graph is enormous. If the architecture holds there, it holds in environments that are far more forgiving.

Consider what the same operating model looks like applied to business processes:

Procurement and vendor management. A multi-agent system with a shared dependency graph can run supplier qualification, contract review, compliance checks, and approval routing in parallel — with each agent seeing the current state of every other agent's work. The human decision-maker sees a completed recommendation, not a queue of sequential tasks.

Regulatory compliance. Compliance processes are, structurally, very similar to mathematical proof: a set of requirements, a dependency tree of sub-requirements, and a need for machine-verifiable confirmation at each step. Agents that can navigate 30,000 theorem dependencies can navigate a regulatory framework.

Complex approvals and escalations. The bottleneck in most approval chains is not the decision itself — it's the assembly of context. An agent architecture that maintains shared state across the dependency graph assembles that context automatically, reducing the time senior executives spend on routine decisions from hours to minutes.

The pattern is consistent: structured decomposition, shared state, continuous verification. That's the architecture that turned an 11-day autonomous run into a mathematical milestone. It's also the architecture that removes the human bottleneck from critical business processes — not by replacing human judgment on the hard calls, but by eliminating the manual assembly work that surrounds those calls.

For a deeper look at how this kind of multi-agent coordination architecture gets built in practice, the procurement AI agent blueprint from Google DeepMind's co-scientist framework is worth reading alongside this case.

The Governance Question Nobody Is Asking Yet

Eleven days of largely autonomous operation, six billion output tokens, 30,000 sub-tasks completed without human sign-off on each one. That's not a pilot. That's a production run. And it raises a question that most businesses deploying AI agents haven't answered yet: at what point in an autonomous run do you need a human checkpoint, and what triggers it?

In the Fermat case, the answer was essentially "almost never" — because Lean provided continuous machine verification. Every sub-proof was checked by the formal verification system before the next layer built on it. The human didn't need to review each step because the system had a built-in error-detection mechanism that was more reliable than human review.

Most business processes don't have an equivalent of Lean. There's no formal verification layer that catches a flawed procurement decision before it propagates into a signed contract. That gap — between the autonomous capability the architecture enables and the verification infrastructure that makes it safe — is where governance frameworks need to be built before the architecture is deployed at scale.

This connects directly to a broader pattern in AI agent deployment: the harness matters as much as the model. The architecture of the agent harness — how tasks are decomposed, how state is shared, how errors are caught — determines whether an autonomous run produces a verified proof or a quietly compounding mistake.

The risks of autonomous agents rewriting their own operating parameters without adequate governance are real and documented. Understanding recursive self-modification risks in AI agents is not optional reading for anyone building production agent systems.

The Attribution Problem

One nuance worth noting: Anthropic's achievement rested on community-built infrastructure the company did not create. Kevin Buzzard's Imperial College FLT project, the Mathlib library, and the Prove2Me platform were all prerequisites. The AI model provided the autonomous execution capacity. The scaffolding that made it possible was built by the broader mathematical community over years.

This is the honest picture of where autonomous AI agents currently sit: extraordinary execution capacity, deployed on top of structured infrastructure that humans built. The lesson for businesses is not "replace your processes with AI." It is "build the structured infrastructure — the dependency maps, the shared state systems, the verification layers — and then deploy agents on top of it."

The Benchmark That Just Moved

For twenty years, Freek Wiedijk's list of 100 formalization challenges served as the benchmark for progress in formal mathematics. Fermat's Last Theorem was the final item. Claude closed it in eleven days.

Benchmarks matter in business contexts because they set expectations. When a capability that experts estimated would take years gets compressed into eleven days, it forces a recalibration of what's possible — and what's coming. The businesses that recalibrate early build the infrastructure and governance frameworks while there's still time to do it deliberately. The ones that wait recalibrate under pressure, which is a worse way to do it.

The compression of expert timelines is not unique to mathematics. It's happening in drug discovery, materials science, software engineering, and legal research. The common thread is the same multi-agent architecture: structured decomposition, shared state, continuous verification, minimal human intervention on sub-tasks.

When your board or investors ask what your AI strategy is, the honest answer is no longer about which chatbot you've deployed. It's about whether you've built the coordination infrastructure that lets agents work on your hardest problems autonomously — and whether you have the governance layer to make that safe. The executives who can answer that question concretely, with architecture rather than aspiration, are the ones who will be seen as building something durable rather than chasing a trend.

That feeling of genuine control — knowing your critical processes run on verified logic rather than on whoever happened to be available — is what the right architecture actually delivers. Not the absence of problems, but the confidence that problems get caught before they compound.

FAQ

What exactly did Claude prove, and is it really new? Claude produced the first fully computer-verified, machine-checkable proof of Fermat's Last Theorem in the Lean programming language. Andrew Wiles proved the theorem mathematically in 1995, but that proof had never been formalized into a form a computer could verify step by step. Claude's contribution is the formalization — converting Wiles' argument into 13 million lines of Lean code that Lean's kernel can check automatically, with no assumptions beyond the standard axioms of mathematics.

What is Prove2Me and why did it matter? Prove2Me is an open collaborative platform for formalizing mathematics, developed by Anthropic researcher Tianyi Peng and his group at Columbia University. It maintains a directed acyclic graph of theorem statements and their dependencies, giving every agent in the system visibility into the global proof state. Anthropic's first attempt without this coordination layer failed; Prove2Me was the architectural addition that made completion possible.

How autonomous was Claude really — did humans do any of the work? According to Anthropic's research post, human mathematical input was limited to occasional high-level priority comments — for example, flagging which sub-theorem to tackle next. The agents handled decomposition, proof construction, and verification. The run lasted 11 days and consumed roughly six billion output tokens with that minimal human involvement.

What does this mean for AI agents in business — is it directly applicable? The specific output (Lean code) is not directly applicable to business. The architecture is. The combination of structured task decomposition, shared state across agents, and continuous verification of sub-results is the same pattern that makes multi-agent systems effective in procurement, compliance, and complex approval workflows. The Fermat case is a proof of concept for the operating model, not a product.

What are the governance risks of running agents this autonomously? The Fermat run worked because Lean provided continuous machine verification — every sub-proof was checked before the next layer built on it. Most business processes lack an equivalent formal verification layer. Deploying agents at similar autonomy levels without that verification infrastructure creates compounding error risk. Governance frameworks need to define human checkpoint triggers before autonomous runs are launched, not after.

Does this make Claude better than other AI models for business use? The research used a Claude model. The result demonstrates what's possible with the right architecture and coordination platform — it's not primarily a model capability comparison. The architecture (Prove2Me, the multi-agent harness, the dependency graph) contributed as much to the outcome as the model itself.

---

The Fermat proof is a data point, not a destination. What it demonstrates is that autonomous agent systems, given the right coordination infrastructure, can compress expert timelines by orders of magnitude on problems of genuine complexity. The question for any business leader reading this is not whether that capability is real — it demonstrably is. The question is whether your current operations are structured in a way that lets you deploy it, or whether you're still running agents as isolated point solutions without the dependency maps and shared state that make the architecture actually work. That gap is worth measuring before someone else in your market closes it first.