Formal verification — mathematically proving that code behaves exactly as specified — has been a goal of software engineering for decades. In practice, it has been too expensive, too slow, and too specialized for all but the most critical systems. On November 10, 2026, Google DeepMind announced that researchers used a multi-agent AI framework called AlphaProof Code to formally verify the core cryptographic protocol underlying Signal, the messaging app used by billions of people through Signal and Google Messages. The AI agents generated over six million lines of machine-checked proof in the Lean language, completing in four weeks what has historically taken expert teams years. It is the first time any method — AI-assisted or otherwise — has formally verified a widely deployed cryptographic protocol at this depth.

In Brief

  • Google DeepMind introduced AlphaProof Code on November 10, 2026, an agentic framework that combines human expertise with AI agents for formal verification of software at unprecedented depth
  • AI agents powered by Gemini Carbon generated over six million lines of Lean proof to verify Signal’s cryptographic protocol down to compiled machine instructions — the first time this has been achieved by any method
  • The verification process took four weeks, compared to the years that traditional formal verification of cryptographic protocols typically requires
  • Human experts only needed to review approximately one percent of the codebase, with Lean automatically checking the rest
  • The system correctly identified two real, previously fixed Signal bugs when they were reintroduced, producing machine-checked proofs that the buggy versions were insecure
  • Signal CTO Ehren Kret called the work “a major breakthrough” and said it gives Signal “even greater confidence in our code’s privacy guarantees”
  • DeepMind open-sourced the formal verification artifacts for community use

What AlphaProof Code Actually Does

The framework, described in a blog post by Pushmeet Kohli and Swarat Chaudhuri of Google DeepMind, splits formal verification the way a research team would divide work. Human experts collaborate with AI to decide what properties need to be proven, translating Signal’s security goals into formal mathematical specifications. From there, AI agents powered by Gemini Carbon — DeepMind’s frontier model — generate the proofs themselves, writing Lean code that mathematically demonstrates the implementation meets those specifications.

Lean is a functional programming language and theorem prover. When a proof is written in Lean, the Lean compiler automatically checks whether the proof is valid. This is critical: the AI agents do not need to be trusted. If an agent makes an error, Lean will reject the proof. The human reviewers only need to focus on the specifications — what the code should do — and on the small fraction of cases the agents flag for review.

According to DeepMind, the agents generated over six million lines of Lean proof to verify Signal’s core cryptographic code. The human review burden was reduced to approximately one percent of the codebase. The entire process took four weeks.

Why Verification Down to Machine Instructions Matters

Most formal verification of cryptographic protocols stops at the design level. Researchers prove that the mathematical protocol is correct — that the Double Ratchet algorithm in Signal’s case produces the intended confidentiality and forward secrecy guarantees. But real-world vulnerabilities often live in the gap between the design and the implementation. A protocol that is mathematically perfect can still be compromised by a bug in how the code is compiled, how memory is managed, or how edge cases are handled.

AlphaProof Code went further. According to DeepMind, the agents proved that the compiled code — the actual machine instructions running on devices — fulfills the key security properties. This includes proving that messages remain protected before and after a device is temporarily compromised, which is the forward secrecy and post-compromise security guarantee that makes the Signal Protocol distinctive.

This depth of verification is what makes the work unprecedented. As DeepMind noted, “real-world vulnerabilities often hide in the gap between design and implementation, bridging this gap makes these proofs vastly more complex.”

The Bug Detection Test

To confirm that AlphaProof Code can distinguish correct code from buggy code, the researchers reintroduced two real, previously fixed bugs into an isolated version of Signal’s code. In both cases, the system produced a machine-checked proof that the buggy version was insecure.

This is an important validation. Formal verification is only useful if it can catch real problems. By using actual historical bugs — rather than synthetic test cases — DeepMind demonstrated that the framework detects vulnerabilities that were realistic enough to have been discovered and fixed in production.

What Signal Says

Signal’s leadership endorsed the work directly. Ehren Kret, Chief Technology Officer of Signal, said in a statement quoted in the DeepMind announcement: “Using AI agents to translate live code into valid Lean theorems is a major breakthrough. As AI-driven security threats grow, rigorously verifying the Signal protocol implementation gives us even greater confidence in our code’s privacy guarantees.”

Kret’s mention of “AI-driven security threats” is worth noting. The verification work arrives at a time when AI is being used both to attack and defend software systems. DeepMind also referenced its automated defense agent called CodeMender, suggesting a vision where formal verification and automated defense work together.

Why This Matters for Product Teams

For CTOs and product teams building security-critical software, AlphaProof Code represents a potential shift in the cost curve of formal verification.

The cost problem. Formal verification has traditionally been justified only for the most critical systems — aerospace flight controllers, nuclear plant monitoring, smart contract protocols handling large sums. The cost of hiring formal methods experts and the time required for manual proofs have made it impractical for most product teams. If AI agents can reduce verification time from years to weeks, the economics change.

The trust problem. One concern with AI-generated code and proofs is the black-box problem: if an AI writes the proof, how do you trust it? Lean’s automatic checking solves this for the proof itself — if Lean accepts the proof, it is mathematically valid. The remaining human responsibility is ensuring the specification is correct. This is a meaningful division of labor: humans define what the software should do, and AI proves that it does it.

The scaling problem. DeepMind notes that this approach “lays the groundwork to secure other vital systems, from medical device firmware to power grid software.” For product teams in regulated industries — healthcare, finance, infrastructure — this could become a practical path to higher assurance levels without the traditional cost overhead.

