DeepMind's AlphaProof Code verifies Signal's protocol in four weeks
Google DeepMind published Nov 10 that its new agentic framework AlphaProof Code formally verified key security properties of the actual code underlying the Signal protocol, which protects billions of private conversations in Signal and Google Messages — generating over 6 million lines of machine-checked Lean proof in four weeks, a job DeepMind says historically takes expert teams years.
📊 Scorecard: our Bullish call on $GOOGL is scored from $287.38, the last close before it ran. Its first result comes after the next close.
The News
Google DeepMind published on November 10 that its new agentic framework AlphaProof Code formally verified key security properties of the actual code underlying the Signal protocol. Formal verification is a mathematical proof that code does what it is supposed to do — not a test that tries a few cases and hopes for the best, but a proof that covers every case. The Signal protocol is the encryption system that protects billions of private conversations in Signal and Google Messages, so the code being proved is some of the most widely used security code in the world.
The scale of the work is the story. Agents powered by Gemini Carbon — Google's new flagship model — generated over 6 million lines of machine-checked Lean proof in four weeks. Lean is a programming language used to write proofs a computer can check line by line. DeepMind says the same job historically takes expert teams years. Six million lines of proof in a month is not a small improvement on the old way of doing this; it is a different order of magnitude, and it is the kind of result that makes security teams ask what else could be proved the same way.
DeepMind also ran a check that makes the claim harder to dismiss. The team reintroduced two real, previously fixed bugs into an isolated copy of Signal's code — a copy kept separate so nothing could leak into the real app — and the system proved the buggy version insecure in both cases. In other words, the proof is not just a rubber stamp: when the code was wrong, the system caught it. That is exactly what a verification tool has to do to be trusted.
Six million lines of proof in four weeks — DeepMind just showed AI agents can verify the code that protects billions of conversations.
Why It Matters
This matters because the security of private messaging rests on code almost nobody can check by hand. The Signal protocol protects billions of conversations, and until now, proving its core properties correct was a job for expert teams working for years. If an AI system can do that work in four weeks — and catch real bugs when they are reintroduced — then the most important security code in the world can be checked far more often, and far more thoroughly, than it is today. That is a genuine change in how software security works, not just a faster way of doing the same thing.
It also matters for Google. AlphaProof Code runs on Gemini Carbon, the model Google released the same week, which means the company's flagship AI is being shown doing two very different jobs at once: topping benchmarks and proving security code. For Alphabet, the read-through is that its model investments are producing results outside the chatbot market — in this case, in the unglamorous but valuable world of software verification, where the customers are companies and governments that pay for certainty.
The scope limit is essential, and DeepMind states it plainly. The proof covers the PQXDH handshake — the opening exchange that sets up an encrypted conversation — and the Triple Ratchet, the mechanism that keeps refreshing the encryption as a conversation goes on, in libsignal, the library that implements the protocol, down to compiled AArch64 code, the machine code that runs on phone processors. It does not cover the whole Signal app, group chats, or other platforms. Anyone claiming Signal is now proven unhackable is overstating the result: the protocol's core is proved, the app around it is not.
Analyst's Take
Our call is Bullish. Over 6 million lines of machine-checked proof in four weeks, a job that historically takes expert teams years, with a bug-catching check that proves the system is not just rubber-stamping — this is one of the most concrete demonstrations yet of AI agents doing work humans cannot do at scale. The scope limit is real and stated, but it does not shrink the achievement: the core of the world's most trusted messaging protocol is now mathematically proved.
What to watch: which codebases get the AlphaProof treatment next. If the framework moves from Signal's protocol to other widely used security code — browsers, operating systems, payment systems — the market for formal verification changes shape. Alphabet closed Tuesday at $287.38, down 0.27%; the stock has not moved on this news, and the payoff, if it comes, will show up in enterprise and government contracts, not in a single day's trading.
Are you bullish or bearish on this story?
By The Numbers
FAQ
What is formal verification?
It is a mathematical proof that code does what it is supposed to do. Instead of testing a few cases and hoping for the best, it proves the code is correct for every case — and a computer checks the proof line by line.
What did AlphaProof Code actually prove?
It proved key security properties of the actual code behind the Signal protocol — specifically the PQXDH handshake, which sets up an encrypted conversation, and the Triple Ratchet, which keeps refreshing the encryption, in the libsignal library down to compiled AArch64 phone-processor code.
Does this mean Signal is now unhackable?
No. The proof covers the protocol's core code, not the whole Signal app, group chats or other platforms. The app around the protocol — and the phones it runs on — are not part of this proof.
How do we know the proof system works?
DeepMind tested it by reintroducing two real, previously fixed bugs into an isolated copy of Signal's code. The system proved the buggy version insecure in both cases — it caught the errors instead of rubber-stamping the code.
What is Lean?
Lean is a programming language designed for writing mathematical proofs that a computer can check. The agents generated over 6 million lines of Lean proof in four weeks.
👁
Source: Google DeepMind