Google DeepMind has used a multi-agent system called AlphaProof Code to formally verify core parts of Signal's encryption — work that has historically taken teams years. Five people finished in about four weeks. It is a genuinely significant result, and it proves considerably less than most headlines about it imply.

What was done

Formal verification means proving mathematically that code behaves according to its specification for every possible input, rather than testing a sample. It is the strongest assurance software can have, and it is normally so laborious that only aerospace, chip design and cryptography bother.

In AlphaProof Code, human experts set the security goals and AI agents write the proofs in Lean, a proof assistant. Lean's kernel then checks them. The agents generated roughly 6.5 million lines of Lean.

What they covered: Signal's post-quantum handshake (PQXDH) and the Triple Ratchet, verified against the compiled 64-bit Arm binary rather than only the source. That last detail is the technically impressive one — it closes the gap in which a compiler could introduce a flaw that no amount of source review would catch.

DeepMind reported no new vulnerabilities in the portions examined. Run against older Signal versions containing known, long-fixed bugs, the system flagged them — which is the right way to check that a verification tool can actually find anything. The Lean artifacts are published on GitHub, and Signal's CTO Ehren Kret said the work increases confidence in the implementation's privacy guarantees.

The limits, stated plainly

The guarantees cover one-to-one chats in the researchers' own build of the library. Not the Signal apps you install. Group messaging is outside it. So are the client applications, the servers, and the operating system underneath — which, as the Muse notification story this week showed, is exactly where a real-world privacy failure occurred while the cryptography itself was working perfectly.

Those two stories landing in the same month is a useful pairing. One proves the maths is right. The other shows the maths was never the weak point.

One figure circulating in coverage — that human experts reviewed only about 1% of the codebase — could not be confirmed against the primary material, so it is left out here rather than repeated.

Why the four weeks matters more than the proof

The interesting claim is not that Signal's handshake is correct. Most cryptographers already believed that.

It is that formal verification may stop being economically absurd. The reason almost no software is verified is cost: it has required scarce specialists and years per component, so it was reserved for systems where failure kills people. If a five-person team can do a serious protocol in a month, the calculation changes for a much wider class of software.

There is also a neat structural point about AI reliability here. The usual objection to AI-generated code is that you cannot trust it. In this setup you do not have to: the model proposes, Lean's kernel disposes, and a hallucinated proof simply fails to check. Verification moves the trust from the model to the checker — and that is a pattern worth copying well beyond cryptography, as we argued in our review of autonomous coding agents.

The risk that remains is specification error: proving the wrong property correctly. That is a human problem and no amount of compute removes it, which is why experts set the goals in the first place.

Written by the WritePures newsroom. Spotted something that needs updating? Tell our editors.