---
title: "Google DeepMind Verified Signal's Code"
url: https://nativefirst.ai/blog/alphaproof-code-signal/
description: "Agents on Gemini Carbon wrote over six million lines of Lean to verify libsignal at machine-code level. One percent of the code went to a human."
author: John Tan
category: "AI Models"
published: 2026-11-12
updated: 2026-11-12
publisher: nativefirst.ai
format: Markdown copy of the web page at the url above, same text.
---

# Google DeepMind Verified Signal's Code in Four Weeks. It normally takes years.

Agents on Gemini Carbon wrote over six million lines of Lean to verify libsignal at machine-code level. One percent of the code went to a human.

John Tan · November 12, 2026 · 5 min read

On 10 November, Google DeepMind published AlphaProof Code, and with it something more useful than a benchmark: agents produced a machine-checked mathematical proof that the real Signal protocol code does what it claims.

Signal is the encrypted messaging app, and its protocol is the part the rest of the industry borrowed: WhatsApp, Messenger and Google Messages all run on it. So this is not a proof about a research toy. It is a proof about the code behind most end-to-end encrypted messaging on earth.

Not a model of the protocol. Not the design on paper. The implementation: **libsignal**, the Signal protocol's reference implementation, proved at the machine-code level.

Be precise about what that means, because the headline version drifts. They linked libsignal into a small command-line harness, compiled it with stock rustc to AArch64 Linux machine code, and proved properties of that executable. It is the real compiled artifact rather than a tidy abstraction of it, and it is not the build sitting on your phone.

DeepMind's claim for it is narrow and checkable: this is **"the first time the implementation of a widely deployed protocol like this has been formally verified by any method"**. By any method includes people with years and no AI at all.

6M+

Lines of Lean written by the agents. Lean is a language where a computer checks the proof, not a reviewer.

4 weeks

Start to finish. DeepMind says work of this kind has historically taken expert teams years.

1%

The share of the codebase the agents flagged for a human to look at. Lean checked the rest automatically.

**The workflow · Google DeepMind** Three roles. The user approves the specification, prover agents do the volume, and a gatekeeper accepts nothing Lean has not checked.

Figure 1 from the technical paper, "AlphaProof Code: Verifying Signal\\'s Security at the Machine-Code Level", 10 November 2026.

## The one percent is the number to take

Six million lines is the headline and four weeks is the compression, but the operator number is the one percent.

The agents did not ask a human to read six million lines of proof. Nobody could. They produced proofs a machine verifies, then pointed at the small part of the codebase where a person's judgement was actually required. Everything else was checked by Lean without anyone reading it.

That is a different shape of work from reviewing AI output. The usual arrangement puts a person downstream of the model, reading what it produced and deciding whether to trust it, which caps the whole system at human reading speed. Here the checking is done by something that does not get tired, and the human is routed to the exceptions.

## Why verifying the code is harder than verifying the design

Most protocol verification checks the design. You write down what the protocol is supposed to do, prove the scheme sound, and ship an implementation that is supposed to match.

The gap between those two is where real vulnerabilities live. A sound design implemented with an off-by-one, a reused nonce or a missing bounds check is still broken, and the proof of the design says nothing about it. Closing that gap means proving things about the actual compiled artifact, which is a much larger and uglier problem than proving things about a clean abstraction.

That is the part DeepMind did, and it is why the line is "by any method" rather than "by AI".

**Fig. 1 Where the work went · Humans decided what to prove. Agents proved it. A compiler checked it.**

*Chart: Three stages. First, humans and models turn Signal's security goals into formal specifications, and every specification is reviewed by a human expert. Second, agents built on Gemini Carbon write over six million lines of Lean proof. Third, Lean checks the proofs automatically, and the agents flag about one percent of the codebase for human review.*

*Chart: The same three stages, stacked for a narrow screen.*

Figure by nativefirst, from DeepMind's description of the framework.

