AI Agents Just Proved Signal's Compiled Code Secure Down to the Machine Instructions, With 6.5 Million Lines of Proof in Four Weeks
The proof covers the code that runs, not just the design on paper
Google DeepMind announced AlphaProof Code on November 10, and the result it arrived with is the kind of claim security people have wanted for decades. A team of AI agents mathematically proved key security properties of the actual compiled code behind Signal, the protocol that protects private conversations in Signal, Google Messages, and, in variants described in the technical paper, WhatsApp and Messenger.
DeepMind makes two first claims, and both need to be read exactly as written. It says this is the first time AI has been used to formally verify a widely deployed cryptographic protocol at this depth. It also says this is the first time the implementation of a widely deployed protocol like this has been formally verified by any method, with or without AI. Earlier verification work largely stopped at the design level: prove the protocol on paper, then trust that the software matches the paper. This work targets the gap where real bugs live, between the design and the binary a phone actually runs.
The verified target was specific. According to the technical paper, the team took the unmodified libsignal version 0.105.4 library, together with the SPQR version 1.6.0 crate, built it with the stock Rust compiler into a statically linked AArch64 Linux executable, and proved properties of that compiled output, roughly 560 kilobytes of source covering about 140,000 machine instructions. The scope was one to one session code: the PQXDH handshake that starts a conversation and the Triple Ratchet that keeps it secure as messages flow.
What the agents actually proved
The properties proved are the promises Signal is known for, stated in the researchers’ formal specifications. They include forward secrecy, which keeps past messages protected if a device is compromised later, post compromise security, which restores protection after a temporary compromise ends, plus authentication and initiator and responder secrecy. DeepMind’s blog describes the same idea in plain terms: keeping messages protected before and after a device is temporarily compromised.
The paper gives the result two independent legs. One is symbolic: ten theorems proved under idealized cryptographic assumptions. The other is computational: a proof that bounds how much advantage an attacker who controls the network and the server can gain, built from cryptographic assumptions and statistical terms. The main theorem carries the name signal_session_secure_placed in the published artifacts.
The numbers describe a new division of labor. The proof itself runs to about 6.5 million lines of Lean, the proof language whose kernel checks every step, produced in four weeks by a small research team running agent teams continuously. A typical proof team, per the paper, was 40 to 80 agents working for 24 to 72 hours on one machine, under a supervising agent. Against those millions of generated lines sits the part humans had to get right: roughly 26,000 lines of trusted specification and machine semantics that state what security means and how the AArch64 processor behaves. DeepMind is direct about where the effort went. The majority of the human effort went into the specifications, not the proofs, and none of the authors wrote the proof code themselves.
How AlphaProof Code divides the work
AlphaProof Code is a framework, not a model you can buy, and DeepMind has not released the agent system itself. What it released, under an open license, is the evidence: the specifications, the proofs, the machine semantics, and a map from the paper to the code, so outsiders can check the work.
The workflow splits by trust. Human experts worked with a mix of models to translate Signal’s security goals into formal specifications, and humans reviewed every one. Published analysis notes that drafting and review used both Gemini 4 Carbon and Claude Opus 5.5, so a different model family checked the wording of what had to be proved. Then agent teams powered by Gemini Carbon wrote the proofs.
A gatekeeper decided what counted as done. A proof was accepted only after Lean’s kernel checked it and a comparator confirmed the statement proved matched the held out, human approved specification, using only Lean’s standard axioms. That matters because a proof agent rewarded for finishing will happily prove the wrong, easier statement.
After the proofs, the agents audited their own work and flagged about one percent of the material as needing a second human look. Because Lean had checked the rest mechanically, experts could spend their time on that one percent, where judgment mattered.
The bug test is the part that makes it believable
A verification system that always says secure is worthless, so the team tested whether AlphaProof Code can tell good code from bad. They took an isolated copy of the Signal code and put back two real bugs that had previously been found and fixed. In both cases, the system produced a machine checked proof that the buggy version was insecure. Independent readers who cloned the public repository after publication reported that the disproof sections for those reintroduced bugs contain no proof escape hatches, though a full recheck by Lean’s kernel takes several hours and substantial memory, so most outside checks so far are audits of the artifacts rather than fresh verifications.
Signal’s own response was measured. Chief technology officer Ehren Kret said the work gives Signal even greater confidence in the code’s privacy guarantees. That is an endorsement of the method and the result, not a claim that the whole Signal app is now proven safe, and the paper’s own limits show why the distinction matters.
What was not proved, stated plainly
The limits are not fine print. They define what the headline does not cover:
- Key generation was not verified. The proof starts from keys that already exist.
- Group messaging was left for future work. The result covers one to one sessions only.
- Side channels and multi device state are outside the scenario. The verified setup is the researchers’ command line build of libsignal running as a fresh process, not every app, phone, and sync state in the wild.
- The post quantum healing property of SPQR was not established. The computational proof covers classical attackers, and in the symbolic ratchet theorems the attacker is allowed to choose the SPQR keys.
- The trusted base still needs human reading. About 26,000 lines of specification and semantics are assumed correct. If a specification states the wrong property clearly, the agents can prove it perfectly.
None of this shrinks the result. It marks its border, and a team that cannot state the border of its own proof has not finished the work. DeepMind stated it.
What this changes for everyone building secure software
- Verification cost collapsed for proof writing, not for thinking. Four weeks instead of years sounds like automation of the whole job. The paper shows the opposite split: proofs got cheap, specifications became the scarce human work. Budget for people who can say precisely what secure means.
- Demand the artifact, not the claim. This result is believable because the specifications and proofs are public and machine checked. Ask any vendor offering verified security for the same package: the spec, the proof, the checker, and what is outside the scope.
- Use the bug test as your acceptance test. Feed any AI assurance tool a version with a known, real bug put back in. A tool that cannot prove the buggy version wrong has told you nothing when it calls the clean version safe.
- Expect this pattern beyond messaging. DeepMind names medical device firmware and power grid software as the direction. Any system where a flaw exposes millions at once, and where the property can be stated precisely, is a candidate.
- Do not cancel the audits you already run. A proof covers the properties in its specification, for the build it checked. It does not cover the app around the library, the servers, the update path, or the next version.
The bottom line
On November 10, DeepMind’s AlphaProof Code did something the security field has treated as a grand challenge: AI agents proved, down to compiled machine instructions, that the core one to one cryptography in libsignal delivers the secrecy and authentication properties its specifications promise, writing about 6.5 million lines of machine checked proof in four weeks, and proving two deliberately reintroduced bugs insecure along the way. The honest limits, no key generation, no group messaging, no side channels, no post quantum healing claim, do not weaken the milestone. They are what a real proof looks like. The shift to copy is simple: when machines can write proofs by the million lines, the valuable human skill is no longer checking every step. It is deciding, precisely and in writing, what must be true.