LIVE TICKER
[Live wire]Connecting to the newsroom…
CodingPublished 10 November 2026 • 11 min read • 2,408 words • 5 cited sources

AlphaProof Code verified Signal's encryption code — what the proof covers

Google DeepMind's AlphaProof Code used Gemini agents to machine-check security proofs for libsignal, the implementation behind Signal's encryption, in four weeks. The result covers one-to-one messaging at the binary level, not the whole app.

AlphaProof Code verified Signal's encryption code — what the proof covers
Google DeepMind — view at source ↗

Key facts at a glance

Proof size
About 6.5 million lines of Lean proofGoogle DeepMind technical paper
Verification time
Four weeks, versus years for earlier large verification effortsGoogle DeepMind
Verified target
libsignal v0.105.4, one-to-one sessions, compiled AArch64 machine codeGoogle DeepMind technical paper
Prover model
Gemini Carbon agents, 40 to 80 per campaignGoogle DeepMind
Cost
Not disclosed; Google declined to share the cost or commercial plansWIRED

What did AlphaProof Code prove about Signal?

On November 10, 2026, Google DeepMind published what it calls the first formal verification of a widely deployed cryptographic protocol's real implementation. The target was libsignal, the open-source library behind the Signal messaging protocol, at version 0.105.4.

The proofs cover Signal's post-quantum PQXDH handshake and the Triple Ratchet that derives a fresh key for every message. According to the technical paper, they establish forward secrecy, authentication, post-compromise security and handshake secrecy.

What makes the result unusual is the level of detail. Most protocol proofs reason about an abstract design or a rewritten model. This one reasons about the compiled AArch64 machine code that ships to devices. The code is loaded as an ELF binary and checked instruction by instruction.

DeepMind calls it the first time AI has been used to formally verify a widely deployed cryptographic protocol at this depth. The paper goes further. It describes the proofs as the first to connect protocol-level guarantees to the unmodified code of a widely used implementation. Both are company claims, though independent outlets reported the milestone without disputing the framing.

The practical claim is narrower than some headlines suggest. WIRED's report notes that the analysis did not find any new vulnerabilities in the portions of Signal it examined. The value here is assurance, not a bug hunt.

How does AlphaProof Code work?

AlphaProof Code is not a single model. It is a framework that divides verification work the way a research group would, pairing human judgment with teams of AI agents.

The first component is a specification-writing agent. It works with a human to turn published security models into Lean definitions and theorem statements. Reviewer agents critique each draft, and a person approves the final version. That approved commit becomes the baseline for everything that follows.

The second component is a formal semantics for AArch64 Linux. It takes an executable as a list of bytes and describes every possible run. The paper says it covers 467 instructions and 31 system calls in 7,578 lines of Lean.

The third is the prover team. Agents powered by Gemini Carbon, DeepMind's frontier model, write proofs against the approved specification. Campaigns typically used 40 to 80 agents and ran for 24 to 72 hours on a single machine. An orchestrator splits the work, team leads absorb context, an architect plans the decomposition, and an integrator merges verified lemmas.

The fourth is a gatekeeper. A proof is accepted only if Lean's kernel checks it. A comparator must also confirm it proves exactly the held-out specification the human approved. That matters because a theorem can be quietly weakened by editing a definition it depends on.

Every agent, including the specification writer, is a general-purpose coding agent configured by skills. A skill is a natural-language document describing the task, the sources to consult and the checks to perform. The orchestrator never edits Lean files itself; it schedules workers and relies on team leads to absorb their back-and-forth.

Proof attempts can expose a specification that is subtly wrong about the code. Agents cannot edit the approved specification, but they can propose amendments to a critic that never sees the proof attempts. An amendment must be necessary, must not weaken security, and must stay small. Changes to trusted assumptions need human approval and are logged with a justification.

The output was about 6.5 million lines of Lean proof. The parts a reader must actually trust are far smaller. They amount to roughly 18,000 lines of statements and definitions. The machine semantics and symbol names add about 8,000 lines.

DeepMind says an audit pass then flagged about one percent of the codebase for human review. Because Lean checks the rest, experts could concentrate on the places where judgment mattered. The blog frames that split as deliberate, with agents doing the volume and people reviewing where judgment matters most.

Why does machine-code verification matter?

Cryptographic protocols are usually analyzed at the design level. That leaves a gap between the protocol on paper and the binary running on a phone.

Real attacks often live in that gap. A missing validation check, a mishandled error path or a compiler-level detail can undo a sound design.

The Signal protocol has been analyzed before. The DeepMind paper builds on prior symbolic and computational work, including studies that found real bugs in libsignal. To test whether its specifications were strong enough, the team re-injected two fixed bugs into an isolated copy. They then recompiled it.

The work runs two kinds of proof. The symbolic model, also called Dolev–Yao, treats cryptography as abstract black boxes with ideal properties. The computational model bounds an efficient attacker's success probability by the hardness of the underlying primitives.

