Related: Anthropic, Formalizing Fermat's Last Theorem (2026); Buzzard, FLT: Anthropic has beaten me to it (Xena Project); Prove2Me; Ford–Green–Konyagin–Maynard–Tao (FGKMT) 2018 and the Sol / Astra prime-gap manuscripts; Alpöge / Claude results on the Jacobian conjecture, \(S^6\), and the Riemann zero-density bound; Qwen–Fudan et al., The Verification Horizon (arXiv:2606.26300); Tao, Mathematics in the age of AI (ICM 2026) and the Palomar Lean registry; Chen, Epistemic Memory Failures in Long-Form Narrative Agents (ICLR 2026 Workshop on Memory for LLM-Based Agentic Systems).

In September 2026, Anthropic announced that Claude agents had finished an end-to-end Lean formalization of Fermat's Last Theorem in about eleven days. Public figures: roughly 13.4 million lines of Lean, about 30,300 intermediate theorems (about 29,500 used in the final proof), and on the order of six billion output tokens. Tianyi Peng, an Anthropic researcher whose Columbia group builds formalization tooling, ran the effort. Kevin Buzzard's Formalising Fermat project—years of national funding aimed at the same skeleton—was scooped.

Wiles and Taylor closed FLT in 1995. What Anthropic shipped is a machine-checked formalization of a known route: the Darmon–Diamond–Taylor sketch, along Langlands–Tunnell and Ribet, plus existing formal work for regular primes.

A machine check can still close on the wrong object. The failure modes that matter here are: proving a weaker statement than FLT; smuggling a hard theorem in as an unproved axiom; or redefining symbols so Lean accepts something that is no longer Fermat's Last Theorem. The public repo ships guardrails aimed at those modes. The top theorem is written in ordinary natural-number form. Asking Lean which axioms the proof rests on returns only the three classical logic axioms that Lean and Mathlib already use. A small comparator program imports Mathlib alone and demands that the delivered proof imply Mathlib's standard statement of FLT. A second checker, a Rust Lean kernel called nanoda, replays the declarations outside Lean's main C++ implementation.

I read Anthropic's disclosure and had GPT-6 Astra walk the public repository against those failure modes. On the points it checked—root theorem, axiom closure, main proof path, comparator, and nanoda replay—it reported no weakened goal, no smuggled mathematical axioms, and no structural skip of the key chain. That is what that audit means: the published artifact, under those checks, looks like a real FLT formalization rather than a renamed or axiom-padded stand-in. Buzzard and others also described the delivered object by size: temporary names, mechanical expansion, many times Mathlib's footprint—a one-shot proof credential. Machine completion here is logical closure. What later mathematicians can read, reuse, and build on is a separate job, and that job is still open.

The engineering punchline is elsewhere. Early runs let many Claude agents collaborate freely. Single-step Lean skill was already strong. After a while the system collapsed: agents lost the macroscopic project state, reinvented lemmas, and drifted. About seven percent of the non-boilerplate code from those attempts survived. The project closed after switching to Prove2Me, with a theorem-dependency DAG and Lean kernel certificates as the shared substrate.

That ablation is the claim worth keeping. Once models clear a competence bar, long-horizon multi-agent math work bottlenecks on external state governance—the runtime outside any one context window—not on single-step IQ. Agents claim frontier nodes on a DAG: which statements are proved, which are open, what depends on what. A reduction sketch for a hard parent theorem is compiled in Lean before child tasks spawn, so the plan itself is a checkable object. Communication is deterministic artifacts—status = PROVED plus a Lean certificate—not natural-language summaries of "I mostly finished lemma X." The next agent imports Theorems.Thm_X. It does not re-read another agent's trajectory.

The same month's discovery claims show what still sits after local certificates close.

Large gaps. GPT-5.6 Sol's tilted residue-class construction improved the FGKMT 2018 lower bound on large prime gaps. Green publicly digested the new middle sieve—new enough, he said, that it alone would once have paid Erdős's cash prize—while calling most of the write-up horrific reuse. I had GPT and Kimi K3 check the Lean repo: no sorry on the proof chain, no custom axioms, final theorem about consecutive prime gaps for all large enough $X$. What was still missing in the public record was an author-independent full rebuild from a pinned commit. As of those checks, Erdős Problems still listed FGKMT 2018 as the best bound. Days later Astra published a further long-gap improvement on a different structural idea (sparse remainder plus short translate), again with Lean; the same open questions about rebuild and digestion apply.

Short gaps. On 4 September 2026, OpenAI released a candidate for \(H_1 \le 186\)—openai/PrimeGaps186, paper, numerical certificate, conditional Lean—with the proof attributed to GPT-6 Astra. The repository's formalization.yaml marks review status as self-assessed. I had GPT-5.6 Sol Pro and Kimi K3 walk the repo, the three external axioms, and the numerical certificate. The first two axioms lined up with Deligne–Katz and Fouvry–Kowalski–Michel; the third, the packed numerical integral bounds, had no published third-party production recomputation yet. Meaning: internally consistent, serious, and still waiting on that numerical close and on human semantic review before it enters the accepted tables.

Three earlier shapes show how verification cost varies when generation is already cheap.

