Skip to content
Neural Daily

ResearchNews

Claude formally verifies 123 open-source libraries

Anthropic and Theorem used Claude to prove at machine-code level that 239 fuzz entry points never crash on inputs under 64 MB, finding long-hidden bugs along the way.

By: Mikola Máté Patrik · · 3 min read

Anthropic illustration for its formal verification research: geometric circle diagrams on green and grey dots on red
Image: Anthropic · Press kit · Official research post social image (og:image) · Source

What happened?

On October 22, Anthropic's Frontier Red Team published how it used Claude for formal software verification together with a company called Theorem (Anthropic). The premise: AI can now find and exploit bugs easily, so testing alone is not enough and we need proofs that code is free of a given class of bugs.

Formal verification has been expensive. Anthropic's example is the seL4 kernel, which took two person-years to write and far more to verify. That is why it has mostly been used in mission-critical code such as avionics.

How it works

The team started from existing fuzz tests in Google's OSS-Fuzz projects. Each library and its fuzz test were compiled to a RISC-V binary, and Theorem's RISC-V and Linux process semantics turned that into a spec: the test never crashes on any input under 64 MB. Claude wrote the proof in Rocq, and the Rocq kernel checked it.

  • 239 entry points across 123 OSS-Fuzz libraries, in a few weeks.
  • About 180 million lines of checked Rocq proofs; a typical proof is around 600,000 lines.
  • Median binary length: 18,000 RISC-V instructions.
  • Agents could reuse each other's proofs; in one experiment this cut token use by 17%.

Nobody has to review those millions of lines by hand. What you have to trust is the RISC-V and Linux model, the exact theorem statements and the Rocq checker.

Bugs it found

Claude patched the bugs it found while proving. Many are ones a fuzzer would be unlikely to hit: a counter underflow in a decompressor that caused an out-of-bounds write only on a roughly 20 MB input with a rare layout, an out-of-bounds read in an image decoder that needed a 64 MB input and over 2 GB of memory, and a rediscovery of CVE-2026-56132 in libexpat.

Anthropic also describes other experiments: proving that the Linux kernel's zlib implementation matches RFC 1950 on the x86 binary, and a Rust Python interpreter that matched CPython on 99.95% of 1.7 million random programs.

What it does not mean

Anthropic is explicit that formally verified does not mean bug-free. The proofs cover single-threaded static RISC-V binaries linked against musl libc, while these libraries mostly run on x86 or ARM with dynamic linking. Not every entry point was verified, and ASan does not catch every memory-safety bug.

What you can do with it

A subset of the proofs and the RISC-V and OS semantics are public. Theorem offers to run the same pipeline for other open-source projects and has published a Claude skill for verifying your own code. If you maintain a C or C++ library with OSS-Fuzz tests, take a look: your fuzz test becomes the spec.

    Produced with the help of AI, reviewed by an editor. How we make our articles

    Reviewed and edited by the Neural Daily desk. About

    Related articles