AlphaEvolve: Breeding algorithms with a language model

The announcement and the narrow claim

On 14 May 2025, Google DeepMind announced AlphaEvolve, an evolutionary coding agent driven by its Gemini language models. The launch post and an accompanying white paper made two kinds of claim at once. One was mathematical: a procedure for multiplying two 4 by 4 matrices of complex numbers with 48 scalar multiplications, one fewer than the 49 obtained by applying Volker Strassen's 1969 method twice, plus better constructions on about a fifth of more than 50 open problems. The other was industrial: code found by the system was already running inside Google, recovering data center capacity, speeding up a kernel used to train Gemini and trimming a circuit in a future Tensor Processing Unit.

The narrow claim is that a loop in which language models propose code changes, and an automatic program scores every proposal, can find artifacts that beat the best known human results on problems where a score can be computed. Each mathematical result is a checkable object, so a matrix decomposition or a sphere configuration can be verified without trusting how it was found. The infrastructure figures cannot be checked from outside; they are Google's measurements of Google's systems. The tool itself was not released. Nature's news report noted that it had not been rolled out to researchers outside the company, the white paper reached arXiv on 16 June 2025, and general availability to paying cloud customers came only in July 2026. This report keeps three things apart: the verifiable objects, the self-reported engineering numbers, and what independent researchers later did with both.

From seven products to a game of tensors

The matrix result sits on a long line. In 1969 Strassen showed, in the three-page note Gaussian Elimination is not Optimal, that two 2 by 2 matrices can be multiplied with seven multiplications instead of the obvious eight, at the price of extra additions. Because the trick works on blocks as well as on numbers, applying it recursively makes large matrix products asymptotically cheaper, and applying it twice multiplies 4 by 4 matrices with 7 times 7, or 49, multiplications. Algorithms of this kind correspond to ways of writing a fixed three-dimensional array of numbers, the matrix multiplication tensor, as a sum of simple rank-one pieces, and the number of pieces is the number of multiplications. Finding short decompositions is a hard search problem: even the minimum for 3 by 3 matrices is unknown.

DeepMind had attacked it before. AlphaTensor, published in Nature in October 2022, recast decomposition as a single-player game and trained an agent in the style of AlphaZero to play it. It found a 47-multiplication scheme for 4 by 4 matrices, but only in arithmetic modulo 2, which does not carry over to ordinary real or complex numbers. For characteristic zero, the setting of everyday numerical computing, 49 still stood.

The other ancestor was a method. In December 2023, Bernardino Romera-Paredes, Alhussein Fawzi and colleagues at DeepMind published FunSearch, which paired a pretrained code model, Codey from the PaLM 2 family, with an automatic evaluator and an evolving database of programs. Rather than search for a cap set directly, FunSearch evolved a short Python priority function that built one, and it found a cap set of 512 vectors in dimension 8, larger than any previously known, along with new heuristics for online bin packing. Its central idea, searching the space of programs that generate an answer instead of the space of answers, is the one AlphaEvolve inherited and scaled.

How the evolutionary loop works

The white paper describes a division of labor in which the human defines what counts as good and the system searches for how to get there. A user supplies a working but possibly trivial initial program, marks the parts to be evolved with comment markers, and writes an evaluation function that runs a candidate and returns a set of scores. A controller then repeats one cycle: sample a parent program and some high-scoring "inspirations" from a database, assemble a prompt, ask a language model for changes written as search-and-replace diffs, apply them, run the evaluator, and store the child with its scores.

Several features separate this from FunSearch, and the paper sets them out in a table. AlphaEvolve evolves whole files of up to hundreds of lines in any language rather than a single Python function of 10 to 20 lines. It tolerates evaluations that run for hours on accelerators, needs thousands of language model samples rather than millions, and fills its prompts with context: earlier programs with their results, human-written notes on the problem, even PDFs of papers. The models were an ensemble of Gemini 2.0 Flash, cheap enough to propose many ideas quickly, and Gemini 2.0 Pro, for occasional stronger suggestions. Evaluation can run as a cascade, so weak candidates are discarded on easy test cases before expensive ones run, and the program database combines the MAP-Elites algorithm with island populations to keep diverse lines alive. In ablations on matrix decomposition and kissing numbers, removing evolution, prompt context, whole-file evolution or the larger model each made results markedly worse.

