Sources: Elvis Saravia's LinkedIn post; DeepMind blog, 2026-11-10; technical report and Lean development (Chaudhuri, Ferraiuolo, Kovsharov, Chajed, Schlesinger, Seth, Katz, Sutton, Kohli); paper PDF; code.
In one paragraph
Google DeepMind used a multi-agent framework, AlphaProof Code, to prove security properties of libsignal (Signal's Rust reference implementation) against the compiled AArch64 binary, not the source or a protocol model. Agents built on Gemini 4 Carbon produced about 6.5 million lines of Lean proof resting on about 26,000 lines of trusted specification and machine semantics. A team of five did the proof work in four weeks; seL4, the usual comparison, took about twenty person-years. The proofs cover the post-quantum PQXDH handshake composed with the Triple Ratchet, in both a symbolic and a computational model: forward secrecy, authentication, post-compromise security and handshake secrecy. When two previously fixed Signal bugs were reintroduced into an isolated copy, the system produced machine-checked proofs that the buggy versions were insecure. The authors claim it is the first proof linking protocol-level guarantees to the unmodified code of a widely deployed crypto implementation.
The core idea: specs are trusted, proofs are not
The design rests on one split. The specification (Lean theorem statements plus every definition they depend on, including the machine semantics and contracts for hooked routines) is trusted and cannot be checked automatically, so a flaw there silently weakens the guarantee. The proof is untrusted: Lean's kernel rejects any logical error, so the reliability of the result does not depend on the reliability of the agents that wrote it. The paper's claim is that proof writing is no longer the bottleneck; specification engineering is, and that is where humans stay.
Architecture
Specification writing. A spec-writer agent drafts Lean theorems with close user guidance, starting from published symbolic and computational models of Signal and composing them (prior work verified handshake and ratchet separately). A pool of skeptical reviewer agents checks drafts against sources and the implementation. The user approves; that git commit becomes the baseline.
Spec strength checks. Weak specs (over-restrictive input assumptions, weak output claims, under-constrained witnesses) can hold for buggy code. Prover agents also prove that hypotheses are jointly satisfiable and that premises are met by concrete runs, like vacuity detection in model checking.
Machine-code semantics. A Lean model of user-mode AArch64 Linux takes the ELF bytes and describes every possible run (decoder, instruction semantics from Arm's ASL spec, memory with page permissions, loader, syscall model). The trusted part is definitions only, validated by lockstep testing against Unicorn and Arm's Sail model and against qemu-aarch64. The program logic (separation logic, weakest preconditions, automation) is proved sound in Lean, so it is not trusted.
Proof synthesis. An orchestrator schedules but never edits Lean. Team leads absorb worker back-and-forth and send short summaries upward, to manage context limits and compaction. An architect owns the proof decomposition, an integrator alone commits and dedupes lemmas, and each file has at most one writer at a time. Agents try to falsify a goal before working on it. Typical campaigns: 40 to 80 agents on one machine for 24 to 72 hours.
Spec amendments. Provers cannot edit the spec. They propose amendments to a critic agent that never sees the proof attempts, and it accepts only changes that are necessary (shown by a disproof, a counterexample on the binary or a code-grounded argument), do not weaken security, and are small. Changes to trusted assumptions need user approval and are logged.
Gatekeeping. The spec is copied into a held-out directory no agent can write. A gatekeeper runs Lean's comparator tool through a deterministic script: the statement and every definition it depends on must match the held-out copy, only standard axioms may be used, and the kernel must accept. Only the gatekeeper can declare a top-level goal done.
What is and isn't covered
Trusted base: Lean's kernel, the AArch64 semantics, the security definitions and models, and contracts for cryptographic primitives and a few library routines (output, error formatting, file writes). Not trusted: the Rust source or the compiler.
Assumptions: idealized primitives in the symbolic model; standard hardness assumptions (Gap-DH, XEdDSA unforgeability, Kyber1024 collision resistance, HKDF/HMAC PRF security, AES-CBC+HMAC CCA) in the computational model.
Binary-level facts: every valid init, send and recv run does what the Lean model prescribes, never faults or diverges, and a separate theorem rules out running out of memory within stated limits.
Not covered: computational secrecy in the symbolic setting, more than two parties, SPQR's post-quantum healing, quantum attackers in the computational model, multi-device state, and large-scale sessions (the computational bound becomes vacuous for many long sessions). Results are for a specific CLI harness built with stock rustc and musl; carrying them to the Android and iOS apps assumes their builds preserve the same behavior.
Tradeoffs and open questions
The spec is the trust root. A commenter on the post put it plainly: Lean only says the proof matches the spec. The paper agrees and invests in reviewer agents, vacuity checks and a critic-gated amendment process, but 26,000 trusted lines still need expert human review.
Hooked routines are contracts, not proofs. Crypto primitives and some library functions are modeled, so a bug inside them is outside the guarantee.
Vendor evidence. The cost comparison to seL4 compares a human-only effort with an agent effort that ran on large compute; agent compute cost is not given. The bug-reintroduction demo is a good sanity check of spec strength, but two bugs is a small sample.
Why it matters for engineering teams
It is a concrete design for running dozens of agents on one long task: role separation, single-writer files, a sole committer, summary-only reporting up a hierarchy, and an independent judge the workers cannot influence.
It shows where human effort moves when generation is cheap and checking is mechanical: into deciding what must be true and reviewing that statement.
For security-critical libraries, verifying the shipped binary removes the compiler from the trusted base, which source-level verification cannot do.
Checklist if you want to apply the pattern
Separate trusted statements from untrusted generated work, and store the trusted part where agents cannot write.
Have the judge check that dependencies are unchanged, not just the top-level statement.
Make agents propose changes to the goal through a reviewer that does not see their attempts, with a necessity test.
Test the spec itself: satisfiable hypotheses, concrete runs that meet premises, and known-bad versions that must fail.
Validate any trusted model against independent oracles.
Related
R020 (the model proposes, the harness enforces): the same split between untrusted generation and a deterministic enforcer.
R016 (do humans still need to check AI's facts?): where human verification effort should go.
R024 (contracts locked and frozen files hashed before agent edits): a lighter version of the held-out spec.