The DeepMind AlphaProof Signal verification, announced on 10 November 2026, is a claim about proof, not about a new product. Google DeepMind said its new system, AlphaProof Code, had mathematically verified key security properties of the code underlying the Signal protocol, the encryption technology behind the Signal messaging service. The DeepMind AlphaProof Signal work took four weeks, according to DeepMind, where the same kind of verification has historically taken expert teams years. AI agents powered by Gemini generated about 6.5 million lines of Lean proof code, a formal language in which every step of a proof is checked by machine. The result is striking, but its limits matter as much as its headline: only one specific build of the code was verified, under stated assumptions, and the whole Signal app was not certified. This article explains what was proved, how it was proved, what the numbers mean, and what was left out.

Signal's protocol is one of the most studied pieces of cryptography in everyday use. Its design has been analysed by researchers for years, and its security properties, such as forward secrecy, have been argued over in academic papers. What had never been done, according to DeepMind, was to verify the actual implementation, the compiled code that runs on a machine, rather than the mathematical model of the protocol. A protocol can be secure on paper while its code mishandles a key, a state transition or an edge case. Closing that gap between the model and the machine code is the problem AlphaProof Code was built to solve, and the Signal verification is its first large demonstration.

What the DeepMind AlphaProof Signal verification actually proved

The DeepMind AlphaProof Signal verification proved ten security properties of a specific build of the Signal protocol code. The target was libsignal v0.105.4, the Rust reference implementation of the Signal protocol, together with SPQR v1.6.0, the post-quantum extension to that protocol. The two were built into a test harness called libsignal-cli and compiled with rustc 1.98.1 into a statically linked AArch64 Linux executable of about 560 KB, containing roughly 140,000 machine instructions. That executable, not the Signal app on a phone, is what was verified.

The ten properties cover session establishment through PQXDH, the post-quantum key exchange used when two people start a conversation, and the Triple Ratchet protocol, the mechanism that refreshes encryption keys as a conversation continues. Between them, the properties cover forward secrecy, which limits the exposure of older messages if a current key is compromised, authentication, which confirms that messages come from the intended person, post-compromise security, which allows future messages to become secure again after an attacker loses access and the ratchet advances, and handshake secrecy. The proofs were checked by the kernel of Lean, the proof assistant in which they were written, so every accepted proof was mechanically checked rather than taken on trust.

DeepMind describes the work as the first time AI has been used to formally verify 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. The paper behind the announcement is 57 pages long, has nine authors, and is titled "AlphaProof Code: Verifying Signal's Security at the Machine-Code Level". Signal itself has made no statement endorsing the work, although DeepMind thanked three Signal staff for feedback on its methodology.

DeepMind AlphaProof Signal: the numbers behind the proof

The DeepMind AlphaProof Signal numbers are large, and they need careful reading. AI agents powered by Gemini generated about 6.5 million lines of Lean proof code. Those proofs rest on about 26,000 lines of trusted specifications and AArch64 semantics: about 18,000 lines of specification code, which states the security properties in mathematical form, plus about 8,000 lines of AArch64 semantics, which describe what the machine instructions actually do. The specifications are the part humans must trust, because a proof can only show that the code meets the specification, not that the specification itself is the right one. Human experts reviewed every formal specification, and that review is the foundation the whole result stands on.

An independent check of the open-sourced repository counted 7,528,293 lines of .lean files and found zero "sorry" statements in the headline proofs. In Lean, "sorry" is a placeholder that admits a claim without proof, so its absence in the headline proofs is a meaningful check that the proofs are complete rather than sketched. The total line count differs from DeepMind's figure of about 6.5 million because the two counts measure different things: DeepMind's number describes the generated proof code, while the independent count covers all Lean files in the repository, including supporting material.

The verification took four weeks, according to DeepMind. That is the figure that has drawn the most attention, because formal verification of this kind has historically taken expert teams years. The agents also ran their own audit pass and flagged about 1% of the codebase for a second human look, so human attention was concentrated on the small fraction of the code the agents themselves found hardest or most uncertain.

How AlphaProof Code works: humans, Gemini agents and Lean

AlphaProof Code, the framework behind the DeepMind AlphaProof Signal verification, is a multi-LLM agentic framework for formal verification, and it divides the work the way a research team would. Human experts work with AI models to decide what to prove, translating Signal's security goals into formal mathematical specifications. The AI agents then do the proving, generating Lean code that shows the implementation meets those specifications. Every proof is then checked by Lean's kernel, which mechanically verifies each step. If a proof does not check out, it is rejected, so the agents cannot simply assert that code is secure.

The framework matters because formal verification has always been limited by human effort. Writing a proof that code behaves correctly is slow, detailed work, and the proofs for real systems run to millions of lines. By splitting the task between humans, who set the specification and review it, and agents, who generate the proof, DeepMind argues that verification can be done at a depth and scale that was previously impractical. The agents worked from the compiled machine code, reasoning about the AArch64 instructions the executable actually contains, rather than about the Rust source code alone. That is the step that makes the result a verification of the implementation, not just of the design.