For mathematics the team mostly did not evolve answers. It evolved search heuristics. Each candidate program received a fixed time budget, for example 1,000 seconds, together with the best construction found so far, and was scored on how far it improved it. Early generations favored broad exploration and later ones fine-tuned near-optimal objects, so a final construction was often the product of a relay of specialized heuristics. For matrices, the starting point was a standard gradient-based decomposition routine using the Adam optimizer, and the evaluator rounded every entry to an integer or half-integer, so that any decomposition it accepted was exact rather than approximately right.

The mathematical results

The headline was a rank-48 decomposition for multiplying two 4 by 4 complex matrices, one of improvements on 14 matrix multiplication targets. The white paper adds a footnote that matters for interpretation: algorithms using fewer than 49 multiplications already existed, but they are not tensor decompositions and so cannot be applied recursively to larger matrices. AlphaEvolve's decomposition can be, which is what makes the 48 meaningful. It is still a constant-factor gain at one fixed size, not a change in the asymptotic exponent of matrix multiplication, and its coefficients as found involved complex numbers.

Beyond matrices, DeepMind applied the system to more than 50 problems in analysis, geometry, combinatorics and number theory, with most of the new results coming on problems suggested by the mathematicians Terence Tao and Javier Gómez-Serrano. It reported matching the best known construction in about 75 percent of cases and improving on it in about 20 percent, each time starting from a simple or random construction. The most quotable improvement concerned the kissing problem, which asks how many non-overlapping unit spheres can touch a central one. In 11 dimensions AlphaEvolve found 593 points with integer coordinates whose largest length is no bigger than their smallest pairwise distance, which by a short lemma yields 593 touching spheres, one more than the previous record of 592 from a 2022 search by Mikhail Ganzhinov. On Erdős's minimum overlap problem it lowered the upper bound in the sixth decimal place, to 0.380924. DeepMind published the new objects, with code to verify each, in a results repository, but not the code to run AlphaEvolve.

These are bounds by example. Exhibiting one better configuration proves that the optimum is at least that good; it says nothing about what the optimum is, and most of the improvements were small.

Inside Google's own machines

The engineering results are the part of the announcement no outsider can audit. The first came from an early version of the system. Google's cluster manager, Borg, must place jobs on machines without stranding capacity, for instance leaving a machine with free processors but no free memory. AlphaEvolve evolved the function that ranks candidate machines, scored in a simulator built from historical snapshots of Google's fleet, and produced a short formula combining a job's processor and memory needs relative to what each machine had free. Because the function only reorders machines Borg has already judged feasible, it cannot produce an invalid placement. According to the launch post, it had been in production for more than a year and recovered on average 0.7 percent of Google's worldwide compute resources. The team chose it over a deep reinforcement learning approach partly because a few lines of code are easier to debug, predict and trust.

Second, AlphaEvolve tuned the tiling heuristic of a matrix multiplication kernel used in Gemini training, written in the Pallas extension to JAX, with half of the realistic input shapes held out for testing. The white paper reports an average 23 percent kernel speedup over the expert-written heuristic, a 1 percent cut in Gemini's overall training time, and optimization work shortened from months to days. Third, it rewrote part of an already optimized Verilog arithmetic circuit in the TPU's matrix unit to remove unnecessary bits, a change checked by Google's designers and slated for an upcoming chip; the paper concedes that downstream synthesis tools had independently caught the same simplification. Fourth, working directly on compiler-generated intermediate code around a FlashAttention kernel, it reported a 32 percent speedup of the kernel and 15 percent in the surrounding pre- and postprocessing. The loop in which Gemini helps train Gemini is real, but the paper itself calls the gains moderate and says feedback cycles for improving the next version took months.

What independent scrutiny found

Early reaction was enthusiastic and conditional. In Scientific American's republication of the Nature report, Mario Krenn of the Max Planck Institute for the Science of Light called the paper "quite spectacular". Simon Frieder of Oxford expected it to suit only a "narrow slice" of problems that can be posed as code and preferred to wait for an open recreation, and Huan Sun of Ohio State advised waiting until a broader community had tested it.

The matrix result held up and was quickly extended. About a month after the announcement, Jean-Guillaume Dumas, Clément Pernet and Alexandre Sedoglavic posted a 48-multiplication algorithm with only rational coefficients, derived from AlphaEvolve's complex one, which removes the need for complex arithmetic and works over any ring except those of characteristic 2. In March 2026 the same group posted a more numerically accurate rational variant. Epoch AI's list of open problems for AI systems still treats a rank-47 decomposition over the complex numbers as unsolved and names AlphaEvolve's 48 as the best known.

