Artificial intelligence is often judged by how well it writes code, answers questions or automates routine work. A more demanding test is whether it can help prove that critical software behaves according to a precise security specification. Google DeepMind’s AlphaProof Code project, announced on 10 November 2026, puts that question into practice by using AI agents to help formally verify selected security properties of the code underlying the Signal messaging protocol.

The result is significant, but it needs to be described accurately. DeepMind did not certify every part of the Signal app, every device configuration or every possible attack. The research focused on a defined implementation and a set of mathematical properties. Its wider importance lies in showing how AI agents may help make formal verification more practical for software that people and organisations depend on.
What is formal verification?
Software testing checks how a program behaves in selected situations. It is essential, but tests cannot cover every possible input, execution path or system state. Formal verification takes a different approach. Engineers define what a program is required to guarantee, express those requirements in a mathematical language and construct a proof that the implementation satisfies them under stated assumptions.
A proof checker then validates the argument according to a formal logic. In the AlphaProof Code project, the proof assistant Lean acts as the trusted checker. The AI agents can help write specifications and construct proofs, but the final proof must pass Lean’s verification process. This separation matters: a persuasive explanation generated by a language model is not, by itself, evidence that software is secure.
Formal methods have been used in specialised systems for years, including cryptography, hardware and safety-critical software. The difficulty is the time and expertise needed to translate complex code into precise specifications and complete the proof. AI assistance could reduce some of that workload, although it does not remove the need for sound assumptions and expert review.
What DeepMind says it verified
DeepMind researchers used AlphaProof Code to examine libsignal, the reference implementation of the Signal protocol. The technical paper describes proofs connected to compiled AArch64 machine code, rather than relying only on a high-level description of how the protocol should work. The work addressed selected properties associated with the protocol’s post-quantum handshake and its Triple Ratchet messaging design.
Among the properties named by the researchers are forward secrecy, authentication, post-compromise security and handshake secrecy. In broad terms, these properties are intended to protect the confidentiality and authenticity of conversations, including in situations where a device or key may be compromised. They are important concepts in modern encrypted messaging, but the exact guarantees depend on the formal model, implementation and assumptions used in the proof.
DeepMind says the project took four weeks and produced about 6.5 million lines of machine-checked Lean proof code. To test whether the framework could distinguish correct code from known-buggy code, researchers reintroduced two previously fixed bugs into an isolated version of the implementation. The system then produced proofs showing that the altered versions did not meet the specified security properties.
Why checking compiled code matters
There can be a gap between a protocol’s design and the software that actually runs. A design may be mathematically sound while a programming error, compiler issue or implementation mistake creates a weakness. Verifying properties at the machine-code level attempts to narrow that gap by connecting the proof to the compiled program.
That is a demanding task. The researchers had to model the relevant machine instructions and define what the software was supposed to guarantee. The work also built on earlier formal-verification research involving Signal. It should therefore be viewed as an extension of a longer engineering effort, not as a system that independently discovered and solved every possible security problem.
What the announcement does not mean
The most important limitation is scope. Wired reported that the project did not formally verify the entire Signal mobile application. The proofs concern selected properties of a particular implementation and build. They do not establish that every feature, operating system, network interaction, user device or future software release is free of vulnerabilities.
The project is also research, not a commercial security product that organisations can simply install. DeepMind has not presented it as a universal certification service. The company has described the work as a milestone and acknowledged that scaling the approach across large software systems remains a challenge.
Human judgement remains central. Someone must decide which properties matter, formulate specifications that reflect the intended security model, review assumptions and interpret what a proof actually establishes. If the specification is incomplete or the assumptions do not match the real deployment, a mathematically valid proof may still leave important risks outside its scope.
Potential implications for businesses and developers
For technology companies, the promising possibility is a stronger verification process during development. AI agents could help security teams examine critical libraries, payment systems, identity services and infrastructure software. Instead of relying only on tests and code reviews, teams may eventually be able to prove selected properties of components where failures would have serious consequences.
That does not mean every business should wait for automated proofs before improving security. Secure development still depends on patch management, access controls, independent testing, dependency reviews, monitoring and a clear process for responding to vulnerabilities. Formal verification is likely to complement those controls rather than replace them.
Smaller organisations may benefit indirectly if verification tools become easier to use and are incorporated into the software and cloud services they already purchase. However, buyers should ask what was verified, which version was examined, what assumptions were made and whether the proof is maintained as the product changes.
What to watch next
The next test is whether the approach can be independently examined and applied to more systems without requiring disproportionate time or computing resources. The release of the technical paper and proof materials gives researchers something concrete to study. Wider adoption will depend on reproducibility, practical costs, tool integration and confidence in the specifications.
For readers following the broader AI industry, this development is a different kind of progress from a new chatbot or model launch. It explores whether AI can help engineers establish stronger guarantees about software. Digismartiens has also covered the wider business impact of cloud service outages and the policy debate around AI regulation in the UK. Both topics underline why reliability and accountability matter alongside innovation.
AlphaProof Code does not make software invulnerable. It does, however, demonstrate a promising research direction: combining human expertise, AI-assisted reasoning and independently checked mathematical proofs to examine important parts of real software. The value will depend on how carefully that method is applied, reviewed and maintained.
Sources and further reading
- Google DeepMind: Introducing AlphaProof Code
- Technical paper and verification materials
- Wired: Reporting on the scope and limitations of the Signal verification project
- Axios: How AI was used to check Signal protocol code



