🔍 Read the full analysis: What Claude’s Proofs Say About The Limits Of Fuzz Testing on ThorstenMeyerAI.com
TL;DR
Anthropic’s Frontier Red Team and Theorem reported that Claude proved a no-crash property for 239 fuzz-test entry points across 123 open-source libraries. The work also found bugs, but the proofs apply to specific compiled RISC-V programs and stated assumptions—not every version or use of the software.
Anthropic’s Frontier Red Team and collaborator Theorem said on October 22 that Claude had proved a no-crash property for 239 fuzz-test entry points across 123 open-source libraries. The proofs concern compiled RISC-V programs under specific assumptions, and the team said the work found bugs that years of fuzzing had not detected—an example of AI-assisted formal verification extending software testing, not replacing it.
The team used each library’s existing fuzz test as a specification: for every input smaller than 64 MB, the compiled program must not crash. The property also rules out AddressSanitizer memory errors and failed assertions within the modelled system. The approach avoids writing a broad new definition of what each library is supposed to do, but it proves only the property expressed by that test.
According to the project description, the libraries and tests were compiled into RISC-V executables with AddressSanitizer instrumentation. Theorem supplied formal models of RISC-V instructions and Linux processes; Claude generated proofs in Rocq, a proof assistant whose checker verifies whether a proof follows from its stated assumptions. When a proof attempt exposed a failure, the system could identify a possible bug, patch the code, regenerate the specification and try again.
The output was large: roughly 180 million lines of Rocq proof. Anthropic said a typical proof was about 600,000 lines and covered a binary with a median length of 18,000 RISC-V instructions. It reported finding hundreds of bugs, including cases involving large or unusually structured inputs and sequences of calls. The source says Anthropic is publishing proofs that needed no patching, some trusted components that were not already public, and specifications for fuzz tests the team could not prove.
Infographic 01 · From test to proof
Existing fuzz tests became specifications. Claude proved them.
Over a few weeks, Claude proved at the machine-code level that hundreds of real fuzz entry points can no longer crash, after patching the bugs it found.
The pipeline
From an existing test to a checked proof
- Compile. The library and its existing fuzz test become a RISC-V executable, instrumented with AddressSanitizer.
- Specify. Theorem’s RISC-V and Linux process semantics plus the no-crash property mechanically yield the specification.
- Prove. Claude writes the proof in Rocq. A failed attempt points at a possible bug; Claude patches it and proves the new spec.
- Check. The Rocq proof checker verifies the proof. Virtually none of the proof needs human review.
Fuzzing vs. proof
Same entry point, different guarantee
| Fuzzing | Proof | |
|---|---|---|
| Inputs | Fuzzing: Generated samples, typically capped at 1 MB | Proof: Every input under 64 MB |
| Paths | Fuzzing: Guided by code coverage, no guarantee | Proof: Every path reachable from the entry point |
| Result | Fuzzing: Bugs found so far | Proof: No crash left to find on the modelled system |
Typical proof: about 600,000 lines for a binary with a median length of 18,000 RISC-V instructions.
“If Claude can prove this spec, the fuzz test on RISC-V becomes superfluous.”Anthropic, 22 Oct 2026
Source: Anthropic, “LLMs are making formal software verification feasible at a much larger scale” (22 Oct 2026).
Powered by Thorsten Meyer AI
Where Proofs Extend Fuzzing
Fuzz testing runs a large number of inputs through software and records crashes or other failures. It can be highly effective, but it samples possible executions: a rare code path may remain untouched even after years of testing. A successful proof, by contrast, covers every execution represented by its formal model and theorem. That difference can expose defects requiring inputs or call sequences that ordinary fuzzing is unlikely to reach.
The report describes bugs tied to inputs around 20 MB with a rare layout, an image-decoder case requiring a 64 MB input and more than 2 GB of memory, and a defect requiring a particular sequence of calls across two handles to the same file. It also says the process rediscovered CVE-2026-56132 in libexpat and found a logic bug involving a file-loading restriction. These examples illustrate both the reach and the limits of the method: proof findings depend on the chosen entry points and properties.
For software maintainers, the possible benefit is a machine-checked guarantee about a specific class of failures, rather than another finite batch of test results. The cost remains a major constraint. Anthropic says some proofs consume hundreds of millions of tokens, though newer models and reuse of shared proofs can reduce the effort. The project’s scale is a report of what the team achieved, not evidence that the same process is already practical for every codebase.
Popular right now

