AlphaEvolve's Compute Savings Are Verified; Its 56-Year Claim Needs a Ring Specified

Google DeepMind's own white paper states its matrix-multiplication record in one precise sentence, footnoted to the setting it applies to. The blog post a million people actually read drops the footnote.

DeepMind's own blog post and its own technical white paper both state the headline figure and the scoping footnote in the same document. The gap this article traces is not between the announcement and the truth — it is between the announcement and what got repeated afterward. — Image prompt and art direction by Brecht Corbeel; image generated to that direction.

Abstract

On 14 May 2025, Google DeepMind announced that its AlphaEvolve coding agent had recovered 0.7 percent of the company's worldwide compute continuously for over a year, sped up a Gemini training kernel by 23 percent, and found the first improvement to matrix multiplication in 56 years. This article checks each claim against its actual source rather than its retelling. The infrastructure claims hold up exactly as stated, verifiable against Google's own operational numbers. The matrix-multiplication claim holds up too, but only once a scope word DeepMind's own technical white paper supplies — complex-valued, characteristic zero — is restored to it, because DeepMind's own 2022 AlphaTensor system had already broken the same 49-multiplication count three years earlier, in a different algebraic setting. A live check of a third claim, the kissing-number lower bound AlphaEvolve set in 11 dimensions, finds it was already superseded in June 2026 by an unrelated research platform — a result no announcement, dossier, or retrospective written before this one had reason to record.

Google DeepMind’s 14 May 2025 announcement bundled four separate AlphaEvolve results under one banner, and three of them are the same kind of claim wearing different clothes. A scheduling heuristic recovering 0.7 percent of Google’s worldwide compute, a kernel-tiling fix trimming a sliver of Gemini’s training time, and a rewritten TPU arithmetic circuit are each a statement about a system Google itself operates and keeps measuring — nothing published anywhere next year can retroactively make last year’s fleet-wide percentage untrue. The fourth claim, the one every retelling led with, is built differently: AlphaEvolve had found “the first improvement to matrix multiplication in fifty-six years” [1], a record in a search that never stops, over a domain DeepMind’s own technical white paper narrows in one sentence the blog post drops entirely — the gap that closed was for algorithms over fields of characteristic 0, not over any field whatsoever [2]. Google’s own AlphaTensor system had already broken the same 49-multiplication count three years earlier, in 2022, inside a narrower, different algebraic setting [3].

This article checks all four claims against their actual sources, and treats the infrastructure claims and the mathematical one as needing two different kinds of scrutiny rather than one undifferentiated “AlphaEvolve did X.” An infrastructure claim is checkable for scale — what fraction of a real operating budget a reported percentage actually touches. A mathematical claim is checkable for currency — a number anyone can, in principle, still be improving right now is a claim with a shelf life, not a fact fixed on the day it was announced. This piece runs the scale check on all three infrastructure claims, and a currency check the matrix claim’s own defenders have had no occasion to run: whether any of AlphaEvolve’s headline mathematical records have since been broken. One had. The kissing-number lower bound AlphaEvolve set in eleven dimensions did not survive to see this sentence published, and the system that broke it has nothing to do with Google.

0.7 Percent of a Borg Cell Is Not a Rounding Error

Google’s cluster manager, Borg, has been described in public since 2015, when a team from the company itself published the paper that remains the standard reference for how it works: clusters run “each with up to tens of thousands of machines,” serving “hundreds of thousands of jobs, from many thousands of different applications” [6]. Borg’s job is bin-packing at a scale most engineers never touch — deciding which of those hundreds of thousands of jobs gets which machine, out of tens of thousands of candidates, without wasting capacity. Waste in this setting has a specific, well-understood shape: a machine can be full on memory while its CPU sits idle, or full on CPU while its memory sits idle, and either way the leftover resource is “stranded” — present, paid for, and unusable by anything else because nothing currently pending fits what’s left. AlphaEvolve was set to work on exactly this: not solving a new kind of problem, but designing a better scoring function for an old one, taking a pending job’s resource needs and a candidate machine’s remaining capacity and returning a single priority number the existing scheduler could rank machines by [2].

