AlphaProof Code Signal Verification Explained: DeepMind's AI Proved Signal's Encryption in 4 Weeks

Image: Signal — Signal logo (official product image). Source: Wikimedia Commons, public domain.

TL;DR: AlphaProof Code Signal verification explained in short: on 10 November 2026, Google DeepMind announced that AI agents had mathematically proved key security properties of the code behind the Signal protocol — in four weeks, a job that historically takes expert teams years. The proof covers one-to-one chats only, not the whole Signal app, and users need to install nothing.

Key Highlights

Google DeepMind announced AlphaProof Code on 10 November 2026: an agentic framework that formally verifies software with AI-written mathematical proofs.
Its first result: the compiled code of libsignal, the library behind the Signal protocol, was proved to keep one-to-one chats secret, authenticated and recoverable after a key compromise.
Agents powered by Gemini Carbon wrote more than six million lines of Lean proof in four weeks; humans reviewed every specification, and Lean's kernel checked every proof.
The work found no new vulnerabilities in the parts examined — and when two old, fixed bugs were deliberately reintroduced, the system proved the buggy code insecure.
The proof does not cover group chats, the full Signal app, other phone architectures or the low-level cryptographic primitives, which were assumed secure.

What happened?

On 10 November 2026, Google DeepMind published a research post by Pushmeet Kohli and Swarat Chaudhuri introducing AlphaProof Code, a new framework that uses teams of AI agents to formally verify software — to prove, mathematically, that code does what it promises. As its first demonstration, the team applied it to the Signal protocol, the end-to-end encryption technology that protects billions of private conversations in Signal and Google Messages, and in modified form in WhatsApp and Messenger.

Formal verification is the highest standard of security assurance: instead of testing code against examples and hoping nothing was missed, researchers state the security properties in mathematics and prove that the code satisfies them. The catch has always been cost. Verifying production code this way traditionally takes expert teams years of painstaking manual work, which is why most protocol verification stops at the design level — the diagram of how a protocol should work, not the code that actually runs. DeepMind's team did the whole job in four weeks.

The result is a genuine first, in DeepMind's words: 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 — the compiled code, not just its design — has been formally verified by any method, with or without AI.

AlphaProof Code Signal verification explained: what DeepMind actually proved

The target was libsignal version 0.105.4, the reference implementation of the Signal protocol, together with SPQR version 1.6.0, compiled with the stock Rust compiler into AArch64 (64-bit Arm) Linux machine code and linked to a small command-line harness. In total, the team verified about 560 KB of code — roughly 140,000 machine instructions — and proved that executions of that compiled code satisfy four core security properties:

Forward secrecy: if a long-term key is compromised later, messages sent earlier stay secret.
Post-compromise security: after a temporary compromise, the protocol recovers its security once fresh key material is exchanged — the job of the Triple Ratchet, which changes the encryption key with every message.
Authentication: a participant cannot be tricked into accepting the wrong peer, and compromising one party's long-term key does not open the door to certain impersonation attacks.
Handshake and message secrecy: the post-quantum PQXDH handshake that sets up a chat, and the messages that follow it, stay secret and authentic against an attacker who controls the network.

The proofs cover the parts of Signal that guard a conversation: the PQXDH handshake and the Triple Ratchet, including the post-quantum layer designed to resist future quantum computers. According to the technical paper, as summarised by independent coverage, the result rests on ten symbolic theorems. Crucially, this is a proof about the compiled code — the instructions a phone actually runs — not the protocol on paper. Real-world vulnerabilities often hide in the gap between design and implementation, and closing that gap is what makes the work so much harder than ordinary verification.

Two details show the proof is not a rubber stamp. First, DeepMind deliberately reintroduced two real, previously fixed Signal bugs into an isolated copy of the code. In both cases AlphaProof Code produced a machine-checked proof that the buggy version was insecure — evidence the system can tell correct code from broken code. Second, the work found no new vulnerabilities in the parts examined, according to WIRED's reporting of the project.

How AlphaProof Code works

AlphaProof Code splits formal verification the way a research team would split a hard project. Human experts decide what must be proved, and a group of AI agents does the proving. The pipeline has three stages:

