- Google DeepMind announced AlphaProof Code: AI agents mathematically proved key security properties of the real code behind the Signal protocol.
- They produced over 6 million lines of Lean proof, humans reviewed about 1%, and it took 4 weeks.
Google DeepMind announced AlphaProof Code on 10 November, a system in which AI agents mathematically proved key security properties of the real code behind the Signal protocol, not just its design on paper. The work took four weeks. According to DeepMind, expert teams used to need years for tasks like this, and the implementation of such a widely used protocol had never been formally verified by any method before. For anyone who builds software, it is a sign that the highest level of assurance may stop being a luxury.
Testing versus proving
Software is usually checked with tests: feed it data and see what comes out. Tests show that something works in the cases you tried. Formal verification goes further: it proves that a program meets its requirements in every possible case. It is the highest security standard, but so labour-intensive that it is rarely used, and usually only on small pieces of code. In cryptography most analysis stopped at the level of protocol design, while real bugs often hide in the gap between the design and what was actually programmed.
How the work was split
DeepMind describes a split like a research team’s. First, people worked with several models to translate Signal’s security goals into a specification, a precise mathematical description, and reviewed every part of it. Then agents built on the Gemini Carbon model did the proofs themselves: more than 6 million lines in the Lean language. Lean checks every step on its own, so people did not have to read everything. The agents flagged only about 1% of the code for a second look by a human.
The proofs cover the compiled code that runs on devices, and properties such as keeping messages protected before and after a device is temporarily compromised. The Signal protocol protects conversations in Signal and Google Messages, so this is code used by billions of people.
Two old bugs as an exam
A good verification system also has to tell correct code from flawed code. So the researchers put two real, previously fixed bugs back into an isolated copy of the code. In both cases the system produced a machine-checked proof that the flawed version was insecure. Signal’s CTO Ehren Kret says in the announcement that agents translating live code into Lean theorems is a major breakthrough.
The arithmetic that changes
The key number is the ratio of 6 million lines to about 1% reviewed by hand. If the cost of a proof falls from years of expert work to weeks of agent work under human supervision, the question shifts from “is this affordable” to “which code gets checked first”. DeepMind points to software in medical devices and power grids, and it is releasing the verification files openly. I write more about work like this in the Research & papers hub.
What a proof does not settle
A proof is only as good as its specification. If people describe badly what the code must guarantee, the agents will flawlessly prove the wrong thing. DeepMind writes about “key” security properties of the cryptographic core, not about the whole Signal app with its interface, backups and servers. This is also the authors’ own announcement, and the wider community has yet to review the published files and the technical paper. In my view the sensible reading is this: the method is now mature enough for large, real code, but it does not replace a security review or testing of the whole product.
If you write your own app, the practical takeaway for today is more modest: use established, well-reviewed cryptography libraries instead of writing encryption yourself. Those are exactly the pieces that will get proofs like this first.