Figure 1. Google's own Borg paper describes clusters running to tens of thousands of machines and hundreds of thousands of jobs. Recovering an average 0.7 percent of a fleet that size, continuously, for over a year, is what "otherwise stranded" compute actually adds up to. — Image prompt and art direction by Brecht Corbeel; image generated to that direction.

DeepMind’s own account of how this claim was checked is unusually procedural for a company blog post, and it is worth stating in full because the procedure is what makes the number trustworthy. An early version of AlphaEvolve evolved a heuristic function against a simulator built from historical snapshots of Google’s actual fleet, tested it against a held-out set of recent workloads to confirm it generalized rather than overfitting the training snapshots, and only after it beat the heuristic already running in production was it rolled out fleet-wide [2]. The number reported afterward is not a simulator estimate: “post-deployment measurements across Google’s fleet confirmed the simulator results, revealing that this heuristic function continuously recovers on average 0.7% of Google’s fleet-wide compute resources, which would otherwise be stranded” [2]. Half a percent recovered from tens of thousands of machines per cluster, sustained continuously rather than as a one-time cleanup, is a real and durable engineering win — the kind of number that, once measured against Google’s own metering, does not need re-verifying next year the way a mathematical record does, because it is not a claim about who found something first. It is a claim about what a piece of code does to a running system, and the system keeps running.

The white paper’s own justification for choosing this approach over the more fashionable alternative is worth quoting directly, because it undercuts any reading of this result as evidence of an emerging superintelligence rather than a specific engineering tradeoff: “AlphaEvolve was chosen over a deep reinforcement learning approach because its code solution not only leads to better performance, but also offers clear advantages in interpretability, debuggability, predictability, and ease of deployment — essential qualities for a mission-critical system” [2]. That is an argument for evolving a short, readable scoring function over training an opaque policy network, made by people whose job is keeping Google’s data centers running. It is a mechanistically unsurprising reason for a mechanistically unsurprising result, and none of that makes the 0.7 percent figure less real.

A 23 Percent Kernel Speedup Buys Gemini One Point of Training Time, Not Twenty-Three

The second infrastructure claim runs the same pattern at a different layer of the stack. Training a model like Gemini leans on custom low-level kernels — hand-tuned code that decides, among other things, how a large matrix multiplication gets broken into tiles that fit an accelerator’s memory and compute units efficiently. Tuning that tiling strategy is normally either a search that has to rerun every time the input shapes change, or a heuristic senior engineers hand-craft and maintain, and DeepMind frames the second option as “a major engineering bottleneck due to its complexity” [2]. AlphaEvolve was set on the second path: evolve a general tiling heuristic against half of a set of realistic kernel input shapes pulled from real usage, then test it against the other half to check it generalized. The result, reported plainly: “an average 23% kernel speedup across all kernels over the existing expert-designed heuristic, and a corresponding 1% reduction in Gemini’s overall training time” [2]. DeepMind’s blog post states the same pair of numbers in the same order [1].

Figure 2. A 23 percent kernel speedup and a 1 percent reduction in Gemini's own training time are the same measurement taken at two different scales. Both figures are DeepMind's; neither is the other one in disguise. — Image prompt and art direction by Brecht Corbeel; image generated to that direction.

The 23-to-1 ratio is not a discrepancy to be explained away — it is the honest arithmetic of what “a kernel” is. One kernel is one operation inside one layer of one model; a full training run executes an enormous number of operations, most of which this particular kernel has no claim on, so a large local speedup shrinking to a small global one is exactly what should happen when a real optimization is measured honestly rather than reported at the scale that sounds most impressive. The detail that belongs alongside both numbers, and rarely travels with either, is what the win actually replaced: not a slower version of the same automated process, but “several months of dedicated engineering effort” compressed into “just days of automated experimentation” [2] — a claim about engineer-time recovered, sitting next to the claim about compute-time recovered, both equally real and equally modest once stated at the scale they actually operate.

