Google DeepMind has used teams of AI agents to mathematically prove that the code behind Signal encryption does what it promises, completing in four weeks a task that has historically taken expert teams years. The work, announced on 10 November 2026, used a new framework called AlphaProof Code to formally verify key security properties of the Signal protocol at the level of compiled machine code, rather than stopping at the protocol design.
In short: DeepMind AI agents generated more than six million lines of machine-checked proof showing that one-to-one Signal chats keep messages secret, stay secure if a key leaks later, and recover after a temporary compromise. The proof covers one version of the code on one chip architecture, not the whole app.
Key takeaways:
- AlphaProof Code is the first AI system to formally verify a widely deployed cryptographic protocol at this depth, according to DeepMind.
- The verification took four weeks; comparable formal verification projects have historically taken years of expert work.
- The proof covers the post-quantum PQXDH handshake and the Triple Ratchet in one-to-one sessions, down to AArch64 machine code.
- It does not cover group chats, the full Signal app, linked devices, or the phone operating system.
- DeepMind is open-sourcing the specifications and proof artifacts so independent researchers can examine them.
What DeepMind announced on 10 November
Google DeepMind published the results on 10 November 2026, in a research post by Pushmeet Kohli and Swarat Chaudhuri. The team built AlphaProof Code, a multi-model agentic framework that splits formal verification the way a research team would: human experts decide what to prove, and groups of AI agents do the proving.
The target was libsignal, the open-source library that implements the Signal protocol. The protocol protects billions of private conversations, not only in the Signal app but also in Google Messages and in modified form in WhatsApp, which is why an independent proof of its core guarantees matters well beyond one app. DeepMind says the work marks 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.
That second claim is the important one. Cryptographers have spent decades formally analysing protocol designs, but most verification stops at the design level. Real vulnerabilities often hide in the gap between a design and its implementation, and AlphaProof Code closed that gap by proving properties of the compiled code itself.
What formal verification actually means
Formal verification is the highest standard of security assurance. Instead of testing software against known examples and hoping nothing was missed, researchers write a mathematical specification of what the software must do, then produce a proof that the code satisfies that specification. Every step of the proof is checked by software, so the result does not depend on trusting the judgement of the person who wrote it.
The catch has always been cost. Writing specifications and proofs by hand is slow, specialist work, which is why formal verification has historically been reserved for small, critical systems such as operating-system kernels and compilers. DeepMind argues that AI agents change that equation: the agents did the bulk of the proof-writing, while humans wrote and reviewed the specifications and checked only the small fraction the agents flagged, about one percent of the codebase.
The proofs were written in Lean, a programming language that doubles as a strict proof checker. Lean kernel-checked every proof against a held-out copy of the human-approved specification, so the AI could not silently relax the goal to make the proof easier. Trust therefore rests on the specification, the Lean checker, and a trusted base of about 26,000 lines covering the specifications and the AArch64 instruction set rules, rather than on the millions of lines the agents generated.
How AlphaProof Code verified Signal
The process ran in three stages. First, DeepMind researchers worked with a mix of models to translate Signal security goals into formal mathematical specifications, with human experts reviewing every one. Second, agents powered by Gemini Carbon, Google model for demanding technical work, generated the proofs, producing more than six million lines of Lean. Third, the agents audited their own proof and highlighted the areas that needed human review.
The team compiled unmodified libsignal version 0.105.4, together with the SPQR version 1.6.0 crates, using the standard Rust compiler, and proved properties of the resulting AArch64 Linux machine code linked into a small command-line harness. That is a deliberately narrow target: one version, one processor architecture, one execution model. It is also what makes the result strong within its bounds, because the proof connects high-level security claims all the way down to machine instructions.
The whole project took four weeks. For comparison, the formal verification of the seL4 microkernel, a much smaller codebase and a landmark in the field, took around 20 person-years of expert work. DeepMind research scientist Swarat Chaudhuri told WIRED that the result was encouraging, but scaling the approach to all software remained a long way off. The work built on earlier Signal Foundation verification, and DeepMind thanked Signal staff, including chief technology officer Ehren Kret, for feedback on its methodology. Kret said the work gives Signal even greater confidence in its code privacy guarantees.
What the proof covers
The verification covers the post-quantum PQXDH handshake, the step in which two phones agree on encryption keys, and the Triple Ratchet, the mechanism that keeps changing those keys as a conversation continues. Across the symbolic and computational models in the technical paper, the proofs establish ten theorems covering the following properties for one-to-one sessions.
| Property proved | What it means in plain language |
|---|---|
| Message confidentiality and authenticity | Messages in a covered session stay secret and cannot be forged by a network attacker. |
| Forward secrecy | If a long-term key leaks later, earlier message keys stay secret. |
| Post-compromise security | After a temporary compromise, security recovers once fresh keys are exchanged. |
| Handshake authentication | A participant cannot be tricked into accepting the wrong peer. |
| Handshake secrecy | The keys agreed during the handshake stay secret from a network attacker. |
| Resistance to key-compromise impersonation | Compromise of one party key does not let an attacker impersonate the other party. |
Source: Google DeepMind, 10 November 2026, and the AlphaProof Code technical paper, as reported by WIRED and independent technical coverage.
Two details deserve emphasis. First, the symbolic analysis also considers a later quantum break of the classical Diffie-Hellman component, while the computational argument is limited to classical attackers under its stated assumptions. Second, the low-level primitives themselves, such as SHA-2, AES and ML-KEM, were not proved from scratch. Thirty-seven primitives were represented by trusted contracts, so their security enters the proof as an assumption, not a conclusion.
The control test: two old bugs, correctly caught
A proof system that always says yes would be worthless, so DeepMind ran a control test. The team reintroduced two real, previously fixed bugs into an isolated version of Signal code, known in the project as the weak-state and small-subgroup flaws, and ran AlphaProof Code on the altered binaries. In both cases the system produced a machine-checked proof that the buggy version was insecure.
WIRED reported that the analysis found no new vulnerabilities in the parts of the protocol it examined. That is the closest thing to a control group in this kind of work: the tool can tell correct code from buggy code, and the code it examined passed. The specification and proof are being released publicly, so outside researchers can inspect both rather than taking the claim on trust. The artifacts are published at github.com/google-deepmind/code-verification under the Apache 2.0 licence.
What the proof does not cover
The easiest mistake with this announcement is to turn a narrow, strong claim into a universal one. AlphaProof Code did not prove that Signal is unhackable, and DeepMind researchers emphasise that the findings are one milestone in a larger process, not a clean bill of health for a messaging app.
| Verified | Not covered |
|---|---|
| One-to-one sessions using PQXDH and the Triple Ratchet | Group messaging |
| libsignal version 0.105.4 compiled to AArch64 machine code | The full Signal app, including storage, notifications and updates |
| Forward secrecy and post-compromise security in the modelled sessions | Multi-device behaviour and every linked-device state |
| Handshake and message secrecy under stated assumptions | Operating-system security, spyware, physical access, unlocked devices |
| Detection of two reintroduced, previously fixed bugs | Key generation, sealed sender, server-side code, side-channel attacks |
| Symbolic post-quantum analysis of the handshake | SPQR post-quantum healing, outside the symbolic result |
Source: Google DeepMind technical paper and project documentation, as summarised by independent technical coverage on 10 and 11 November 2026.
A proof for version 0.105.4 also does not automatically transfer to code modified after that version. Every future change to libsignal would need its own verification, which is one reason the cost and speed of the method matter as much as this single result. Google declined to disclose what the project cost and did not say whether it plans a commercial formal verification product, according to WIRED. DeepMind conducted the Signal analysis free of charge as a research project.
Why it matters beyond Signal
The larger result is methodological. Formal verification has often been reserved for systems where years of specialist work can be justified. AlphaProof Code shows that a human-guided team of AI agents can generate and integrate proof work at a scale that would previously have been impractical for an existing industrial codebase.
If the approach scales, the most useful shift would be from testing whether software fails on known examples to proving that defined classes of failure cannot occur within a modelled boundary. DeepMind points to medical device firmware and power grid software as candidates, alongside banking code, cloud infrastructure and critical industrial controls. Each would need domain-specific properties and independent review, and writing a strong specification remains difficult work that AI cannot yet do alone. The project’s own documentation treats specification quality as the next major challenge.
There is also a defensive logic. As AI-driven security threats grow in speed and scale, the same agentic techniques that find vulnerabilities can be turned to proving protections. Paired with automated defence agents such as CodeMender, formal verification could help counter that speed, and enterprises are already tightening controls around autonomous AI agents. The announcement lands in a week when AI security is already in focus: Google opened wider access to Gemini 4 Carbon, the model behind these proofs, on 10 November, and UK cyber authorities have warned that AI is reshaping the ransomware threat.
For readers following DeepMind work, this is a different kind of milestone from its recent cryptography research. DeepMind earlier work on RSA-1024 encryption weaknesses examined where existing encryption falls short; AlphaProof Code is about proving, mathematically, that a widely used implementation does what it claims. The two directions, finding weaknesses and proving strengths, are complementary, and both now run on AI.
What Signal users should do now
Nothing in the announcement requires any action from Signal users. There is no emergency patch, no account change and no special update tied to the research. The practical advice remains the ordinary account and device hygiene that protects the layers outside the proof: keep Signal current on every device, review linked devices and remove anything unrecognised, verify safety numbers for sensitive conversations, and protect account recovery with the second-factor options Signal offers.
That advice matters precisely because the proof is narrow. Mathematics can establish that the protocol code behaves as specified, but it cannot determine whether the human on the other end is who they claim to be, and it cannot protect a phone that is already compromised. The proof strengthens one critical layer. The other layers still depend on the user.
Frequently asked questions
What is AlphaProof Code?
AlphaProof Code is a Google DeepMind framework that uses teams of AI agents to formally verify software. Human experts write and approve a mathematical specification of what the code must do, agents powered by Gemini Carbon generate proofs in the Lean proof language, and Lean machine-checks every proof against the specification.
Did DeepMind prove that Signal is unhackable?
No. DeepMind proved specific security properties of one version of the libsignal library, version 0.105.4, compiled to AArch64 machine code, for one-to-one sessions. Group chats, the full mobile app, linked devices, the operating system and the phone itself are outside the proof.
How long did the verification take?
Four weeks, according to DeepMind. Comparable formal verification projects have historically taken expert teams years. The agents generated more than six million lines of Lean proof, and humans reviewed the specifications plus about one percent of the code that the agents flagged for a second look.
What is formal verification?
Formal verification means mathematically proving that code satisfies a written specification, with every step of the proof checked by software. It is the highest standard of security assurance, but it has traditionally been slow and expensive, which limited it to small, critical systems.
Does this affect WhatsApp or Google Messages?
Indirectly. The Signal protocol, in modified form, underpins encryption in Google Messages and WhatsApp, so a proof about its core library is relevant to those apps. But the proof covers the libsignal implementation itself, not the WhatsApp or Google Messages apps.
Conclusion
AlphaProof Code is a genuine first: AI agents formally verified a widely deployed cryptographic protocol at the level of compiled machine code, in four weeks, and the proof survived the only test that matters for a verification tool, correctly failing code with known bugs reintroduced. The achievement is real, and so are its limits. It covers one version, one architecture and one-to-one sessions, and it rests on human-written specifications and assumed-secure primitives. The value of the work will be decided by what happens next: whether the method scales to other critical software, whether independent researchers confirm the artifacts, and whether proving code becomes routine rather than remarkable.
Sources and Further Reading
- Google DeepMind: Formal Verification of Signal Protocol with Gemini, 10 November 2026
- WIRED, via Cybernoz: A New AI Tool From Google DeepMind Proved the Signal Protocol Is Secure, 10 November 2026
- ReaderSpice: AlphaProof Code Verifies Signal Security, Scope and Limits, 10 November 2026
- ShiftDelete: AlphaProof Code Verifies Signal Encryption at Machine Level, 10 November 2026
- Dev.to: AlphaProof Code, A Developer Checklist Before You Trust an AI-Verified Codebase, 11 November 2026
- EuropeSays: Google DeepMind AI Wrote 6.5 Million Lines of Proof for Signal Encryption in Four Weeks, 10 November 2026
- Google DeepMind on GitHub: code-verification, formal verification artifacts, Apache 2.0
- WebReOn: Nvidia Board Opens Investigation Into Jensen Huang Over Spy Claims
