🔍 Read the full analysis: Anthropic’s Work Puts Claude At The Intersection Of Testing And Proof on ThorstenMeyerAI.com
Get hardware and tech essentials delivered free with Prime
- Fast, free delivery on millions of items
- Prime Video, Amazon Music and more included
- Member-only deals all year
TL;DR
Anthropic and verification company Theorem report that Claude proved a defined no-crash property for 239 entry points in 123 open-source libraries, checking compiled RISC-V programs with the Rocq proof assistant. The effort also found hundreds of bugs, but the proofs apply only to specific builds and assumptions—not to the libraries in every environment or to software generally.
Anthropic’s Frontier Red Team and collaborator Theorem said on October 22 that Claude had produced proofs covering 239 fuzz-test entry points in 123 open-source libraries. Checked by the Rocq proof assistant, the proofs establish that specific compiled RISC-V programs do not crash on inputs under 64 MB, subject to stated assumptions—a defined result that the teams say also helped uncover hundreds of bugs.
The project used existing fuzz tests as specifications rather than trying to define software correctness from scratch. Each library and test was compiled into a RISC-V executable and instrumented with AddressSanitizer, which makes certain improper memory accesses cause a crash. The target property was that the test would not crash on any input below the stated 64 MB limit.
Claude generated proofs in Rocq, a proof assistant whose checker verifies whether a proof follows from its formal specification. Theorem supplied formal models of RISC-V instructions and Linux processes. When a proof attempt failed, the failure could point to a possible bug; the team says Claude could patch the code, regenerate the specification and try to prove the revised program.
Anthropic reports that the proofs amount to about 180 million lines of Rocq. A typical proof was about 600,000 lines, and the median binary contained 18,000 RISC-V instructions. The company says the work took a few weeks. It also says the proofs can consume hundreds of millions of tokens, making cost a substantial constraint, though newer models and reuse of shared proofs can reduce the amount of work.
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
Proofs Reach Beyond Fuzz Testing
Fuzzers test software by feeding it many inputs and observing whether it crashes. That can find serious defects, but it cannot establish that every possible input or execution path has been checked. A formal proof can cover all paths allowed by its model and assumptions. If the no-crash property is proved for a particular entry point, further fuzzing cannot find a crash within that same defined scope.
The teams say the process found hundreds of bugs, including cases that ordinary fuzzing was unlikely to reach. Examples in the source account include a decompressor defect triggered by an input around 20 MB with a rare layout, and an image-decoder read error requiring a 64 MB input and more than 2 GB of memory. Another issue depended on a sequence of calls across two handles to the same file. These examples illustrate how exhaustive reasoning can expose paths that random testing may not exercise.
The approach could matter to developers of widely used libraries, where a defect can affect many applications. But the result is not a general guarantee that AI has made software safe. The proof covers a particular entry point, compiled program and property. Its practical value depends on the accuracy of the formal models, the theorem being proved, the build matching deployed software and the cost of producing proofs at scale.
As an affiliate, we earn on qualifying purchases.
From Existing Tests to Formal Proof
Formal verification has traditionally demanded substantial specialist effort. Anthropic’s account cites the seL4 microkernel as an example: its development took two person-years and its verification took 20 person-years. That level of work has limited formal methods largely to settings where high assurance justifies the expense.
Using fuzz tests as the starting point gives the system a narrower, existing specification: the test must not crash for any input within the specified range. This does not answer every question about whether a library behaves correctly. It does make a particular safety property explicit and testable against the compiled code.
The work is performed on single-threaded, static RISC-V binaries linked against musl. That differs from common production builds, which may use x86 or ARM processors and glibc. Anthropic says it is publishing proofs that did not require patches, certain trusted components that were not already public, and specifications for tests it could not prove. The company describes the effort, to its knowledge, as the first large-scale AI use of formal verification on production software at assembly-code level.
“The process “discovered hundreds of bugs.””
— Anthropic and Theorem, as summarized in the October 22 report
As an affiliate, we earn on qualifying purchases.
Where the Proofs Stop
A proof is not a claim that a library is bug-free. The reported theorem concerns whether a specified fuzz-test entry point crashes on inputs below 64 MB in the modeled program. It does not establish that the library has no logic errors, that every interface is safe, or that all possible bugs have been found.
The results also depend on assumptions and trusted components, including the formal models of RISC-V and Linux processes, the exact theorem statements and the Rocq checker. Anthropic notes additional dependencies involving hardware, the operating system and the OCaml compiler used by Rocq. The source does not establish that the proofs transfer unchanged to the x86 or ARM builds with glibc that many users run.
The report says some proof attempts did not finish and that producing proofs can require hundreds of millions of tokens. The supplied material does not give a complete cost breakdown, a full independent audit of every result, or details showing how many of the reported bugs have been fixed and released. It also does not quantify how often the approach will be economical across other codebases.
As an affiliate, we earn on qualifying purchases.
Publication and Broader Testing
Anthropic says it is making selected materials available: proofs that did not require code patches, previously unpublished trusted components and specifications for fuzz tests it could not prove. Those releases give outside researchers and developers material to inspect, although the source does not specify a schedule for each publication.
The next practical test is whether independent reviewers can validate the formal models and theorem statements, and whether maintainers can apply relevant findings to the builds used in production. Wider use will also depend on reducing proof-generation costs and extending the method beyond the particular RISC-V, musl and single-threaded configuration described in the report.
Until those questions are answered, the result is best read as a demonstration of a defined verification workflow—not a blanket certification of the libraries or a replacement for other security work. The reported proofs address one property under stated conditions; fuzzing, review and testing remain relevant to properties outside that scope.
As an affiliate, we earn on qualifying purchases.
Key Questions
What did Claude prove?
It generated proofs that 239 specified fuzz-test entry points in 123 open-source libraries would not crash on inputs under 64 MB, for the modeled compiled programs and under stated assumptions.Does this mean the libraries are bug-free?
No. The proofs establish a defined no-crash property for particular entry points and builds. They do not rule out every bug, logic error or vulnerability in a library.How were the proofs checked?
Claude generated proofs in Rocq. Rocq’s proof checker checked them against specifications built from the fuzz tests and formal models of the machine instructions and Linux processes.Why did the effort find bugs fuzzers missed?
Fuzzers sample inputs and execution paths. A successful proof must account for every path covered by its formal model, which can expose defects that random or mutated test inputs do not reach.Do the results apply to software people commonly run?
Not automatically. The reported proofs concern single-threaded, static RISC-V binaries linked against musl. The source says many commonly used builds instead target x86 or ARM and use glibc.Source: ThorstenMeyerAI.com
Evergreen bestsellers Picks
bestsellers
As an affiliate, we earn on qualifying purchases.