Stage	Who does it	What happens
1. Specify	Humans + a mix of models	Signal's security goals are translated into formal mathematical specifications in Lean; human experts review every one.
2. Prove	Agent teams on Gemini Carbon	Prover agents write the proofs — more than six million lines of Lean — reasoning about the compiled AArch64 machine code, not the design document.
3. Check	Lean's kernel + gatekeeper	Every proof is machine-checked by Lean; a gatekeeper accepts a result only when the proof matches the held-out specification exactly. Auditor agents flag about 1% of the code for a second human look.

The division of labour is the point. An AI that writes millions of lines of proof would be worthless if the same AI could quietly weaken the goal it was proving. AlphaProof Code separates the roles: humans approve the specification, the agents prove against a fixed copy of it, and Lean — an independent proof checker — verifies the result. The trusted base is far smaller than the generated proof, but it is not zero: readers must still trust the approved specifications (about 18,000 lines, or 28,000 with documentation), the AArch64 machine-code semantics (about 8,000 lines), Lean's kernel, and the cryptographic assumptions. DeepMind says it tested the instruction semantics against independent emulators and models.

The scale is worth pausing on. The proof agents worked in teams of 40 to 80, running for 24 to 72 hours at a time on a single machine, according to secondary coverage of the paper — and none of the authors wrote any proof code themselves. Most of the human effort went into the specifications, not the proofs. That is the shift DeepMind is advertising: once agents can prove things cheaply, deciding what to prove becomes the hard, human part.

AlphaProof Code builds on AlphaProof, DeepMind's 2024 system that reached silver-medal level at the International Mathematical Olympiad by writing Lean proofs. It also builds on earlier, non-AI formal verification of smaller parts of libsignal carried out by the Signal Foundation with the firm Cryspen — work DeepMind says gave the team a head start. Signal CTO Ehren Kret welcomed the result, saying that while earlier verification focused on smaller portions of the code, DeepMind's approach "enables a significant expansion".

Google DeepMind logo — AlphaProof Code Signal verification

Image: Google DeepMind — Google DeepMind logo. Source: Wikimedia Commons, public domain.

What the proof does not cover — and why the limits matter

The easiest mistake with this story is to turn a narrow, strong claim into a universal one. AlphaProof Code did not prove that Signal is unhackable. Here is the boundary, as stated in DeepMind's own post and the technical paper:

Covered by the proof	Not covered
One-to-one sessions: PQXDH handshake and Triple Ratchet	Group chats — the paper restricts its Signal model to one-to-one sessions
libsignal v0.105.4 + SPQR v1.6.0, compiled to AArch64 Linux machine code	The full Signal Android, iOS or desktop app — interface, storage, notifications, media handling, update delivery
Forward secrecy, post-compromise security, authentication, handshake secrecy	Multi-device behaviour and every linked-device state; operating-system security, spyware, physical access or an unlocked phone
Symbolic and computational security models, with stated assumptions	The internal security of low-level cryptographic primitives, modelled as trusted contracts; some post-quantum properties (SPQR healing sits outside the symbolic result)
The exact version verified, in the project's modelled environment	Other processor architectures, and future libsignal versions — a proof for v0.105.4 does not transfer automatically to later code

A mathematical proof can only check the security rules researchers tell it to check. It cannot determine whether the human on the other end of a chat is who they claim to be, and it cannot protect a phone that is already compromised. DeepMind research scientist Swarat Chaudhuri was candid with WIRED about the distance still to go, saying there is "a long distance to go" before the method can scale "to all the software of the world". Google also declined to tell WIRED what the four-week project cost, or whether it plans to sell verification as a service — this was a research project, done free of charge, not a product launch.

Why it matters for readers in India and worldwide

For most readers, nothing changes today — and that is the honest headline. There is no emergency patch, no app to install, no setting to change because of this announcement. But the result matters for a reason that touches Indian readers directly: the Signal protocol family protects the chats Indians send every day. Signal itself has a large Indian user base, and variants of the same protocol protect WhatsApp and Google Messages — the two messaging apps most Indians actually live in. A mathematical proof that the core of that protocol does what it promises, down to the machine code, is stronger evidence about the privacy of those conversations than any number of security audits.

