🔍 Read the full analysis: Does Turning Fuzz Tests Into Proofs Change Software Verification? on ThorstenMeyerAI.com
Prime made for students and young adults
- Fast, free delivery for dorm and study essentials
- Prime Video and Amazon Music included
- Member-only deals
TL;DR
Anthropic’s Frontier Red Team and Theorem report that Claude produced Rocq-checked proofs for 239 fuzz-test entry points across 123 open-source libraries. The proofs establish a defined no-crash property for specific compiled RISC-V programs, not that the libraries are bug-free or that their commonly used builds are safe.
Anthropic’s Frontier Red Team and collaborator Theorem reported on October 22 that Claude produced machine-checked proofs for 239 fuzz-test entry points in 123 open-source libraries. The proofs cover a specific property of compiled RISC-V programs—no crash on inputs below 64 MB under stated assumptions—and the teams say the work also exposed bugs missed by years of fuzzing.
The method turns an existing fuzz test into a formal specification. Each library and test is compiled into an instrumented RISC-V executable; Claude then writes a proof in Rocq that the program cannot crash under the specified conditions. The Rocq proof checker checks the result against the specification. When a proof attempt fails, the failure can point to a potential bug, which the system may patch before generating a new specification and proof.
The reported project ran over several weeks and produced about 180 million lines of Rocq proofs. Anthropic says a typical proof was about 600,000 lines, covering a binary with a median length of 18,000 RISC-V instructions. The company says the proofs that required no patching, some previously unpublished trusted components, and specifications for tests it could not prove are being published.
Anthropic and Theorem say the process found hundreds of bugs, including memory errors that required unusually large inputs or particular sequences of operations. Examples in the source include an out-of-bounds write requiring an input of 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. The report also describes a file-loading restriction that was not always enforced, a logic flaw that did not necessarily cause a crash.
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 Fuzzing
Fuzzers try many inputs and report failures they encounter, but they cannot establish that every possible input has been tested. A machine-checked proof can cover all inputs described by its specification and assumptions. If the reported proof applies, further fuzzing of that exact entry point cannot find a crash within the modelled conditions. That makes the approach potentially useful for identifying rare, input-dependent failures that conventional testing may not reach.
The project also puts attention on the cost of formal verification. Anthropic cites the seL4 microkernel as an example of the human effort traditionally involved: two person-years to build and 20 person-years to verify. In this project, AI generated the proofs while Rocq checked them. That division matters because checking a proof can be automated even when producing one is difficult. But the reported scale—hundreds of millions of proof lines and potentially hundreds of millions of tokens—shows that cost and computing demands remain material constraints.
For software users, the immediate result is not a general safety guarantee. The value lies in a method that could turn selected existing tests into mechanically checked claims, while also making failures easier to locate. Whether it can be extended economically across larger projects and the platforms people actually run remains an open issue.
As an affiliate, we earn on qualifying purchases.
From Existing Tests to Specifications
Fuzz testing uses generated or mutated inputs to exercise a program and detect crashes. The reported work starts with OSS-Fuzz entry-point tests rather than attempting to specify an entire library’s intended behavior. A test that treats a crash as failure can be recast as a property: for every input within a defined size limit, execution does not crash.
The teams compiled the programs for RISC-V and used AddressSanitizer instrumentation so certain improper memory accesses would cause a crash. The formal model covers RISC-V instructions and Linux processes; Claude generated Rocq proofs against the resulting specifications. The proof checker verifies the proof, but the overall result still relies on trusted components, including the models, theorem statements, checker, hardware, operating system and OCaml compiler used by Rocq.
The source says the work covers single-threaded, static RISC-V binaries linked against musl. It does not establish the same properties for the x86 or ARM builds linked with glibc that are more commonly used. The source also notes that some fuzz tests encode higher-level properties: for example, a compression test can assert that decompression restores the original input. A successful proof of that test can establish more than the absence of a memory error, but only for the property actually specified.
“To its knowledge, this is the first large-scale use of AI to apply formal verification to production software at the assembly code level.”
— Anthropic, describing the project
As an affiliate, we earn on qualifying purchases.
The Proofs Have Defined Limits
The reported result does not establish that the 123 libraries are free of bugs. It addresses specific test entry points and properties under stated assumptions; behavior outside those specifications may remain unchecked. The source does not provide enough detail here to independently assess every theorem, proof obligation or reported bug.
The platform gap is also material: the proofs concern single-threaded static RISC-V binaries linked against musl, not the x86 and ARM builds with glibc that many users run. The source does not say that equivalent proofs have been produced for those configurations. Nor does it quantify the full computational cost per library or show how often this method can be applied to projects beyond the reported sample.
Some reported bugs were found during attempts that did not result in completed proofs. The source distinguishes those findings from the verified no-crash claims, but does not give a complete breakdown of how many bugs were patched, how many proofs completed after patches, or how maintainers responded to each disclosure.
As an affiliate, we earn on qualifying purchases.
Publication and Broader Testing
Anthropic says it is publishing proofs that did not require code patching, trusted components that were not already public, and specifications for fuzz tests the system could not prove. Those materials will allow readers and other researchers to inspect the formal claims and their limits.
The next test for the approach is whether teams can reproduce and extend the results, reduce the token and compute costs, and cover builds closer to those used in production. The source does not give a schedule for proofs on other architectures or for a broader deployment of the method. Until then, the reported work is evidence that AI can help generate large formal proofs for a bounded set of compiled programs—not evidence that software verification has become comprehensive or inexpensive.
As an affiliate, we earn on qualifying purchases.
Key Questions
What did Claude prove?
According to Anthropic and Theorem, it proved that 239 specified fuzz-test entry points in compiled RISC-V programs do not crash on inputs below 64 MB, subject to the stated models and assumptions. The claim is limited to those programs and specifications.
Does this mean the libraries are bug-free?
No. A proof covers the property written into its specification, not every possible defect or behavior. The teams reported finding hundreds of bugs, and the source explicitly cautions that formal verification here does not mean a library is bug-free.
How is this different from fuzz testing?
Fuzzing tries many inputs and detects failures reached during testing. A proof can establish the specified property across all inputs covered by its model and assumptions. In this work, existing fuzz tests supplied the starting point for those specifications.
Does the result cover software people run on x86 or ARM?
Not as described in the source. The reported proofs cover single-threaded static RISC-V binaries linked against musl. The source says they do not establish the same result for x86 or ARM builds linked with glibc.
What remains to be tested?
Researchers and maintainers can inspect the published proofs and specifications, while further work would be needed to establish results across other architectures, build configurations and larger software sets. The source does not provide a timetable for that work.
Source: ThorstenMeyerAI.com
Halloween Picks
halloween
As an affiliate, we earn on qualifying purchases.
