🔍 Read the full analysis: Does Claude’s Work Turn Test Results Into Proof? on ThorstenMeyerAI.com
Get business pricing on office and shipping supplies
- Business-only prices and quantity discounts
- Tax-exempt purchasing
- Multiple users, one account, clear invoices
TL;DR
Anthropic’s Frontier Red Team and Theorem say Claude helped prove that 239 fuzz-test entry points across 123 open-source libraries do not crash for any input under 64 MB in the modelled systems. The Rocq proof checker verified the proofs, and the process found bugs missed by fuzzing; the results do not establish that the libraries are bug-free or that common builds have the same guarantees.
Anthropic’s Frontier Red Team and collaborator Theorem reported on October 22 that Claude generated formal proofs for 239 fuzz-test entry points in 123 open-source libraries, establishing a specific no-crash property for compiled programs under stated conditions. The work matters because the machine-checked proofs also exposed bugs that years of fuzzing had missed, while the results apply only to a defined set of binaries and assumptions—not to every build or behavior of the libraries.
The team used each library’s existing fuzz test as a specification. Fuzz tests send many generated or altered inputs to a program and treat crashes as evidence of defects. For the reported proofs, the property was that a compiled program would not crash for any input under 64 megabytes, including through an AddressSanitizer memory error or failed assertion. This guarantee applies to the modelled program and stated assumptions, not to every possible meaning of “correct.”
According to Anthropic’s account, the libraries and tests were compiled as RISC-V executables, instrumented with AddressSanitizer, and described using Theorem’s formal models of RISC-V instructions and Linux processes. Claude then wrote proofs in Rocq, a proof assistant whose checker verified whether each proof followed from its specification. When a proof attempt failed, the team could investigate a potential bug, patch the code, regenerate the specification and attempt a new proof.
The work produced about 180 million lines of Rocq proofs. Anthropic said a typical proof was roughly 600,000 lines and concerned a binary with a median length of 18,000 RISC-V instructions. It reported that the process found hundreds of bugs, including memory-safety issues and logic errors. Anthropic said the proofs that did not require patches, along with some supporting materials, are being published.
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
What Machine-Checked Proofs Add
The result shows how formal verification might be applied to much more software than has traditionally received it. Fuzzing can test large numbers of inputs, but it cannot establish that every reachable path has been exercised. A proof, if its specification and model are sound, can establish the stated property across all inputs in the covered range. That difference helps explain why this approach found bugs involving rare input layouts, large inputs or sequences of calls that ordinary fuzzing may not reach.
The findings also put a limit on what the headline achievement means. The proved property is that particular test entry points do not crash under specified conditions; it is not a general proof of software quality, security or absence of vulnerabilities. One example in the source account was a file-loading restriction that was not always enforced, a logic problem that did not necessarily cause a crash. The method’s value may lie both in proving narrow guarantees and in using proof attempts to expose defects—not in declaring whole libraries safe.
Cost remains a practical barrier. Anthropic’s account says proof generation can consume hundreds of millions of tokens, although newer models and reuse of existing proofs can reduce the amount needed. The work suggests AI can help produce formal proofs, but it does not yet show that the method is inexpensive or straightforward to apply across the software people use.
Products Worth Considering
Apple MacBook Air 13-inch with M5 Chip, 16GB Memory, 512GB SSD, Silver
Apple MacBook Air 15-inch Laptop with M5 Chip, 16GB Memory, 512GB SSD, Midnight
Logitech MX Master 4 Ergonomic Wireless Mouse with Haptic Feedback, Graphite
As an affiliate, we earn on qualifying purchases.
From Fuzz Tests to Rocq Proofs
Formal verification has often been costly because engineers must state precisely what a system should do and then prove that it does so. Anthropic’s account cites the seL4 microkernel as an example of the effort involved: two person-years to build and 20 person-years to verify. The experiment takes a narrower route by treating an existing fuzz test as the specification, rather than attempting to prove every aspect of a library’s behavior.
In the reported setup, the target was a single-threaded, static RISC-V binary linked against musl. This is a deliberately specific model, not the usual configuration for many deployed applications. The source says the team’s trusted base includes the formal models, theorem statements and Rocq checker, alongside underlying components such as hardware, the operating system and the OCaml compiler used by Rocq. The checker validates the proof against the specification; it does not independently establish that the specification captures every property users care about.
Anthropic described the work as, to its knowledge, the first large-scale AI application of formal verification to production software at the assembly-code level. That wording is the company’s characterization of its report. The reported scale—123 OSS-Fuzz libraries—is notable, but the narrow property and target configuration are central to interpreting it.
“The work is, “to our knowledge,” the first large-scale use of AI to apply formal verification to production software at the assembly code level.”
— Anthropic
Limits of the Verified Binaries
The report does not establish that the libraries are bug-free. It addresses a particular no-crash property for specified fuzz-test entry points and inputs under 64 MB, in a single-threaded, static RISC-V and musl setup. The source specifically warns that this is not the same as proving the commonly used x86 or ARM builds linked against glibc safe.
Other limits include the assumptions built into the formal models and the scope of the fuzz tests used as specifications. A property not expressed by a test may not be covered, and a program can contain serious logic defects without crashing. The source material does not give a complete breakdown of the bugs found, how many were fixed or independently confirmed, or the total cost and compute resources for the full project. It also says proofs can require very large token budgets, but provides no single average cost for the 239 entry points.
Published Proofs and Further Checks
Anthropic said it is publishing proofs that did not require code patching, previously unavailable trusted components, and specifications for fuzz tests that it could not prove. Those materials give other researchers and developers a way to inspect the stated properties and the verification setup. The available source account does not specify a publication schedule for every artifact.
Further work would need to show how well the method transfers to other architectures, operating-system configurations and software properties, and whether proof costs can fall enough for routine use. Readers should also look for details on the disposition of the reported bugs and independent examination of the proofs and assumptions. Until then, the confirmed result is a large set of checked proofs for narrowly defined binaries—not a blanket security certification for the source libraries.
Key Questions
What did Claude prove?
It generated proofs that 239 fuzz-test entry points across 123 libraries would not crash for inputs under 64 MB in the specified model, including no AddressSanitizer memory error or failed assertion. The proofs were checked by Rocq.
Does this mean the libraries are bug-free?
No. The results establish a limited property for specific compiled binaries and test entry points. They do not prove that every behavior is correct or that every bug is absent.
Why did the process find bugs that fuzzers missed?
Fuzzers test selected inputs and paths, while a successful proof must account for every path reachable within its specification and model. Some reported defects involved rare input structures, large inputs or sequences of calls.
Do the guarantees apply to software people commonly run?
Not necessarily. The reported proofs cover single-threaded, static RISC-V binaries linked against musl. Anthropic’s account says that does not automatically establish the same properties for common x86 or ARM builds linked against glibc.
What is the main remaining obstacle?
Cost and scope remain open issues. Anthropic says some proofs can consume hundreds of millions of tokens, and the report does not establish that the method can yet be applied affordably across typical software builds.
Source: ThorstenMeyerAI.com
