AlphaProof Code Formally Verified Signal With 6M Lines of Lean in Four Weeks
DeepMind says Gemini Carbon agents generated more than 6 million lines of Lean to formally verify Signal's protocol in four weeks, a process that took human teams years. Agents flagged roughly 1% of code for human review and found two reintroduced bugs in isolated test builds.
DeepMind introduced AlphaProof Code this week, and the headline number is hard to fit in a sentence: Gemini Carbon agents generated more than 6 million lines of Lean to formally verify Signal's end-to-end encrypted messaging protocol, and they did it in four weeks. DeepMind says comparable manual verification effort for a widely deployed cryptographic protocol has historically taken years. The agents flagged only about 1% of the generated code for human review, and the process identified two reintroduced bugs in isolated test builds.
DeepMind positions the work as the first AI-driven formal verification of a widely deployed cryptographic protocol at implementation depth. That framing matters. This is not a model proving toy theorems in a competition setting. It is a pipeline pointed at code that carries private conversations for millions of people, producing machine-checkable proofs rather than test results or vibes. All of the artifacts were open-sourced, which is the difference between a claim you take on faith and one you can re-run.
Key Takeaways: What Matters Most?
- DeepMind's AlphaProof Code generated 6M+ lines of Lean to formally verify Signal's protocol in four weeks, versus years of manual effort.
- Gemini Carbon agents flagged only ~1% of the generated code for human review, per DeepMind's account.
- The verification identified two reintroduced bugs in isolated test builds of Signal.
- DeepMind positions this as the first AI-driven formal verification of a widely deployed cryptographic protocol at implementation depth.
- All verification artifacts were open-sourced, so the Lean output can be checked by anyone rather than trusted on DeepMind's word.
Takeaways like these, every weekday morning. Get the briefing
The verification gap just closed
Formal verification has always had a straightforward value proposition and a brutal cost. On the value side, a machine-checked proof gives you a mathematical guarantee that a property holds for all inputs, not just the ones your test suite happened to cover. On the cost side, writing those proofs by hand is slow, specialized work. Teams at places like AWS and Meta have reserved it for the most painful corners of their systems, because a year of a proof engineer's time is a real budget line.
AlphaProof Code's Signal result attacks the cost side directly. Four weeks versus years is not an incremental speedup; it is a category change in what a security team can even consider verifying. And the ~1% human-review figure means the pipeline is not a human-guided assistant dressed up as autonomy. The agents proposed the proofs, and humans audited a small slice.
The two reintroduced bugs are worth dwelling on. Per DeepMind's account, the verification identified bugs that had crept back into isolated test builds. In a normal test-based workflow, a reintroduced regression is caught if a test covers it and missed if it does not. In a verification workflow, the proof itself fails, which is the whole point. The finding also quietly validates why protocol implementations deserve this treatment: even a heavily audited codebase can silently regress.
What the claim does and does not cover
DeepMind's own framing carries caveats that a buyer should hold onto. "Verification of the protocol at implementation depth" is not the same as "Signal is now unbreakable." A proof guarantees the properties it specifies. If the specification omits a leak, or if the threat is metadata exposure, key theft on a compromised device, or a social-engineering attack, the Lean proof says nothing about it. Formal verification proves code matches a spec; it cannot prove the spec covers reality.
There is also a trust chain question the open-sourcing partially answers. When agents generate 6 million lines of proof, no human is reading all of it, so the ~1% review figure is a statistic you either believe or check. DeepMind's answer is to publish the artifacts, which lets third parties run the Lean checker themselves. That is the right move, and it is also the pattern to expect from any vendor claiming agent-driven verification: no artifacts, no claim.
The competitive context matters here too. The same week, Anthropic reported Claude Fable 5.2 producing peer-review-ready solutions to open physics problems that have not cleared independent review. Both announcements point the same direction: the frontier's most defensible enterprise application is shifting from generating code to verifying it. Verification work has a ground truth a checker can confirm, which makes it a natural fit for agents and a natural fit for skeptical buyers.
Where it gets expensive and where it breaks
The honest cost accounting starts with the models. Gemini Carbon is a frontier-class system, and DeepMind has not published token counts or compute costs for the Signal run. Four weeks of agent time on a frontier model is not free, and until there is a public price-per-verified-line, enterprises cannot budget this. The right comparison is not "verification for free" but "verification at some multiple cheaper than a proof-engineer team," and that multiple is currently unknowable from the announcement.
Second, the target matters. Signal is a well-specified protocol with a small, security-critical surface and a famous codebase. Verifying a sprawling enterprise monolith is a different project: the spec has to be written first, and writing the spec is most of the work. Teams that cannot state their invariants precisely will get precisely verified nothing. The 1% review ratio will also look different on less mature code, where agents will surface ambiguity rather than proof obligations.
Third, there is the skills gap. Someone still has to read that 1%, judge the specification quality, and decide what to do when a proof fails. Lean expertise is scarce and expensive. Agent tooling lowers the typing cost, but the audit responsibility moves up the stack, not away.
What To Do About It
- Read the artifacts: pull the open-sourced Lean artifacts from the AlphaProof Code release and run the checker yourself before repeating any of these claims to a customer.
- List your invariants: pick one service you own and write down its five must-hold properties. If you cannot, that spec gap is your real blocker, not tooling.
- Pilot on a small surface: pick a payment-validation or auth-token routine, not a whole protocol, and timebox an agent-assisted Lean verification of it.
- Budget the audit, not the typing: assume the 1% review ratio on Signal does not transfer, and staff review time at your project's actual ambiguity level.
- Watch the price signal: when a vendor quotes per-verified-line pricing, compare it against a proof engineer's loaded cost, which is the number it has to beat.
The Bottom Line
The Signal verification is the first data point where AI agents did not assist a formal verification effort but replaced the bulk of it: 6 million lines of Lean in four weeks, with humans reviewing roughly 1% and two real bugs caught in test builds along the way. For builders, the takeaway is not that security is now solved; it is that the cost curve on the most expensive form of software assurance just bent hard. The teams that benefit first will be the ones that can write down exactly what their code must never do. Everyone else gets a fascinating demo and the same test suite they had last month.
Sources
Frequently Asked Questions
Share this article