Anthropic Just Showed AI Can Prove Code Has No Bugs — That Opens a New Service: Formal Verification Audits for Codebases That Can't Afford to Be Wrong.

Anthropic did not publish a research curiosity.

It published a price list for a new kind of security audit.

What actually happened

Anthropic and a partner used Claude to formally verify software at a scale nobody had attempted before: 239 entry points across 123 different OSS-Fuzz libraries, proved to never crash, backed by 180 million lines of generated Rocq proof code. Individual proofs ran up to 600,000 lines long, verifying binaries as large as 18,000 RISC-V instructions.

The headline claim is blunt: this is "the first large-scale effort to use AI to apply formal verification to production software at the assembly code level."

And the bugs it found were not trivial. Claude caught issues that had "eluded detection for years, despite trillions of test runs" inside OSS-Fuzz projects — code that Google has been continuously fuzzing for years. In a separate experiment on a PDF reader, the team found a logic bug that had been latent for over a decade, plus multiple new security bugs in about a week.

The gap this opens

Formal verification has existed for decades. It is also notoriously expensive. Anthropic cites the canonical example: formally verifying the seL4 microkernel took roughly 20 person-years, compared to about 2 person-years to actually build it. A 10x cost multiplier is why almost nobody does this for anything short of an operating system kernel or avionics software.

AI changes that ratio. Not to zero, but enough that it becomes a service a small team can sell instead of a research program only a handful of labs can afford. Anthropic even reports the cost is still dropping — their newer model used 40% fewer tokens than its predecessor on the same verification tasks, and agents that could read each other's proofs needed 17% fewer tokens than agents working in isolation.

The business

You don't need to build an AI lab to sell this. You need to be the person who scopes a believable pilot:

1. Pick one target. A client's most exposed function — a parser, a crypto primitive, a memory allocator, anything touching untrusted input.

2. Prove one property. Not "this code is correct." Something narrow and provable: no crashes, no out-of-bounds reads, no use-after-free.

3. Show the miss. If the target is already fuzzed, frame the pilot as "here's what your fuzzer didn't catch" — Anthropic's own results make that framing credible, not hypothetical.

4. Price the retainer, not the one-off. Code changes. A proof from six months ago doesn't cover today's diff. Continuous re-verification on every release is the actual recurring product.

Who buys this

• Wallet and payment infrastructure teams where a memory bug is a direct financial loss
• Firmware and embedded teams shipping code that can't be patched easily post-deployment
• Any team maintaining a parser or codec that processes untrusted files or network input
• Security teams that need to show an auditor or regulator more than "we run a fuzzer"

Bottom line

Fuzzing tells you a bug wasn't found yet. A proof tells you it doesn't exist. Anthropic just showed that gap is now closeable with AI in weeks instead of years — and most security-critical teams have no idea this is affordable yet.

Source: https://www.anthropic.com/research/formal-verification