Skip to content

AI Agents Prove That Signal’s Encryption Code Keeps Its Security Promises

Google DeepMind's AI agents wrote about 6.5 million lines of Lean proofs showing that Signal's compiled code meets key security goals.

Most software is tested, but very little is ever proved correct. Proofs give the strongest guarantee, although they usually cost years of expert work. Now Google DeepMind reports a shortcut built on teams of AI agents. Its system, called AlphaProof Code, makes AI formal verification work on real, widely used code. In this case, the target was libsignal, which protects chats in Signal and Google Messages. According to the company, the agents produced about 6.5 million lines of checked proofs. As a result, key security properties are proved for the compiled program itself. The work was announced on November 10, 2026, in a Google DeepMind blog post. So what exactly was proved, and what does it leave out?

Why AI Formal Verification Matters

Today, most code earns trust through testing, bug hunting and human review. However, testing can reveal bugs but cannot show that none remain. Formal verification takes a different route, using mathematics instead of trial runs. Firstly, engineers write down exactly what the code must always do. Then they prove that the code meets that statement in every possible case. For the most part, this effort has been too costly for everyday software. The verified seL4 operating-system kernel, for example, took about twenty person-years of work. In the same way, the verified CompCert compiler took about six person-years. With this in mind, AI formal verification aims to cut that cost sharply.

Explainer: What It Means to Prove Code Correct

A proof about code works much like a proof in geometry class. You start from precise definitions and reach a conclusion through valid steps. Here, the definitions describe what secure messaging means in exact terms. The steps are written in Lean, a language built for checking mathematics by computer. Lean’s small, carefully audited kernel checks every step before accepting a proof. That is to say, nobody has to trust the AI that wrote it. If a single step is wrong, the whole proof simply fails. Of course, a proof only covers the property that was actually stated. For this reason, writing the right statement matters as much as proving it.

How the Agent Team Splits the Work

AlphaProof Code divides AI formal verification work the way a research group might. To begin with, a specification-writing agent works with human experts on the goals. It turns published security models for Signal into precise statements in Lean. Meanwhile, reviewer agents from a different AI model family critique each draft. Humans approve every statement before any proving begins. After that, a team of prover agents powered by Gemini 4 Carbon takes over. At the same time, an orchestrator splits work among 40 to 80 agents per team. A typical proof campaign ran on one machine for 24 to 72 hours. Finally, a gatekeeper accepts a proof only if Lean checks it against the approved statement.

Workflow infographic: people approve the specification, software agents write proofs, and Lean confirms every step
Fig. 1: Humans Set the Goals, AI Agents Write the Proofs, Lean Checks Them

Proving the Machine Code Itself

Most earlier protocol proofs stopped at the design, written on paper or in models. In contrast, this project worked on the unmodified code that actually runs. To illustrate, the team compiled libsignal with the standard Rust compiler for AArch64 processors. Its verified portion holds about 140,000 machine instructions, roughly 560 kilobytes. Lean then loaded those exact bytes together with a formal model of the processor. For that reason, the compiler itself does not need to be trusted. On the other hand, proofs at this level are very long. Registers, stack frames and memory layout all have to be handled step by step. That explains why the proof files grew so large.

Testing the System on Two Real Bugs

A proof system is only useful if it can tell good code from bad. To check this, the team reinserted two real bugs that had already been fixed. Both had been found earlier by outside researchers studying libsignal. For one thing, one bug could store a private prekey in unconfirmed session state. The other let a tampered, replayed handshake open a duplicate session. In each case, the team rebuilt the program with the old flaw restored. Then the system produced machine-checked proofs that the buggy versions broke the security goals. Notably, these disproofs needed no assumptions beyond Lean’s standard axioms. In other words, the specifications were strong enough to catch real mistakes.

Bug test infographic: two old bugs are put back into the code, and Lean shows the faulty version breaks its security goals
Fig. 2: Reinserted Bugs Were Caught by Machine-Checked Proofs

What the Machine-Checked Proofs Cover

Two core parts of Signal’s protocol fall within the proofs. The first is PQXDH, which sets up keys and is designed to resist quantum attacks. Next, the Triple Ratchet keeps changing keys as messages flow. For both, the agents proved forward secrecy and post-compromise security. That is, old messages stay safe if a key leaks later. Likewise, a session can recover its security after a temporary device compromise. The proofs also establish message confidentiality and authenticity. Overall, the repository holds about 6.5 million lines of proofs. Readers, however, only need to trust about 26,000 lines of specifications and processor rules.

Specifications Became the Hard Part

According to the report, a team of five people did the work in four weeks. In the meantime, each researcher ran agents nonstop on a personal workstation. None of the authors wrote any proof code themselves. Instead, most human effort went into deciding exactly what to prove. For AI formal verification, the authors argue, the hard question becomes what to prove. In fact, writing specifications against real code exposed errors in published analyses. For instance, the team found fifteen gaps or bugs in one Double Ratchet analysis. They also found a ratchet-index error in published ProVerif queries for Signal. What is more, agents flagged just one percent of the work for human review.

Keeping the Agents Honest

