🔍 Read the full analysis: The Case For Claude In Formal Verification—and Its Limits on ThorstenMeyerAI.com
Get the little things that make your day 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’s Frontier Red Team and Theorem say Claude produced Rocq-checked proofs that 239 fuzz-test entry points across 123 open-source libraries do not crash on inputs under 64 MB, subject to stated assumptions. The effort also found hundreds of bugs, but the proofs apply to specific compiled RISC-V binaries and do not establish that the libraries are bug-free across other platforms or behaviors.
Anthropic’s Frontier Red Team and collaborator Theorem reported on October 22 that Claude produced machine-checked proofs for 239 fuzz-test entry points across 123 open-source libraries. The proofs cover a specific property of compiled RISC-V programs: under stated assumptions, each entry point does not crash on inputs smaller than 64 MB, a result the teams say also exposed hundreds of bugs that existing fuzzing had missed.
The work turns existing fuzz tests into formal specifications. A fuzz test supplies inputs to a small entry point in a library, with crashes treated as failures. The researchers compiled each library and test into a RISC-V executable, added AddressSanitizer instrumentation, and used formal models of RISC-V instructions and Linux processes to define the property to prove.
Claude then generated proofs in Rocq, a proof-assistant language and system. Rocq’s checker verifies whether a proof follows from the specification; it does not rely on a reader manually inspecting every generated line. Anthropic says the proof corpus amounts to about 180 million lines of Rocq, with a typical proof around 600,000 lines. The company says it is releasing proofs that did not require patches, some previously unpublished trusted components, and specifications for tests it could not prove.
The reported bugs included cases that are difficult for fuzzers to reach, according to Anthropic. Examples in the source account include a decompressor issue requiring an input of about 20 MB with a particular layout, an image-decoder read requiring a 64 MB input and more than 2 GB of memory, and a bug dependent on a sequence of calls using two handles to the same file. The team also reported rediscovering CVE-2026-56132 in libexpat. These are examples described by the researchers, not evidence that every bug class or execution path in the libraries was covered.
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 Extend Beyond Fuzzing
Fuzzing tests many inputs but cannot establish that every possible input has been tried. A formal proof can establish a stated property for all inputs within its model, which is why the reported approach may find conditions that random or mutated test inputs rarely reach. It also changes the role of AI: Claude generates the proof, while a separate proof checker tests its validity against a formal specification.
That distinction matters for software security. Anthropic argues that stronger automated methods are needed as AI systems become more capable of finding and exploiting software flaws. The reported results suggest that machine-generated proofs could help expand formal verification beyond projects with large specialist teams. However, the achievement is a proof of a defined property in a defined build—not a general certificate that a library is secure or correct.
Cost remains a practical constraint. Anthropic says some proofs can consume hundreds of millions of tokens, although newer models and reuse of shared proofs can reduce the amount needed. The project shows scale, but the source account does not establish how affordable or repeatable the method would be across ordinary software-development teams and diverse production systems.
Products Worth Considering
LEVOIT Vital 200S-P Smart Air Purifier for Large Rooms, White
Therabody Theragun Prime 6th Gen Deep Tissue Massage Gun
Oura Ring 5 Smart Ring, Silver, Size 7
As an affiliate, we earn on qualifying purchases.
How Existing Tests Became Specifications
Formal verification uses mathematical reasoning to show that software satisfies a specification. The difficult step is often defining what correct behavior means. In this project, Anthropic and Theorem used an existing fuzz test as a narrower specification: for every input below the stated size limit, the instrumented program must not crash. That includes avoiding AddressSanitizer memory errors and failed assertions, subject to the model and assumptions used.
The reported scope is specific: single-threaded, static RISC-V binaries linked against musl. Most readers’ systems may run different builds, including x86 or ARM binaries linked against glibc. A proof for the RISC-V build does not automatically transfer to those versions. Nor does a no-crash result cover every possible functional, security, or availability requirement.
Anthropic describes the effort as, to its knowledge, the first large-scale application of AI to formal verification of production software at the assembly-code level. That is the company’s characterization. The article’s source also notes that verification has historically been costly, citing the seL4 microkernel project as an example of substantial human effort. The new work tests whether AI can reduce some of that burden, but does not by itself show that the broader economics have changed.
What the Proofs Do Not Cover
The results do not show that the 123 libraries are bug-free. They cover a no-crash property for selected fuzz-test entry points under a 64 MB input limit and within specified models. The work does not establish that all library functions, inputs, configurations, or interactions were proved safe. Some bugs, including a reported logic flaw involving file-loading restrictions, may not be captured by a property defined only around crashes.
The proofs also depend on assumptions and trusted components, including the formal models, theorem statements, Rocq checker, and supporting software and hardware noted by Anthropic. The source account does not give a full independent assessment of those dependencies, the severity and remediation status of every reported bug, or the project’s complete computational cost. It is also unclear how often the method will succeed on different codebases or on the platform builds most commonly deployed.
Releases and Replication Ahead
Anthropic says it is publishing the proofs that required no patches, trusted components that were not already public, and specifications for fuzz tests it could not prove. Those materials may allow researchers and maintainers to inspect the claims and test whether the approach can be reproduced. The source account does not specify a schedule for every release or say when fixes for all reported bugs will be available.
The next practical test is whether independent teams can verify the artifacts, reproduce results, and extend the method to other architectures and production configurations. Until then, the report supports a narrower conclusion: Claude can help generate formal proofs for selected compiled programs, while the value of the method depends on its scope, assumptions, reproducibility, and cost.
Key Questions
What did Claude prove?
According to Anthropic and Theorem, Claude produced Rocq-checked proofs that 239 selected fuzz-test entry points across 123 libraries do not crash for inputs under 64 MB in the modeled builds, subject to stated assumptions. This is not a proof that the libraries are bug-free.
Does this cover software people run on ordinary computers?
Not automatically. The reported proofs concern single-threaded, static RISC-V binaries linked against musl. They do not directly establish the same results for x86 or ARM builds or binaries linked against glibc.
How did the team check Claude’s proofs?
Claude generated proofs in Rocq, and Rocq’s proof checker checked them against formal specifications. The method still relies on trusted models, theorem statements, and supporting components.
What remains uncertain about the results?
The full severity and status of the reported bugs, the complete cost of the work, and how well the method generalizes to other software and platforms are not established in the source account. The proofs also cover selected properties and entry points, not every behavior of each library.
Source: ThorstenMeyerAI.com