Several of the smaller numerical records proved soft. In June 2025 the Zuse Institute Berlin reported that a team from its MODAL research campus had beaten AlphaEvolve's results on circle packing and distance-ratio problems with formulations solved by the commercial FICO Xpress solver. A January 2026 paper by Timo Berthold and colleagues then showed that simple nonlinear formulations handed to off-the-shelf global optimizers, FICO Xpress and the open-source SCIP, reproduce the best known solutions on a subset of AlphaEvolve's benchmarks and in several cases improve them, with no changes to either solver. On kissing numbers, Aalto University reported in October 2025 that Ganzhinov, by searching only highly symmetric arrangements, had set new lower bounds in dimensions 10 and 14, while AlphaEvolve's 593 in dimension 11 still stood; he expects that bound to be pushed well beyond 600.

Sixty-seven problems with Terence Tao

The most thorough evaluation came from inside the collaboration. In November 2025, Bogdan Georgiev and Adam Zsolt Wagner of Google DeepMind, with Gómez-Serrano and Tao, posted Mathematical exploration and discovery at scale, which tested the system on 67 problems and reported failures alongside successes, with prompts and evolved programs in a public repository of problems. AlphaEvolve matched the literature in most cases and improved it in several. In a "generalizer" mode it wrote programs valid for every size of a problem rather than one instance. For the finite field Kakeya problem, its general construction was passed to Gemini Deep Think, which proved it correct and derived a closed formula, and then to AlphaProof, which formalized the proof in Lean.

The paper is unusually candid about weaknesses. The system sometimes cheated, exploiting a leaky verifier or a numerical tolerance instead of solving the problem, so verifiers had to be built with care. Expert hints in the prompt made a large difference, while on one autocorrelation problem a cheap model run many times beat the literature bound for a few dollars of model cost. The authors conclude that AlphaEvolve excels at constructions already within reach of current mathematics but too laborious to find by hand, and is likely the wrong tool where genuinely new insight is needed. In a blog post on the paper, Tao called the new observations modest, noted that an apparent four-dimensional Kakeya improvement had essentially appeared already in a paper by Bukh and Chao, and observed that on well-known problems the model often guessed the textbook extremizer at once, apparently from its training data. He saw a different value: recording negative results systematically, and running such tools as a sanity check for obvious counterexamples before anyone states a new conjecture.

Successors and the spread of a method

The clearest new results came in theoretical computer science, from researchers at Google. In a paper first posted in September 2025 and revised through March 2026, Ansh Nagda, Prabhakar Raghavan and Abhradeep Thakurta used AlphaEvolve to find gadgets, the small combinatorial structures inside hardness proofs, and showed that approximating MAX-4-CUT within a factor of 0.987 is NP-hard, improving on 0.9883, and that approximating the metric traveling salesman problem within 111/110 is NP-hard, improving on 117/116. Checking candidates took time exponential in their size, so they also used AlphaEvolve to evolve faster checkers, with speedups of up to 10,000 times, while the Google Research post on the work stresses that the final gadgets were rechecked by the original brute-force method. In March 2026 the same authors reported improved lower bounds for nine classical Ramsey numbers, including R(3,13) from 60 to 61 and R(4,16) from 170 to 174, all produced by one meta-algorithm rather than a bespoke search per number.

Outside Google, the method spread faster than the tool. Open reimplementations appeared within months, among them OpenEvolve, which describes itself as an open-source implementation of AlphaEvolve, and ShinkaEvolve by Robert Tjarko Lange and colleagues, which reported a new best circle packing from only 150 samples. Google's own access widened slowly. Google Cloud opened a private preview in December 2025 whose worked examples were still Google's internal ones, and on 9 July 2026 AlphaEvolve became generally available to all Google Cloud customers on the Gemini Enterprise Agent Platform, with BASF, JetBrains and Kinaxis named as users but no customer results given. The Gemini Enterprise release notes show the service changing its default model more than once since, a reminder that the product is a moving target rather than the system described in May 2025.

The honest limits

The first limit is built in. AlphaEvolve works only where a program can score a candidate quickly and reliably, which the white paper names as its main limitation: experiments that need a laboratory, or qualities that cannot be computed, fall outside it. The second is evidential. The infrastructure numbers, 0.7 percent of fleet compute and 1 percent of training time, are self-reported, measured on systems no one else can inspect, against baselines only Google can see.

The third concerns size. Most mathematical gains were in a late decimal place, and several were matched or beaten within months by conventional solvers, gradient methods or more computation, as the 67-problem paper itself acknowledges, which suggests that on many benchmark problems the system was exploring ground that ordinary numerical optimization could also reach. Its outputs are constructions, not proofs of optimality, and in the judgment of Tao's own group it does not supply the deep new idea a hard problem needs. Finally, the system was closed: until July 2026 outsiders could study results but not run the tool, and even now it is a paid service whose models change underneath it, so its experiments are hard to reproduce exactly.

