Anthropic and Theorem Use Claude to Generate Machine-Checkable Security Proofs for 123 Open-Source Libraries

By Hector Herrera | October 29, 2026 | Security

Anthropic and security firm Theorem published results this week showing Claude was used to generate formally verified, machine-checkable security proofs across 123 open-source software libraries. The work is among the first large-scale deployments of AI for formal verification — proving code is correct — rather than just generating or reviewing code. According to reporting from The Neuron, the proofs are compatible with existing automated theorem-proving toolchains, meaning they can be independently checked by machines without human review.

If AI can verify code at scale, the attack surface of the software supply chain — a major source of enterprise security incidents — shrinks materially.

What Formal Verification Is (And Why It Hasn't Scaled Until Now)

Formal verification is the process of mathematically proving that a piece of software behaves exactly as specified — that it cannot produce incorrect outputs, access memory it shouldn't, or be exploited through specific vulnerability classes. Unlike code review (humans reading for bugs) or fuzzing (automated random input testing), formal verification provides a mathematical guarantee for the properties it covers.

The problem: writing formal proofs has historically required PhD-level expertise in programming language theory and could take weeks per function for non-trivial code. It was practical for safety-critical systems — avionics software, cryptographic protocols, medical device firmware — where the verification cost was justified. For general open-source libraries used in millions of applications, it was simply not economically viable.

AI changes the labor economics of proof generation. Claude can produce formal proof structures that human experts would spend days writing, in minutes. The critical innovation in Anthropic and Theorem's work is that these proofs are machine-checkable — they're not AI-generated claims that "this code looks safe," they're formal proof objects that an automated theorem prover can independently verify. The AI generates the proof; a machine checks it. Human experts are removed from the verification loop.

What the 123-Library Project Covered

The collaboration between Anthropic and Theorem targeted open-source libraries — the shared dependencies that underpin enormous amounts of enterprise and consumer software. A vulnerability in a widely deployed open-source library (think Log4Shell in 2021, or the OpenSSL Heartbleed bug in 2014) can simultaneously expose millions of applications.

Details from the published results:

• Scope: 123 open-source software libraries
• Output format: machine-checkable formal proofs compatible with existing theorem-proving toolchains
• Verification model: proofs verified by automated theorem provers, not human review
• Vulnerability classes covered: the announcement does not enumerate every class, but formal verification at this scale typically targets memory safety (buffer overflows, use-after-free), integer overflow, and cryptographic protocol correctness
• AI model: Claude (specific version not disclosed in available reporting)
• Theorem's role: security verification firm providing the formal specification framework and toolchain integration

Why This Matters for the Software Supply Chain

Open-source software is the load-bearing infrastructure of the modern internet. The Linux kernel, OpenSSL, glibc, Python's standard library, Node.js dependencies, Java's Apache Commons — these libraries run inside nearly every enterprise application, cloud service, and connected device. They are also persistently understaffed: most are maintained by small teams of volunteers, and formal security review has been out of reach economically.

The supply chain attack vector — compromising a widely used library to reach every application that depends on it — has been one of the most productive attack categories in the past five years. SolarWinds, Log4Shell, XZ Utils, and dozens of smaller incidents all exploited the fact that widely deployed dependencies lack the security investment their usage warrants.

Formally verified libraries are substantially harder to exploit in the vulnerability classes the proofs cover. A proof that a library's memory allocation routines cannot overflow does not eliminate all possible vulnerabilities — formal verification covers what it specifies, nothing more — but it does remove entire categories of attack surface.

The scaling argument is the key insight. Anthropic and Theorem's project didn't verify one critical library over six months. It verified 123 libraries. That pace — if it holds and expands — could realistically reach the 500–1,000 most widely deployed open-source dependencies within 18–24 months.

Limitations and What This Doesn't Do

Formal verification is not a security silver bullet. Important caveats:

It verifies what you specify. If the formal specification of expected behavior is wrong or incomplete, a correct proof of the specification still doesn't mean the software is safe. Writing accurate formal specifications requires deep domain knowledge.

Coverage is partial. Proofs covering memory safety don't cover logic errors, authentication bypass, or insecure API design. Formally verified cryptographic code can still be misused by calling applications.

AI-generated proofs need checking. The machine-checkable design addresses this directly — the proof object is independently verified by a theorem prover, so Claude's output is validated rather than trusted. But the formal specification that the proof is checked against still requires human authorship.

Deployment friction. Even if proofs exist, getting Linux distributions, package managers (npm, pip, crates.io), and enterprise toolchains to adopt proof-checked packages as standard requires industry coordination.

What to Watch

The natural next target for this approach is critical infrastructure: OpenSSL (used in virtually every TLS connection on the internet), glibc (the C standard library underlying most Linux systems), and cryptographic libraries with known implementation complexity. If Anthropic and Theorem expand the program to these libraries, the security impact would be orders of magnitude larger than 123 general-purpose packages.

Watch also for integration announcements with major package managers or Linux distributions. The proofs are only valuable if the software supply chain adopts them as a standard artifact — not just a research result.

Hector Herrera covers AI applications in cybersecurity for NexChron.