6.5 Million Lines of Math: Signal’s Code Gets Verified
How AI agents and human experts built a mathematical proof that selected security properties of Signal’s cryptographic protocol hold in compiled machine code—and why the real power lies behind the gatekeeper, not in the agents themselves
The Proof, Not the Promise: What AlphaProof Code Actually Does
When Google DeepMind announced AlphaProof Code on November 10, 2026, the result invited a tempting but inaccurate shorthand: that Signal had been proved unhackable. AlphaProof Code does something narrower. Human experts approve the formal specification, AI agents construct candidate proofs, and Lean’s kernel checks whether those proofs follow. The authority comes from the reviewed claim and the checker, not from an agent declaring the software secure.
Google DeepMind used this framework to prove selected security properties of libsignal’s compiled AArch64 machine code. The resulting proof corpus contains approximately 6.5 million lines of Lean proof code—a formal mathematical language—resting on roughly 26,000 lines of human-reviewed specifications and processor semantics. Those approved definitions are part of the trusted base on which the result depends.
The work covers selected properties of Signal’s post-quantum PQXDH handshake and Triple Ratchet, including authentication, forward secrecy, post-compromise security, and handshake secrecy under the stated symbolic or computational assumptions. These are important protocol guarantees, but they do not certify every behavior of Signal or every attacker model.
The essential boundary is that the proof establishes what the human-approved specification says, not that every Signal app or platform is unhackable. It does not account for potential vulnerabilities in every surrounding layer—operating systems, device firmware, user behavior, or platform-specific implementations. It is assurance for one defined component and model, not a blanket security guarantee.
The Trust Chain: From Security Goal to Checked Proof
Building confidence in security-critical code requires more than just clever algorithms—it demands a careful chain of custody where humans and machines each play essential roles. The AlphaProof Code framework establishes this trust chain through a series of deliberate checkpoints.
The process begins with human expertise. Security researchers and domain specialists collaborate with AI systems to translate abstract security goals into formal mathematical specifications—precise, unambiguous descriptions of what the code should prove. This translation is crucial because it ensures everyone agrees on what secure actually means for this particular system. Before any computational work begins, human reviewers scrutinize and approve these formal specifications, acting as gatekeepers to prevent flawed assumptions from poisoning the entire verification effort.
Next comes the code itself. The researchers used unmodified libsignal Rust crates in a small command-line harness and compiled that target with stock rustc into an AArch64 Linux executable. The proof therefore reaches a particular compiled implementation rather than stopping at a protocol sketch, but the harness, hooked routines, build configuration and environment remain part of the verification boundary. It is not a proof of a complete deployed Signal application binary.
Here’s where AI agents enter the picture. Multiple prover agents work together to generate candidate proof steps, proposing logical arguments for why the code satisfies the specification. But here’s the critical safeguard: Lean’s verification engine—a mathematical kernel far simpler and more trustworthy than the agents themselves—independently checks whether each proposed step is actually valid. The AI’s confidence means nothing; only mathematical validity matters.
Finally, a gatekeeper mechanism confirms that any completed proof matches the held-out, human-approved specification. Invalid proofs are rejected regardless of how confident the AI agents are. Through this multilayered process, human judgment defines the target while agents expand the volume of proof construction that can be attempted.
Bridging the Implementation Gap: Why Machine Code Matters
Formal verification of cryptographic protocols has often focused on design-level models. Those proofs can establish properties of the model, but implementation details can create a gap between a protocol description and the instructions a processor actually runs.
This verification breakthrough does something fundamentally different. Rather than stopping at the design level, it connects protocol guarantees all the way down to the actual compiled machine code—the instructions that a processor executes. This matters because real-world attacks often exploit exactly this gap: subtle bugs introduced during implementation, compiler quirks, or processor-specific behaviors that the original specification never anticipated.
The proof accomplishes this by using formal semantics of the AArch64 processor architecture—essentially a mathematical description of how the processor works—combined with a command-line harness. This creates a checked connection from high-level security claims to individual machine instructions within the declared semantics, contracts and process assumptions.
The verification uses two complementary models: a symbolic model and a computational model. Each provides different types of security assurance and operates under explicitly different assumptions and threat models, giving a more complete picture of the code’s security properties.
Because this proof concerns one specific binary in one specific build environment, the claims must remain narrow and versioned. That specificity is a strength: it creates an auditable assurance artifact for selected properties of code drawn from a widely deployed cryptographic implementation, without claiming that the verified command-line build is itself every deployed app binary.
The Labor Shift: Four Weeks vs. Years, and What That Actually Means
The Signal protocol verification was completed in approximately four weeks by a five-person research team running AI agent campaigns continuously. To appreciate what this represents, consider the scale of prior landmark verification projects: the seL4 microkernel required 20 person-years of effort, while the CompCert compiler demanded 6 person-years. These weren’t small undertakings—they represented some of the most ambitious formal verification efforts in computing history.
But here’s what matters: this comparison isn’t a straightforward productivity experiment, nor should it be mistaken for a universal forecast about AI replacing human labor. The projects differ dramatically in scope, technical domain, and the maturity of existing tools available to tackle them. Comparing four weeks to twenty years without acknowledging these differences would be misleading.
What has shifted in this project is the division of labor. AI agents handled the large proof-construction workload. Human experts concentrated on defining precise specifications, validating assumptions, and making review decisions. Whether that separation changes the broader economics of verification remains to be measured.
The practical consequence is still a research question. One four-week, five-person project suggests that agent teams may reduce the proof-construction burden enough to make more production verification projects worth attempting. But the team did not publish a matched cost study or a universal compute figure, and the earlier projects differ substantially in scope. Economic feasibility has to be demonstrated project by project.
Testing the Gatekeeper: Two Restored Bugs and What They Show
To truly validate their verification framework, the researchers conducted a critical sanity check: they deliberately reintroduced two previously fixed bugs from libsignal’s history into isolated test builds. This approach allowed them to confirm that their system could actually distinguish between secure and vulnerable code—rather than simply rubber-stamping every binary that passed through the process.
The first bug involved a small-subgroup condition failure in the PQXDH handshake processing. The second centered on weak state retained after a failed decryption. In both cases, when the researchers fed these deliberately altered versions into their verification framework, the binaries failed their respective security theorems. Lean produced machine-checked artifacts showing that the altered binaries violated the relevant symbolic security theorem under the approved model.
This is a useful bounded sanity check: the workflow did not automatically bless both altered binaries. However, two historical bugs do not establish a universal defect detector. Vulnerabilities can still escape the proof in several ways. A security flaw operating outside the specification, beyond the assumed attacker model, violating platform assumptions, or exploiting gaps in the trusted contracts could potentially evade detection. In essence, the framework proves what it’s designed to prove—but not necessarily everything.
The Boundary the Proof Cannot Cross: Specification, Build, Environment, and Beyond
Formal verification is powerful, but it has clear limits. The most important one is this: a proof is only as good as the specification it’s asked to verify. If a security threat never makes it into the formal statement—if a developer simply forgot to specify that a particular attack scenario should be impossible—then the mathematical proof cannot catch it. The checker proves what it was asked to prove, nothing more.
The verified artifact is also remarkably specific. In the Signal case, the proof covers one particular AArch64 Linux build of a command-line harness. This is a controlled, minimal environment. The actual mobile apps, group messaging features, server infrastructure, key generation logic, and protection against side-channel attacks that leak information through timing or power consumption—these remain separate challenges entirely.
Additionally, some components rely on trusted contracts rather than proof from first principles. Certain cryptographic primitives and low-level routines are represented by trusted contracts rather than proved internally in this project, so the result depends on those contracts. The computational theorem covers classical attackers, while the symbolic model represents some later primitive-break scenarios, including a later Diffie–Hellman break. Neither should be broadened into a claim covering every quantum attack. Multi-device behavior, future builds, deployment configuration and surrounding application logic remain outside the verified target.
This doesn’t diminish the achievement. Unlike vague security scores or marketing claims, formal verification produces an auditable artifact with precise meaning: this specific binary, running under these exact assumptions, provably satisfies these documented properties. It’s transparency rather than perfection—but that clarity is exactly what makes it valuable.
What Comes Next: From Milestone to Practice
This result is a substantial demonstration, but the path from one verified target to wider adoption still requires several additional steps.
First, independent teams must reproduce these results. Science advances through verification, and other researchers need to confirm that the methodology holds up under scrutiny and can be applied beyond the initial Signal protocol demonstration. This reproducibility builds confidence and identifies any limitations in the approach.
Next comes scaling. The techniques must work across additional platforms, architectures, and larger portions of the trusted computing base—moving from cryptographic protocols to the broader ecosystem of critical software. Equally important, proof maintenance must keep pace with real-world software evolution. As developers release updates and new versions, the formal guarantees cannot become outdated artifacts.
The practical applications are compelling. Organizations managing critical infrastructure could request narrow, versioned guarantees for medical devices, power-grid controllers, financial protocols, and safety interlocks. Rather than proving everything, they could seek machine-checked assurance about specific behaviors that matter most, within clearly stated assumptions.
Ultimately, the durable advance is a transformed division of responsibility: machines generate millions of candidate proof steps, human experts define and inspect the contracts and specifications, and Lean’s small kernel accepts only proof terms that check against that approved target. This partnership could extend formal assurance to more critical software, but reproduction, maintenance and broader coverage still have to prove that promise.
Stay ahead of the curve! Subscribe for more insights on the latest breakthroughs and innovations.


