AlphaProof Code: Signal Proof, 6.5M Lean Lines in 4 Weeks
Google DeepMind released AlphaProof Code on November 10, 2026, a framework of agents for formal verification. The team used it to prove mathematically that the real code of the Signal protocol satisfies its core security properties. The target was not a design document. It was the compiled code that runs on devices, and the Signal protocol protects billions of private conversations in apps such as Signal and Google Messages.
The proving agents are based on Gemini Carbon. They generated more than 6 million lines of Lean proof code, about 6.5 million lines by the technical paper count, and the Lean kernel rechecked every proof. The whole effort took 4 weeks. DeepMind says work of this depth would normally take an expert team years, which is the claim that turns this from a research result into a cost question for every team that maintains critical code.
"The first time the implementation of a widely deployed cryptographic protocol has been formally verified by any method." Google DeepMind, official announcement
Verified Target and Scope
According to the technical paper, the verified artifact was unmodified libsignal v0.105.4 with SPQR v1.6.0, built with stock rustc into an AArch64 Linux binary. That precision matters. Most protocol verification stops at the design stage, while real vulnerabilities often hide in the gap between a design and its implementation. Verifying the compiled artifact closes that specific gap for the code inside the stated scope.
The scope was the one to one session path: the PQXDH handshake and the Triple Ratchet. The confirmed properties were forward secrecy, authentication, post-compromise security and handshake secrecy. Anything outside that session path needs separate treatment, and the limits section below lists what was left out. Reading the result as a blanket certificate for everything Signal does would go well past the evidence.
Proof Scale and the Trusted Base
Against roughly 6.5 million lines of proof, the trusted base is small: the specification and the AArch64 semantics together run to about 26,000 lines. That ratio is the structure of the result. A formal proof is only as meaningful as the statement it proves, so the human approved specification carries the weight here. The agents produced volume, and the kernel checked consistency, but neither of those steps can rescue a specification that states the wrong property.
DeepMind made the verification artifacts available as open source. Outside researchers can therefore inspect the specification and the proof setup instead of taking the headline on trust, which is the right standard for a first of its kind claim.
Division of Labor Between Humans and Agents
The workflow mirrors how a human research team divides labor. People decided with the AI what should be proved. Agent groups then carried out the proving. During specification translation, several models reviewed each other's output, and humans approved every specification. After verification finished, the agents audited their own proof and flagged the parts that deserved another human look. Those flags covered about 1% of the codebase.
That 1% figure is easy to misread as automation of 99% of the work. The more careful reading is narrower: the audit concentrated human attention on a small slice, and the specification approval stayed fully human. The scarce expert input moved to the two points where judgement matters most, the statement of the property and the final review. The nine named researchers were Swarat Chaudhuri, Andrew Ferraiuolo, Anton Kovsharov, Tej Chajed, Sam Schlesinger, Karn Seth, Jonathan Katz, Charles Sutton and Pushmeet Kohli.
Discrimination Test With Reinserted Bugs
A proof system that says yes to everything would be worthless, so the team tested discrimination directly. Researchers reinserted two bugs that had been found and fixed in the past into isolated code. In both cases, the system produced a machine checked proof that the modified version was unsafe.
Two cases are a sanity check, not a statistical evaluation. The test shows the pipeline can reject known bad code under controlled conditions. It does not measure how often the system would catch an unknown bug in an unfamiliar codebase, and no such rate was published. Treating the result as a detection guarantee would be a mistake, while treating it as no evidence at all would undersell a deliberately adversarial check.
Limits of the Verification
The verified scope covers one to one session code only. Group messaging, key generation, side channels and multi-device state were not part of this verification, and the result is not a safety certificate for the Signal app as a whole.
The symbolic proofs also rest on idealized cryptographic assumptions. The cryptographic primitives themselves were not proved from scratch. The verified target was a libsignal-cli build running as a fresh process, which is a specific and controlled condition rather than the full diversity of production app states.
Two practical questions remain open. Whether the framework transfers directly to other codebases is unknown, and the cost of running it has not been disclosed. Those unknowns decide whether this stays a flagship demonstration or becomes a repeatable service. A 4 week run by a DeepMind team with a frontier model behind it says little yet about what a smaller team would spend in time, compute or expert review.
Implications for Engineering Teams
Formal verification differs from testing in kind, not degree. A test shows behavior on selected inputs, while a proof covers the property itself. If agents can now produce that proof at compiled code depth in weeks, the cost structure of security assurance changes. Libraries that were previously too expensive to verify, with libsignal as the working example, become plausible candidates.
For Android and messaging developers, the realistic near term reading is selective adoption. Start with small, stable, high value components where the security property can be stated precisely, because the specification step is where human experts remain mandatory. The result does not remove the expert bottleneck. It relocates it, from writing millions of proof lines to writing and approving the roughly 26,000 lines everything else depends on.
Related Reading
An earlier AI proof result with Lean verification is covered in the report on the Aaronson-Ambainis proof. The base model family behind the proving agents is covered in the report on Gemini 4 Carbon.
FAQ
What did AlphaProof Code verify?
It verified the compiled code of unmodified libsignal v0.105.4 with SPQR v1.6.0, built with stock rustc as an AArch64 Linux binary. The scope was the one to one session PQXDH handshake and Triple Ratchet.
How large was the proof and how long did it take?
Agents based on Gemini Carbon generated about 6.5 million lines of Lean proof in 4 weeks, and the Lean kernel rechecked every proof. DeepMind says verification at this depth would normally take an expert team years.
Does this prove the Signal app is safe?
No. The target was a libsignal-cli build running as a fresh process, not the whole Signal app. Group messaging, key generation, side channels and multi-device state were outside the verified scope.
How was the system tested for discrimination?
Researchers reinserted two previously fixed bugs into isolated code. In both cases the system produced a machine checked proof that the modified version was unsafe.
Can other teams apply AlphaProof Code to their own codebases?
That is not yet established. DeepMind released the verification artifacts as open source, but whether the framework transfers directly to other codebases and what it would cost have not been disclosed.
Sources
- Google DeepMind official: Introducing AlphaProof Code (November 10, 2026)
- The Register: Google DeepMind melds humans and AI agents to vet Signal's secure messaging techniques (November 10, 2026)
- Unite.AI: Google DeepMind Uses AI Agents to Verify Signal's Core Machine Code (November 10, 2026)
- Original issue: ax-trend issue #3901