AI Formally Verified Signal's Real Code in Four Weeks — What Changes Now?
Google DeepMind's AlphaProof Code split the work between people and agents to formally verify Signal's shipped implementation: over six million lines of Lean in about four weeks, with humans reviewing roughly one percent of the codebase.
Formal verification has always been the discipline software engineering admires from a distance. It is the branch of the field that asks for mathematical proof, not test coverage, that a program does exactly what it claims and nothing else. The reason it stays at a distance is arithmetic: proving properties about real production code has historically consumed expert-years, so it gets spent on the narrowest possible targets, such as a cryptographic primitive or a boot loader, and almost never on the messy thing that actually ships.
On 10 November, Google DeepMind published a case that attacks that arithmetic directly. Working with Signal, the encrypted messaging service, a framework called AlphaProof Code produced a machine-checked proof about the protocol's real implementation in roughly four weeks. DeepMind frames it as the first time AI has been used to formally verify a widely deployed cryptographic protocol at this depth, and the first time an implementation of a widely deployed protocol like this has been formally verified by any method at all. Signal's software protects, in DeepMind's phrasing, billions of private conversations.
The headline number is not a benchmark score. It is six million lines of Lean, the proof assistant language, plus a review budget that came down to about one percent of the codebase. Those two numbers describe a different kind of result from the ones the industry has been arguing about all autumn.
The claim is narrower than "AI solved security", and stronger for it
Read the announcement quickly and it sounds like a victory lap for agents. Read it properly and the division of labour is more interesting than that.
Humans decided what to prove. Researchers and multiple models worked together to turn Signal's security goals into formal specifications, and human experts reviewed each specification one by one. Only then did the agents go to work, producing Lean proofs, auditing their own output, and flagging the places where a person needed to look.
That ordering matters. Specification is where formal verification usually dies, because a spec that encodes the wrong property produces a beautiful proof of the wrong thing. AlphaProof Code does not remove that step. It automates the expensive middle, the part where a trained mathematician grinds through proof obligations for months, and leaves judgement with people.
DeepMind describes the framework as multi-LLM rather than a single model: the proof agents were powered by Gemini Carbon, while the specification work drew on a mix of models. It is a pipeline, not an oracle.
Six million lines of Lean, and a one percent review bill
The raw output was over six million lines of Lean. A human being cannot read that, and nobody pretended otherwise. What made the result usable was the audit design: agents reviewed the generated proofs and marked the sections that needed human eyes, and the fraction that reached a person landed at roughly one percent of the codebase.
That is the load-bearing claim of the whole exercise. Formal verification's cost has always been dominated by human proof engineering, so a system that shifts the ratio from "review everything" to "review one percent" changes the economics and not merely the speed. Whether that one percent is genuinely the dangerous one percent is the question reviewers outside DeepMind will now spend time on, and it is the right question to ask.
The timeline compounds the effect. DeepMind puts the work at four weeks against a historical norm of years for comparable efforts by expert teams. Take the comparison as approximate, since "comparable" is doing quiet work in any such sentence, but the order of magnitude is the point: months instead of years moves formal verification from a special-occasion budget line into something a serious team could plan around.
The two-bug test: proving that broken code is broken
A proof that good code is good is only half a result. The failure mode that haunts this field is a verification stack so permissive that it certifies anything you feed it.
So the team reinserted two real bugs, both of which had previously existed in the code and had already been fixed. In both cases the system produced a machine-checked proof that the defective version was insecure. It did not wave the broken build through. That is a small experiment by count and a meaningful one by kind: it tests the verifier against known-bad input, which is exactly how you would want to be convinced.
DeepMind has not published a pass rate across a large corpus of injected faults, and no honest reading of the post should imply one. Two out of two is evidence, not a track record.
Why compiled code is the hard part
Most verification stories stop at the design level, where the algorithm lives in a clean specification and the implementation is assumed to match. The gap between those two layers is where real vulnerabilities hide: compiler optimisations, memory layout, the assumptions a build system quietly makes.
DeepMind says the work reaches the compiled code that actually runs on devices, not just the design. That is a materially harder target, and it is the reason the result is worth more than a proof about a pseudocode sketch.
There is a second reason the Lean detour earns its keep. Lean proofs are checked by a small kernel, which means verification does not require anyone to trust the model that wrote the proof. A reviewer who distrusts every agent in the pipeline can still accept the artifact, because the artifact is a certificate that either compiles or does not. That property is what separates this from asking a chatbot whether code looks secure, and it is also why the six million lines are less absurd than they first appear: volume is cheap when the check is mechanical.
The concrete claim is bounded. It covers specific security properties, including protection of messages around the moment a device is temporarily compromised, on a specific real implementation. It is not a proof that Signal is unhackable, and anyone reading it that way is reading a different document.
Signal's chief technology officer, Ehren Kret, called the translation of live code into valid Lean theorems a major breakthrough, and framed it as added confidence in the privacy guarantees of a codebase that faces AI-driven attackers.
What the agent economy should take from this
Strip away the cryptography and the shape of the result is familiar to anyone who has tried to price an AI workflow. A general model was doing a job that a much narrower setup could do better and cheaper, and the win came from decomposing the work rather than from turning a bigger model loose on it.
The industry's habit is to rank models on a single leaderboard and treat the ordering as the answer. AlphaProof Code is a reminder that the ordering is close to useless until you fix the task: proof obligations are not chat, and the mix of models that writes a good specification is not necessarily the mix that closes a proof. The practical question is what a given setup delivers per task you actually have to pay for, and at what human review cost. That is the filter worth applying to any AI tool shortlist, and it is roughly the filter we apply at aibookmarks.net, where tools are indexed by the job they finish rather than by the size of the model behind them.
Applied here, the filter produces a specific reading: the deliverable is a proof artifact a third party can check, the human cost is one percent review, and the model choice is an implementation detail. Very few AI products can be described that cleanly, which is part of why this one landed.
What has not been proven
Several things, and they matter for anyone tempted to generalise.
First, generalisation itself. Signal is an unusually favourable target: a well-specified protocol, a security team that knows exactly what properties it wants, and decades of prior cryptographic analysis to build on. Port that pipeline to a sprawling internal codebase with fuzzy requirements and the specification step becomes the bottleneck again, with agents proving things nobody needed proven.
Second, the one percent. A review fraction is not a review quality guarantee. If the agents' own auditing is what decides which lines reach a human, then the audit is now part of the trust boundary, and it deserves the same adversarial scrutiny as the proofs.
Third, maintenance. A proof is a snapshot. Code changes, and a verified snapshot drifts out of correspondence with the shipping build unless the pipeline is cheap enough to re-run routinely. DeepMind's own framing points toward pairing verification with defensive agents such as CodeMender, which is an admission that proving something once is not the end state.
Fourth, the open question of access. The formal verification artifacts are being open-sourced and a technical paper accompanies the work, but the framework itself has not been described as a product anyone can rent. Until independent teams can reproduce the pipeline on their own code, the four-week figure stays a vendor-reported result with unusually good documentation.
The four-week number is the story
Two claims will be tested in the coming months. The first is technical: can outside reviewers confirm that the one percent of code humans examined was the one percent that carried real risk. The second is economic: does a four-week verification cycle survive contact with ordinary software, where the specification is vague and the requirements move.
If both hold, formal verification stops being a luxury reserved for the crypto layer and becomes a routine gate in the release process, the way fuzzing and static analysis did before it. If only the first holds, this is still a landmark result about what agent pipelines can do when the task is bounded and the reward is checkable.
Either way, the interesting part is not that an AI wrote proofs. It is that the proof was cheap enough, and auditable enough, that a real engineering organisation could consider doing this on purpose.
---
Google DeepMind's AlphaProof Code team, with comments from Signal CTO Ehren Kret. Primary source: DeepMind's 10 November 2026 announcement; technical paper and open-sourced verification artifacts published alongside it.
Published by AI Bookmarks · More AI news →