Claude formally verifies 123 open source libraries with Theorem

Anthropic's Frontier Red Team published results on 22 October 2026 showing that its Claude model can write large-scale formal proofs of software correctness, in collaboration with the verification startup Theorem. Over a few weeks, Claude proved that 239 fuzz-test entry points across 123 real-world open-source libraries from Google's OSS-Fuzz project never crash on any input under 64 MB, working on the compiled RISC-V assembly instructions rather than the source code. While building those proofs, Claude found and patched bugs that had survived trillions of fuzzer test runs, including a rediscovery of CVE-2026-56132 in libexpat.

Formal software verification is a mathematical proof, checked by a separate tool, that a program obeys a stated rule for every possible input rather than just the ones a test happens to try. Anthropic and Theorem used Claude to write such proofs, checked by the Rocq proof assistant, for 123 open-source libraries at the compiled RISC-V assembly level, a scale that used to take years of specialist labor per project.

What changed

Claude turned existing fuzz tests into formal specifications, encoding the rule that a given test suite always passes over a general model of a RISC-V binary running on Linux, then wrote proofs in Rocq that satisfy those specs.

Across 123 OSS-Fuzz libraries, Claude proved 239 entry points free of crashes for every input under 64 MB. Anthropic says the proofs total about 180 million lines of Rocq, with a typical proof running to roughly 600,000 lines for binaries with a median length of 18,000 RISC-V instructions.

Fuzzers typically cap inputs at 1 MB, according to Anthropic, so several of the bugs Claude found would have been unlikely for a fuzzer to reach on its own: a counter underflow causing an out-of-bounds write triggered only by a roughly 20 MB input with a rare layout, an out-of-bounds read needing a 64 MB input and more than 2 GB of memory, and a file-restriction feature that was not always enforced.

Anthropic and Theorem also proved that the Linux kernel's zlib implementation matches the RFC 1950 spec on compiled x86 binaries, and had Claude build a Rust interpreter for a large subset of Python, proven with the Verus tool to match CPython's semantics. Across 1.7 million randomly generated Python programs, Anthropic says it matched CPython's behavior 99.95% of the time.

Anthropic reports that Claude Opus 5.5 completes half of a 36-task verification benchmark using about 40% fewer tokens than Opus 5, and that letting agents copy each other's proofs in a shared workspace cut token use by 17% on average.

Theorem is offering the same pipeline free to other qualifying open-source projects through its OSS Verify program, and has published a Claude Agent Skill, add-project, that walks a maintainer's coding agent through enrolling a project: asking what counts as correct behavior, writing fuzz targets, and preparing the enrollment pull request.

Why it matters for agent builders

Agent builders get a checkable example of how an agent's output can be verified without needing a human to trust the agent: the Rocq kernel mechanically checks Claude's proof against the stated spec, so the proof itself needs no human review.

The published add-project Skill is a real agent skill already in use: it specifies the exact questions a coding agent must ask a maintainer before writing anything, instead of guessing, which is the discipline agent-skill authors on aiagentslisting.com's skills directory should be reproducing.

The reusability finding, that agents sharing a workspace needed 17% fewer tokens by copying each other's proofs, suggests multi-agent coding setups benefit from a shared store of verified building blocks rather than each agent re-deriving everything alone.

What to watch

Anthropic is explicit that "formally verified" is not "bug-free": the published proofs cover single-threaded, statically linked RISC-V binaries using musl libc, while most deployed software runs on x86 or ARM dynamically linked against glibc. Closing that gap, and specifying what calling code must do to avoid corrupting a verified library from the outside, is what Anthropic and Theorem say comes next. Whether that extension holds up at the same scale once attempted is still open.

Key takeaways

• Claude proved 239 fuzz-test entry points across 123 OSS-Fuzz libraries never crash on inputs under 64 MB, using about 180 million lines of Rocq proof code, per Anthropic's 22 October 2026 report.
• The proofs operate on compiled RISC-V assembly rather than source code, so only the RISC-V and Linux process models, the exact theorems proved, and the Rocq checker itself need to be trusted.
• Claude found bugs that fuzzers had missed for years, including a rediscovery of CVE-2026-56132 in libexpat and a file-restriction check that was not always enforced.
• Theorem now offers the same formal verification pipeline free to other qualifying open-source projects through its OSS Verify program, and has published a Claude Agent Skill, add-project, to help maintainers enroll.
• Anthropic says Claude Opus 5.5 needs about 40% fewer tokens than Opus 5 to complete the same verification tasks.

FAQ

What is formal software verification?

It is a mathematical proof, checked by a separate tool, that a program always satisfies a stated rule for every possible input, rather than just the test cases someone wrote or a fuzzer happened to try. Anthropic and Theorem's project builds these proofs over compiled RISC-V binaries rather than source code, using the Rocq proof assistant to check Claude's work.

Does a formal proof mean the software has no bugs?

No. Anthropic says explicitly that "formally verified" does not mean "bug-free": a proof only guarantees what its exact spec states, under the assumptions built into the model of the hardware and operating system. The published proofs assume single-threaded, statically linked RISC-V binaries using musl libc, so bugs that show up only on a real x86 or ARM deployment with glibc, or bugs caused by a caller misusing the library, fall outside what was proved.

How can a maintainer get their open-source project formally verified?

Maintainers can enroll through Theorem's OSS Verify program by opening a pull request against the theorem-labs/oss-verify GitHub repository with a project.yaml, Dockerfile and build.sh, the same model Google's OSS-Fuzz uses. Theorem also published a Claude Agent Skill called add-project that walks a coding agent through asking the maintainer what "correct" means and preparing that pull request.

Source: Anthropic Discussion: Hacker News

Browse more agent skills like this one in the skills directory on aiagentslisting.com.