You send a private message, and an app tells you it is protected by end-to-end encryption. What is that promise really based on? There are mathematical ideas behind the encryption, extensive testing, expert audits and years of scrutiny. But there is a difficult gap between a secure protocol on paper and the exact instructions a computer actually executes. That gap is where some of the most consequential software mistakes can hide.
On November 10, 2026, Google DeepMind announced that an AI-assisted verification system called AlphaProof Code had helped researchers mathematically establish several important security guarantees for the code behind the widely used Signal protocol. The four-week project examined an implementation rather than merely a simplified description of how encryption should work. The team published its technical report and proof artifacts for scrutiny.
The result is notable, but its meaning is narrower—and more interesting—than the idea that an AI somehow declared Signal “unhackable.” It points toward a future in which software can carry machine-checkable evidence that particular protections are implemented correctly.
When tests are not enough
A test runs software through chosen situations and checks the outcome. A strong test suite may explore thousands of cases, but it cannot automatically cover every possible interaction an attacker might exploit. Formal verification approaches the problem differently: researchers define a property in mathematical terms, then prove that a model of the software satisfies it under explicit assumptions.
Consider a messaging guarantee such as forward secrecy. In simplified terms, compromising certain keys today should not automatically reveal messages exchanged in the past. Ordinary testing can look for failures in selected circumstances. A rigorous proof attempts to establish that the relevant property holds across all executions covered by its model and assumptions.
Yet writing the proof is extremely demanding, particularly when engineers must show that the promise survives the trip from protocol design to real executable code. A beautiful mathematical analysis of a protocol does not, by itself, guarantee that programmers implemented it without mistakes.
The leap from a security design to machine instructions
DeepMind’s team applied AlphaProof Code to libsignal, the reference implementation of the Signal protocol. The researchers focused on parts of its one-to-one messaging session machinery, including the PQXDH handshake and Triple Ratchet mechanism. These help establish secure sessions and continuously update cryptographic keys as messages are exchanged.
The researchers compiled the existing Rust implementation into AArch64 machine code, the kind of low-level instructions used on many Arm-based devices, and reasoned about that compiled program in a formal model. Their proofs connected specified security properties to the behavior of this executable, instead of assuming a simplified algorithm was equivalent to the deployed implementation.
That distinction is the heart of the achievement. The verification addressed guarantees such as message confidentiality, authentication and protection against certain key compromises. It was not a general scan for suspicious code. It was an attempt to establish precisely stated claims about how selected cryptographic operations behave.
The research paper reports approximately 6.5 million lines of machine-checked Lean proofs, produced with the assistance of AI agents. Lean is a proof assistant: software that checks whether the reasoning supplied actually establishes a formal theorem. The team says the work involved five researchers over four weeks.
Who checked the AI’s homework?
The crucial safeguard is that the AI’s answer is not accepted just because it looks convincing. Human researchers helped decide what should be proved and reviewed the specifications—the definitions and assumptions that give a theorem its meaning. AI agents then developed candidate proofs. A separate proof-checking process using Lean assessed whether those proofs met the approved specifications.
Think of the difference between an AI saying, “I examined the software and it seems safe,” and submitting a mathematical argument to a strict checker that will reject a missing logical step. The second approach still depends on correct assumptions, but it does not require readers to trust an AI’s confidence or eloquence.
This is also why formal verification has an important human component. A flawless proof of a badly chosen specification could establish something technically true but irrelevant to real threats. The researchers therefore had to assess whether their specifications captured meaningful security properties and whether the underlying models represented the code accurately.
Two old bugs became a stress test
A proof system should not merely succeed on code believed to be secure. It should also recognize when a known security guarantee is broken.
To challenge their approach, the researchers reintroduced two previously fixed vulnerabilities into isolated versions of the code. AlphaProof Code’s verification process was able to establish that the altered binaries violated the relevant security properties. This provided evidence that the specifications were capable of catching at least those concrete flaws, rather than simply producing comforting proofs.
It is a meaningful test of the method, not proof that every possible vulnerability would be detected. A tool cannot reject flaws outside the properties its specifications address.
What this does not prove about Signal
This research does not establish that the entire Signal application is invulnerable. The project did not formally verify every screen, operating-system interaction, server service, or feature of the mobile app. The technical work covered specific cryptographic functionality and an explicitly modeled environment.
The technical report is unusually clear about the boundaries. For example, its verification covers session initialization and message sending and receiving in a command-line harness, but not the key-generation operation within that harness. Its proofs also rely on assumptions about cryptographic primitives and on the accuracy of the machine-code model.
Nor would an encryption proof solve every way a private conversation can be exposed. A person might lose access to an unlocked phone, be tricked into revealing a message, or face a vulnerability somewhere outside the verified components. Even excellent encryption cannot protect against every weakness in an entire communication ecosystem.
A responsible headline therefore distinguishes between proving selected security guarantees and certifying a whole product as perfectly secure. DeepMind’s results support the former, not the latter. The company and outside reporting both emphasize the limits of the exercise.
Why the bigger story could be software development itself
Signal is an especially demanding demonstration because its cryptography is foundational to everyday private communication. The protocol, or variants of it, underpins secure messaging features in multiple major platforms. Verifying such code has traditionally required considerable specialist effort; even documenting precisely what a program must do is difficult.
If AI agents can reduce the labor of constructing proofs without being trusted to grade themselves, mathematical verification could become accessible to more development teams. Instead of relying only on unit tests, penetration tests and audits, engineers might attach precise, reproducible evidence that selected safety or security guarantees hold.
That possibility stretches far beyond messaging. Software used in banking, infrastructure and medical technology would benefit from stronger evidence about properties where failure carries serious consequences. But scaling the method to large, constantly changing systems—and doing so affordably—remains a research challenge. DeepMind has not shown that every application can now be formally verified on demand.
The real milestone
The memorable number is 6.5 million lines of proofs. But that is not the most important part. The important change is a new division of labor: people establish meaningful requirements, AI agents search for formal proofs, and a mathematical checker validates the result.
For private messaging users, this adds evidence for crucial parts of an already heavily scrutinized cryptographic system. For software engineering, it suggests a more ambitious future: not just using AI to write code faster, but asking it to produce checkable reasons to trust what the code does.
The takeaway: Google DeepMind’s AlphaProof Code established specific cryptographic guarantees for selected compiled libsignal operations; it did not certify every part of the Signal app. The breakthrough is a credible demonstration of how human-guided AI and machine-checked mathematics may make deeper software verification possible.
Sources
- Google DeepMind — “Introducing AlphaProof Code: a breakthrough in verifying complex software at depth” (November 10, 2026). Official research announcement and project overview.
- Chaudhuri and colleagues — “AlphaProof Code: Verifying Signal’s Security at the Machine-Code Level” (November 10, 2026). Technical paper, scope, assumptions and proof details.
- Google DeepMind — Public verification artifacts and code. Source and formal artifacts for inspection.
- WIRED — “A New AI Tool From Google DeepMind Proved the Signal Protocol Is Secure” (November 10, 2026). Independent interview-based coverage and limitations.

