Anthropic says Claude proved a no-crash property for 239 entry points in 123 libraries
The Frontier Red Team, in a research post dated Thursday: about 180 million lines of Rocq, checked by the proof kernel, for OSS-Fuzz targets compiled to static RISC-V binaries. The guarantee stops at inputs under 64 megabytes. Anthropic says formally verified does not mean bug-free, and that it is withholding proofs that could expose an unpatched bug.
Feature4 minIn-depth
James Okonkwo4 min read
- Anthropic
- Claude
- Formal verification
- OSS-Fuzz
- Theorem

Photo: AnthropicSource page
Anthropic’s Frontier Red Team said Claude had produced formal proofs of a no-crash property for 239 entry points across 123 open-source libraries drawn from Google’s OSS-Fuzz project. The research post, “LLMs are making formal software verification feasible at a much larger scale,” is dated 22 October and names Keane Lucas, Nicholas Carlini and Jason Gross among the authors, with Theorem as the collaborator. The work ran over a few weeks. The proofs are in Rocq. Anthropic puts the total at about 180 million lines, a typical proof at about 600,000 lines, and the median binary at 18,000 RISC-V instructions.
The property is narrower than a claim that the libraries have no bugs. Claude proved, the post says, that these programs always exit normally, without memory-safety errors or failed assertions, for every input smaller than 64 megabytes and every modeled Linux response and memory layout. The assumptions are in the post: a single-threaded static binary, a fixed memory budget, a RISC-V processor and Linux. The Rocq kernel checks the proof. Anthropic says the pieces a developer still has to trust are the formal models of RISC-V and of Linux processes, the theorem statements themselves, and the checker. “Formally verified does not mean bug-free,” the post says. Most deployments, it adds, run these libraries on x86 or ARM and link them dynamically against glibc, not as static RISC-V binaries linked against musl.
A fuzz test, rewritten as a statement to prove
The method starts from tests already in OSS-Fuzz. A project author writes an entry point that accepts inputs, and a crash is treated as a bug the author cares about. AddressSanitizer, which OSS-Fuzz applies to C and C++, is supposed to make many improper memory accesses crash when they happen. Anthropic and Theorem compiled the library and its fuzz test to a RISC-V executable and, using Theorem’s semantics for the instruction set and for a Linux process, turned “this test does not crash” into a specification. Claude writes the proof. If the kernel accepts it, Anthropic’s claim is that fuzzing that entry point will not find a crash inside the limits above.
Trying to build those proofs surfaced bugs, the post says, on the order of hundreds. Claude was allowed to patch the code, which regenerated the specification, and then to prove the patched program. The examples Anthropic gives include a counter underflow in one library’s copy of a decompressor, leading to an out-of-bounds write only on inputs of around 20 megabytes with one rare layout; an out-of-bounds read in an image decoder that needed a 64-megabyte input and more than 2 gigabytes of memory; an out-of-bounds read that needed a particular sequence of calls on two handles to the same file; and a rediscovery of CVE-2026-56132 in libexpat, which needed deeply nested input. One finding is not a crash at all: a control meant to limit which files an application can load is not always enforced. The post says the patching step can be gamed, because a model could satisfy the goal by rewriting a program into one that never crashes for a trivial reason. Anthropic says it penalized patches, offered extra credit for showing which inputs a patch changes and how few they are, and logged and audited the patches.
A subset of the proofs, and a smaller token comparison
Anthropic says it is publishing the trusted components that were not already public, Claude’s complete Rocq proofs for the fuzz tests that did not need a patch, and specifications for tests it could not prove. It is not releasing proofs that might reveal an unpatched bug. Theorem is offering the same pipeline to other open-source projects and is publishing a Claude skill for developers who want to verify code of their own. On a separate set of 36 small tasks taken from OSS-Fuzz, the post says Opus 5.5 proves half of them with about 40 percent fewer tokens than Opus 5. When agents could copy one another’s proofs, they used 17 percent fewer tokens than agents working alone, and some finished a task they had missed on a solo attempt.
The same post describes two other exercises. One asks Claude to prove that the zlib code in the Linux kernel matches a formal reading of RFC 1950, checked against an x86 binary rather than RISC-V. Another asks it to write a Rust interpreter for a subset of Python and prove it, with Verus, against a semantics taken from an academic paper. Anthropic says it then ran more than 1.7 million mostly random Python programs and saw behavior identical to CPython in 99.95 percent of those tests, with the rest described as known corner cases. Those percentages are the company’s. The OSS-Fuzz result does not cover every entry point in each library, does not cover dead code, and does not stop a caller from misusing a library. AddressSanitizer does not detect every memory-safety bug. Moving the same guarantee onto the processors people actually ship, the post says, is further work.


