On November 10, 2026, Google DeepMind announced something the security field has chased for years: a mathematical proof that the actual code behind Signal's encryption delivers the security properties it promises. Not a code review, not an audit, not a test suite. A proof, checked by a machine, covering the compiled code that runs on real devices. The work was done with AlphaProof Code, a multi-LLM agentic framework for formal verification, and it took four weeks - a task DeepMind says historically takes expert teams years. This post explains what was proved, how, and the limits that matter before anyone calls an app "proven secure."
What was proved, and why the compiled code matters
Most protocol verification stops at the design level: the math of the protocol is checked, while the code that implements it is trusted to match the math. Real vulnerabilities hide in that gap - a key handled wrong, a state transition missed, an edge case the design never mentioned. DeepMind's agents went further, proving that the compiled code fulfills the key security properties down to the exact code running on devices. The properties include keeping messages protected before and after a device is temporarily compromised: forward secrecy, which limits exposure of older messages after a current key is compromised, and post-compromise security, which lets future messages become secure again after an attacker loses access and the key ratchet advances. Per the technical paper, as reported by independent coverage, the target was libsignal version 0.105.4 with SPQR version 1.6.0, restricted to one-to-one sessions, covering the PQXDH handshake that starts a conversation and the Triple Ratchet that keeps rotating keys as messages flow, verified as compiled AArch64 machine code. DeepMind says this is the first time AI has formally verified a widely deployed cryptographic protocol at this depth, and the first time the implementation of such a protocol has been formally verified by any method, with or without AI. The Signal protocol protects billions of private conversations in Signal and Google Messages, and variants of it protect WhatsApp and Messenger, which is why the result matters beyond one app.
How it worked: humans decide what to prove, agents do the proving
AlphaProof Code splits the work the way a research team would. Human experts worked with a mix of models to translate Signal's security goals into formal mathematical specifications, with human experts reviewing every specification. From there, agents powered by Gemini Carbon did the proofs, generating over six million lines of Lean, a computer language that mathematically proves the accuracy of code. Every proof is checked by Lean's kernel, so the agents' work is verified mechanically rather than trusted. Then the agents audited the proof and highlighted the areas that needed a second look by a human: just one percent of the codebase, which DeepMind calls a massive time saving. The design principle is worth stealing for any agent workflow: specifications are trusted, proofs are not. A human checks the small, critical thing - what "secure" means, written as a specification - and the machine checks the enormous thing, whether the code meets it. The same split applies to infrastructure work: a human defines the invariant, automation checks it continuously. Our Grafana monitoring guide covers the same idea for servers - define what healthy means, then let the machine watch it.
The control experiment: it catches real bugs
A verification system that always says "secure" is useless, so DeepMind ran the control experiment. The team reintroduced two real, previously fixed bugs into an isolated version of Signal's code. In both cases, the system produced a machine-checked proof that the buggy version was insecure. That is the result that makes the headline believable: the framework can tell correct code from buggy code, not just generate impressive-looking proof text. It is also the standard to hold any AI security tool to. Before trusting an agent that claims your code is safe, ask what it does with code you know is broken. If it cannot find a planted bug, its clean bill of health is worth nothing.
What was not proved
The limits are as important as the result, and DeepMind's own framing plus the paper coverage agree on them. The proof covers the core cryptographic code, not the whole app: not the servers, the key servers, the user interface, or the operating system and hardware underneath. It covers one-to-one sessions; group messaging is future work. It applies to the specific versions verified, compiled for ARM Linux inside a test harness, not to every build on every phone. The low-level cryptographic building blocks are assumed secure, not proven. And AlphaProof Code itself has not been released as a general-purpose package you can point at your own repository: what shipped is the open-sourced formal verification artifacts and the technical paper. None of that diminishes the milestone. It means the honest sentence is "the core crypto code of one version of libsignal, in one-to-one sessions, was formally verified down to the machine code in four weeks" - which is still a remarkable sentence. The direction of travel is what matters for builders: verification that took expert teams years is becoming a weeks-long, agent-assisted process, and the teams that define their security specifications clearly will be the ones who can use it first. If you want your own systems checked with the same rigor - specifications first, automation second - book a free infra audit with DevOpsBY. We run the infrastructure behind Web3 launches, where the gap between design and implementation is where the expensive bugs live.
Disclaimer: This post is educational only, not financial advice. Figures are as reported by the sources on 2026-11-12 and may change - always confirm version numbers, requirements, and scope in the official docs and paper before acting on them.
