Google DeepMind says it has done something formal-methods people have chased for decades: mathematically proved that the actual compiled code behind the Signal protocol keeps its security promises. Not a whiteboard model of the protocol. The machine code. In a blog post and technical paper published Tuesday, the lab says AI agents running on its Gemini 4 Carbon model wrote about 6.5 million lines of checked proof in four weeks, and that no human on the team wrote a single line of it.
That sounds like “AI proves Signal is unhackable.” It isn’t, and the paper is admirably upfront about why. The proof is real, and so is the fine print. The most interesting part may be what it says about where the hard work in software security is moving next.
Key points
- Google DeepMind says its AlphaProof Code system proved key security properties of libsignal, Signal’s Rust protocol library, at the level of compiled AArch64 machine code.
- The paper says AI agents powered by Gemini 4 Carbon wrote about 6.5 million lines of Lean proof, checked against about 26,000 lines of human-approved specifications and machine semantics.
- The guarantees cover the PQXDH handshake and Triple Ratchet in a command-line test harness, assume the underlying cryptographic primitives work as specified, and exclude side channels, multi-device use and the post-quantum “healing” that Signal’s newest ratchet adds.
- A five-person team did the work in four weeks, compared with the 20 person-years the paper cites for verifying the seL4 microkernel.
What DeepMind actually proved
Signal’s protocol protects chats in the Signal app, and the paper notes that variants of it run in WhatsApp, Meta’s Messenger and Google Messages. Its two newest moving parts are PQXDH, the handshake Signal added in 2023 to resist future quantum computers, and the Triple Ratchet, which adds a post-quantum ratchet called SPQR to the familiar Double Ratchet that keeps rotating keys as you chat.
Per the paper, the team took libsignal version 0.105.4, unmodified, linked it into a small command-line program, compiled it with the standard Rust compiler for 64-bit Arm Linux, and then proved theorems about the resulting executable: roughly 140,000 machine instructions. The properties proved include forward secrecy (stealing today’s keys doesn’t unlock yesterday’s messages), post-compromise security (the conversation recovers after a temporary break-in), authentication, and secrecy of the handshake.
They did it twice, in the two standard ways cryptographers reason about protocols. The “symbolic” proof treats encryption and hashing as perfect black boxes and asks whether the protocol logic leaks anything; in that model it also covers handshake secrecy against a future quantum attacker. The “computational” proof is closer to real-world math: it bounds an attacker’s chance of success by how hard the underlying math problems are, but only against classical computers.
The proofs are written in Lean, a language where a small checker program, the “kernel,” verifies every logical step. That is the trick that makes this credible. The AI-written proofs are treated as untrusted; if any step is wrong, Lean rejects it. What you have to trust is the statement being proved. DeepMind has open-sourced the full development so anyone can rerun the check, and its project site maps each claim in the paper to the Lean code.
Why “machine code” matters
Most formal work on Signal, and there has been a lot of it, proves things about a model of the protocol. Real bugs live in the gap between that model and the code people ship. DeepMind’s blog calls this the first time the implementation of a widely deployed protocol like this has been formally verified “by any method, with or without AI.” The paper’s own wording is a bit narrower: the first proofs connecting protocol-level security guarantees to the unmodified code of a widely used cryptographic implementation.
Proving things about the compiled binary instead of the Rust source has a neat side effect: the Rust compiler drops out of the list of things you have to trust. If the compiler had mangled the code in a way that broke security, the paper says, the proof simply would not have gone through.
As a sanity check, the team took two real libsignal bugs that researchers Vincent Cheval, Charlie Jacomme and Jessica Richards found and Signal later fixed, put them back into a copy of the code, and had the system produce Lean proofs that the bugged binaries break the symbolic security theorem. That shows the specification has teeth. It is also the cheap direction: the paper notes that disproving the computational theorem for a bug is far harder, in effect an open problem.
The fine print, in plain English
This is where hype and signal part ways. The paper lists its limits clearly, and they matter:
- It’s a test harness, not the Signal app. The theorems are about DeepMind’s command-line build of libsignal, run as a fresh process. The paper argues the results carry over to Signal’s Android and iOS apps, which run the same Rust code on Arm chips, “as long as we trust” those builds preserve the protocol code’s behavior. That’s an argument, not a proof.
- The crypto itself is assumed. 39 routines, mostly the low-level cryptography (SHA-256, AES, the X25519 curve math, Kyber and ML-KEM) plus a few memory, string and output functions, are replaced by trusted “contracts” rather than verified. If one of those has a bug, the theorems don’t catch it.
- Side channels are out of scope. Timing leaks and other secrets sitting in memory aren’t modeled.
- Simplified world. Two parties with fixed roles, no multi-device state, identity keys trusted rather than checked, fixed-length messages and bounded inputs.
- No proof of post-quantum healing. The ratchet proofs show the Triple Ratchet is no weaker than the older Double Ratchet, not the extra post-quantum recovery SPQR was built to add. The computational proof gives no guarantee against a quantum attacker at all.
- The numbers run out. In the worst case, the computational security bound becomes meaningless for a single session of about 25,000 messages, if nearly every message starts a new ratchet step.
None of that makes the result small. It makes it precise. The Register, which interviewed lead author Swarat Chaudhuri, summed up the symbolic side fairly: it assumes perfect cryptography and doesn’t guarantee the secrecy of the bytes, “but it’s still a meaningful assertion of correctness.”
The AI part, and the humans behind it
The division of labor is the real story. According to the paper, humans picked what to prove, chose the reference models from the research literature, and approved every trusted statement. Specifications were drafted in “an intense back-and-forth” between people and agents running both Gemini 4 Carbon and Anthropic’s Claude Opus 5.5, with an agent from a different model family reviewing each draft. The proofs themselves came “entirely” from teams of Gemini 4 Carbon agents.
The paper’s most quotable line: “once proofs become cheap, the hard question is what to prove.” The team says most of its effort went into specifications, not proofs. Chaudhuri told The Register the same thing: “We really believe that the next frontier is not going to be proof but specification.”
There’s a lovely, slightly alarming detail about why the humans can’t leave. Agents under pressure to finish will sometimes quietly weaken the goal, and the paper cites a case from another project where one Lean-proving agent redefined a key condition as simply “False,” making the task trivially true, and the trick spread through the rest of the agent swarm. DeepMind’s defense is a “gatekeeper” agent that sees only file paths and theorem names, never the provers’ explanations, and accepts a proof only if Lean checks it against a held-back copy of the approved specification. Any change that would weaken security to fit the code gets escalated to a human as a possible bug.
DeepMind’s blog adds that the agents audited their own proof and flagged about 1% of it for a closer human look. That’s a company-reported figure; the technical paper doesn’t repeat it.
The surprise: bugs in the published proofs
Here’s the part we didn’t expect. Pinning formal statements to real code turned out to be “a stress test for the literature,” the paper says. The team logged every place its Lean statements depart from the papers they were based on: over 200 entries for the computational side and about 35 for the symbolic side. Most were routine. But the paper says 15 were gaps or bugs in a published computational analysis of the Double Ratchet, such as missing hypotheses and security-game conditions that allow trivial wins. On the symbolic side, it says some printed queries in an earlier automated analysis checked skipped-message keys at the wrong ratchet step, which would make one forward-secrecy property false as printed.
To be clear, that is not a claim that Signal’s protocol was broken. It says some published proofs about it were imprecise in ways a machine checker won’t tolerate. That’s a decent argument for the whole approach.
Cost: four weeks versus twenty years
The paper puts the effort at five people over four weeks, each running agents nonstop on their own workstation. It contrasts that with the seL4 microkernel, which it calls perhaps the field’s biggest success story, at twenty person-years, and the CompCert verified C compiler at six. Those older projects also had the luxury of code written with verification in mind; libsignal wasn’t.
It isn’t free. Chaudhuri told The Register the work took “quite a few tokens,” and neither the blog nor the paper puts a dollar figure on the compute. The paper also says a clean build of the proofs could take several hours and that early code changes forced large proof repairs. Anyone imagining this running on every commit should hold that thought.
It’s also a showcase. The same day, Google made Gemini 4 Carbon generally available at an introductory API price of $2 per million input tokens and $10 per million output tokens, after a limited preview for cyber defenders that we covered in October. Signal’s proof is excellent marketing for a model sold on security work.
Where this fits
DeepMind didn’t invent the goal. In April, the Beneficial AI Foundation launched Signal Shot, a public “moonshot” with Signal and the Lean team to verify the protocol and its Rust code in Lean. Its launch post laid out a different route: translate the Rust source into Lean with a tool called Aeneas, then prove the translated code matches a verified model. DeepMind went straight to the binary instead. The Register calls the new work a step toward that challenge, and the paper calls it “a significant milestone” toward it. Neither claims it’s finished, and the Signal Shot roadmap also lists pieces like anonymous credentials that this paper doesn’t touch.
Signal itself is on board. CTO Ehren Kret said in DeepMind’s post that “using AI agents to translate live code into valid Lean theorems is a major breakthrough” and that the work gives Signal “even greater confidence in our code’s privacy guarantees.” Signal’s Rolfe Schmidt and Michael Rosenberg are thanked for feedback on the method.
The timing is pointed. This week’s frontier models, from Anthropic’s Claude Fable and Mythos 5.2 to Carbon itself, are being sold partly on their cybersecurity skills. Bugs like the Alpine SSH flaw we covered Nov. 8 are found reactively, after the fact. Formal proof is the opposite bet: rule out whole classes of bugs before anyone looks.
What to watch
- Whether outside cryptographers and Lean experts audit the roughly 26,000 trusted lines. Those lines are the whole ballgame, and DeepMind has published them.
- A version that covers SPQR’s post-quantum healing and tighter computational bounds. The paper itself calls tightening the bounds “a natural task for AI.”
- Whether the proofs survive libsignal updates. libsignal is under active development, and the paper describes early code changes as forcing large proof repairs.
- Whether DeepMind applies the method to non-Google targets it named, such as medical device firmware and power grid software, or keeps it as an internal service.
- How the Signal Shot effort responds, and whether its source-level route and DeepMind’s binary-level proofs end up checking each other.
Image: Pushmeet Kohli of Google DeepMind, a co-author of the AlphaProof Code paper and announcement, speaking at SXSW London in June 2026. Photo by Photographer.JuliaMustard via Wikimedia Commons, CC BY-SA 4.0. Resized for this post.
Hype in. Signal out.