A third infrastructure claim, reported with less fanfare than the first two, ran the identical treatment on the compiler-generated code implementing FlashAttention, the attention-mechanism kernel underlying most modern transformer training [2]. The blog post’s headline figure: “up to a 32.5% speedup for the FlashAttention kernel implementation in Transformer-based AI models” [1]. The white paper’s more granular figure for the specific configuration it tested: “the FlashAttention kernel for the configuration of interest was sped up by 32%,” with a separate, additional “15% speed up” found in the surrounding pre- and post-processing code that feeds the kernel its inputs and consumes its outputs [2] — two different numbers for two different scopes, both DeepMind’s own, neither contradicting the other. A fourth engineering result, smaller and more candidly qualified than any of the three above, involved a Verilog rewrite to a Tensor Processing Unit’s arithmetic circuit: AlphaEvolve “found a simple code rewrite that removed unnecessary bits, a change validated by TPU designers for correctness,” but the same paragraph adds, without being asked, that “this specific improvement was also independently caught by downstream synthesis tools” [2] — meaning ordinary compiler tooling, running after AlphaEvolve’s proposed change, would likely have arrived at the same fix on its own. Four claims, four different orders of significance, and DeepMind’s own document is the source honestly disclosing the smallest one’s limits.

The Matrix-Multiplication Claim Rests on Two Words: Complex Numbers

Multiplying two 4×4 matrices the schoolbook way takes 64 scalar multiplications. Volker Strassen showed in 1969 that a recursive divide-and-conquer trick could do 2×2 multiplication in 7 multiplications instead of 8, and applying that trick twice — recursively, on 4×4 matrices treated as 2×2 blocks of 2×2 blocks — brings the 4×4 count down to 49, a result that “works over any field,” meaning any number system with addition, multiplication, and division defined on it, real or complex or otherwise [2]. AlphaEvolve’s own headline result, restated in the language of the technical document rather than the announcement: “AlphaEvolve is the first method to find a rank-48 algorithm to multiply two 4×4 complex-valued matrices” [2], confirmed by the blog post’s parallel wording: “an algorithm to multiply 4x4 complex-valued matrices using 48 scalar multiplications, improving upon Strassen’s 1969 algorithm that was previously known as the best in this setting” [1]. Both documents use the phrase “in this setting.” Neither claims the 56-year gap held over every field.

The setting matters because a narrower, related record already existed, and DeepMind’s own white paper states it in the same paragraph as the headline: “For the very specific case of multiplying in the field with 2 elements, Fawzi et al. found an algorithm with rank 47” [2] — a reference to AlphaTensor, DeepMind’s own 2022 reinforcement-learning system, whose Nature paper reports finding matrix-multiplication algorithms “more efficient than the state of the art for many matrix sizes,” including “Strassen’s two-level algorithm in a finite field” [4, 3]. A field with 2 elements — arithmetic done modulo 2, where every value collapses to 0 or 1 — is a finite field of characteristic 2. The complex numbers, where AlphaEvolve found its 48-multiplication algorithm, are a field of characteristic 0: no matter how many times you add 1 to itself, you never wrap back around to 0. These are not two readings of the same claim. They are two different algebraic worlds, and a construction valid in one carries no automatic weight in the other — which is precisely why DeepMind’s own footnote states, with a precision the blog post’s headline compresses away, that “for 56 years, designing an algorithm with rank less than 49 over any field with characteristic 0 was an open problem” [2]. Read that way, the sentence is defensible exactly as written. Read the way a retelling that drops “characteristic 0” would have a reader take it — as a claim that nobody, anywhere, in any setting, had beaten Strassen’s count since 1969 — it is false, and has been false since 2022, inside DeepMind’s own research program.

