News · AI Reliability & Operations · Software Factories & AI-Assisted Engineering
AlphaProof Code proves libsignal security properties in machine code
Google DeepMind used a multi-agent Lean framework to formally verify the Signal protocol's reference implementation at the AArch64 machine-code level.
On November 10, 2026, Google DeepMind introduced AlphaProof Code, a multi-agent framework for formal specification and verification. It used the framework to prove key security properties of libsignal, the Signal protocol's reference implementation, at the machine-code level (Google DeepMind). The accompanying paper reports about 6.5 million lines of machine-checked Lean proof, resting on about 26,000 lines of trusted specifications and processor semantics. The results rely on the security of the cryptographic primitives, and secondary analysis notes the proofs do not cover the Signal apps.
What happened
DeepMind announced the work in a blog post and a paper, both dated November 10, with a PDF version of the paper also published.
The paper describes three components. A human-guided agent writes specifications in Lean. A formal semantics models AArch64 machine code. A team of autonomous prover agents then produces proofs, which are accepted only if Lean's kernel checks them against the approved specification. A gatekeeper agent enforces that rule. It accepts a proof only when Lean's kernel checks it and the Lean comparator confirms it proves exactly a held-out copy of the specification.
On scale, the paper reports about 6.5 million lines of machine-checked Lean proof resting on about 26,000 lines of trusted specifications and AArch64 semantics. The blog post gives a rounder figure, "over six million lines." The two figures are consistent but differ in precision. The Register also covered the scale.
The proofs cover the post-quantum PQXDH handshake and the Triple Ratchet. The properties are forward secrecy, authentication, post-compromise security and handshake secrecy. According to the paper's Table 1, all four are proved in the symbolic (Dolev-Yao) model, where handshake secrecy also holds against a future quantum attacker. The computational model separately bounds message confidentiality and authenticity, with forward secrecy and post-compromise security, against classical attackers only. Table 1 lists handshake secrecy only under the symbolic model, and lists quantum attackers as not covered by the computational model (paper; The Register).
According to the paper, the team compiled unmodified Rust code with stock rustc to AArch64 Linux machine code and linked it into a small command-line harness. Low-level cryptographic primitives are specified by contracts. The results rely on Lean's kernel, on the security of those primitives, and on the contracts of some called routines.
DeepMind says Gemini Carbon powered the proof agents and that humans reviewed every specification. The agents flagged about one percent of the codebase for human review, and the verification took four weeks (Google DeepMind). As a check on the method, the team reintroduced two real, previously fixed bugs into an isolated version of the code. DeepMind says that in both cases the system produced a machine-checked proof that the buggy version was insecure (Google DeepMind).
DeepMind says this is the first time the implementation of a widely deployed protocol like this has been formally verified by any method. That is the company's claim. The blog also quotes Signal's CTO supporting the work (Google DeepMind). DeepMind's post on X put it this way: "For the first time, AI has mathematically proven @signalapp's protocol is secure down to the code level." The artifacts are open-sourced, and the Lean development is available at the paper site (Google DeepMind; paper).
Secondary analysis sets out the limits. sysnote reports that the proofs do not cover the cryptographic primitives, key generation, group chats or the Signal apps. The Register notes that the result assumes perfect cryptography.
The Transition2 desk did not run an experiment for this story. The released Lean development needs the AArch64 semantics and a large Lean build, and the desk did not reproduce any proof.
Why it matters
The design question that matters most is where trust sits. In AlphaProof Code, the agents generate proofs, but acceptance does not depend on the agents. A proof counts only if Lean's kernel checks it and the comparator confirms it matches a held-out copy of the approved specification (paper). Trust shifts from the model's output to a small checker plus human-reviewed specifications. That is why the paper can state exactly what the result relies on.
The level of verification also matters. The proofs concern machine code built from unmodified Rust with a stock compiler, which is the form the code takes when it runs on AArch64 Linux, rather than an idealized model of the protocol (paper). The reintroduced-bug test shows the method produced proofs of insecurity for two real past flaws (Google DeepMind).
The limits are just as concrete. About 26,000 lines of specifications and semantics are trusted, the primitives are assumed secure, and parts of the product are out of scope (sysnote). The X post's wording, that the protocol is "secure down to the code level," reads more broadly than the paper's stated trust base. Readers should use the paper's scope. More on verification and assurance practice sits in AI Reliability & Operations and Software Factories.
What it means for businesses
For organizations that depend on security-critical code, this is a documented example of agents producing very large proofs while humans review the specifications. DeepMind says the agents flagged about one percent of the codebase for human attention and the work took four weeks (Google DeepMind). When a vendor claims software is "formally verified," the useful follow-up questions are the ones this paper answers. What is in the trusted base? Which components are out of scope? Who reviewed the specifications?
What it means for AI users
People who use Signal get a stronger, machine-checked argument for specific properties of the protocol code: forward secrecy, authentication, post-compromise security and handshake secrecy (paper). The result does not cover the apps, group chats or key generation (sysnote). Device security and app behavior are separate questions.
What it means for developers
The reusable pattern is to let models generate artifacts freely in volume while accepting only what a small deterministic checker verifies against a held-out specification. The same principle applies at smaller scale: tests, type checks and schema validation as gatekeepers for agent output. With the Lean development open-sourced (paper), teams with formal methods experience can inspect the specifications directly. The trusted base deserves the closest reading: the specifications, the AArch64 semantics and the primitive contracts.
Copyright Eric MacDougall.
Sources
- Introducing AlphaProof Code (accessed 2026-11-13)
- AlphaProof Code: Verifying Signal's Security at the Machine-Code Level (accessed 2026-11-13)
- Formal Verification of Signal (paper PDF) (accessed 2026-11-13)
- Google DeepMind melds humans and AI agents to vet Signal's secure messaging techniques (accessed 2026-11-13)
- AlphaProof Code: what DeepMind's 6.5 million lines of Lean actually prove about Signal (accessed 2026-11-13)
- Google DeepMind on X (accessed 2026-11-13)