What happened
Anthropic, in collaboration with Theorem, has utilized Claude to perform large-scale formal verification of software at the assembly code level. By translating existing fuzz tests into formal specifications, the model autonomously generated proofs to verify that specific programs—compiled to RISC-V—would not crash or trigger memory-safety errors under defined conditions. This effort covered 123 open-source libraries from Google’s OSS-Fuzz initiative, resulting in 239 verified entry points. During the process, Claude identified and patched previously undetected bugs, including complex vulnerabilities that had persisted for years despite extensive testing.
Anthropic’s research demonstrates that Claude can autonomously produce correctness proofs for real-world software. The team focused on 123 open-source libraries, proving that executable artifacts would not crash under specific constraints, such as memory-safety errors or failed assertions, for inputs under 64 MB.
The process involved converting developer-written fuzz tests into formal specifications. Claude then wrote the proofs, which were mechanically checked by the Rocq kernel. The proofs operate directly on compiled RISC-V assembly code, bypassing the need for source-level verification.
During the verification process, Claude identified and fixed hundreds of bugs, including complex logic errors and out-of-bounds vulnerabilities that had eluded traditional fuzzing methods for years. The team noted that even when a full proof is not achieved, the attempt itself serves as an effective bug-discovery tool.
Anthropic is releasing the trusted components used in this project, including RISC-V and OS semantics, along with a subset of the generated proofs. Theorem is also providing a Claude skill to assist developers in applying these verification techniques to their own projects.
Source details: anthropic.com ↗
Why it matters
Formal verification has historically been a labor-intensive, niche practice reserved for mission-critical systems like avionics, often requiring years of expert effort. By automating the generation of these proofs, Anthropic’s approach significantly lowers the barrier to entry for securing production software. This capability allows developers to obtain mathematical guarantees of security for existing codebases without needing to rewrite them, potentially transforming how critical infrastructure and open-source dependencies are audited and hardened against cyberattacks.
The primary impact is the democratization of formal verification. By reducing the human effort required to write proofs, this method makes it feasible to apply rigorous security guarantees to a much broader range of software, including critical open-source dependencies.
The ability to verify code at the binary level allows for security improvements without requiring developers to rewrite entire codebases in memory-safe languages. This provides a practical path toward hardening existing, widely deployed software.
The research highlights a shift in the role of AI in cybersecurity: moving from merely finding bugs to providing mathematical proof that specific classes of vulnerabilities have been eliminated. This could fundamentally change the standard for 'secure' software development.
Interactive Mechanism: How It Actually Works
Explore the underlying technology behind this development interactively.
Which component of an AI application is the machine-learning model itself?
What to watch next
The scalability of this method depends on standardizing formal semantics across different CPU architectures and operating systems. Anthropic is publishing a subset of its proofs and collaborating with Theorem to offer this to other open-source projects. Future developments will likely focus on expanding the scope of these proofs beyond single-threaded static binaries and improving the cost-efficiency of usage as models are further trained on long-form verification tasks.
The current proofs rely on specific assumptions, such as single-threaded execution and fixed memory budgets on RISC-V. Expanding these proofs to support multi-threaded applications and diverse hardware architectures remains a key technical challenge.
Cost-efficiency is a significant factor, as these proofs require millions of tokens. Anthropic reports that newer models like Opus 5.5 are already showing improved efficiency, and they expect this trend to continue as models are optimized for long-form reasoning.
The long-term goal is to create a library of reusable proofs. Similar to the growth of the Mathlib library in Lean, Anthropic envisions a future where verified dependencies can be shared and built upon, significantly reducing the cumulative cost of securing the software ecosystem.