Figure 3. Strassen's count stood for fifty-six years in the setting AlphaEvolve actually closed. DeepMind's own 2022 system had already struck a different line in a narrower setting three years earlier — and a 2026 paper has since drawn a further line under AlphaEvolve's own row, generalizing it rather than crossing it out. — Image prompt and art direction by Brecht Corbeel; image generated to that direction.

A further nuance the white paper volunteers, in a footnote most retellings would have no reason to reproduce: “there exist algorithms using fewer than 49 multiplications, but they do not correspond to decompositions of the matrix multiplication tensor, and they cannot be applied recursively to multiplying larger matrices” [2]. That closes off the objection a careful reader might raise next — that some other sub-49 trick, unrelated to Strassen’s tensor-decomposition framework entirely, might already have existed and gone uncounted. DeepMind checked for that too, and the answer is no: within the specific mathematical framework the 56-year figure is stated in, 48 was a genuinely new floor.

None of this makes the 4×4 case an isolated stunt. The white paper reports that “AlphaEvolve improve[d] the state of the art for 14 different matrix multiplication targets” beyond the headline one [2], with its own results table listing several: a 4×4-by-4×5 multiplication improved from 62 to 61 scalar multiplications, a 4×4-by-4×8 case from 98 down to 96, a 4×5-by-5×6 case from 93 to 90, and a 5×5×5 case matched at 93 without improvement [2]. Fourteen improved targets, most producing single-digit gains, is a pattern of steady, checkable progress on a well-defined search problem — considerably less dramatic than “first in 56 years,” and a more honest description of what the method actually does across its own reported results.

The Chain Resolves in One Table; a Companion Piece Runs the Full Audit

Laid end to end, the four dated results form a chain that a single-number headline cannot show:

• Result — Year — Scalar multiplications for 4×4 — Setting
• Strassen [2] — 1969 — 49 — any field
• AlphaTensor, Fawzi et al. [3] — 2022 — 47 — field with 2 elements (characteristic 2)
• AlphaEvolve [1] — 2025 — 48 — complex numbers (characteristic 0)
• Dumas, Pernet & Sedoglavic [5] — 2025–2026 — 48 — rational coefficients, any ring except characteristic 2

Read down the “scalar multiplications” column alone, the numbers look like a race — 49, then 47, then 48, a step backward. Read across, with the setting column attached, the shape changes entirely: characteristic 2 and characteristic 0 are disjoint algebraic regimes, so AlphaTensor’s 47 and AlphaEvolve’s 48 are the best known answers to two different questions that happen to share a matrix size, and the fourth row closes the chain rather than reopening it — a paper submitted the following month generalizes AlphaEvolve’s own construction to hold over almost any ring, crediting it explicitly as a starting point rather than a prior claim it displaces [5].

That table is as far as this article needs to take the chain to support its own claim — that the 56-year figure needs a scope word restored to it, not removed from it. A companion piece in this series, Mathematicians Finished the Job After an Evolutionary Search Beat 56 Years of Human Proofs [9], runs the audit this table only summarizes: an independent, from-scratch reimplementation of AlphaEvolve’s 48-multiplication decomposition checked to machine precision, two outside specialists in exactly this subfield asked on the record whether the result was genuinely new, and the full arithmetic on what “complex-valued” costs a computation that only has real numbers to work with — the gap Dumas, Pernet, and Sedoglavic’s paper closes in the fourth row above. Nothing in that companion audit changes a cell in this table. It is simply the more useful place to go for a reader who wants the chain proven rather than stated.

The Kissing-Number Record Didn’t Survive the Time It Took to Verify This Article

The matrix-multiplication claim is durable in a way the compute-savings claims are not, and also in a way one more of AlphaEvolve’s own headline results is not, and the difference is worth stating precisely because it is easy to miss. A 0.7 percent fleet-wide compute recovery is a fact about a running system on a given date; it does not get retroactively un-true if a better scheduler ships next year, it simply gets superseded going forward. A mathematical lower bound is a different kind of object: it is true forever once proven, but “the best known lower bound” is a claim about the current state of a search that never stops, and checking it requires checking again, not just once.