iRobot Roomba Plus 405 (G181) 2-in-1 Vacuum and Mop Robot with AutoWash Dock

Ninja PB051 Single-Serve Coffee Maker for Pods and Grounds

Ninja Crispi 4-in-1 Portable Glass Air Fryer, Grey, FN101GY
As an affiliate, we earn on qualifying purchases.
From Existing Tests to Rocq
Formal verification attempts to establish mathematically that a program satisfies a stated property. Its long-standing challenge is often the specification: teams must define precisely what “correct” means before proving it. Anthropic and Theorem narrowed that task by starting with existing fuzz tests, treating their crash conditions as the property to verify.
The resulting claim is deliberately narrower than “the library is bug-free.” The reported proofs cover single-threaded, static RISC-V binaries linked against musl, with inputs below the stated size limit and the assumptions encoded in the formal models. They do not automatically establish the behavior of the x86 or ARM builds linked against glibc that many users run.
Anthropic characterizes the work as, to its knowledge, the first large-scale use of AI for formal verification of production software at the assembly-code level. It also notes that the proof checker is not the only trusted element: the formal models, theorem statements and parts of the software and hardware toolchain matter. The report says proof volume does not require human review line by line, but the reliability of the result still depends on those foundations.
„“Formally verified” does not mean bug-free.“
— Anthropic’s report
What the Proofs Do Not Cover
The report does not establish that the same guarantees hold for the libraries’ commonly used x86 or ARM builds, different system libraries, multithreaded execution, or inputs outside the specified limit. Nor does a no-crash theorem rule out every possible defect: a bug that does not trigger the tested assertion or memory-safety condition can remain outside the proof. The file-restriction logic bug described in the report underscores that the results depend on what is specified and how failures are represented.
It is also unclear from the supplied account how many reported bugs were independently confirmed, fixed, or disclosed to affected maintainers, and what the full token and compute costs were across the project. The source says some proof attempts did not finish and that Anthropic is releasing certain proof materials, but it does not provide a complete breakdown of coverage, failure rates or adoption by library teams.
Publication and Practical Adoption
Anthropic says it is publishing successful proofs that required no code patch, previously unavailable trusted components, and specifications for tests the system could not prove. Those materials should let other researchers examine the claims and assess which parts of the process can be reproduced.
The next practical test is whether maintainers can use the method across more libraries and target configurations at a manageable cost. Further reporting would need to establish how the proofs transfer to production builds, how discovered bugs are handled, and whether shared proof components and newer models lower the reported token burden. Until then, the result is evidence that AI can help generate machine-checked guarantees for defined properties—not a general certification that the covered libraries are secure.
Key Questions
What did Claude prove?
According to Anthropic and Theorem, Claude proved that 239 fuzz-test entry points in 123 open-source libraries did not crash for inputs under 64 MB, under the specified models and assumptions. The property includes no AddressSanitizer memory error or failed assertion.
Does this mean the libraries are bug-free?
No. The proofs cover particular properties, entry points and compiled configurations. Bugs outside those properties, or in other builds and execution conditions, are not ruled out.
How is formal proof different from fuzz testing?
Fuzzing tests many generated inputs but cannot guarantee that every possible path is exercised. A formal proof can cover all executions represented by its model, provided the specification and assumptions are correct.
What software configurations were covered?
The reported work covered single-threaded static RISC-V binaries linked against musl. The source says the proofs do not automatically apply to x86 or ARM builds linked against glibc.
What remains uncertain about the project?
The supplied report does not give a full account of bug confirmation and remediation, total compute costs, or how readily the proofs transfer to production builds. It also says some proof attempts did not finish.
Source: ThorstenMeyerAI.com