180M Rocq Lines Across 123 Verified Libraries

Machine-checked proofs over compiled binaries are moving from Airbus-style specialty work toward the same class of tooling continuous fuzzing already occupies for many maintainers. The recent shift is a published LLM pipeline that converts existing crash tests into machine-checked proofs spanning tens of thousands of assembly instructions per target.

In Anthropic's formal verification research post, the lab reports that Claude, working with collaborator Theorem, proved useful security properties across open-source libraries drawn from Google's continuous fuzzing program. The proofs target RISC-V assembly under a modeled Linux process, and a subset is published for independent checking.

123 libraries and 239 entry points

Per Anthropic's write-up, Claude patched bugs it found, then proved no crashes on any input up to a stated size bound for 239 entry points across 123 OSS-Fuzz libraries. The artifacts are Rocq proofs over compiled RISC-V instructions, totaling about 180 million lines, with a typical proof around 600,000 lines for binaries whose median length is about 18,000 RISC-V instructions.

The trusted base shrinks to the RISC-V and Linux process models, the theorem statements, and the Rocq checker. Claude is the only frontier model named as the proof author on this scale in that post. Worth treating as a research release with published artifacts, not a product SKU with a public meter.

20 person-years for the seL4 kernel

Anthropic's introduction restates the classic cost ratio: roughly two person-years to implement seL4, and about 20 person-years to formally verify it. The same post points to mission-critical precedent such as Airbus avionics code, where expert teams could justify that spend.

The same Anthropic post then reports Claude completing proofs for 239 entry points across 123 libraries over a span of a few weeks, with the Rocq corpus totaling about 180 million lines. The 2-versus-20 person-year seL4 ratio remains the human-led cost frame that post cites; the new result is measured in weeks of LLM proof generation on that scale of libraries and entry points.

Thousands of OSS-Fuzz harnesses as specs

Google's OSS-Fuzz program supplies continuous fuzz testing for qualifying open-source projects, and Anthropic describes turning developer-authored crash entry points from that corpus into specs. The post notes that OSS-Fuzz contains thousands of such entry points, often with AddressSanitizer instrumentation so improper memory access crashes the harness.

Anthropic turns those OSS-Fuzz crash entry points into no-crash specs and proves them for every input under 64 MB on the modeled RISC-V Linux machine. OSS-Fuzz supplies the harnesses; it does not produce the Rocq proofs.

Nearly 300,000 Mathlib theorems as reuse

Anthropic compares proof reuse to Mathlib in Lean, which it says grew to nearly 300,000 theorems from more than 700 contributors because each new proof builds on shared work. In their own agent experiments on 36 small verification tasks, giving agents a shared workspace cut token use by 17% versus solo agents, and Opus 5.5 proved half of those tasks with about 40% fewer tokens than Opus 5.

Per the same write-up, Claude's OSS-Fuzz run shows agents copying another team's finished proof and adapting it, because most of a proof concerns shared C runtime and AddressSanitizer initialization. The 17% token cut on the 36-task shared workspace is the cost signal that post publishes for reuse.

1.7 million programs against Verus

Beyond the RISC-V fuzz-to-proof track, the same research post describes Claude writing a large-subset Python interpreter in Rust and proving adherence to CPython semantics from an academic paper with Verus. Empirical checks ran over 1.7 million randomly generated Python programs, matching CPython behavior in 99.95% of tests, with remaining differences framed as known corner cases.

Separate case work in that post covers proving zlib against an RFC-derived spec at the x86 binary level, finding minor unexploitable corner-case bugs along the way, and hunting logic bugs in critical apps while chasing simple security properties. The Verus Python-interpreter experiment stays a source-level adherence proof checked against CPython behavior on those 1.7 million programs at the reported 99.95% match rate.

x86, glibc, and caller misuse

Anthropic's limitations section is explicit: the OSS-Fuzz proofs assume single-threaded static RISC-V binaries linked against musl libc with a fixed memory budget on Linux, often far from how those libraries ship on x86 or ARM with dynamic glibc. The proved claim is no crash for inputs under 64 MB on the covered entry points under AddressSanitizer-style detection; ASan does not catch every memory bug, not every entry point was verified, and callers can still misuse a library outside the harness.

Anthropic is publishing trusted components, a subset of complete Rocq proofs, and specs for unproved harnesses, and Theorem offers to run the same pipeline for other open-source projects. For a C or C++ maintainer whose library already sits in OSS-Fuzz, those published artifacts and Theorem's offered runs are the concrete path this release opens; they do not rewrite the binary's production ABI assumptions away.