Connecting machine code to either model is awkward. Hardware has no notion of messages; the CPU only reads and writes registers and memory. Hardware values are also finite byte strings, so an attacker can guess an 8-byte MAC with probability 2 to the minus 64. The proof handles that with a collision clause rather than pretending the gap does not exist.

One injected bug, labeled weak state, involved a prekey message that fails to decrypt and is retried against older sessions. That leaves an unconfirmed session state holding a copy of the signed prekey secret.

The other, called small subgroup, involved a missing check that an initiator's X25519 base key is torsion-free. A replayed handshake with a mangled key could then create a second session with the same shared secret.

For both bugs, the agents produced machine-checked proofs that the security theorem fails on the buggy binary. That is the strongest available evidence that the specification is not vacuous.

The cost comparison is the headline for engineering leaders. The paper notes that verifying the seL4 microkernel took twenty person-years and the CompCert C compiler took six years. Both were designed with verification in mind, which makes the comparison favorable to the new work.

DeepMind's campaign took four weeks, according to the blog and the paper. The Register interviewed research scientist Swarat Chaudhuri. It reports a team of five people and, in his words, "quite a few tokens".

Signal's chief technology officer, Ehren Kret, welcomed the result in a statement. He said using AI agents to translate live code into valid Lean theorems is "a major breakthrough". He added that rigorous verification gives Signal greater confidence in its privacy guarantees as AI-driven threats grow.

How is this different from AI bug-finding?

Most software assurance comes from testing, bug finding and code review. The DeepMind paper argues that this reactive approach has inherent limits, even with strong AI cyber-defense tools hunting for defects.

A proof makes a different kind of claim. If the specification is right and the proof checks, the code cannot violate the stated properties. That covers attacks nobody has thought of yet, not just the bugs someone managed to trigger.

The two methods also answer different questions. A bug finder can surface an unknown defect in code nobody modeled. A proof can only speak to the properties its author wrote down. A verified confidentiality theorem says nothing about a flawed user interface or a careless backup feature.

DeepMind presents the approaches as complementary. Its blog points to CodeMender, an AI agent for code security introduced in October 2025, as a counterpart to formal verification. Proofs raise the assurance floor; bug finders widen the search.

The Signal result shows how the division works in practice. The campaign found no new vulnerabilities, according to WIRED. It did show that two historical bugs would break the proof, because the specification was strong enough to exclude them.

There is an economic argument underneath this. Reactive security pays again every time a new class of bug appears. A proof about a fixed binary does not expire in the same way. It does need rechecking when the code or its assumptions change.

What does the proof not cover?

The scope is narrower than "Signal is proven secure". The paper is explicit about the boundaries, and they matter for anyone tempted to over-read the result.

The target is a single-threaded, statically linked process. The semantics does not model threads, signals, the vDSO, dynamic linking or files outside the current directory. Group messaging is left as future work, and the analysis covers one-to-one sessions only.

The security models impose their own limits. Symbolic guarantees assume perfect cryptography. The computational theorem is classical, so it gives no guarantee against a quantum adversary. The symbolic proof does cover handshake secrecy against a future quantum attacker. The ratchet proofs also let the attacker choose the SPQR keys. That shows the Triple Ratchet is no weaker than the Double Ratchet. It does not prove the post-quantum healing SPQR is meant to add.

Some properties sit outside the campaign entirely. Payload privacy, responder authentication for first messages of handshakes that are never promoted, and side channels are not covered. The Signal mobile apps are not covered either; WIRED notes that the analysis did not verify the entire app.

There is also a trusted base that Lean cannot check. It includes the AArch64 semantics, the model of how Linux runs a process, contracts for hooked cryptographic routines, and Lean's own kernel. It also includes the scripts that build the binary reproducibly and the tooling that extracts symbol names from the compiler's object files.

The specification itself is the largest soft spot. A theorem that assumes too much or states too little can hold even for buggy code. DeepMind mitigates this with reviewer agents, vacuity checks and mutation testing. The paper still concedes that human review of a large specification will not catch every mistake.

The specification also took real work to assemble. Published models analyzed Signal's handshake and its ratchet separately, and they predate the post-quantum ratchet. With human guidance, the agents composed those models and extended them to the deployed protocol after several rounds of drafting and review.

One design choice cuts the other way. Because the proofs are stated over machine code, the Rust compiler is not trusted. A compiler bug would make the theorem false and the proof would fail, rather than silently undermining the guarantee.

What does formal verification cost now?

Google has not published a price. WIRED reports that DeepMind ran the Signal analysis free of charge as a research project. The company declined to share the cost and would not comment on plans for a commercial verification product or service.

That silence matters. The pitch is that AI collapses the labor cost of proof writing. The remaining costs are specification work, compute and expert review.

Compute is not trivial either. A campaign of 40 to 80 agents runs for days, with repeated Lean builds and an integrator merging proofs. Google has not put a number on that compute, which leaves cost estimates to whoever tries to repeat the work.

The people cost may prove stickier. Someone has to decide what to prove, write the threat model and approve amendments that change trusted assumptions. Those skills sit with a small group of cryptographers and formal-methods engineers. The paper says AI reduces that burden without replacing it.

