AI Proved Signal's Encryption in 4 Weeks. Here's What It Actually Proved
Here's the headline first: Google DeepMind's AlphaProof Code formally verified the compiled code of Signal's core cryptographic protocol in four weeks. The same kind of work, done by expert teams, historically takes years.
But it did not prove that "Signal is absolutely secure." It proved something narrower and more precise: this code satisfies these four properties — forward secrecy, authentication, post-compromise security, and handshake confidentiality. Everything outside that scope, it guarantees nothing about. Let's get the boundaries straight first, then talk about why it still matters.
How it works: humans write the spec, agents write the proof, Lean judges
AlphaProof Code is a multi-LLM-agent framework, organized like a research team:
- Humans decide what to prove. Researchers work with the models to translate Signal's security goals into formal mathematical specifications — and every single specification is reviewed by human experts. The AI designs proofs, not claims. The claims are written by people.
- Agents write the proofs. Agent teams driven by Gemini Carbon produce Lean proofs. The DeepMind blog's main text says over 6 million lines of Lean; its abstract says over 3 million lines of machine-checked proofs. The two numbers don't agree, so I'm stating both rather than treating either as settled.
- The Lean kernel checks everything. Every proof has to pass machine checking by the Lean kernel — if it doesn't pass, it doesn't count. The agents flagged only about 1% of the codebase for human review; the rest was machine-checked.
The target was libsignal's post-quantum PQXDH handshake and Triple Ratchet, verified down to the compiled machine code — not just the protocol design diagram. Signal CTO Ehren Kret's take: the method translates "real code" into "valid Lean theorems," raising confidence in the privacy guarantees at the implementation level.
The reverse test: can it tell good code from bad code?
DeepMind ran a refreshingly honest control experiment: they took two real bugs that had previously been fixed, reintroduced them into an isolated copy, and asked the system to verify it. The system produced a machine-checked proof that this version was unsafe.
This step matters more than the headline. The worst failure mode of formal verification isn't "can't prove it" — it's "proves everything." A verifier that always says yes is worthless. The ability to falsify is what earns the right to verify.
The numbers
| Dimension | Number |
|---|---|
| Time | 4 weeks (expert teams historically take years for comparable work) |
| Proof size | Blog main text: over 6M lines of Lean; abstract: 3M lines — figures not reconciled |
| Human review | ~1% of the codebase flagged; the rest checked by the Lean kernel |
| Reverse test | 2 reintroduced bugs, both proven unsafe |
| Properties verified | Forward secrecy, authentication, post-compromise security, handshake confidentiality (property names from secondary reporting) |
| Verification level | Compiled machine code, not the protocol design layer |
The honest limits: what it did not guarantee
These boundaries belong in the body of the article, not in a footnote:
- It doesn't certify the whole app. The operating system, the hardware, metadata handling, and client behavior are all outside this guarantee. Timing leaks and hardware faults are out too, unless they're modeled.
- The proof rests on a trusted base. The specifications, the compiled artifacts, and the underlying assumptions each need to be examined on their own. The AI proves "the spec you wrote down" — not "the security you had in mind."
- The framework isn't generally available. AlphaProof Code hasn't been released as a general-purpose package. The verification artifacts are open-sourced and the technical paper is published.
- The same code powers more than Signal. libsignal also underpins Google Messages; WhatsApp and Messenger come from secondary reporting — the DeepMind blog itself names only Signal and Google Messages.
What it means for developers
The cost curve of formal verification just changed. It used to be that only a crown-jewel protocol like this merited years of manual verification. Now one pass takes four weeks. The question is no longer "can we afford to verify?" — it's "which piece of code do we verify first?"
But the division of labor hasn't changed: humans still write the spec. AI is good at turning a specification into a proof. Deciding what to prove is still a human job. Write the spec wrong, and the AI will rigorously prove a wrong claim.
Three things you can actually do with this:
- Read DeepMind's published verification artifacts and technical paper, and look at what a real specification looks like.
- Pick the one piece of code in your own project that is most critical and most frightening to change — and try writing a single formal specification for it.
- Use "can it catch a planted bug?" as your acceptance test. Deliberately introduce a known bug first and see whether your verification process catches it.
Would you put formal verification into your own project's CI? If you could only pick one piece of code to start with, which one would it be?
Top comments (0)