Skip to main content

AlphaProof Code: DeepMind Agents Verify Signal's Protocol in Lean

AlphaProof Code is a Google DeepMind framework in which teams of AI agents write formal proofs that the Lean proof assistant then checks. DeepMind used it to prove security properties of libsignal, the Signal protocol's Rust library, at the level of compiled machine code. The proofs cover one-to-one sessions only, and they rest on stated cryptographic assumptions.

On this page

What DeepMind announced on 10 November

Google DeepMind has introduced AlphaProof Code, which it describes as a multi-LLM agentic framework for formal verification. Its first target is a demanding one: the library behind Signal, the encrypted messenger whose protocol also protects conversations in other apps.

The division of labour is the core idea. Human experts decide what should be proved, and agents write the proofs. The accompanying paper lists four parts: a human-guided agent that helps write specifications, a formal model of AArch64 machine code, a team of autonomous prover agents, and a gatekeeper agent. A proof only counts if Lean's kernel accepts it against the approved specification.

The numbers are large. The paper reports about 6.5 million lines of machine-checked Lean proof code, and the blog says the verification took four weeks. According to the paper, teams of 40 to 80 agents ran on a single machine for 24 to 72 hours per proof campaign. DeepMind names Gemini Carbon as the model behind the prover agents, and says the agents flagged about one percent of the codebase for a second look by people.

What the proofs actually cover

The target is libsignal, the protocol's reference implementation in Rust. The team wrapped the unmodified protocol crate and the post-quantum ratchet crate in a small command-line harness, compiled it with the standard Rust compiler to an AArch64 Linux binary, and proved properties of that binary. Working on machine code means the Rust compiler does not have to be trusted.

The properties are the ones people rely on Signal for: forward secrecy, post-compromise security, authentication, handshake secrecy, and message confidentiality and authenticity. In plain terms, a temporary compromise of a device should not expose earlier messages, and the session should recover afterwards.

No new bugs turned up. As a test, the team reintroduced two real bugs that Signal had already fixed into an isolated copy. In both cases the system produced a machine-checked proof that the altered binary was insecure. That matters because a verifier that can only say yes is not much use.

Signal was involved to a degree. The blog carries an endorsement from Signal's chief technology officer, Ehren Kret, and thanks three Signal staff for feedback on the method. When we checked, Signal's own blog had no post about the work, and the sources do not say that Signal reviewed the proofs themselves.

The limits a reader should know

Formal proofs are precise about what they assume, and this one assumes a lot. The paper lists what is out of scope: group messaging, more than two parties, multi-device state, key generation, and the healing behaviour of the post-quantum ratchet. The computational proof considers a classical attacker only, and its bound becomes vacuous across many long sessions.

The cryptographic primitives are not proved secure. They are idealised in one model and covered by standard hardness assumptions in the other. Readers also have to trust Lean's kernel, the machine-code model, 37 routines replaced by contracts, and roughly 18,000 lines of definitions and statements that describe what security means.

Then there is the gap between a harness and a phone. The paper says the Signal apps for Android and iOS are not verified directly, so the results only carry over if those platforms preserve the binary's behaviour. Claims that this is the first verification of its kind are DeepMind's own, and we found no independent review yet.

Why private messaging users should care

Until now, confidence in an encrypted messenger came from audits, open source code, and academic analysis of the protocol design. Those leave a gap between the design on paper and the code that runs. Machine-checked proofs about compiled code narrow that gap, and agents make the labour affordable.

The artifacts are public, so others can check the work. DeepMind has published the Lean development and a repository on GitHub, which was last updated on the day of the announcement. The repository's licence is not a standard one that GitHub recognises, so read it before reusing anything.

DeepMind points to medical device firmware and power-grid software as future targets, though these are aspirations and not completed work. For anyone who cares about private communication, the practical takeaway is modest but real: a core part of Signal's one-to-one messaging now has machine-checked evidence behind it, with its assumptions written down.

CuriousLM runs supported AI models locally on your device. Try CuriousLM.