The kissing number problem asks how many non-overlapping unit spheres can simultaneously touch one central unit sphere in a given number of dimensions — in three dimensions the answer is a settled 12, but in most higher dimensions only a lower and upper bound are known, and the gap between them is an active research target. AlphaEvolve was applied to the eleven-dimensional case, and DeepMind’s white paper reports the result precisely: “AlphaEvolve improved the lower bound on the kissing number, finding a configuration of 593 non-overlapping unit spheres that can simultaneously touch a central unit sphere, surpassing the previous record of 592” [2]. That prior record of 592 belongs to Mikhail Ganzhinov’s 2022 paper on highly symmetric lines, which reports “3 new kissing configurations which improve lower bounds on the kissing number in d=10,11,14 to 510, 592 and 1932 respectively” [7] — a citation this article confirmed directly against Ganzhinov’s own paper rather than taking DeepMind’s attribution on faith. AlphaEvolve’s contribution, stated at this resolution, was a gain of exactly one sphere over the existing record, in a search space large enough that finding even one better configuration is genuinely hard.

Figure 4. A record set in May 2025 was current for thirteen months. This article's own verification pass is the reason that fact appears here at all — no dossier, blog post, or retrospective written earlier had cause to know the wire had a fourth tag coming. — Image prompt and art direction by Brecht Corbeel; image generated to that direction.

That record has since moved again. A paper submitted in June 2026 by Federico Bianchi, Yongchan Kwon, Aneesh Pappu, and James Zou describes an “agent-native platform for open distributed research and discovery” called EinsteinArena, on which independent AI agents submit candidate solutions to open problems against shared automated verifiers and a public leaderboard, and reports a dozen state-of-the-art results — among them, in the paper’s own words, “the kissing number problem in dimension 11, where the platform improved the best known lower bound from 593 to 604” [8]. That is a gain of eleven spheres over AlphaEvolve’s own gain of one, achieved roughly thirteen months after AlphaEvolve’s announcement, by a system with no evident connection to Google DeepMind, built around a fundamentally different mechanism — not one company’s evolutionary coding agent working in isolation, but, in the paper’s description, an outcome that “did not come from a single agent or isolated run” but “arose through a sequence of submissions, public discussion, verifier refinement, and subsequent agent-to-agent borrowing of ideas” among many independent participants [8].

None of this makes AlphaEvolve’s 593-sphere result any less real at the time it was found, and it is not evidence against the honesty of DeepMind’s original claim — 593 genuinely beat 592 in May 2025, checkably, and DeepMind never claimed the record would stand forever. It is evidence about a category error a reader can easily fall into when a mathematical-discovery claim gets treated with the same permanence as an infrastructure claim. Google’s Borg fleet is still running the heuristic AlphaEvolve designed for it, today, and will presumably keep recovering roughly 0.7 percent of stranded compute until someone replaces that specific piece of code. The 11-dimensional kissing-number record AlphaEvolve set has already been replaced, by a different piece of code, and nothing about the original announcement — read a year after the fact, the way most readers now encounter it — signals that the number it states is no longer current.

A Scoreboard Outlives Any Single Verdict on AlphaEvolve

Put the two kinds of claim side by side and the difference in what “verified” means for each becomes the actual finding here, more than any single number. The infrastructure claims — the 0.7 percent Borg recovery, the 23-percent-to-1-percent Gemini kernel result, the FlashAttention speedups, the TPU circuit rewrite — are hard for an outsider to audit directly, since none of us can log into Google’s fleet and check the metering ourselves, but they are dated, specific, and mechanistically unsurprising: bin-packing heuristics, kernel tiling, and RTL cleanup are exactly the kinds of problems an LLM-guided evolutionary search, checked against a fast automated evaluator, should be good at, and DeepMind’s own account of each result includes the caveats — an independently-caught TPU fix, a training-time reduction two orders of magnitude smaller than the kernel-level figure — that a purely promotional document would have every incentive to omit. The mathematical claims are the opposite kind of hard: any reader can check the arithmetic on a construction directly, with no need to trust Google’s internal metrics at all, but “verified” for a mathematical record means verified as of a date, and that date recedes further into the past every time someone reads the original announcement instead of the current state of the field.

