Google DeepMind announced on November 10, 2026, that AlphaProof Code had helped formally verify selected security properties of the code implementing the Signal protocol, extending to compiled code. The project did not verify the complete Signal app.
AlphaProof Code combines multiple AI models and agents with human expertise to construct mathematical proofs about software. In this project, people helped determine exactly which security guarantees to express mathematically, agents built proofs, and Lean checked those proofs against the specifications.
“having the core Signal protocol rigorously verified with automated theorem proving gives us even greater confidence that our code delivers on its privacy guarantees.” — Ehren Kret, Signal’s chief technology officer
What was verified in Signal’s code?
The verification addressed selected properties of Signal’s protocol implementation. The Register identified the components more specifically as the PQXDH handshake and Triple Ratchet in libsignal, and named forward secrecy, authentication, post-compromise security, and handshake secrecy among the properties covered.
Those properties address different security questions. Around a temporary device compromise, for example, forward secrecy concerns the protection of earlier messages, while post-compromise security concerns protection afterward. Authentication and handshake secrecy concern the participants in the initial exchange and the secrecy of that exchange.
The Register also reported an important assumption: the result treated cryptography as perfect, meaning the cryptographic operations were modeled as ideal building blocks. It did not establish computational secrecy of the message bytes—the security question of whether an attacker with bounded computing resources could recover their contents.
The distinction between protocol code and an application matters beyond Signal. Google DeepMind described the underlying technology as used in Google Messages, while 9to5Mac noted the Signal protocol’s use in WhatsApp. Sharing that protocol does not make this project an app-wide verification of either service.
How did people, AI agents, and Lean divide the work?
Human experts and models translated Signal’s security goals into formal specifications: precise mathematical statements of what the code should guarantee. Google DeepMind said experts reviewed every specification.
That review is consequential. A proof checker can determine whether a proof satisfies a specification; deciding whether the specification captures the intended security goal requires a separate judgment. If the mathematical statement asks the wrong question, successfully proving it does not answer the right one.
Gemini Carbon-powered agents then generated proofs written in Lean, a language and system for formal proof checking. Lean checked the generated proofs against the specifications. The workflow therefore separated creating a proposed proof from checking its mathematical validity, rather than relying on an AI model’s assurance that its answer was correct.
The specification determines the security question. Proof checking determines whether the mathematical argument answers it under the stated assumptions.
Google DeepMind also said the agents flagged 1% of the codebase for additional human review, while Lean checked the remainder. That additional code-review pass was separate from the experts’ review of every formal specification.
A Reddit commenter raised a related concern: could Lean itself contain bugs? The workflow places trust in Lean as the proof checker. Its checking operates within the formal specification and assumptions of the proof setup; the checker is itself part of that trusted machinery.
What did the test with two known bugs show?
Google DeepMind said the Signal verification effort took four weeks. As a control test, researchers reintroduced two real, previously fixed bugs into isolated versions of Signal’s code.
The framework produced machine-checked proofs that both altered versions were insecure. The control exercised the system against known failures, giving the team a concrete way to test whether its formal setup exposed those particular mistakes.
The result was specific to the two deliberately altered versions. It demonstrated detection of those known failures within the tested setup, rather than a general ability to detect every vulnerability.
Axios described the Signal work as a research project rather than a commercially available cybersecurity product.
How did this differ from earlier formal analysis of Signal?
Signal’s protocol had already undergone formal analysis before AlphaProof Code. An academic study listed by CISPA in September 2020 proved standard security properties of its key-exchange core in an abstract model.
The two projects worked at different levels:
| Work | Subject analyzed | Level of analysis |
| 2020 academic analysis | Initial X3DH key agreement and Double Ratchet core | An abstract, multi-stage authenticated key-exchange model |
| 2026 AlphaProof Code project | Selected security properties of Signal protocol implementation code | Implementation-focused verification extending to compiled code, according to Google DeepMind |
A protocol model describes the rules of an exchange mathematically. Implementation-level verification addresses the additional question of whether the program satisfies specified properties. A sound design and a correct implementation are related achievements, but they require different arguments.
That is the significance of reaching compiled code: the proof addresses properties closer to the program that runs on a device, rather than stopping at an abstract description of the protocol. The earlier model-level analysis and the newer implementation-focused work contribute at those different layers.
In its November 10 announcement, Google DeepMind also said it was open-sourcing the formal-verification artifacts for community use.