AI spent four weeks giving Signal's encryption a 'math checkup' -- and proved key properties in the real code for the first time

The backstory: encrypted chat runs on trust

When you send a message on Signal or chat in Google Messages, a set of encryption rules called the Signal protocol is working in the background. Its job is simple to state: nobody except you and the person you're talking to should be able to read the conversation. Billions of people's private messages depend on it.

But when we say it is "secure," much of that rests on expert review and years of real-world use. Mathematicians can prove that the protocol's design is sound. The catch is that there is often a gap between the blueprint and the code that actually ships on your phone. Think of a building: the architect's calculations can be perfect, but if a bolt is missing during construction, the building can still fail. Many real-world security bugs live in exactly that gap.

Proving the real code correct, line by line, is enormously laborious. Comparable efforts have historically taken expert teams years, which is why most protocol verification stops at the design.

What happened

On November 10, Google DeepMind introduced an AI system called AlphaProof Code and said it had formally verified key security properties of the actual code behind the Signal protocol.

"Formal verification" sounds intimidating, but the idea is straightforward. Instead of testing software to see whether anything breaks, you prove it, like a math problem, step by step: under these stated conditions, this code will always behave as intended. A test can only say "I didn't find a problem." A proof says "under these conditions, this kind of problem can't happen."

DeepMind described the process roughly like this:

First, human experts worked with several AI models to translate Signal's security goals into precise mathematical statements, such as "messages stay protected before and after a device is temporarily compromised." Human experts reviewed every one.

Second, a team of AI agents powered by Gemini Carbon wrote the proofs: more than six million lines of Lean. Lean is a computer language built to check whether mathematical proofs are valid. Think of it as an extremely strict grader that never lets anything slide.

Third, the agents audited their own work and flagged the parts that needed a human second look. DeepMind said that was only about 1 percent; Lean checked the rest automatically.

The key point is that these proofs went all the way down to the compiled code, the version that actually runs on devices, not just the design. The whole job took about four weeks.

To make sure the system wasn't simply declaring everything safe, the researchers ran a reverse test. They took two real bugs that had been found and fixed in Signal's past and put them back into an isolated copy of the code. Both times, the system produced a machine-checked proof that the buggy version was insecure. In other words, it can confirm what's right and catch what's wrong.

DeepMind said this is the first time AI has formally verified a widely deployed cryptographic protocol at this depth, and the first time the implementation of such a protocol has been formally verified by any method, with or without AI. Signal chief technology officer Ehren Kret said earlier formal verification had focused on smaller portions of the code, and called using AI agents to turn live code into valid Lean theorems a major breakthrough. DeepMind is open-sourcing the verification materials and has published a technical paper.

Where the claim stops

This is easy to over-read. What was proved are the specific security properties the team wrote down and experts reviewed, not a guarantee that every part of the Signal app is flawless. The app's interface, your phone's operating system, and your own habits are all outside the scope. The "first time," "four weeks," and "about 1 percent" figures also come from DeepMind itself; independent experts still need to dig into the open-sourced materials.

What it could change

If the approach proves reliable and repeatable, the impact could reach well beyond Signal.

Until now, math-grade security proofs have been too slow and expensive for all but a handful of critical systems. If AI can shrink years of work into weeks, other software where mistakes are very costly, such as banking systems, payment apps, medical devices, and car control software, could one day be proved correct layer by layer. Software security might gradually shift from "patch it after something goes wrong" toward "prove it before it ships."

For now, this is one case. Whether other software will go as smoothly, what it really costs, and how much expert time it still demands remain open questions.

What it means for you

If you use Signal or Google Messages, the encryption behind your chats now has something like a mathematical health report, and it checked the code actually running on phones, not just the blueprint. That doesn't make you invincible: a stolen phone, a phishing link, or a weak password are all outside what was proved.

The bigger takeaway is the direction it points. The software we rely on every day may someday be backed not just by "experts say it's fine," but by "it has been mathematically proven fine." For ordinary people, that could mean fewer privacy leaks and hacks, fixed at the root.

Original source published: Google DeepMind, Nov 10, 2026, 20:00 Beijing time (UTC+8)