The practical consequence for the next “AlphaEvolve did X” claim in circulation, or the next system’s claim built on the same pattern, is a question rather than a caveat: which kind of claim is X? If it is an infrastructure claim, the right skepticism is about scale — ask what fraction of a real system’s operating budget the reported percentage actually touches, the way 23 percent at a kernel became 1 percent at a training run, not about whether the underlying mechanism is exotic, because it usually isn’t. If it is a mathematical claim, the right skepticism is about currency — not whether the construction is correct, which anyone can check, but whether the record it claims to hold is the one still standing, which requires checking a source dated after the announcement rather than the announcement itself. DeepMind’s own account of AlphaEvolve was, on the evidence gathered here, more careful about scope than the claim’s public life has been: the “in this setting” qualifier was there from day one, in both the blog post and the white paper, for anyone who read past the headline. What the announcement could not have told a reader, on 14 May 2025, was how long any of its records would last. One of them, it turns out, lasted thirteen months.

Sources

1. Google DeepMind. AlphaEvolve: A Gemini-powered coding agent for designing advanced algorithms. Google DeepMind (2025).
2. Alexander Novikov, Ngân Vũ, Marvin Eisenberger, Emilien Dupont, Po-Sen Huang, Adam Zsolt Wagner, Sergey Shirobokov, Borislav Kozlovskii, Francisco J. R. Ruiz, Abbas Mehrabian, M. Pawan Kumar, Abigail See, Swarat Chaudhuri, George Holland, Alex Davies, Sebastian Nowozin, Pushmeet Kohli, and Matej Balog. AlphaEvolve: A coding agent for scientific and algorithmic discovery. Google DeepMind, white paper (2025).
3. Alhussein Fawzi, Matej Balog, Aja Huang, Thomas Hubert, Bernardino Romera-Paredes, Mohammadamin Barekatain, Alexander Novikov, Francisco J. R. Ruiz, Julian Schrittwieser, Grzegorz Swirszcz, David Silver, Demis Hassabis, and Pushmeet Kohli. Discovering faster matrix multiplication algorithms with reinforcement learning. Nature, vol. 610, pp. 47-53 (2022). DOI: 10.1038/s41586-022-05172-4.
4. Google DeepMind. Discovering novel algorithms with AlphaTensor. Google DeepMind (2022).
5. Jean-Guillaume Dumas, Clément Pernet, and Alexandre Sedoglavic. A non-commutative algorithm for multiplying 4x4 matrices using 48 non-complex multiplications. arXiv (2025).
6. Abhishek Verma, Luis Pedrosa, Madhukar R. Korupolu, David Oppenheimer, Eric Tune, and John Wilkes. Large-scale cluster management at Google with Borg. Proceedings of the European Conference on Computer Systems (EuroSys), ACM (2015).
7. Mikhail Ganzhinov. Highly symmetric lines. arXiv (2022).
8. Federico Bianchi, Yongchan Kwon, Aneesh Pappu, and James Zou. Harnessing the Collective Intelligence of AI Agents in the Wild for New Discoveries. arXiv (2026).
9. Brecht Corbeel. An Evolutionary Search Beat 56 Years of Human Proofs, and Mathematicians Finished the Job. Absolute Digital Publishers (2026).

Originally published at https://absolutedigitalpublishers.com/articles/alphaevolves-compute-savings-are-verified-its-56-year-claim-needs-a-ring-specified.