DeepMind argues the payoff could extend well past messaging. The blog says verifying Signal's core cryptography lays groundwork for medical device firmware and power grid software.

Machine-code proofs are long. The paper says a substantial fraction of the proofs concerns registers, stack frames and memory layout. Those are the parts source-level verification would hide. Verifying at the source level would be cheaper in compute, at the price of trusting the compiler and the language semantics.

Chaudhuri told The Register that the next frontier is not proof but specification. That is where ambiguity, threat models and security trade-offs live, and where humans remain in the loop.

He also drew a line against full automation. He told WIRED the team did not want a situation where AI sets the goals and writes the proofs. That would amount to grading its own work.

Pushmeet Kohli, DeepMind's vice president of research, framed the payoff in assurance terms. He told WIRED that if you can now verify the correctness of these implementations, then you can "rest easy". He pointed to banks and other companies that depend on assurances about bugs.

For now, the honest answer to "can I verify my codebase?" is that the method has been demonstrated once. It ran on a library with unusually clear security goals and years of prior analysis to build on.

What happens next for Signal and AI verification?

The Signal work did not start from nothing. It is a milestone toward a challenge called Signal Shot. The Beneficial AI Foundation launched that challenge on April 20, 2026 with Signal and the Lean FRO.

The challenge's stated goals go beyond a one-off proof. It wants tooling for continuous verification as software evolves. It also wants a reference for how verified software should be shipped, and a stronger Lean ecosystem.

Its co-chairs are Max Tegmark, president of the Beneficial AI Foundation, and Leonardo de Moura, chief architect of the Lean FRO. Signal research engineer Rolfe Schmidt is an organizing co-chair. The foundation argues that capable AI hacking tools make the project timely.

DeepMind says it is open-sourcing the specification and proof artifacts. The paper lists three directions. They are to strengthen the theorems, shrink the trusted base, and expand beyond one-to-one sessions. The targets include group messaging, sealed sender and server-side protocols.

Chaudhuri told The Register that the dream is to scale this up. He cited insecure systems that are "going to be exploited". He also said the team has good insights, though "not the last word by any means".

The near-term test is independent scrutiny. A proof is only as good as its specification, and the specification is now public. Cryptographers can read it, attack it and argue about whether it captures the properties Signal actually needs.

Reproduction is feasible in principle. The paper's proofs rest on a pinned ELF binary. Lean's kernel parses that binary and steps through its AArch64 code for each witness trace. A reviewer with the artifacts can rerun the checker rather than trusting a screenshot.

The longer-term question is whether continuous verification becomes part of normal engineering. If proofs can be regenerated as code changes, the gap between a security review and a shipping binary starts to close. If every campaign still needs a hand-built specification and a research team, the technique will stay where it started. That is with the most critical systems.

Three signals are worth watching. The first is whether Signal or another maintainer wires this kind of proof into a release process. The others are whether outside teams reproduce the libsignal result, and whether the specification reaches group messaging and the apps.

Books behind the context

  • Simon Singh

    A history of codes and code-breaking that explains why provable secrecy is a distinct goal from practical encryption.

  • Niels Ferguson, Bruce Schneier and Tadayoshi Kohno

    Explains how implementation details and protocol composition decide real-world security, the gap this verification work targets.

  • Adam Chlipala

    A practical introduction to machine-checked proofs about programs, the discipline AlphaProof Code automates at a much larger scale.

Sources used for this dispatch

  1. Google DeepMind - Introducing AlphaProof Code: a breakthrough in verifying complex software at depth
  2. Google DeepMind - AlphaProof Code: Verifying Signal's Security at the Machine-Code Level
  3. WIRED - A New AI Tool From Google DeepMind Proved the Signal Protocol Is Secure
  4. The Register - Google DeepMind melds humans and AI agents to vet Signal's secure messaging techniques
  5. Beneficial AI Foundation - Signal Shot

This article is original analysis and synthesis. Facts, figures and quotations are attributed to the sources above. Images remain the property of their publishers and are credited in the caption.

Questions readers ask

Did DeepMind find a new security flaw in Signal?

No. WIRED reports that the analysis did not find new vulnerabilities in the parts of Signal it examined. The team instead verified existing security properties.

Does this mean Signal is now proven completely secure?

No. The proof covers one-to-one sessions in libsignal v0.105.4 at the machine-code level. It excludes group messaging, the Signal apps, the server, side channels and several properties listed in the paper.

How long did the Signal verification take?

Four weeks, according to Google DeepMind. The Register reports that the effort involved a team of five people and a large but undisclosed amount of model compute.

What is AlphaProof Code?

It is a multi-agent framework for formal software verification. Humans approve a Lean specification, Gemini Carbon agents write the proofs, and Lean's kernel checks every step.

Can other software be verified this way today?

Not routinely. The method still needs a carefully written specification, a formal model of the execution environment and expert review. DeepMind calls scaling it to more software a research goal.

Topics:AlphaProof CodeSignalformal verificationLeanGoogle DeepMindcryptography

More from the research desk