Google DeepMind's machines did in four weeks what human experts could not finish in years. Using AI formal verification, its agents mathematically proved that the code guarding billions of Signal messages holds, right down to the instructions running on your phone. The breakthrough points toward a future where the software running critical systems can finally be trusted.
By Blumefield | November 11, 2026
A Four-Week Proof That Shook the Field
For decades, AI formal verification sat in the realm of wishful thinking. Proving that a piece of software does exactly what it claims, with mathematical certainty rather than educated hope, is one of the hardest problems in computer science, and the work has traditionally taken expert teams years for even a single program. On November 10, Google DeepMind said its artificial intelligence had done it for one of the most important programs on earth in four weeks.
The target was Signal, the encrypted messaging protocol that protects billions of private conversations inside the Signal app and Google Messages. DeepMind's new system, called AlphaProof Code, generated more than six million lines of machine-checked mathematical proof confirming that key security properties of Signal's actual running code hold as advertised. Not the design on paper, which researchers had already studied, but the compiled software executing on real devices. Google DeepMind called it the first time a widely deployed cryptographic protocol has been formally verified at this depth by any method, with or without AI.
The claim is bold and, by the company's own admission, a self-assessment rather than an audited record. But the achievement is real, and the people who build Signal are impressed. "Using AI agents to translate live code into valid Lean theorems is a major breakthrough," said Ehren Kret, Signal's chief technology officer. Coming from the organisation whose entire reputation rests on the integrity of that code, the endorsement carries weight.
What the Machines Actually Proved
Signal's security rests on two cryptographic workhorses, and AI formal verification was pointed at both. The first is the handshake that two phones perform when they begin a conversation, now hardened against the threat of future quantum computers. The second is the ratchet, the mechanism that constantly refreshes encryption keys so that stealing one message does not unlock the rest. DeepMind's agents proved that both keep their promises, including the crucial guarantee that a conversation recovers its secrecy even after a device has been briefly compromised.
What makes the result striking is how far down it reaches. Earlier academic work had verified Signal at the level of design, the abstract description of how the protocol should behave. This effort went to the executable itself, an artefact built for the 64-bit Arm processors inside ordinary smartphones. The gap between a clean design and the messy compiled reality is exactly where real-world vulnerabilities tend to hide, and closing that gap is what AI formal verification was built to do.
To test whether the proofs meant anything, DeepMind ran a deliberate experiment. It took two security bugs that Signal had already found and fixed, reintroduced them into isolated copies of the code, and set the system loose. In both cases the machines produced a mathematical proof that the broken versions were insecure, catching the planted flaws rather than waving them through. A verifier that cannot detect a known bug is worthless. This one passed.
Inside AlphaProof Code
AlphaProof Code is not a single model but a team of them. DeepMind describes it as a multi-model agentic framework, a structured crew of AI agents powered by its Gemini 4 Carbon model, each assigned a role in an assembly line of proof. Human experts still decide what should be proven and write the precise specifications that define success. The agents do the grinding labour of constructing proofs, which a separate gatekeeper agent checks before anything is accepted, and the Lean theorem prover verifies every line independently.
The division of labour is the whole trick, and it is why formal verification suddenly looks practical rather than theoretical. Writing a formal proof by hand is brutal, exacting work that has kept the technique confined to the most safety-critical niches. Handing that labour to tireless agents while keeping humans in charge of the specification changes the economics. DeepMind reported that human reviewers needed to inspect only about one percent of the codebase directly, with the system flagging the specific areas that warranted a closer human look.
DeepMind is not keeping the method to itself. The company has open-sourced its verification artefacts on GitHub, alongside a technical paper describing the approach, an unusually open gesture for a result this strategically valuable. The underlying prover, Lean, is itself a community-built tool, which means the broader research world can scrutinise, reproduce and extend what the agents produced rather than taking Google's word for it.
The Limits Behind the Milestone
Impressive as it is, the proof is not a certificate of perfect safety, and DeepMind is careful about the boundaries. The guarantees hold only within the attacker models and cryptographic assumptions the researchers chose. The analysis covered the core protocol implementation, not the entire messaging application, and it does not address side-channel attacks, the sneaky exploits that read secrets from timing, power draw or other physical leakage rather than from the mathematics itself. A phone compromised by spyware at the operating-system level is still a compromised phone.
There is also some haze in the numbers. DeepMind's main writeup cites more than six million lines of Lean proof, while its own summary text elsewhere says three million, and outside analysts counted roughly six and a half million. The discrepancy does not undermine the result, but it is a reminder that even a landmark in AI formal verification arrives wrapped in the usual marketing imprecision. The first-ever framing, too, is Google's own characterisation rather than an independent ruling, and rival labs and academic groups may yet contest it.
None of this diminishes what changed. The point was never to declare Signal flawless. It was to show that AI formal verification can be applied to real, deployed, security-critical software at a speed and scale that human teams cannot match, and to do it transparently enough that others can check the work.
Why This Outlasts the Headline
The reason this matters far beyond one messaging app is that almost nothing else we rely on has been verified this way. The firmware in a pacemaker, the control software in a power grid, the code in a car's braking system, all of it ships on testing and hope rather than proof. DeepMind explicitly frames AI formal verification as the on-ramp to changing that, pointing at medical-device firmware and critical-infrastructure software as the next frontiers where mathematical certainty could replace crossed fingers.
There is a darker motivation too, and Google does not hide it. The same artificial intelligence that can hunt for software flaws can be turned to finding them for malicious ends, a tension Blumefield examined when Google gated its Gemini 4 Carbon security model to defenders first. Formal verification is one of the few defences that scales in the right direction. If attackers get AI that finds bugs, defenders need AI that proves their absence, and this week's result is a working demonstration that such a tool is now within reach.
For an industry midway through an expensive argument about whether its spending will ever pay off, the Signal proof is a rare piece of evidence that frontier AI can do something concrete, hard and genuinely useful. It will not settle the valuation debate. But it moves AI formal verification from a laboratory curiosity to a capability that the people guarding the world's most sensitive software can actually use, and that is the kind of progress that tends to outlast the news cycle. Follow the story as it develops at Blumefield.