🔍 Read the full analysis: How Far Does Claude’s Formal Verification Work Take Us? on ThorstenMeyerAI.com
Get the latest gadgets 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 proved a no-crash property for 239 entry points across 123 open-source libraries, with proofs checked by Rocq. The results cover specific compiled RISC-V binaries and inputs under 64 MB, not every build or all possible software defects; the team also reports finding hundreds of bugs.
Anthropic’s Frontier Red Team and formal-verification company Theorem say Claude proved no-crash properties for 239 fuzz-test entry points across 123 open-source libraries, with a proof checker validating the results against compiled machine code. The work, reported October 22, also uncovered bugs the teams say years of fuzzing had missed, but its guarantees apply only to specific programs and assumptions—not to the libraries’ every build or to software being bug-free.
The team used existing fuzz tests as specifications: for each selected entry point, the property was that the compiled program would not crash on any input below 64 megabytes. The binaries were compiled for RISC-V and instrumented with AddressSanitizer, which makes certain improper memory accesses trigger a crash. Claude generated proofs in Rocq, whose checker evaluated whether those proofs established the stated properties.
Anthropic and Theorem report completing the work over a few weeks. The proof corpus totals about 180 million lines of Rocq; a typical proof was about 600,000 lines, covering a binary with a median of 18,000 RISC-V instructions. The companies say the proof checker, rather than a person reading every line, validated the proofs. Anthropic describes this as, to its knowledge, the first large-scale use of AI for formal verification of production software at the assembly-code level.
The researchers also report finding hundreds of bugs. Examples in the source account include memory errors requiring unusually large or structured inputs, and a flaw involving a sequence of calls across two handles to the same file. One issue was a rediscovery of CVE-2026-56132 in libexpat. The findings do not mean every reported bug was newly discovered by the project, nor that all affected software has been fixed.
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 Could Extend Software Testing
The result matters because fuzzing and formal verification provide different kinds of evidence. A fuzzer tries many inputs and can reveal crashes, but testing cannot by itself show that all possible inputs have been covered. A machine-checked proof can establish a specified property for every input in its defined range—provided the program model, theorem and assumptions accurately represent the system being discussed.
That distinction is relevant to security. A bug missed by ordinary test inputs may still be exploitable, while proof of a narrow property can rule out a defined class of failures in a particular binary. The project suggests AI could reduce some of the human effort involved in writing proofs. But its reported token demands—sometimes hundreds of millions, according to the source account—also make computational cost and reuse of existing proofs important practical questions.
The work does not establish that AI can automatically verify arbitrary software at low cost. It demonstrates a specific workflow applied to selected fuzz-test entry points, with results checked by Rocq. How much of that approach transfers to other architectures, larger applications or properties beyond crash behavior remains open.
As an affiliate, we earn on qualifying purchases.
Existing Fuzz Tests Became Specifications
Formal verification aims to prove that software meets a stated specification. Writing that specification is often difficult: developers must define what the program is supposed to do, not merely test some examples. In this project, Anthropic and Theorem sidestepped part of that challenge by taking a property already expressed by each fuzz test—typically, that the test should not crash—and turning it into a formal claim about the compiled executable.
The reported pipeline compiled the libraries and tests into instrumented RISC-V programs. Theorem supplied formal models of RISC-V instructions and Linux processes, while Claude generated Rocq proofs. When a proof attempt failed, the failure could help identify a possible defect; the team could patch code, regenerate the specification and attempt a new proof. A proof’s conclusion was limited to the exact theorem and modeled environment.
Anthropic says the work relied on trusted components including the formal models, the theorem statements and Rocq’s checker, with additional dependencies such as hardware, the operating system and the OCaml compiler. The source account says Anthropic is publishing proofs that did not require patches, previously unpublished trusted components, and specifications for fuzz tests it could not prove.
AddressSanitizer compatible software tools
As an affiliate, we earn on qualifying purchases.
As an affiliate, we earn on qualifying purchases.
Limits of the Verified Binaries
The proof guarantees are restricted to the single-threaded, static RISC-V binaries modeled by the project, linked against musl, and to the stated input limit and properties. The source account notes that most users run x86 or ARM builds linked with glibc. It does not establish that those different builds share the verified behavior.
A no-crash proof is also not a general proof of correctness or security. It covers the property encoded in the theorem, including any assertions and AddressSanitizer errors represented in the setup. It cannot establish that the program produces the right answer in every case, or that every security flaw has been removed. The source describes one logic bug that did not crash, illustrating why the scope of each specification matters.
Other open questions include how the full set of reported bugs was triaged, which have been patched or disclosed, and how the reported compute and token costs vary across libraries. The material also does not provide an independent replication of the results or quantify how often the method succeeds on projects outside this selection.
As an affiliate, we earn on qualifying purchases.
Publication and Broader Testing
Anthropic says it is releasing parts of the work, including proofs that did not require code patches and specifications for tests it could not prove. Those materials could let other researchers inspect the theorem statements, trusted components and proof-checking process. The account does not give a schedule for that release or say when all artifacts will be available.
The next practical test is whether teams can extend the approach beyond the selected RISC-V builds while keeping its assumptions explicit. Comparisons across architectures, more varied software and additional properties would help show where the method is reliable and what resources it requires. Until such evidence is available, the findings support a bounded claim: Claude helped produce machine-checked proofs for particular binaries and properties, not blanket guarantees about the libraries themselves.
As an affiliate, we earn on qualifying purchases.
Key Questions
What did Claude prove?
It generated Rocq proofs for a no-crash property at 239 fuzz-test entry points in 123 libraries. The reported property covered inputs under 64 MB for the modeled compiled programs, including specified AddressSanitizer errors and failed assertions.
Does this mean the libraries are bug-free?
No. The proofs cover specific binaries, inputs, assumptions and stated properties. They do not establish that every version, architecture or behavior is correct or secure.
How were the proofs checked?
Claude wrote proofs in Rocq, and Rocq’s proof checker checked them against formal specifications. The verification still depends on the accuracy of the models and theorem statements, as well as the trusted software and hardware components.
What bugs did the project report finding?
Anthropic and Theorem report hundreds of bugs, including memory errors requiring large or unusual inputs, a flaw involving calls across two file handles, and a rediscovery of CVE-2026-56132 in libexpat. The source material does not give a full status report on fixes or disclosures.
Will the results apply to software people use now?
Not automatically. The reported proofs concern single-threaded, static RISC-V binaries linked with musl. The source account says common x86 and ARM builds linked with glibc were not covered by those guarantees.
Source: ThorstenMeyerAI.com
Halloween Picks
halloween
As an affiliate, we earn on qualifying purchases.
