Google DeepMind uses AI to verify Signal's cryptographic security
Researchers used AI agents to mathematically prove that Signal's core code matches its privacy promises, marking a milestone in software verification.

The short version
- The project generated approximately 6.5 million lines of checked proofs over a four-week period in October 2026.
- AI agents produced the proof code while human experts defined the security claims and reviewed the specifications.
- The verification covers the PQXDH handshake and Triple Ratchet components of the Signal protocol.
- The team verified the production Rust code compiled for an Arm-based computing environment.
- The results include proofs for authentication, forward secrecy, and post-compromise security.
Why it matters
This work bridges the gap between theoretical security designs and the actual code running on devices, ensuring that software doesn't contain hidden flaws. It demonstrates how AI can be used to perform high-level formal verification, which was previously too labor-intensive for many large systems.
Bridging theory and machine code
Google DeepMind researchers recently completed a project to mathematically verify the security properties of libsignal. This is the reference implementation of the Signal messaging protocol, which powers the popular encrypted messaging app. The goal was to connect high-level cryptographic guarantees to the actual compiled machine code that runs on devices.
Previous security analyses often focused on mathematical designs or very narrow parts of production software. This project is different because it examines the code within a defined execution environment. By doing so, the team can ensure that the transition from a design to executable code does not introduce new vulnerabilities.
The verification specifically covers two major components: the PQXDH handshake and the Triple Ratchet. These parts of the protocol are responsible for establishing secure connections and maintaining encryption. The researchers addressed properties like authentication, forward secrecy, and post-compromise security to see how messages stay protected if keys are exposed.
How AI agents handled the proof
The project utilized a framework called AlphaProof Code to manage the verification process. This system combines human-directed specification writing with teams of AI agents. These agents were tasked with generating the proof code, which was then validated by Lean, a specialized programming language and proof assistant.
The researchers used models including Gemini 4 Carbon and Claude Opus 5.5 to help develop the specifications. Human experts were responsible for the heavy lifting of deciding what needed to be proved and reviewing the drafts. This human oversight is critical because an AI might produce a valid proof for a requirement that is too weak or too restrictive.
The team monitored the agents' progress and reviewed changes to trusted assumptions throughout the process. While the AI produced the bulk of the work, the human researchers provided the direction. The final output consisted of approximately 6.5 million lines of checked proofs alongside about 26,000 lines of trusted specifications.
Testing the system against bugs
To ensure the verification system actually worked, the team performed a series of tests using historical data. They reintroduced two previously fixed bugs into separate experimental builds of the libsignal code. This allowed them to see if the AI agents could successfully identify that the altered code violated security theorems.
In both test cases, the agents produced Lean-checked proofs showing that the buggy implementations were insecure. This confirmed that the framework could detect deviations from the intended security goals. These tests were conducted using old bugs rather than searching for new vulnerabilities in the current software.
The results provide a level of confidence that is difficult to achieve through traditional testing alone. By using symbolic and computational models, the team could bound an attacker's chances of success. These models help define how the system behaves under specific scenarios, such as when a device is compromised or a key is stolen.
Limitations and future applications
While the results are significant, the verification has specific boundaries and limitations. The project verified a compiled command-line program, not the entire Signal application. This means the surrounding application behavior and certain low-level cryptographic routines were outside the scope of the formal proof.
The computational results also do not provide guarantees against quantum attackers. However, the symbolic analysis does address some quantum-related properties under specific assumptions. The researchers also noted that some routines were represented through contracts, which are formal descriptions of how those routines are assumed to behave.
Looking ahead, Google DeepMind identifies other high-stakes areas for this technology. They see potential applications in medical device firmware and power-grid software. The team plans to work with open-source contributors to improve the Lean specifications and proofs they have released for the community.
Impact on software trust
This project represents the first time protocol-level security properties have been verified at this depth for a widely deployed, unmodified cryptographic protocol. It moves the needle on how we trust the software we use for private communication. By using automated theorem proving, the team provides a more rigorous foundation for privacy guarantees.
Ehren Kret, Chief Technology Officer of Signal, noted that as AI-driven security threats grow, these types of verifications provide greater confidence. The work shows that AI can be a tool for strengthening security rather than just a source of risk. It allows for a level of scrutiny that was previously too expensive or slow for complex production code.
The success of this project relies on the foundation of trusted specifications and the Lean checking system. Because the AI handles the vast majority of the proof generation, the integrity of the human-written rules is paramount. This balance of human expertise and AI scale offers a new path for securing critical infrastructure and private communications.
What to watch
- How the AlphaProof Code framework scales to larger, more complex software systems.
- Whether medical device firmware begins to see widespread formal verification using these AI agents.
- How the community contributes to the released Lean specifications for libsignal.
Try it
Check the official Signal website or their GitHub to see if they have released any updated documentation regarding their protocol's formal verification.
Sources and links
Liked it? Say why
Add a line for other readers.
No account needed. We never show your email. Comments with links, ads or abuse are held and not shown. Your comment shows after a quick check.
Listen to the AI Wire headlines
Listen to the AI WireListen to our daily AI shows every morning: on your commute, in the shower, wherever you are
Listen to the daily showsFirst reported by EdTech Innovation Hub · Read the original. Written by the SI Agent News Desk from the reporting above.Written with AI from the source above. Every number is checked against the source. Spot a mistake? Corrections.