AlphaProof Code is part of a larger pattern. In November 2025, Anthropic released FlashProve, an open-source system that generates zero-knowledge proofs of LLM inference, allowing users to verify that a model actually produced a given output. Both projects share a common thread: using AI to generate proofs about AI systems and the software they depend on.

The difference is scope. FlashProve proves that a specific inference happened. AlphaProof Code proves that the cryptographic protocol protecting billions of messages is mathematically correct. The former is about trust in AI outputs. The latter is about trust in the infrastructure that AI — and everything else — runs on.

For product teams thinking about AI coding agent quality and testing, formal verification offers a complementary approach to the testing problem. Where Dan Luu’s evaluation of 26 testing techniques showed that AI coding agents struggle with knowing how to test their own code, AlphaProof Code suggests that AI agents can be effective at a different kind of verification — one where the proof checker (Lean) provides an objective ground truth that does not depend on the agent’s judgment.

What This Means for Pakistan and Emerging Markets

The Signal Protocol underpins not just the Signal app but also WhatsApp’s end-to-end encryption, which is used by over 100 million people in Pakistan. The security of private communications, business transactions, and journalist sources in Pakistan depends on this cryptographic foundation being correct.

For Pakistani software teams, the broader implication is about access to security assurance. Formal verification expertise is scarce globally and practically nonexistent in most Pakistani engineering teams. If AI agents can democratize access to formal methods — even partially — it could allow Pakistani startups building fintech, healthtech, or government software to achieve higher security guarantees than they could afford today.

This matters in the context of Pakistan’s expanding digital payments infrastructure. As Raast and other digital payment systems scale, the security of the underlying cryptographic code becomes more critical. AI-assisted formal verification could become a tool for Pakistani fintech teams to validate their implementations against specifications without hiring specialized formal methods researchers.

Limitations and Open Questions

The AlphaProof Code announcement is significant, but several caveats are worth noting.

Signal is a well-studied protocol. The Signal Protocol has been analyzed by cryptographers for years. The specifications were relatively clear before AlphaProof Code started. Verifying a protocol that is less well understood — or one where the specification itself is ambiguous — would be harder.

Four weeks is still not trivial. For teams operating on continuous deployment cycles, a four-week verification process is accessible for critical releases but not for every iteration. The question is how quickly this time can be compressed as the framework matures.

Open-source artifacts are available but the framework itself is not. DeepMind open-sourced the formal verification artifacts — the proofs and specifications — but the AlphaProof Code framework as a general-purpose tool is not yet publicly available. Other teams cannot simply download it and verify their own code. Making this a repeatable, general-purpose tool will require additional engineering.

The human specification step remains manual. The framework’s division of labor puts humans in charge of defining what to prove. This is a feature, not a bug — but it means the quality of verification depends on the quality of the specifications. A team that specifies the wrong properties will get a proof of the wrong things.

Scale of the verified code. The verification covers Signal’s core cryptographic protocol, not the entire Signal application. Messaging apps include UI code, network stack code, backup systems, and contact management — none of which were part of this verification. The core protocol is the most security-critical component, but it is a subset of the full application.

What to Watch Next

  • DeepMind’s open-source release. The formal verification artifacts are available, but the broader framework may follow. Watch for whether AlphaProof Code becomes a reusable tool or remains a research demonstration.
  • Adoption beyond Signal. DeepMind mentioned medical device firmware and power grid software as targets. The first non-research deployment of this approach will be a stronger signal than the initial announcement.
  • Lean ecosystem growth. The Lean prover community has been growing, but it remains small compared to mainstream programming languages. If AI-assisted formal verification becomes practical, demand for Lean expertise — and for tools that abstract away Lean’s complexity — will increase.
  • Competition. Other AI labs are likely working on similar approaches. The combination of frontier LLMs with theorem provers is a natural research direction, and DeepMind’s demonstration will accelerate interest.
  • Regulatory response. Formal verification is already referenced in some safety standards for automotive (ISO 26262) and aviation (DO-178C). If AI-assisted verification becomes practical, regulators in fintech and healthcare may update their assurance requirements.

For product teams and CTOs, the practical takeaway is this: formal verification is moving from a niche specialty to something that AI agents can assist with. It is not yet a turnkey solution, but the trajectory suggests that within a few years, verifying critical code with AI-assisted formal methods could be as routine as running a test suite — albeit for a much smaller subset of code. The teams that start building familiarity with these tools now will have an advantage when the economics shift.

Sources

Shamyl Bin Mansoor

Shamyl Bin Mansoor is a technology entrepreneur, product builder and STEAM educator. He is Co-founder and CTO of LearnOBots and works on educational technology, robotics and interactive learning products. Learn more about him.

Related Articles

Agentic Robotics: How AI Agents Are Learning to Program Robots Without Massive Datasets

UC Berkeley roboticist Ken Goldberg and NVIDIA's Spencer Huang have introduced 'agentic robotics' — a framework where AI agents generate, test, and refine robot-control programs in simulation. Presented at CoRL 2026, the approach bypasses the data bottleneck that has slowed robotics for years.

When a CEO Replaces Their Chief of Staff With AI Agents: What Brian Armstrong's Workflow Reveals

Coinbase CEO Brian Armstrong says he now runs his workday through a hierarchy of always-on AI agents, with a chief-of-staff agent managing lead agents that manage sub-agents. Here is what the setup does, what Goldman Sachs's rollback tells us, and what it means for founders, CTOs, and product teams building AI-first organizations.

Anthropic's FlashProve: What Provable LLM Inference Means for AI Trust and Product Engineering

Anthropic released FlashProve, an open-source system that generates zero-knowledge proofs of LLM inference at 110 tokens per second on a single H100. Here is what provable inference means for CTOs, product teams, AI regulation, and infrastructure architecture.