Jacobian. Alpöge's three-dimensional counterexample (Claude Fable 5) is a finite certificate: one polynomial map, determinant constantly \(-2\), three points to one image—hand- and CAS-checked within a day, then Lean.

\(S^6\). A 108-page claim of a complex structure on \(S^6\), no Lean; finite data packed into the first two pages for rebuild. I had GPT and Kimi audit those finite parts; they found no fatal arithmetic on the matrices and interfaces they could recompute. The main theorem collides with Campana–Demailly–Peternell on algebraic dimension, so expert adjudication of that conflict is still the scarce step.

Riemann 67.2%. A research Claude made a Montgomery–Taylor-type lower bound on critical-line zeros unconditional, with Lean aimed at Mathlib's riemannZeta. The mathematicians who reviewed it inside Anthropic were Alpöge and Furman. Meaning: formalization plus affiliated expert review ran ahead of a field-wide rebuild.

Generate, verify-local, digest

Headlines collapse three jobs into one word—"solved."

1. Generate a manuscript, a Lean sketch, or a parallel formalization that moves a bound or closes a known route.
2. Verify-local certificates: the statement matches the intended claim, axioms are the expected ones, a script or kernel replay still accepts the artifact.
3. Digest what is new for the field: which layer is novel, which literature it collides with, whether an independent group rebuilds it into the live record.

I borrow a name from coding-agent work for the cost inversion: the Verification Horizon (Qwen–Fudan et al., arXiv:2606.26300). Classical intuition says checking is cheaper than searching. For strong agents the marginal cost of a high-scoring candidate falls. Faithfully checking whether the candidate matches the intended claim—intent, definitions, side conditions—moves to the center. Unit tests scale and miss intent. Model judges understand more and can be gamed. Human experts are faithful and do not scale.

A Lean yes is a proposal until commit. Commit, here, means the step where the community treats the claim as part of its live record: peer review, an independent rebuild, a site updating its best-known bound. Local guardrails and model audits are logs of those checks. They tell you what was examined and what turned up. They leave the commit step to the field.

The runtime lesson from Prove2Me sits next to that step. Keep project state outside the model: a DAG of immutable theorem objects, frontier tasks, and kernel-checked certificates. Compile the proof sketch before spawning workers. Import certificates, not chat summaries. The same failure mode shows up in long narrative agents (ICLR 2026 MemAgents workshop): a fluent draft can rediscover a fact the story already knew. Multi-agent formalization rediscovers known lemmas and loses project state when the binding constraintwhat is proved, what is open, what may be imported—was never written down as the thing that gates the next write.

Single-step model skill sets how far one agent can go. When dozens of agents must close tens of thousands of steps over days, the decisive piece is a runtime that owns dependency topology, deposits deterministic state, and lets a compiler refuse bad plans. FLT showed that stack on a theorem the field already believed. Formalizing a settled result and moving a best-known bound are different jobs; on the discovery side, the scarce step after Lean accepts a candidate is still digestion into the live record—Green reading which sieve layer is new, a third party rebuilding from a pinned commit, a site updating its table. Prime-gap candidates are waiting on that step. Prove2Me is what made the formalization log possible at scale.

When human hours run out

The bottleneck is no longer only "can the model write a proof." It is that human verification hours do not scale with the flood. Terence Tao's ICM 2026 lecture Mathematics in the age of AI names the shift: generation and machine checking accelerate; what piles up is proof indigestion—candidates waiting for someone to vouch for them, readable writeups, refereeing, and canonicalization into the textbooks the next models will train on. He argues the culture should weight digestion more heavily than being first.

That diagnosis has an engineering corollary. Drive the cost of verify-local as low as the tools allow, so scarce human attention spends on digestion rather than redoing mechanical checks. The stack is AI plus Lean: a kernel that refuses weakened goals and smuggled axioms; a comparator that ties the formal statement to a standard claim; a second kernel or pinned rebuild that replays the artifact; and models that walk repositories against those failure modes before a human opens the file. Tao's Palomar registry is one institutional version of the same idea—mechanical Comparator checks plus a model pass that the informal description matches the Lean claim—explicitly short of peer review, and useful precisely because it clears the cheap layer at registry scale.

The audits in this note are the personal version of that stack. When a new FLT repo, a prime-gap Lean tree, or an \(S^6\) certificate drops, I read the public disclosure and send a named frontier model (GPT-6 Astra, GPT-5.6 Sol Pro, Kimi K3, as above) against the failure modes that matter for that case. The output is a log: what was checked, what lined up, what is still open. That is how I spend my own scarce hours—on deciding what still needs a specialist, not on retyping #print axioms by hand.

So the picture closes as one pipeline. A runtime like Prove2Me lets many agents finish a long formalization without losing project state. AI-plus-Lean, and registries built on it, compress the cost of local certificates. Humans, and the reviewing systems we design for them, take the remaining scarce step: digest a closed log into the live record. Generation will keep getting cheaper. The work that remains is to make verification cheap enough that digestion can keep up.

Method

I read public disclosures and, where named above, asked GPT-6 Astra, GPT-5.6 Sol Pro, GPT, or Kimi K3 to audit repositories, axioms, and numerical certificates against the failure modes in the text. Numbers are those reported in those sources.