Anthropic's Claude Automates Mathematical Safety Proofs for Open-Source Software

Anthropic has demonstrated that its Claude model can independently verify the correctness of existing software by generating mathematical proofs at a scale previously thought impossible for automated systems.

The announcement, released on Thursday, details a collaboration between Anthropic and the formal verification specialist Theorem. The project aimed to solve a long-standing bottleneck in software engineering: the high cost and labor intensity required to mathematically prove that code is error-free. By leveraging Claude, the teams achieved in a few weeks what traditionally requires years of specialized human labor.

Historically, formal verification was reserved for critical systems where failure is costly, such as the seL4 operating system kernel, which took a team of experts 20 person-years to verify. This method was largely impractical for general software development. In this new initiative, Claude was tasked with processing test programs from 123 open-source libraries associated with Google’s OSS-Fuzz security project. The model generated approximately 180 million lines of mathematical proof code during this short period.

The process did not involve Claude writing new code from scratch. Instead, the model translated existing crash tests into mathematical problems and analyzed compiled machine code to produce rigorous proofs. These proofs were then checked by an independent verification program called Rocq. Anthropic describes the workflow as "fully autonomous," noting that while the underlying formal foundations and tools were built by humans at Theorem, the generation of the proofs required minimal human review.

Beyond simply confirming correctness, the automated process uncovered significant flaws in existing software. Claude identified hundreds of bugs that conventional testing methods had missed. Many of these errors only manifested under specific conditions, such as unusually large input files or specific sequences of memory accesses, making them difficult to detect through standard quality assurance practices.

The impact of these findings was highlighted during the verification of a widely used PDF reader, where the team discovered as many security bugs in one week as are typically reported for that software in an entire year. In another instance, Claude identified a logical error that had remained undetected for more than a decade. Anthropic notes that even when a complete proof ultimately fails, the attempt still surfaces real-world bugs, adding value to the verification process.

Despite the breakthrough, the company acknowledges the strict limitations of the current approach. The proofs are valid only under specific conditions, including a particular processor architecture, single-threaded execution, and input sizes under 64 MB. In real-world scenarios, these libraries often run on diverse hardware configurations, meaning the verification does not guarantee error-free behavior in every possible environment.

The computational cost of this process remains high, with individual proofs consuming hundreds of millions of tokens. However, Anthropic points to efficiency gains as models improve; a smaller test run showed that Opus 5.5 solves half the proofs with roughly 40 percent fewer tokens than its predecessor, Opus 5. The company views this as a step toward making formal verification as routine as standard testing.

Theorem’s roadmap already includes plans to apply this technology to critical infrastructure components such as glibc, OpenSSL, and cURL. If AI can reliably write code and prove its safety within defined parameters, the focus of software development may shift from basic functionality to guaranteed correctness. This could fundamentally alter how developers trust and deploy AI-generated software.

For readers in the Texas and South Central regions, where a growing tech sector relies heavily on software infrastructure, this advancement suggests a future where safety checks are automated and integrated into the development cycle. The ability to mathematically guarantee code behavior could reduce the risk of software failures in critical applications, potentially lowering costs for businesses that depend on robust digital systems.