DeepMind uses AI agents to formally verify Signal's cryptographic code

Google DeepMind researchers have successfully used artificial intelligence to formally verify the source code of the Signal protocol, marking a significant milestone in software security. Published on November 10, 2026, this work demonstrates how agentic AI frameworks can bridge the gap between theoretical design and actual implementation in critical cryptographic systems.

What happened

For decades, formal verification has been considered the gold standard for ensuring software correctness, yet it remains prohibitively expensive and time-consuming for large-scale systems. Most previous efforts focused only on high-level designs or small fragments of code, leaving a dangerous gap where implementation bugs could undermine security guarantees. Google DeepMind’s new research changes this by applying an AI-driven approach to the entire core of the Signal protocol, which protects billions of private messages across apps like Signal and Google Messages.

The team utilized a novel framework called AlphaProof Code to guide AI agents through the complex process of mathematical proof generation. This effort resulted in the first-ever formal verification of a widely deployed cryptographic protocol’s actual implementation, rather than just its abstract design. The process confirmed that the compiled code running on user devices strictly adheres to key security properties, such as maintaining message confidentiality even if a device is temporarily compromised.

To validate the system’s reliability, researchers reintroduced two known, previously fixed bugs into an isolated version of the Signal codebase. In both instances, AlphaProof Code correctly identified the vulnerabilities and produced machine-checked proofs demonstrating that the buggy versions were insecure. This test confirmed that the framework can distinguish between secure and flawed implementations with high precision.

How it works

AlphaProof Code operates as a multi-LLM agentic framework that mimics the workflow of a human research team. The process begins with human experts and AI models collaborating to translate Signal’s security goals into formal mathematical specifications. Every specification is reviewed by humans to ensure accuracy before the automated phase begins. This hybrid approach ensures that the mathematical targets are correct before the heavy lifting of proof generation starts.

Once the specifications are set, agents powered by the Gemini Carbon model take over to generate the proofs. These agents write code in Lean, a programming language designed for mathematical verification. During the four-week project, the agents generated over six million lines of Lean code. The system then audits these proofs automatically, flagging only about one percent of the codebase for human review. This drastic reduction in manual workload allows experts to focus solely on areas requiring nuanced judgment, while Lean automatically verifies the rest.

Key details

• The verification was completed in four weeks, a task that historically requires expert teams several years to accomplish.
• The framework generated over six million lines of Lean code to mathematically prove the accuracy of the Signal implementation.
• Human experts reviewed only one percent of the generated code, relying on Lean’s automatic checking for the remainder.
• The system successfully detected two reintroduced real-world bugs, proving its ability to identify insecure code.
• This is the first time a widely deployed cryptographic protocol’s implementation has been formally verified by any method.
• Google DeepMind is open-sourcing the formal verification artifacts for community use.

Why it matters

For software engineers and security architects, this breakthrough addresses the persistent "implementation gap" where secure designs fail due to coding errors. Cryptographic protocols underpin essential services from online banking to healthcare, and a single flaw can expose millions of users. By proving that the actual compiled code matches the security specification, developers can achieve a level of assurance that traditional testing and auditing cannot provide. This moves security from probabilistic confidence to mathematical certainty.

The efficiency gains demonstrated by AlphaProof Code suggest that formal verification may finally become scalable for critical infrastructure. As cyber threats evolve and become more automated, the ability to rapidly verify firmware for medical devices, power grid software, and other vital systems becomes crucial. This approach allows organizations to defend against agent-driven threats by ensuring their own foundational software is mathematically sound, reducing the attack surface significantly.

What you can do

• Review the open-sourced formal verification artifacts provided by Google DeepMind to understand the structure of machine-checked proofs.
• Explore the Lean programming language to familiarize yourself with tools used for mathematical verification of software.
• Assess your current security protocols to identify critical components that might benefit from formal specification, even if full verification is not yet feasible.
• Stay updated on agentic AI frameworks like AlphaProof Code to anticipate how automated theorem proving may integrate into future CI/CD pipelines.
• Consider collaborating with security researchers to translate high-level security requirements into formal specifications for your most critical assets.
• Monitor developments in AI-assisted security tools to prepare for a shift towards mathematically verified software standards in regulated industries.