Field noteNov 16, 20266 min read1 source

Fable 5.2 Fermat Lean code still unpublished, so the 30-hour claim cannot be checked

In one minute

Anthropic says 1,000 agents running an early version of Claude Fable 5.2 reproduced its formalization of Fermat’s Last Theorem in Lean in 28.7 hours. The experiment is a useful account of how agents coordinated through Git and a shared database under layered controls, but the result still needs a public artifact for independent checking.

What happened

Anthropic’s November 9, 2026 announcement describes a “toy experiment” in which 1,000 agents running an early version of Claude Fable 5.2 reproduced a formal proof of Fermat’s Last Theorem. The team completed the run in 28.7 hours. Anthropic says it used one-third as many output tokens as the company’s September formalization and produced a proof one-seventh the length of that earlier work. The September effort, according to the announcement, involved dozens of agents, a researcher, the Prove2Me platform, 11 days, and roughly 6 billion output tokens. The new run did not use Prove2Me or researcher direction.

Anthropic gave the agents 60 statements to prove: the final theorem and 59 intermediate milestones, each with a one-line informal description. It also supplied definitions and 47 previously proved lemmas from the earlier formalization. The agents had a shell and file editor in separate sandboxes, Lean and Mathlib, Git branches with merge requests, and a shared PostgreSQL database. Each Lean statement counted as proved only when the official checker accepted it. One lead agent was instructed to divide work among 999 helpers; the lead received 19 automated reminders about the remaining time.

The team created its own coordination structure. Within the first ten minutes, the lead set up five database tables for team-wide instructions, assignments, notes, subtasks, and completed work. Helpers assessed the difficulty of their assignments, and the lead initially set aside 47 statements that most judged infeasible within the run’s budget. After the first ten statements were proved, the lead reassigned agents to harder work. Helpers increasingly took on task decomposition themselves. For Langlands–Tunnell, the hardest remaining statement, the team built a tree reaching 2,418 tasks and ten levels deep. The statement was proved at hour 28.4, followed by the final theorem at hour 28.7.

Anthropic says every agent ran in its own lightweight virtual machine without network access. Agents could communicate only through Git and the database. Git changes went through merge requests and a separate merge job; database statements had a five-second limit, and writes above 256 MiB were refused. A classifier checked tool calls before execution, and an offline monitor reviewed actions. Anthropic reports more than a million tool calls, none of which met the bar for blocking in this run. It says the run used an action-based monitor; a parallel monitor that can inspect chain of thought and interagent communication was added shortly afterward.

What the archive adds

New Runtime’s earlier coverage, Introducing Claude Fable 5.2 and Claude Mythos 5.2 (November 9, 2026), reported Anthropic’s claim that Fable 5.2 formalized Fermat’s Last Theorem in 30 hours. This is a new, more detailed account of the harness, coordination and safeguards behind the same result—not a separate proof event.

Trend signal

This account supports agent security moves to runtime boundaries: Anthropic describes containment through isolated sandboxes, restricted tools, identity tagging and monitoring rather than relying on instructions alone. The experiment illustrates the approach, but does not establish how well these controls perform across different models, tasks or adversarial conditions.

Why now

Anthropic frames the run as a way to study how a large agent team handles a long-horizon problem without the specialized platform and researcher direction used in its earlier effort. It says the safety methods will need to evolve as teams take on harder tasks.

Connections to other events

New Runtime’s earlier coverage of OpenAI’s withheld Yang–Mills proof noted that Lean validation does not establish full correctness on its own. That distinction applies here too: a formal proof artifact would let others inspect what the checker accepted, but transparency about the code and assumptions is still necessary to assess the complete claim.

Why it matters

For builders, the most reusable result is not simply that a large model-powered team can attempt an ambitious theorem. It is that parallel work depends on a shared, queryable account of task ownership and progress. Anthropic’s agents used ordinary coordination primitives—database tables, Git branches, merge requests and a task tree—to keep work visible and divisible. The team also revised its plan when early difficulty estimates proved too pessimistic, then concentrated hundreds of helpers on the hardest remaining statement.

The safety design is equally consequential. Network isolation, limited privileges, identity controls and monitoring narrow what agents can do while still allowing them to collaborate. Those mechanisms are concrete design choices, not proof that the setup is safe in general. Teams considering similar systems should separate operational success from verification: a task tracker can show that work was completed, but a trusted checker and inspectable outputs are what make completion meaningful.

Limits and uncertainty

The announcement is Anthropic’s account of its own experiment. The public description does not itself provide the Lean code from this 1,000-agent run for independent reproduction, so outsiders cannot use this account alone to check the proof, its assumptions or the stated length comparison. The reported token reduction and completion time are not an independent benchmark across repeated runs. Anthropic also calls the experiment a toy study and acknowledges that domain-specific harnesses and human direction may still improve efficiency; the result does not show that the same setup generalizes to other difficult tasks. The monitoring account is specific to this run, and the company’s added chain-of-thought monitor was not used during it.

Skill to build now

For a multi-agent task, create a shared task ledger with explicit ownership, status and completion evidence before scaling the number of workers. Use a separate branch or equivalent reviewable unit for each contributor, and define completion through an external checker rather than an agent’s self-report. Start with bounded permissions and isolated execution; add monitoring appropriate to the tools and potential harm. This week, try the pattern on a smaller task and measure duplicated work, blocked actions and verified completion—not just agent activity.

Reader takeaway

Anthropic’s experiment is a compelling example of agent coordination at scale, not yet an independently reproducible proof claim. The builder lesson is to pair a shared task system and constrained runtime with artifacts that an external checker—and eventually other people—can inspect.

Evidence / sources

  1. 1claude.dev/blog/safely-scaling-multi-agent-teams-with-fable-5-2
All Field Notes

Next reads

Read next

Open the graph
  1. 01topicAnthropicExplore the anthropic topic hub.
  2. 02topicClaudeExplore the claude topic hub.
  3. 03archiveField NotesOpen the latest editorial analysis.
  4. 04sourcesSourcesSee the original sources this archive cites.
Who read this page?Machine requests, hidden until opened

Loading the privacy-safe route aggregate...

Open the JSON contract