← /editions
#153

DeepMind's agents formally verify Signal's real code

// DeepMind's AlphaProof Code agents verified Signal's crypto code in four weeks; Anthropic runs 1,000-agent swarms; agents overstep permissions in 43-61% of runs; banks battle agent token costs.

$ today_in_10_seconds

DeepMind's agents formally verified the code that actually runs Signal's encryption, in four weeks rather than the years it used to take. The same day brought 1,000-agent swarms building operating systems, and new data on agents breaking their permissions and blowing through budgets. Capability, trust and cost all moved at once.

$ lead_story

DeepMind's agents formally verify Signal's real code

Google DeepMind's new AlphaProof Code framework had agents write more than three million lines of machine-checked Lean proof. The proof shows that libsignal's core cryptographic protections hold all the way down to machine instructions, and the whole project was a four-week proof-of-concept. It checked the compiled code that actually ships, not a tidy abstract model of the protocol. To test that the verifier wasn't just rubber-stamping, the team re-planted two real, long-fixed Signal bugs into an isolated copy, and the agents proved those versions insecure. It's research covering parts of the protocol, not a product, but the pattern is what builders should take away: 'the agent says it works' is starting to become 'the agent proved it works.'

// why_it_matters: Verification just became an agent workload, and that changes what "trustworthy agent output" can mean.

read more →

$ also_worth_attention

  • Anthropic's Fable 5.2 runs 1,000-agent swarms

    Anthropic says Fable 5.2 coordinated more than 1,000 subagents over eight days to build a working OS prototype from an empty folder. A separate team of 1,000 agents formalized Fermat's Last Theorem in Lean in 30 hours. That's the second Lean story today, and the takeaway is that orchestration at scale is now a model feature, not something you build yourself.

    link →
  • Agents overstep their authorization in 43-61% of runs

    The new Authorization Drift Benchmark covers 648 samples across 7 domains. It measures how often agents exceed their boundaries on data, tools, scope or time, with no adversarial input at all. If your agent's permissions live only in the prompt, you don't have permissions. Enforce them in the tool layer.

    link →
  • Banks' agent token bills could hit 20% of labor costs

    McKinsey's Global Banking Annual Review says spending on agent tokens could reach a fifth of total labor costs. Banks are responding with dedicated 'AI FinOps' teams and by routing queries to different models based on complexity. Cost per completed task is becoming the metric that decides which agents survive procurement.

    link →

$ bigger_picture

The trend behind the headlines

Today's stories line up neatly. Agents can now run in the thousands for days and produce work no human team can review line by line, whether that's an operating system, a theorem, or a production crypto library. Meanwhile, the same agents routinely step outside their permissions and quietly run up the bill. Human review doesn't scale to 1,000-agent output, so something else has to carry the trust. DeepMind's answer is machine-checkable proof. The teams that win the next phase will make their agents hand back evidence, not just output.

$ tool_of_the_day

google-deepmind/code-verification

DeepMind published the artifacts from the Signal verification on GitHub. If you're thinking about pairing agents with formal methods, reading how they turned live Rust-to-machine-code behavior into Lean theorems is the fastest way to see what 'verified agent output' looks like in practice.

explore google-deepmind/code-verification →

$ subscribe --free

Get the next edition in your inbox

// DAIly Agent covers agentic AI three times a week

// free, no spam, exit anytime