Google DeepMind Verified Signal's Code in Four Weeks. It normally takes years.
Agents on Gemini Carbon wrote over six million lines of Lean to verify libsignal at machine-code level. One percent of the code went to a human.
On 10 November, Google DeepMind published AlphaProof Code, and with it something more useful than a benchmark: agents produced a machine-checked mathematical proof that the real Signal protocol code does what it claims.
Signal is the encrypted messaging app, and its protocol is the part the rest of the industry borrowed: WhatsApp, Messenger and Google Messages all run on it. So this is not a proof about a research toy. It is a proof about the code behind most end-to-end encrypted messaging on earth.
Not a model of the protocol. Not the design on paper. The implementation: libsignal, the Signal protocol's reference implementation, proved at the machine-code level.
Be precise about what that means, because the headline version drifts. They linked libsignal into a small command-line harness, compiled it with stock rustc to AArch64 Linux machine code, and proved properties of that executable. It is the real compiled artifact rather than a tidy abstraction of it, and it is not the build sitting on your phone.
DeepMind's claim for it is narrow and checkable: this is "the first time the implementation of a widely deployed protocol like this has been formally verified by any method". By any method includes people with years and no AI at all.
6M+
Lines of Lean written by the agents. Lean is a language where a computer checks the proof, not a reviewer.
4 weeks
Start to finish. DeepMind says work of this kind has historically taken expert teams years.
1%
The share of the codebase the agents flagged for a human to look at. Lean checked the rest automatically.
Figure 1 from the technical paper, "AlphaProof Code: Verifying Signal\'s Security at the Machine-Code Level", 10 November 2026.
The one percent is the number to take
Six million lines is the headline and four weeks is the compression, but the operator number is the one percent.
The agents did not ask a human to read six million lines of proof. Nobody could. They produced proofs a machine verifies, then pointed at the small part of the codebase where a person's judgement was actually required. Everything else was checked by Lean without anyone reading it.
That is a different shape of work from reviewing AI output. The usual arrangement puts a person downstream of the model, reading what it produced and deciding whether to trust it, which caps the whole system at human reading speed. Here the checking is done by something that does not get tired, and the human is routed to the exceptions.
Why verifying the code is harder than verifying the design
Most protocol verification checks the design. You write down what the protocol is supposed to do, prove the scheme sound, and ship an implementation that is supposed to match.
The gap between those two is where real vulnerabilities live. A sound design implemented with an off-by-one, a reused nonce or a missing bounds check is still broken, and the proof of the design says nothing about it. Closing that gap means proving things about the actual compiled artifact, which is a much larger and uglier problem than proving things about a clean abstraction.
That is the part DeepMind did, and it is why the line is "by any method" rather than "by AI".
The part that makes it falsifiable
A proof system that proves everything correct is worthless, because it would also prove broken code correct. DeepMind ran the obvious control.
They took two real bugs that had previously been found and fixed in Signal, put them back into an isolated copy of the code, and ran the system at it. "In both cases, the system produced a machine-checked proof that the buggy version was insecure."
Two is a small number and the bugs were known in advance, so this is a sanity check rather than a measure of detection rate. It is still the right experiment, and more than most AI results published this year bother to run.
Kret
Using AI agents to translate live code into valid Lean theorems is a major breakthrough.
What this does not say
It does not say the Signal app is proven secure. The proofs cover specific security properties of the protocol implementation, not the whole application, not the operating system under it and not the people using it.
It does not prove the cryptography. The paper is explicit that the cryptographic primitives, two output functions and a few library routines are specified by contracts rather than verified, and that the result rests on trusting Lean's kernel and the AArch64 semantics, though notably not the Rust source or the compiler.
It does not say verification is solved. DeepMind's own text says scaling these techniques requires continued research, and the medical device firmware and power grid software they mention are stated as future goals, not results.
And the one percent is a share of the codebase that got human attention on this job, with these specifications, on a protocol implementation written by careful people. It is not a general ratio you can quote for your own codebase.
Why it matters if you are not writing cryptography
Almost nobody reading this is going to formally verify anything. The transferable part is the shape of the arrangement, and it is worth copying.
Three roles, kept separate. Humans decide what correct means and review every specification, because a proof of the wrong property is worth nothing. Agents do the volume work that nobody would otherwise do. A machine does the checking, so trust does not depend on anyone reading the output.
Most teams running agents today have the first and second roles and no third. The output comes back, a person skims it, and the system runs at the speed of that skim. The reason this result is worth more than its benchmark is that it shows what the third role buys you: six million lines nobody had to read, and a short list of the places where judgement was actually needed.
If you want one question from it for your own work: when your agents produce something, what checks it besides you? Tests, types, a linter, a simulator, a second model with a rubric. Anything that is not a person reading. It is the same argument as the scaffolding that turns a model into a factory, with the checking step finally doing real work.
DeepMind are open-sourcing the verification artifacts and have published a technical paper, so the claim can be checked rather than taken.
Build the checker first.