## The part that makes it falsifiable

A proof system that proves everything correct is worthless, because it would also prove broken code correct. DeepMind ran the obvious control.

They took two real bugs that had previously been found and fixed in Signal, put them back into an isolated copy of the code, and ran the system at it. **"In both cases, the system produced a machine-checked proof that the buggy version was insecure."**

Two is a small number and the bugs were known in advance, so this is a sanity check rather than a measure of detection rate. It is still the right experiment, and more than most AI results published this year bother to run.

> Using AI agents to translate live code into valid Lean theorems is a major breakthrough.
>
> **Ehren Kret** · Ehren Kret, CTO, Signal · [deepmind.google](https://deepmind.google/blog/introducing-alphaproof-code/)

## What this does not say

It does not say the Signal app is proven secure. The proofs cover specific security properties of the protocol implementation, not the whole application, not the operating system under it and not the people using it.

It does not prove the cryptography. The paper is explicit that the cryptographic primitives, two output functions and a few library routines are specified by contracts rather than verified, and that the result rests on trusting Lean's kernel and the AArch64 semantics, though notably not the Rust source or the compiler.

It does not say verification is solved. DeepMind's own text says scaling these techniques requires continued research, and the medical device firmware and power grid software they mention are stated as future goals, not results.

And the one percent is a share of the codebase that got human attention on this job, with these specifications, on a protocol implementation written by careful people. It is not a general ratio you can quote for your own codebase.

## Why it matters if you are not writing cryptography

Almost nobody reading this is going to formally verify anything. The transferable part is the shape of the arrangement, and it is worth copying.

Three roles, kept separate. Humans decide what correct means and review every specification, because a proof of the wrong property is worth nothing. Agents do the volume work that nobody would otherwise do. A machine does the checking, so trust does not depend on anyone reading the output.

Most teams running agents today have the first and second roles and no third. The output comes back, a person skims it, and the system runs at the speed of that skim. The reason this result is worth more than its benchmark is that it shows what the third role buys you: six million lines nobody had to read, and a short list of the places where judgement was actually needed.

If you want one question from it for your own work: when your agents produce something, what checks it besides you? Tests, types, a linter, a simulator, a second model with a rubric. Anything that is not a person reading. It is the same argument as [the scaffolding that turns a model into a factory](https://nativefirst.ai/blog/what-a-software-factory-actually-takes/), with the checking step finally doing real work.

DeepMind are open-sourcing the verification artifacts and have published a technical paper, so the claim can be checked rather than taken.

**Build the checker first.**

[John Tan ↗](https://www.linkedin.com/in/johntans/)

Founder of nativefirst.ai. Runs everything on agents and writes down what works.

Sources

1 Google DeepMind, "Introducing AlphaProof Code", 10 November 2026, by Pushmeet Kohli and Swarat Chaudhuri: agents built on Gemini Carbon generated over six million lines of Lean; the verification took four weeks; about one percent of the codebase was flagged for human review; two previously fixed bugs were reintroduced into an isolated copy and the system produced a machine-checked proof that the buggy version was insecure in both cases. [deepmind.google](https://deepmind.google/blog/introducing-alphaproof-code/)

2 Swarat Chaudhuri, Andrew Ferraiuolo, Anton Kovsharov, Tej Chajed, Sam Schlesinger, Karn Seth, Jonathan Katz, Charles Sutton and Pushmeet Kohli, "AlphaProof Code: Verifying Signal’s Security at the Machine-Code Level", 10 November 2026: libsignal is linked into a small command-line harness and compiled with stock rustc to AArch64 Linux machine code; about 6.5 million lines of Lean; cryptographic primitives, two output functions and some library routines are specified by contracts rather than verified; the result trusts Lean’s kernel and the AArch64 semantics but not the Rust source or compiler. [google-deepmind.github.io](https://google-deepmind.github.io/code-verification/)
