SIAgentNews.com
← All news

Google's AI agents wrote proofs for Signal's code, and humans still decide what gets proven

Google DeepMind says AI agents produced machine-checked proofs about Signal's encryption code, while people kept control of what the proofs must show.

· First reported by ADTmag

6.5 millionlines of Lean proof code generated by agents

The short version

  • Google DeepMind says AI-written proofs verified key security properties of Signal's cryptographic implementation.
  • The checks cover PQXDH and Triple Ratchet, at the AArch64 machine-code level.
  • Agents generated about 6.5 million lines of Lean proof code, backed by approximately 26,000 lines of trusted material.
  • Google says the work took four weeks; that is its account of this one project.
  • Humans approve the specifications; Lean only checks the proofs against them.

Why it matters

This shows a way to use AI on high-stakes software without simply trusting the AI: a separate checker must accept the result. It also shows where the risk moves. The human-written definition of 'correct' becomes the thing worth scrutinizing.

What Google says it did

As ADTmag reported, Google DeepMind has described a framework in which AI agents help prove that parts of Signal's cryptographic code behave as intended. Signal is the encrypted messaging app. The announcement is called AlphaProof Code, and a technical report dated November 10 gives the details.

The report covers two pieces of Signal's design: the PQXDH handshake and the Triple Ratchet. The guarantees it describes include authentication and protections for message secrecy after a compromise. In plain terms, these are claims about who you are talking to and about how much stays private if something goes wrong.

Google says the proofs were checked at the AArch64 machine-code level. Machine code is the low-level instruction set a chip runs, after the human-readable program has been compiled. Checking at that level means the claims are about the code that actually executes, not just the source a developer wrote.

Who does what in the process

The division of labor is the heart of the story. Researchers decide what must be established. AI agents then build the proofs. Finally, a tool called Lean, a proof assistant, checks whether each proof really satisfies the formal statement it was written for.

The scale is large. Google reports that the agents generated about 6.5 million lines of Lean proof code. That rests on approximately 26,000 lines of trusted specifications and machine-code semantics. Semantics here means the precise written rules for what each machine instruction does, which the proofs must rely on.

Google says the verification took four weeks. The article is careful to note that this is the company's account of this project, not a general estimate for checking other software.

Signal's chief technology officer, Ehren Kret, said in the announcement that using AI agents to turn live code into valid Lean theorems was "a major breakthrough". That is his assessment of the method, not a claim about everything Signal does.

Why the specification is the weak point

A model saying code looks correct is one thing. A separate checker accepting a proof of a defined property is another, and it gives a stronger kind of assurance. But the report is clear that the assurance is only as good as the statement being proven.

Lean can reject a bad proof. It cannot tell you whether a human-approved statement captures the security requirement that really matters. The specification sets the environment and decides which attacks a theorem rules out. If it is weak or mistaken, a logically valid proof can still be of limited use.

That is why Google's framework leaves final decisions with people: what to prove and how to resolve ambiguities. AI can help draft and check candidate specifications, but the proof agents work against the definitions humans have approved.

What this does not prove

The result is bounded. The work does not show that every part of Signal, the devices that run it, or the services around it cannot be attacked. It covers a chosen implementation and a chosen set of properties.

For software teams, ADTmag's takeaway is practical. The size of a generated proof is not a measure of coverage. A reviewer should read the security claim and its assumptions, then ask what was left out.

The article also points to a wider lesson for anyone reviewing AI-generated code. Another model's confidence should not be the last check. The output has to pass a checker, and people remain accountable for deciding what that check is supposed to establish.

What comes next

The open question is which requirements can be stated precisely enough to justify this kind of effort. Cryptographic code is a natural fit because its goals, such as authentication and secrecy, can be written as exact claims. Much everyday software is harder to pin down.

If the approach spreads, the scarce skill may shift from writing proofs to writing good specifications. That is work humans still own in Google's design, and it is the part outsiders can audit.

What to watch

  • Whether Google or others publish the Signal specifications so outsiders can judge what was and was not proven.
  • Whether this approach works for software where 'correct' is harder to state than in cryptography.
  • Whether the four-week timeline holds up on other projects.

Try it

Before asking an AI to review a contract, spreadsheet or script, write three plain lines describing what correct looks like. Keep that part yours, then check the AI's work against it.

Sources and links

First reported by ADTmag. 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.

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.

More AI news