TL;DR. On November 10, Google DeepMind presented AlphaProof Code. With it, AI agents proved that libsignal, the library behind Signal's encryption, keeps its most important security promises. What was checked was not a design but the finished, compiled machine code. Five people worked on it for four weeks, and agents wrote the 6.5 million lines of proof. Three weeks ago, proofs like these were still about programs not crashing. Now AI proves that software keeps its promises. Humans define what must hold, the machine proves it. The proof has limits, and it is not a product yet.
What DeepMind showed
Tests find bugs. They do not show that none are left. A formal proof shows mathematically that a program follows a defined rule in every possible run, and a checking program verifies every step. At DeepMind that is Lean, a language for machine-checked mathematics.
The technical report describes the process. Humans write the rules, the specification, together with agents based on Gemini 4 Carbon and Claude Opus 5.5, and review them. Then teams of 40 to 80 proof agents take over, running for 24 to 72 hours at a time on a single machine. A proof only counts if Lean's checking kernel accepts it. No human wrote a single line of proof, the report says.
How AlphaProof Code works
- Humans and agentsWrite the rules, humans review each one
- 40 to 80 proof agentsWrite proofs, 24 to 72 hours
- Lean's checking kernelaccepts only rechecked proofs
- Resultproven for the machine code
humans decideagents workmachine checks
What was proven goes beyond a textbook protocol. The agents worked on the unmodified libsignal, version 0.105.4, compiled with the standard Rust compiler for AArch64. Nearly all Android phones and all iPhones run on this processor family. The program comes to about 140,000 machine instructions. Among other things, the proof shows: someone who briefly breaks into a device cannot read old messages after the fact and later loses access to new ones. You do not have to trust the compiler, because the proof starts from the finished program. That removes two limits we noted in October for Anthropic's proofs: those were only about crashes, and what was proven was a test machine.
As a test, the team put two old, long-fixed bugs back in. In both cases the system proved that the buggy version is insecure. In DeepMind's post, Signal's chief technology officer writes that the verification gives them even greater confidence in their code's privacy guarantees.
Four weeks instead of many person-years
The report itself shows how big the jump is. The seL4 operating system kernel, the best-known example of a proven system, took 20 person-years. The proven C compiler CompCert took six. For Signal, five people worked on the proofs for four weeks, which is 20 person-weeks.
Human work for a formal proof, in person-years
What the compute time cost is stated neither in the report nor in the announcement. Even so, the scale of the human work is new. Until now, formal proofs were too expensive for most software. According to DeepMind, the results suggest that AI can make them practical for real-world systems.
What humans still have to read
A proof only holds for the rules you give it. If a rule is wrong or too weak, the machine proves the wrong thing. That is why the most important number in the report is the small one: you have to trust about 26,000 lines of specification and processor model. Lean rechecks everything else.
6.5 million lines of proof, each dot stands for 26,000 lines
249 dots: rechecked by Lean1 dot: humans must read and trust it
We counted the published repository: 11,323 Lean files with 443 MB of text in total. Anyone who wants to recheck the proofs needs several hours and up to 34 GB of memory, according to the instructions. No human has to read all that. In addition, the agents flag about one percent of the codebase for a second look by humans.
DeepMind does not trust the rules blindly either. Humans do not catch every error in that much text, the report admits. That is why reviewer agents also read the rules with a deliberately skeptical eye.
The catch
- Perfect cryptography is assumed. One part of the proof assumes that methods such as X25519 or AES cannot be broken. The bounds in the computational part explicitly do not hold against an attacker with a quantum computer.
- Side channels are left out. Attacks through side paths such as timing or power consumption are not covered by the proof, nor are other secrets in memory.
- Only part of the picture. One-to-one conversations are proven, groups come later. Key generation is not verified. What was checked is a slim command-line program around the unmodified libsignal, not the Signal apps themselves.
- A research project. According to the repository, it is not an official Google product. DeepMind does not state costs. Independent reviews by cryptographers outside Google are still pending. Scaling the technique needs further research, DeepMind writes itself.
What this means for mid-sized companies
Hardly any mid-sized company writes its own encryption. But nearly all of them rely on it: in the VPN, in remote maintenance of machines, in payments. In the short term, the main change is the question you ask suppliers: which building blocks are proven, and which are only tested?
In the medium term, proofs become affordable for small, critical parts of your own software. Think of the safety function of a controller, the calculation logic in a medical device or the access check between tenants. The tools are open: Lean is free, DeepMind has published the rules and proofs under an open license, and Claude Opus 5.5, one of the models used in the project, is generally available. Something else becomes scarce: precise knowledge of what must always hold. That knowledge sits in your business units, not with your software supplier.
What you should do now
- Name the critical spots. Make a short list of the software where an error hits people, money or liability. Usually it is a few building blocks: access, remote maintenance, safety functions, payments.
- Write down what must always hold. Five to ten sentences per building block, such as "A customer never sees another customer's data". That is the raw material of every specification, and it already makes your tests better today.
- Ask your suppliers. Which libraries do they use for encryption and access, and which of them are formally verified? Get the answer in writing.
- Try it on a small scale. Take a manageable piece of code of a few hundred lines. Have an agent phrase the rules in Lean and have an expert read them. You will quickly see whether your requirements are unambiguous.
- Put the proof in context. It holds for what is in the specification, and only for that. Updates, configuration, penetration tests and training are still needed.
Until now, security in software mostly meant: well tested. AlphaProof Code shows that more will soon be possible for critical parts. If you want to find out which parts of your software could qualify, we are happy to look at them with you.