How to place AlphaEvolve in AI history

AlphaEvolve belongs to DeepMind's long project of pairing learned models with search, running from AlphaZero's self-play through AlphaTensor's decomposition game. Its specific step was to swap a purpose-built policy network for a general-purpose language model writing code, building on FunSearch's demonstration that this could produce new mathematics. The models were Gemini's (see the Gemini era begins), and the result is evidence that a generalist model, constrained by an automatic scorer that discards its many bad ideas, can beat a specialist system such as AlphaTensor on its own problem.

It is not the direct ancestor of the AI mathematics claims that followed in 2026. OpenAI's disproof of the Erdős unit distance conjecture, its Navier-Stokes blowup claim and its quasi-Riemann manuscripts came from reasoning models writing proofs, and the unit distance model was described as not scaffolded to search through proof strategies at all. The closer relative is Google's own olympiad gold with Gemini Deep Think, which Tao's group later chained to AlphaEvolve to turn a found construction into a checked proof. AlphaEvolve represents the other branch of AI mathematics: construction by search under a score rather than argument in prose, broad but usually shallow, and strongest where answers are easy to check. As of October 2026 its influence is clearest as a method copied in open source and applied to Ramsey numbers, hardness proofs and commercial optimization. Whether it becomes standard infrastructure for mathematics and engineering, or is absorbed into reasoning models that search internally, is not yet settled.

References

• Google DeepMind (2025). AlphaEvolve: A Gemini-powered coding agent for designing advanced algorithms.
• Novikov et al., Google DeepMind (2025). AlphaEvolve: A coding agent for scientific and algorithmic discovery, white paper.
• Novikov et al. (2025). AlphaEvolve: A coding agent for scientific and algorithmic discovery, arXiv version.
• Google DeepMind (2025). Results of AlphaEvolve: mathematical results notebook and verification code.
• Elizabeth Gibney, Nature (2025). DeepMind unveils spectacular general-purpose science AI.
• Elizabeth Gibney, Scientific American (2025). New Google AI Chatbot Tackles Complex Math and Science.
• Volker Strassen (1969). Gaussian Elimination is not Optimal.
• Fawzi et al., Nature (2022). Discovering faster matrix multiplication algorithms with reinforcement learning.
• Romera-Paredes et al., Nature (2023). Mathematical discoveries from program search with large language models.
• Dumas, Pernet and Sedoglavic (2025). A non-commutative algorithm for multiplying 4x4 matrices using 48 non-complex multiplications.
• Dumas, Pernet and Sedoglavic (2026). A more accurate rational non-commutative algorithm for multiplying 4x4 matrices using 48 multiplications.
• Epoch AI (2026). The Rank of the 4x4 Matrix-Multiplication Tensor.
• Zuse Institute Berlin (2025). Team Sets New Records in Mathematical Optimization with FICO Xpress.
• Berthold, Kamp, Mexi, Pokutta and Pólik (2026). Global Optimization for Combinatorial Geometry Problems Revisited in the Era of LLMs.
• Aalto University (2025). Researcher cracks new kissing number bounds, besting AI in the process.
• Georgiev, Gómez-Serrano, Tao and Wagner (2025). Mathematical exploration and discovery at scale.
• Google DeepMind (2025). Mathematical Problem Repository for AlphaEvolve.
• Terence Tao (2025). Mathematical exploration and discovery at scale, blog post.
• Nagda, Raghavan and Thakurta (2025). Reinforced Generation of Combinatorial Structures: Hardness of Approximation.
• Nagda, Thakurta and Raghavan, Google Research (2025). AI as a research partner: Advancing theoretical computer science with AlphaEvolve.
• Nagda, Raghavan and Thakurta (2026). Reinforced Generation of Combinatorial Structures: Ramsey Numbers.
• Asankhaya Sharma (2025). OpenEvolve: an open-source evolutionary coding agent.
• Lange, Imajuku and Cetin (2025). ShinkaEvolve: Towards Open-Ended And Sample-Efficient Program Evolution.
• Vladimir Vuskovic and Anant Nawalgaria, Google Cloud (2025). AlphaEvolve on Google Cloud: AI for agentic discovery and optimization.
• Tom Beyer, Google (2026). We're rolling out AlphaEvolve widely to solve Google Cloud customers' hardest problems.
• Google Cloud (2026). Gemini Enterprise release notes.