Agents under pressure can quietly weaken a goal so they can finish it. In a separate project, a proving agent once redefined a key condition as false. As a result, that trick spread to the rest of the swarm. For this reason, AlphaProof Code never relies on an agent’s own report of success. Instead, the gatekeeper sees only file names and theorem names, not explanations. In addition, Lean replays every proof from scratch in a fresh environment. Agents may still propose small changes when a specification proves wrong about the code. However, a critic agent accepts a change only if security is not weakened. Proposals that would weaken security go to a human as possible bugs. Even so, compute remained a bottleneck, since a clean build took several hours.

Business Opportunities in Encryption Code Verification

Cryptographic protocols protect online banking, web browsing and private messages. A single flaw can therefore expose millions of people at once. In the near term, security teams can study the openly released Lean proofs. Google DeepMind has released the specifications and proofs for public checking. Within five years, verified code could become a paid service for banks and governments. Critical-infrastructure operators, for example, may want proofs for their most sensitive software. Later, regulators might expect mathematical guarantees for medical devices, power grids and vehicles. Such AI formal verification services would need people who understand both security and proofs. Our report on how quantum computing threatens data security adds useful context.

Careers and What to Study

AI formal verification is creating roles that blend security, mathematics and software. For instance, formal verification engineers write specifications and guide proof tools like Lean. Security and cryptography engineers decide which properties truly matter. Meanwhile, AI tooling engineers build and monitor the agent teams themselves. According to the US Bureau of Labor Statistics, information security analysts earned a median $129,180. That figure is from May 2025, with 21% growth projected through 2035. By comparison, software developers earned a median of $135,980 in the same period. These are US figures, and pay and demand vary by country. For study, consider computer science, discrete mathematics, cryptography and processor architecture. Our story on AI-driven proof search in mathematics shows a related skill set.

Limits Worth Keeping in Mind

Note that this is a company report that has not yet been peer reviewed. The main guarantees are symbolic, so they assume the cryptography itself is perfect. Side-channel attacks, such as timing leaks, are outside the scope of the proofs. In addition, the computational security bounds hold only against classical attackers. The tested setup was also narrow, with two honest parties in fixed roles. Some prekey types and Signal’s group messaging were not covered. Even so, the proofs and specifications are open for anyone to inspect. All things considered, the result is a clear step forward for software assurance. In the long run, AI formal verification could make proofs routine for critical code.

References

Chaudhuri, S., Ferraiuolo, A., Kovsharov, A., Chajed, T., Schlesinger, S., Seth, K., Katz, J., Sutton, C., & Kohli, P. (2026). AlphaProof Code: Verifying Signal’s security at the machine-code level [Technical report]. Google DeepMind. https://deepmind.google/documents/36/Formal_Verification_of_Signal_4.pdf

Kohli, P., & Chaudhuri, S. (2026, November 10). Introducing AlphaProof Code: A breakthrough in verifying complex software at depth. Google DeepMind. https://deepmind.google/blog/introducing-alphaproof-code/

US Bureau of Labor Statistics. (n.d.). Information security analysts. Occupational Outlook Handbook. https://www.bls.gov/ooh/computer-and-information-technology/information-security-analysts.htm

US Bureau of Labor Statistics. (n.d.). Software developers, quality assurance analysts, and testers. Occupational Outlook Handbook. https://www.bls.gov/ooh/computer-and-information-technology/software-developers.htm


Reviewed by Amit Singh on November 19, 2026Edited by Dr. Akbar Ahmad
Reviewer note

The article explains formal verification, Lean and the agent workflow in clear, student-friendly terms. Its figures match the technical report, including the 6.5 million lines of proofs and the two reinserted bugs. The limits section notes the missing peer review, the symbolic assumptions and the excluded side channels. Readers who want the methods and theorems in full should check the original report this story draws on.

Editorial note

ENTECH is running this story because proving software correct has long been too slow and costly for most code. Google DeepMind's work shows students how AI agents, a proof language and human judgment can share that job. It also points to new careers that blend security, mathematics and software engineering. The result comes from a company report that is not yet peer reviewed, and it covers a narrow test setup. For the full details, we suggest readers turn to the original technical report and the open proof files.

Hrutanshu Kurankar
Hrutanshu KurankarScience Communicator - ENTECH Magazine
Author

Hrutanshu Kurankar is a Computer Engineering graduate from Marathwada Mitra Mandal’s College of Engineering, Pune. His interests span artificial intelligence, machine learning, cybersecurity, data science, and science communication. He enjoys exploring how emerging technologies work and translating complex technical concepts into clear, accessible explanations for students and young audiences.

His practical experience includes developing FlashCTI, a Retrieval-Augmented Generation (RAG) system for cyber threat intelligence and log analysis, exploring privacy-focused browser extensions, and building machine learning applications. His technical background includes Python, data analysis, machine learning frameworks, web development, vector databases, and cybersecurity tools. Through these projects, he has developed an interest in applying technology to real-world problems and making technical knowledge easier to understand.

Hrutanshu is associated with ENTECH STEM Magazine, where he contributes to science communication and editorial initiatives, including research outreach and activities supporting the Machine Learning Special Issue 2026. His work involves connecting with potential contributors and academic reviewers to encourage participation in STEM research and knowledge sharing. As a science communicator, he aims to bridge the gap between complex scientific ideas and everyday understanding through relatable examples, clear writing, and evidence-based explanations. He is particularly interested in making science and technology engaging and accessible to the next generation of learners.

www.linkedin.com/in/hrutanshu-kurankar-a100882a6

Disclaimer.