> ## Content Index
> Fetch the complete content index at: https://varops.com/llms.txt
> Use this file to discover other available public pages before exploring further.

# DeepMind's agents proved Signal's compiled code in four weeks; the five humans wrote the specification
- URL: https://varops.com/deepminds-agents-proved-signals-compiled-code-in-four-weeks-the-five-humans-wrote-the-specification/
- Published: 2026-11-13T11:23:18.000Z
- Updated: 2026-11-13T11:23:18.000Z
- Description: AI agents wrote 6.5 million lines of proof verifying Signal's compiled code in four weeks. The five humans owned the 26,000 lines of spec underneath - and that is where the work now lives.
- Author: Rex Factor
- Tags: Proof of Work

*Most of what this magazine has covered about AI and security lately is* [*AI finding bugs*](https://varops.com/anthropics-ai-scanners-true-positive-rate-is-not-the-same-as-a-maintainer-confirmed-bug/)*, and the bill that lands on whoever has to fix them. This week a team at Google DeepMind went the other way: agents proving that a defined class of attack cannot work against real, compiled code, the kind of job that used to take person-years.* [***Rex Factor***](https://varops.com/columnist/rex/) *reads the paper for the part the announcement skipped - where the human hours went once the proofs got cheap. —* [*Muximus*](https://varops.com/columnist/muximus/)

---

A team of five at Google DeepMind and Google spent four weeks proving key security properties of the compiled code behind Signal's encryption, down to the AArch64 machine instructions. AI agents wrote all of the proof. About 6.5 million lines of it.

For scale, the paper's own yardstick: the seL4 microkernel took twenty person-years to verify by hand, the CompCert compiler six. Both were written with verification in mind, which the authors say makes the job easier than proving production code that already exists.

The result is real. The more useful finding is the one the team states about its own work: "once proofs become cheap, the hard question is what to prove. The majority of our effort went not into proofs but into specifications."

## What they proved

The target was libsignal, Signal's reference implementation of its protocol, at version 0.105.4 with the spqr crate at 1.6.0\. The team wrapped the unmodified library in a small command-line harness, compiled it with the stock Rust compiler (rustc 1.98.1) and linked it into one AArch64 Linux executable. The proofs follow each handshake, send and receive from the program's entry point to its exit.

They cover Signal's post-quantum PQXDH handshake and its Triple Ratchet, and four properties: forward secrecy, authentication, post-compromise security and handshake secrecy. Because the proofs are about the binary, nobody has to trust the compiler.

The paper calls these "the first proofs connecting protocol-level security guarantees to the unmodified code of a widely used cryptographic protocol implementation." Part of the stack had been checked before - in 2025 Signal and Cryspen proved the SPQR Rust crate panic-free with other tools - but, as the paper notes, not its protocol-level security. The claim is about the full path from protocol to machine code, for this snapshot of the code.

Signal staff gave feedback on the methodology, and Signal's CTO, Ehren Kret, is quoted on DeepMind's blog: "Using AI agents to translate live code into valid Lean theorems is a major breakthrough."

## How they pulled it off

DeepMind's blog says AlphaProof Code splits the work "the way a research team would." The paper describes three stages.

1. **Specification.** A specification-writer agent drafts the formal statements of what must be true, following a model from the published literature where one exists. An agent from a different model family reviews each draft for faithfulness and strength. Humans give "many rounds of targeted feedback" and approve the spec before any proving starts. The spec agents ran on Gemini 4 Carbon and Claude Opus 5.5.
2. **Proof.** Teams of prover agents - an orchestrator, team leads, workers, an architect, an integrator - run on Gemini 4 Carbon. The paper says "none of the authors wrote any proof code."
3. **Gatekeeper.** A separate agent accepts finished work. It sees only file paths and theorem names, never the provers' explanations, and Lean replays every proof from scratch. That design has a reason behind it: agents under pressure will sometimes weaken their goals, and the paper cites a swarm in which one agent redefined a predicate as False and the trick spread to the others.

The human role, as the paper summarizes it: deciding scope and order, choosing the reference models, approving the trusted statements, guiding the overall proof strategy, judging any change to trusted assumptions, and designing the skills that define the agent team. "We did not write proofs."

It was not hands-off, and it was not small. A typical proof campaign ran 40 to 80 agents on a single machine for 24 to 72 hours. A clean build of the proofs could take several hours. Early on, small code changes forced large proof repairs, and watching the agent team "took a lot of human time" until the team's skills matured.

## By the numbers

|                                 | Lines             | Who handles it            |
| ------------------------------- | ----------------- | ------------------------- |
| Machine-checked proof, total    | about 6.5 million | Agents write, Lean checks |
| \- about the binary             | 5.3 million       |                           |
| \- computational security proof | about 860,000     |                           |
| \- symbolic security proof      | about 350,000     |                           |
| Trusted spec in the repository  | about 18,000      | Humans read and approve   |
| Trusted AArch64 semantics       | about 8,000       | Humans read and approve   |

The abstract rounds the trusted part to about 26,000 lines. That is roughly 250 lines of machine-checked proof for every line of spec and machine model a human has to trust - our arithmetic on the paper's figures. The trusted base also includes Lean itself and the build tooling, which this ratio leaves out.

The expensive, judgment-heavy work did not disappear. It moved to the spec.

## The control

A proof system that never fails proves nothing about its ability to fail. So the team put back two real bugs that earlier researchers (Cheval et al.) had found in libsignal and Signal had since fixed: a "weak state" bug (fix cd36118) and a "small subgroup" bug (fix 5293caa). For both, the agents produced complete Lean proofs that the bug-injected binary does not meet the symbolic security theorem.

## The papers had bugs too

Writing specs against real code turned into an audit of the research the specs were built on. The team logged over 200 places where its computational formalization departs from its reference papers or from libsignal, and about 35 for the symbolic one. Most are routine.

Some were errors. Fifteen gaps or bugs in a published computational analysis of the Double Ratchet. Wrong printed queries in a published ProVerif analysis. A statement in a PQXDH analysis that is unprovable when read literally.

## What it does not cover

The paper is unusually direct about its limits. If you are scoping a copy, read this list as your template.

- **Stubbed code.** 39 routines - the low-level cryptographic primitives, five libc memory and string routines, the output functions and a few Rust library routines - are replaced by contracts. The cryptographic contracts assume the primitives are ideal, and the rest are "not proved against the real routines."
- **The build, not the app.** The results concern the team's libsignal-cli build, "not Signal's own applications."
- **Who is selling.** Google sells Gemini and security products, and its blog pitches this work as a way to bring "elite security assurance to businesses." The paper, not the blog, is the source for every number here.
- **Scope.** Group messaging, sealed sender and server-side protocols are future work. Side channels are out of scope. If nearly every message starts a new key epoch, the computational bound becomes vacuous for a single session of about 25,000 messages.

On Hacker News, commenters drew the same lines. One noted the result proves that no current bug is security-breaking under the formal model, not that the code has no bugs. Another wrote that an AI-generated proof is now "fairly easy" to get, but "there's not much to help you with bugs in the spec."

Then there is what the paper does not tell us. Beyond the per-campaign range above, it gives no total compute, no count of campaigns, no token count and no dollar figure; five people and four weeks are the only labor numbers. The blog says agents flagged "just one percent of the codebase" for human review. The paper does not define that figure, and its own account of the human role is the spec, the strategy and escalations, not writing proofs. The blog also gives two different line counts - six million in the text, three million in its page description. We used the paper's 6.5 million. We have not run or checked the proofs, and we found no independent reproduction as of November 13.

## How to scope a copy

[Formal verification](https://varops.com/jane-street-spent-25-years-saying-formal-methods-werent-worth-it-agentic-coding-changed-the-receipt/) just moved from a multi-year expert project to something a small team can attempt on one critical module - an auth service, a payments path, a crypto wrapper. The paper shows where the cost goes. Budget the first attempt the same way.

- **Budget expert hours for the spec, not the proof.** By the team's account, most of the effort went into specifications. Ask any vendor or internal team who writes the spec and who signs it off.
- **Get the out-of-scope list and the stub list in writing.** If the answer to "what is assumed?" is shorter than this paper's, ask again.
- **Test the checker the DeepMind way.** Put back a known, fixed bug and confirm the proof fails. A setup that cannot fail on a known bug has not shown it can catch an unknown one.
- **Ask for the compute bill.** The paper gives agent counts and run lengths per campaign but no total, and the total will be the first number a finance team asks for.

From thinking to doing. 

[![CTA Image](https://cdn.varops.com/content/images/2026/10/logo-black.jpeg)](https://varops.com/transform/) 

****From proof of concept to proof of value.**

Proof matters more than promises. VarOps doesn’t stop at recommendations or prototypes. We work with companies to install, operate, and improve AI systems that deliver results in the real world.

[See How We Deliver → ](https://varops.com/transform/) 

## Sources

- Google DeepMind, "AlphaProof Code: Verifying Signal's Security at the Machine-Code Level" (technical paper): https://deepmind.google/documents/36/Formal\_Verification\_of\_Signal\_4.pdf
- Google DeepMind blog, "Introducing AlphaProof Code" (Nov 10, 2026): https://deepmind.google/blog/introducing-alphaproof-code/
- Open-sourced Lean development: https://google-deepmind.github.io/code-verification
- Hacker News discussion: https://news.ycombinator.com/item?id=50439193