Recommended Articles
Tech & AI

Anthropic's Claude Produces Machine-Checked Proofs for 239 Entry Points Across 123 Libraries

By Angeled · October 25, 2026 · Tech & AI
Anthropic's Claude Produces Machine-Checked Proofs for 239 Entry Points Across 123 Libraries
Anthropic's Claude Produces Machine-Checked Proofs for 239 Entry Points Across 123 Libraries

Anthropic's Frontier Red Team, working with the verification startup Theorem, published research on October 22, 2026, claiming a first: large-scale formal verification of production software at the assembly level, with Claude writing the proofs and the Rocq proof assistant checking them mechanically. The scale is the story. Security properties were proved for 239 fuzz-test entry points across 123 open-source libraries from Google's OSS-Fuzz project, producing roughly 180 million lines of Rocq proof — about 600,000 lines per proof — covering binaries with a median of 18,000 RISC-V instructions.

The property proved for each entry point is the one C developers care about most: the program always exits normally with no memory-safety errors or assertion failures, for any input under 64 MB. The work took a few weeks. Anthropic describes it, to its knowledge, as the first large-scale application of AI to formal verification of production software at the assembly-code level.

From fuzz tests to proofs

The method is the clever part. Rather than writing new specifications from scratch — traditionally the most expensive step in formal verification — the team converted each project's existing fuzz tests into formal statements. The statement is, in essence, "this test suite must always pass," interpreted over Theorem's RISC-V and Linux process semantics.

The pipeline runs in four steps. First, the library and its existing fuzz test are compiled into a RISC-V executable, instrumented with AddressSanitizer. Second, Theorem's semantics plus the no-crash property mechanically yield the specification. Third, Claude writes the proof in Rocq. If an attempt fails, the failure may point to a real bug; Claude patches the code, the specification is regenerated, and the new program must be proved. Fourth, the Rocq proof checker verifies the proof — and virtually none of the 180 million lines needs human review.

That last point is the conceptual breakthrough. Confidence in the result does not depend on reading the proof. It depends on a small, explicit trusted computing base: the RISC-V and Linux semantics, the theorem statements, and the Rocq checker itself. The model does the exploratory, high-context work; a mechanical checker holds the ground truth.

Bugs found along the way

The process surfaced previously undetected vulnerabilities spanning multiple years. Claude found bugs that fuzzers are unlikely to hit, such as a decompressor flaw that fires only on a rare 20 MB input, and in one PDF reader it found as many security bugs in a week as are typically reported in a year.

Anthropic also reported two related results. Claude formalised RFC 1950 and proved that the zlib implementation in the Linux kernel conforms to that specification at the x86 binary level. And the team built an interpreter in Rust covering a large subset of Python, achieving 99.95% behavioural consistency with CPython across more than 1.7 million randomly generated programs. On 36 small verification tasks, the newer Opus 5.5 model required approximately 40% fewer tokens than Opus 5 to prove half of them.

What the proofs do not show

The scope limits matter as much as the headline. The results assume single-threaded, statically linked binaries, fixed memory budgets, RISC-V CPUs, and Linux environments — unlike the x86 and ARM systems most people actually run. A proof can also take hundreds of millions of tokens, which makes the economics of verification very different from the economics of fuzzing today.

Most importantly, a proof for 239 entry points does not mean 123 libraries are entirely free of vulnerabilities. Remaining issues may live in trusted components or outside the scope of the proofs. The released repository currently covers 60 entry points in 25 libraries, including parts of OpenSSL, simdjson, and zstd.

The historical comparison puts the achievement in perspective. The seL4 microkernel — the classic formal-verification success — took two person-years to build and 20 to verify. Anthropic predicts machine-checked verification "will soon be as practical as fuzzing is today." That prediction is unproven, but the direction is clear: if proof generation becomes cheap, the security economics of open-source software change fundamentally.

What it means for founders and investors

For founders, the immediate lesson is about assurance. Customers in regulated industries, government, and critical infrastructure increasingly ask not just "did you test this?" but "what do you know, and how do you know it?" Formal verification has historically been too expensive to answer that question at scale. If AI-generated proofs close that gap, verified components become a differentiator — and a procurement requirement — in security-sensitive markets.

For investors, the opportunity sits in the tooling layer: proof-generation pipelines, specification tooling, trusted-component libraries, and services that run verification for open-source projects. Theorem is already offering to run its pipeline for other projects and has released a Claude skill for the workflow. The risk is equally clear: verification that only holds under narrow assumptions can create false confidence. Diligence should ask exactly what was proved, under what assumptions, and what remains outside the proof — the same questions Anthropic's own reporting invites.

The deeper implication is cultural. Software security has long relied on finding bugs after the fact. Machine-checked proof inverts that: it establishes, before deployment, that a defined class of failures cannot happen for any input within scope. If that inversion becomes routine, it will reshape how software is built, audited, and insured.

Angeled.com connects founders with investors.

Sources: https://getaibook.com/news/anthropic-llms-formal-verification-assembly-level/ , https://ailetter.ai.kr/en/d/2026-10-23/8 , https://searchenginewatch.com/claude-security-proofs-123-open-source-libraries/

Read Next