JOURNAL
DeepMind Got AI Agents to Write 6.5 Million Lines of Proof for Signal’s Crypto Code
DeepMind's AlphaProof Code formally verified Signal's cryptographic code in four weeks instead of years, with AI agents writing every line of the proof. Here's what it actually checked, and what it didn't.

On this page
On Nov 10, Google DeepMind published a post describing AlphaProof Code, and buried in the announcement is a number that should stop any security engineer mid-scroll: 6.5 million lines of machine-checked Lean proof, generated in four weeks, verifying parts of the cryptographic code behind Signal. Not the design on a whiteboard. The compiled libsignal implementation, built down to AArch64 machine code. None of those 6.5 million lines were written by a person.
Formal verification of real, shipped code has existed for decades. It has also stayed a niche discipline for a simple reason: it’s brutally expensive. A team of five people spending four weeks on one protocol, even with AI agents doing the typing, isn’t cheap either, but it’s a different order of cheap than the multi-year efforts this kind of proof used to take. That gap is the actual story here, more than the headline that an AI proved some math.
Who did what
The division of labor is the part worth understanding before anything else, because it explains both why this worked and why it isn’t a push-button “AI proves your code is safe” product. Humans picked the security properties worth proving, translated them into formal Lean specifications, resolved the ambiguous judgment calls those translations require, and reviewed the specifications line by line. Agents built on Gemini 4 Carbon then took those specifications and wrote the actual proofs — all 6.5 million lines of them, resting on roughly 26,000 lines of trusted specification and AArch64 semantics that the team treated as a given rather than proving from scratch.
That 26,000-versus-6.5-million split matters. The low-level crypto primitives and the hardware semantics are assumed-secure contracts in this setup, not something AlphaProof Code independently verified. What got proved is that the actual compiled implementation of Signal’s protocol logic correctly satisfies its security properties given those building blocks. That’s still a serious result. It’s also a narrower claim than “Signal’s encryption is now mathematically proven secure,” which is the version of this story that will spread on social media by Friday.

What actually got proved
The properties verified cover the core guarantees Signal’s threat model depends on: forward secrecy, post-compromise security, initiator and responder secrecy, authentication, and five corollaries tied to the post-quantum PQXDH handshake’s Theorem 1. In plain terms, the proofs cover how two phones agree on keys in the first place (PQXDH) and how those keys keep changing as a conversation continues (the Triple Ratchet) — the two mechanisms that decide whether a compromised device today still lets an attacker read yesterday’s messages, or tomorrow’s.
DeepMind also ran a check that matters more to me than the headline count of proved theorems: a negative test. The team took two real bugs that had previously been found and fixed in Signal’s code, reintroduced them into an isolated copy, and reran AlphaProof Code against it. It correctly produced machine-checked findings that both buggy versions violated the properties they were supposed to satisfy. A verifier that accepts everything proves nothing. One that catches planted, previously-real bugs is doing actual work.
On the human-review side, DeepMind says roughly 1% of the work required a person’s judgment call — the ambiguous cases where translating “this should be secure” into a formal statement isn’t mechanical. Signal’s own engineering leadership is quoted in the announcement calling the approach a major breakthrough, specifically for the leap from “live, compiled code” to “valid Lean theorems,” which is a harder translation step than proving an already-formalized algorithm on paper.
Why this matters beyond Signal
I’ve watched three cycles now of “AI finds vulnerabilities” stories — PHP2Shell’s decade-old RCE found by Wiz using multiple frontier models, OpenAI’s kernel-exploit pipeline generating hundreds of working root exploits for a few thousand dollars each. Those are all variations on AI getting better at breaking things. AlphaProof Code is the first one I’ve covered that’s squarely about AI getting good enough at proving things don’t break, at a scale that changes the economics of deciding to even attempt it.
If you lead a team that ships cryptographic code, authentication logic, or anything else where a subtle logic bug is catastrophic rather than merely annoying, the four-week number is the one to sit with. Formal verification used to be something you reserved for a handful of components a year, because a multi-year proof effort doesn’t scale to a normal release cadence. A four-week effort, even one that still needs five skilled people steering it, starts to look like something you could budget for a critical subsystem rather than treat as a research luxury.
The honest caveat: this is one case study, on one well-funded team’s protocol, done in partnership with the lab that built the tool. We don’t have a published cost figure, and “quite a few tokens” is DeepMind’s own phrase for the compute involved, not a number you can put in a budget line yet. I’d treat this as proof of a direction rather than a tool you can download this week. But the direction is the one worth planning around: proving code correct is getting cheap enough to stop being exceptional.
Source: Google DeepMind, “Introducing AlphaProof Code”, Nov 10, 2026.



Discussion
Comments are reviewed before publication. Your email is kept private.