The larger result is methodological, and it reaches well beyond messaging. Formal verification has historically been reserved for the few systems where years of specialist work could be justified — operating-system kernels, compilers, aerospace software. AlphaProof Code shows that a human-guided team of AI agents can generate and integrate proof work at a scale that was previously 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 at all.

DeepMind points to the obvious next candidates: medical-device firmware, power-grid software, and other critical infrastructure — systems where a single flaw can hurt people at scale. Paired with automated defence agents like CodeMender, which DeepMind cites as the other half of the strategy, formal verification could help counter AI-driven cyber threats with software that carries a mathematical proof its protections work. That is a long road — specification quality, not proof-writing, is now the bottleneck, and real software has threads, files, dynamic linking and hardware variation that the current semantics do not model — but the Signal result is the first proof the road exists.

Should you care?

✅ Yes — as reassurance, not as a to-do list. If you use Signal, WhatsApp or Google Messages, this is unusually deep evidence that the encryption underneath your chats keeps its promises. You do not need to do anything because of it. The honest verdict: a landmark for software security, a non-event for your phone today.

What Signal users should do now

The announcement does not change ordinary account and device hygiene — the layers outside the proof are still the ones attackers actually target. Signal's own support guidance points to a small set of checks:

Keep Signal updated on your primary phone and every linked device; old releases can miss security fixes and newer protocol support.
Review linked devices in Signal Settings and remove anything you do not recognise.
Verify safety numbers for sensitive conversations, especially after an unexpected change — a changed safety number must be approved before you send again.
Protect account recovery with the second-factor options Signal offers, including passkeys stored in your operating system, a password manager or a physical security key.
Do not read the proof as a reason to ignore social engineering. Signal says it will never contact you in-app to ask for passwords, payment information or verification codes.

DeepMind has open-sourced the specifications and proof artifacts on GitHub, alongside the technical paper, so outside researchers can examine the work instead of taking a model score on trust. That openness is part of the result: a proof you can inspect is worth more than a claim you cannot.

FAQs

What is AlphaProof Code?
AlphaProof Code is Google DeepMind's agentic framework for formal verification, announced on 10 November 2026. Human experts decide which security properties to prove, AI agents powered by Gemini Carbon write the proofs in the Lean language, and Lean's kernel machine-checks every proof. It is a research framework, not a product — there is no signup, no price, and the agent team itself is not public.

Did DeepMind prove that Signal is unhackable?
No. AlphaProof Code proved specific security properties — forward secrecy, post-compromise security, authentication and handshake secrecy — for the compiled code of libsignal v0.105.4 in one-to-one sessions. It did not verify the full Signal app, group chats, multi-device behaviour, operating systems, or the low-level cryptographic primitives, which were assumed secure. No new vulnerabilities were found in the parts examined.

How long did the Signal verification take?
Four weeks, according to DeepMind — a task the lab says historically takes expert teams years. The agents generated more than six million lines of Lean proof, resting on about 26,000 lines of trusted specifications and machine-code semantics that humans reviewed. Auditor agents flagged about 1% of the code for a second human look.

Do Signal, WhatsApp or Google Messages users need to update anything?
No. The announcement is a research result, not an app update, and there is no emergency patch tied to it. Keep your apps updated as usual, review linked devices, verify safety numbers for sensitive chats, and protect account recovery with a second factor — the proof strengthens one critical layer, it does not replace the others.

Takeaway

AI agents just did in four weeks what used to take human experts years: a machine-checked mathematical proof that the code behind Signal's encryption keeps its core promises. The scope is narrow and honestly stated — one-to-one chats, one version, one architecture — but the method is the story. If it scales, the software that runs our banks, hospitals and power grids could one day carry the same kind of proof.

If you want the detail behind the headlines, read DeepMind's own announcement and browse the open proof artifacts linked in the Sources below — and if AI-written security is your beat, our explainer on OpenAI's GPT-6 Cyber, the hacking AI you cannot just sign up for is the natural next read. For the other side of the current AI race, see Claude Fable 5.2, Anthropic's new frontier model and WikiTrace, the system that links AI agent lessons to their source runs.

TechByCountry — Daily Tech News, Country by Country

Search This Blog