The human role is deliberately kept central. Human experts reviewed every formal specification, and the agents flagged about 1% of the codebase for a second human look. That design answers the obvious objection to AI-generated proofs: that the AI might prove the wrong thing, or prove something vacuous. The specification is written and reviewed by people, the proof is generated by agents, and the checking is done by Lean's kernel, which does not care who wrote the proof. Each stage is a check on the others.

The bug test: two old flaws caught again

In the DeepMind AlphaProof Signal work, DeepMind tested whether AlphaProof Code could tell correct code from buggy code, and the test it chose was deliberately hard. The team took two real, previously fixed bugs from Signal's history and reintroduced them into an isolated version of the code. In both cases, the system produced a machine-checked proof that the buggy version was insecure. The bugs were real flaws that had once existed in the code and had been found and fixed by humans; the question was whether the verification system would catch them if they were put back.

The result matters because a verification system that always says "secure" is useless. A proof system must fail loudly when the code is wrong, and it must fail for the right reason: a proof that the buggy code violates the stated security properties. In both cases, that is what happened. The system did not merely flag the code as suspicious; it produced a machine-checked proof that the buggy version broke the security theorems. That is the strongest form of a negative result in formal verification, and it is the evidence DeepMind offers that the positive result on the current code means something.

No vulnerability was found in the current code. That is worth stating plainly, because it is easy to misread a verification announcement as the discovery of a flaw. The verification found that the current build meets the ten specified properties, and the bug test showed that the same system would have caught two known flaws if they had still been present. Together, those two facts are the core of DeepMind's claim: the system can distinguish secure code from insecure code, and the code it checked falls on the secure side of that line.

What the DeepMind AlphaProof Signal result does not prove

The DeepMind AlphaProof Signal result does not mean the whole Signal app is mathematically guaranteed, and DeepMind does not claim that it does. Only one Linux binary and harness was verified, under cryptographic assumptions and strict preconditions. The verification covers one-to-one communication through PQXDH session establishment and the Triple Ratchet protocol. It does not cover group messaging, key generation, multi-device state, or the rest of the Signal application, including its user interface, its handling of metadata, and the operating system and hardware it runs on.

The proofs also rest on assumptions that are stated in the paper. They assume that the underlying cryptographic primitives are sound, that Lean's kernel is correct, and that the modelled AArch64 semantics accurately describe what the processor does. Timing leakage and hardware faults sit outside the guarantee unless they are explicitly modelled. Those are not flaws in the work; they are the stated boundaries of what was proved, and any reader who treats the result as a blanket guarantee for Signal is going beyond what DeepMind claimed.

Signal itself has made no statement endorsing the DeepMind AlphaProof Signal work. That silence is not a criticism, but it is a fact readers should know: the verification is DeepMind's work, reviewed by DeepMind's experts, and not a joint statement from the Signal project. DeepMind thanked three Signal staff for feedback on methodology, which is a narrower form of involvement than endorsement. Users of Signal do not need to install anything as a result of this announcement, and nothing about the app changes.

What happens next for formal verification

DeepMind has open-sourced the verification artifacts in the repository at github.com/google-deepmind/code-verification, under the Apache 2.0 licence. That means other researchers can inspect the specifications, the proofs and the harness, repeat the checks, and look for gaps in the specifications themselves. Open-sourcing the artifacts is the step that turns a company announcement into a checkable scientific claim, and it is the part of the announcement that matters most for researchers who want to test the work.

The wider question is whether the same approach can be applied to other software. DeepMind describes AlphaProof Code as a framework, not a one-off project, and the Signal verification is presented as a demonstration of what it can do. If the four-week timeline can be repeated on other systems, formal verification could move from a technique used on a handful of critical systems to something applied far more widely. That would matter well beyond messaging: operating systems, financial software and critical infrastructure all depend on code whose correctness is currently established by testing, not by proof. Readers following AI and security news can also read Worldlession's coverage of Google's Gemini 4 Carbon model for cyber defence, Australia's AI regulator and the OpenAI Medicare breach and the NCSC warning on AI malware and critical infrastructure.

For now, the honest summary of the DeepMind AlphaProof Signal result is narrow and specific. In four weeks, AI agents generated about 6.5 million lines of Lean proof showing that a specific build of Signal's protocol code meets ten stated security properties, checked by Lean's kernel, with human experts reviewing every specification. The system also caught two reintroduced bugs. The whole Signal app was not verified, the assumptions are stated in the paper, and Signal has not endorsed the work. That is a genuine milestone in software security, and it is also a result with clear, stated limits. Both parts of that sentence belong in any fair account of it.