On October 22, Anthropic and Theorem Labs published research showing Claude can generate machine-checked formal proofs for real production software — not toy examples, not simplified models — at a scale no human team has matched. Working directly on compiled RISC-V assembly, Claude verified 239 fuzz-test entry points across 123 open-source libraries, producing 180 million lines of Rocq proof code. In the process, it discovered hundreds of bugs that years of continuous fuzzing had missed, including a CVE in libexpat and a decade-old vulnerability in a widely-used PDF reader. The proofs are public. The pipeline is reproducible. This changes the calculus on what “tested code” means.
What Fuzzing Couldn’t Find #
Google’s OSS-Fuzz has run trillions of automated tests against these libraries. It is the best continuous fuzzing infrastructure in existence. Claude’s proofs still found bugs it missed.
The reason is not that OSS-Fuzz is bad — it is excellent. The reason is structural. Fuzzing samples the input space probabilistically. For most bugs, that is sufficient. But some bugs only trigger on inputs so specific — a precisely shaped 20 MB decompressor input, a 64 MB image file combined with 2+ GB memory layout — that random generation effectively never reaches them. Fuzzing cannot close that category of gap. Formal verification eliminates it by proving the property holds for every input within the model’s bounds, exhaustively.
The bugs Claude found are not hypothetical:
- A counter underflow in a decompressor causing out-of-bounds writes — requires a specific ~20 MB input layout
- An out-of-bounds read in an image decoder — requires 64 MB input and over 2 GB memory
- CVE-2026-56132 in libexpat — triggered by deeply nested input
- A decade-old logic bug in a widely-used PDF reader — discovered within one week of starting verification
These are not theoretical. They are assigned CVEs, filed patches, and confirmed fixes.
How the Pipeline Works #
The methodology converts existing OSS-Fuzz tests into formal specifications, then has Claude prove those specifications hold against the compiled binary. The steps:
- Source code and fuzz test compiled to RISC-V binary
- Formal semantics and the no-crash property mechanically generate a Rocq specification
- Claude writes the proof autonomously
- The Rocq proof checker validates the proof against the specification
- If Claude discovers a bug during proof attempts: it patches the code, the spec regenerates, Claude reproves
Individual proofs average around 600,000 lines of Rocq to cover binaries with a median of 18,000 RISC-V instructions. cJSON’s 391-line C parser received a 630,000-line proof. The numbers are large because proofs must account for every reachable machine state — the Rocq checker does the validation, so no human reads these line by line.
What “Proved Correct” Actually Means #
This is where precision matters. The proofs cover single-threaded, static RISC-V binaries linked against musl libc. Most production deployments run on x86 or ARM with dynamic glibc linking. The gap between the proof environment and production is real.
That limitation does not diminish the bugs found — a CVE is a CVE regardless of what architecture triggered it. And Theorem Labs’ roadmap explicitly targets glibc, OpenSSL, and cURL next, moving toward the architectures software actually ships on. Qualifying open-source projects can enroll in Theorem’s OSS Verify program for free. The onboarding requires a project.yaml, a Dockerfile, and a build script producing static riscv64 binaries. Anthropic also published the full research post with proof subsets and RISC-V semantics openly available.
The Economics Are Changing #
Verifying OpenSSL fully costs around $220,000 at current token prices. Spread across every downstream package that ships OpenSSL, that is roughly $14 per package. Opus 5.5 required 40% fewer tokens than Opus 5 for identical verification tasks. Proof reuse cut token requirements another 17% when agents shared verified components across similar codebases.
The cost curve is falling in every direction simultaneously — better models, cheaper inference, reusable proofs, shared semantics. Formal verification as a routine part of CI is not yet here for most teams, but the trajectory is clear. A useful primer on how formal verification compares to testing and auditing covers the tradeoffs in depth if the approach is new to you.
What This Means for Your Security Posture #
If your library handles untrusted input and you consider continuous fuzzing sufficient assurance, this research is a direct challenge to that assumption. Fuzzing finds most things. Formal verification eliminates a class of rare-but-real bugs that fuzzing cannot reach in practice. The question for high-assurance code is no longer whether formal verification is worth doing — it is when the tooling becomes accessible enough to be mandatory. Claude just advanced that timeline considerably.