AlphaEvolve

AlphaEvolve is an evolutionary coding agent developed by Google DeepMind and announced on May 14, 2025 ^[1][2]. The system pairs an ensemble of Gemini large language models with automated evaluators and an evolutionary search loop, using the LLMs to generate and mutate code while the evaluators score each candidate, so the system iteratively discovers and optimizes algorithms across mathematics, hardware design, and computing infrastructure ^[1][2]. AlphaEvolve produced the first AI-driven improvement over Strassen's 1969 matrix multiplication algorithm for 4x4 complex-valued matrices, cutting the required scalar multiplications from 49 to 48 after more than five decades without progress on that specific problem ^[1][2].

Google DeepMind describes the design succinctly: AlphaEvolve "pairs the creative problem-solving capabilities of our Gemini models with automated evaluators that verify answers, and uses an evolutionary framework to improve upon the most promising ideas" ^[2]. Because every candidate program is graded by an automatic evaluator rather than trusted on the LLM's word, the system can run autonomously for long stretches and surface solutions that are verified correct before a human ever looks at them ^[1][2].

What is AlphaEvolve?

AlphaEvolve is a general-purpose algorithm-discovery system: the user supplies an initial program and an automatic evaluation function, and AlphaEvolve evolves the program over many generations to maximize the evaluator's score ^[1]. Unlike interactive LLM coding assistants, it is designed to run unattended, accumulating a population of candidate programs and ratcheting up performance over hours or days ^[1][2]. DeepMind has used it internally to improve real Google systems (data-center scheduling, Tensor Processing Unit circuit design, and Gemini training) and to attack open problems in mathematics ^[2].

The name reflects its lineage in DeepMind's "Alpha" series and its evolutionary core: candidate programs are treated as an evolving population, with the Gemini ensemble acting as the mutation operator and the evaluator acting as the selection pressure ^[1].

Background and predecessor systems

AlphaEvolve belongs to a line of Google DeepMind systems that apply AI to algorithm discovery and mathematical reasoning. Understanding where it fits requires tracing the research thread back through several earlier projects.

AlphaCode

AlphaCode (2022) demonstrated that large language models could compete in programming competitions at a level roughly comparable to the median human contestant. That work established that LLMs could generate syntactically correct, logically coherent code for well-specified problems, but it operated in the register of competitive programming rather than open-ended algorithm discovery.

AlphaTensor

AlphaTensor (October 2022) tackled a specific and long-standing algorithmic problem: finding fast matrix multiplication algorithms ^[5]. DeepMind framed the problem as a three-player game, then used a reinforcement learning agent to search for winning sequences of moves. AlphaTensor found algorithms for dozens of matrix sizes that beat previously known methods, including improvements over the standard 50-year-old approaches for certain small matrices ^[5]. For 4x4 matrices over finite fields of characteristic two, it found an algorithm using 47 multiplications, but the analogous result over complex numbers (characteristic zero) remained at Strassen's 49 ^[1][5].

FunSearch

FunSearch (December 2023) introduced the idea of pairing LLMs with evolutionary search to discover short, executable programs ^[4]. The name came from "searching in the function space." FunSearch used relatively small language models trained primarily on code, generating candidate Python functions and scoring them with automated evaluators. It solved variants of the cap set problem (finding large sets of integers with no three-term arithmetic progressions) and discovered new bin-packing heuristics that outperformed known methods ^[4].

FunSearch established several principles that AlphaEvolve would later extend: LLMs as mutation operators rather than end-to-end solvers, automated evaluation to avoid hallucination risks, and an evolutionary database to manage the population of candidate programs ^[1][4]. The main limitation was scope: FunSearch evolved single Python functions and used small code-specialized models, which constrained the complexity of algorithms it could find ^[1].

AlphaProof

AlphaProof (2024) took a different direction, combining language models with formal proof verification to solve competition mathematics problems including International Mathematical Olympiad problems. AlphaProof worked in the domain of symbolic proof rather than algorithmic code, but it reinforced DeepMind's broader strategy of using LLMs in combination with automated verification rather than relying on LLM outputs alone.

How does AlphaEvolve work?

AlphaEvolve operates as an asynchronous pipeline built around four main components: a prompt sampler, an LLM ensemble, a program database, and an evaluation system ^[1]. The system is written to maximize throughput rather than minimize latency on individual tasks, running many candidate evaluations in parallel ^[1].

Prompt sampler

The prompt sampler constructs inputs for the language models by drawing on customizable templates that incorporate solutions sampled from the program database ^[1]. Users can add explicit instructions, stochastic formatting, evaluation results from previous runs, and optional meta-prompt evolution (where the prompts themselves are subject to optimization). This flexibility lets the system adapt its search behavior over time as it learns which kinds of instructions produce useful mutations.

LLM ensemble

AlphaEvolve uses an ensemble of Gemini models with complementary roles. DeepMind explains: "We use an ensemble of Gemini models. Gemini Flash maximizes the breadth of ideas explored, while our most powerful model, Gemini Pro, provides critical depth with insightful suggestions" ^[2].

• Gemini 2.0 Flash handles the high-throughput portion of search. Flash has lower latency, which allows AlphaEvolve to generate and evaluate many more candidate solutions per unit of compute, maximizing the breadth of ideas explored ^[2].
• Gemini 2.0 Pro provides depth. When the search reaches difficult or novel regions of the solution space, Pro generates higher-quality suggestions that are more likely to represent genuine improvements ^[2].

Both models generate code changes in the form of diff specifications, identifying specific blocks of the current program to replace ^[1]. Rather than rewriting entire programs from scratch each iteration, the system makes targeted edits, which preserves working structure while exploring variations.

Program database

The program database stores all candidate solutions along with their evaluation scores and metadata. Its structure is inspired by MAP-elites (a quality-diversity evolutionary algorithm) combined with island-based population models ^[1]. MAP-elites maintains a grid of solutions indexed by behavioral characteristics, ensuring diversity rather than convergence to a single local optimum. Island models keep separate sub-populations that evolve somewhat independently, periodically exchanging their best solutions.

This combination balances exploration (trying genuinely different approaches) against exploitation (refining approaches that are already working). The database provides context to the LLM during prompt construction, so the model can see what has worked before and generate mutations informed by that history.

Evaluation system

Every problem posed to AlphaEvolve requires an evaluation function that maps a candidate program to one or more scalar scores ^[1]. This is a hard requirement of the system: if you cannot automatically grade a solution, AlphaEvolve cannot run. The system supports cascading evaluation, starting with simpler test cases before moving to expensive ones, which reduces wasted compute on clearly poor candidates ^[1]. It also supports parallel evaluation across multiple simultaneous metrics, enabling multi-objective optimization where earlier systems like FunSearch only handled single objectives ^[1].

Beyond numerical scoring, the evaluation component can incorporate LLM-generated feedback, where a language model reads the output of a candidate program and produces a qualitative assessment that the system can use alongside quantitative metrics ^[1].

How does AlphaEvolve differ from FunSearch?

The table below summarizes the main architectural and capability differences between FunSearch and AlphaEvolve.

Scroll sideways for more →

The most significant architectural difference is that AlphaEvolve treats the LLM as an intelligent mutation operator rather than a function generator ^[1]. Because Gemini models are trained on broad natural language and code, they implicitly know standard genetic operators (crossover, mutation, selection) and apply them through their world knowledge rather than through hand-coded procedures. This means AlphaEvolve does not need explicit evolutionary operators in its code; the LLM decides how and where to modify each candidate based on everything it learned during pretraining.

Evolutionary coding agent in practice

The workflow for using AlphaEvolve requires the user to supply two things: an initial program that represents a starting-point solution, and an evaluation function that scores programs against the target metric ^[1]. The system then runs the evolutionary loop autonomously until improvement plateaus.

This is a notably different interface from typical LLM coding tools, where a human iterates interactively with the model. AlphaEvolve runs for hours or days without human oversight, accumulating a population of programs and gradually ratcheting up performance. The human role shifts from pair programmer to problem framer.

For each iteration, the system samples a parent solution from the database (biased toward higher-scoring programs but maintaining diversity), constructs a prompt with context from previous solutions, calls the LLM ensemble to generate a diff, applies that diff to the parent program, evaluates the result, and stores any program that achieves a new high score or a score above a quality threshold in a new region of the behavioral space ^[1]. The loop continues asynchronously, with Flash handling the bulk of rapid-fire iterations and Pro called in when the search appears stuck.

AlphaEvolve needs only thousands of sample evaluations to converge, compared to the millions FunSearch required ^[1]. This improvement in sample efficiency reflects the higher capability of frontier Gemini models: each suggestion is more likely to be useful, reducing wasted evaluations on dead ends.

What has AlphaEvolve discovered?

Matrix multiplication: beating Strassen after 56 years

The most mathematically significant result from AlphaEvolve is an algorithm that multiplies two 4x4 complex-valued matrices using 48 scalar multiplications, one fewer than Strassen's 1969 algorithm ^[1][2]. According to DeepMind, "AlphaEvolve... found 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" ^[2].

Volker Strassen's 1969 paper introduced a recursive approach to matrix multiplication that reduced the naive $n^3$ operation count. For 2x2 matrices, Strassen showed that 7 multiplications suffice instead of 8. Applying this recursively gives an algorithm for 4x4 matrices using $7^2 = 49$ multiplications. For more than five decades, mathematicians and computer scientists could not improve on 49 multiplications for 4x4 matrices over fields of characteristic zero (which includes the real and complex numbers) ^[1][2].

AlphaTensor (2022) had found 47-multiplication algorithms for 4x4 matrices over fields of characteristic two (finite fields), but that result did not carry over to characteristic zero because of different algebraic rules ^[1][5]. The challenge for complex matrices specifically remained at Strassen's 49.

AlphaEvolve found a solution that uses complex numbers in a way human researchers had not tried, creating algebraic cancellations that reduce the count to 48 ^[1]. The algorithm works over non-commutative rings, meaning it applies not just to scalar complex numbers but also to matrices of complex numbers (block matrix multiplication). Independent verification confirmed the result is correct ^[1][8]. The fact that AlphaEvolve, a general-purpose system not specifically designed for matrix multiplication, outperformed AlphaTensor, which was purpose-built for that problem, demonstrated the flexibility of the evolutionary coding approach ^[1].

Practical impact scales non-linearly. An 8x8 matrix multiplication built by applying the 4x4 algorithm twice requires $48^2 = 2304$ scalar multiplications rather than $49^2 = 2401$. At each doubling of matrix size, the advantage compounds. For the very large matrix multiplications that appear in neural network training and inference, even small improvements to the fundamental algorithm can accumulate into meaningful reductions in compute cost.

AlphaEvolve also found improvements for 14 other matrix sizes beyond 4x4, suggesting that decades of human work had left a number of optimization opportunities unexplored ^[1].

Data center scheduling at Google

Google's data centers run a task scheduling system called Borg, which allocates computing jobs across large clusters of machines. Scheduling is a combinatorially hard problem: given thousands of jobs with different resource requirements and priorities, find an assignment that maximizes utilization and minimizes latency.

AlphaEvolve developed a new scheduling heuristic for Borg that, in DeepMind's words, "now in production for over a year, continuously recovers, on average, 0.7% of Google's worldwide compute resources" by finding better task placements that human engineers and prior automated approaches had missed ^[2]. The heuristic outperformed solutions from deep reinforcement learning, which was the previous state of the art for this problem.

DeepMind has noted that this 0.7% recovery means jobs that would otherwise sit in a pending queue can be scheduled, effectively reclaiming stranded capacity across millions of servers ^[2]. The heuristic code is human-readable and was deployed to production after review by Google engineers, which is notable: the system produced code that engineers could understand, audit, and maintain rather than an opaque function they had to take on trust ^[2].

TPU circuit design

AlphaEvolve proposed a simplification to the Verilog code for a matrix multiplication arithmetic circuit in Google's Tensor Processing Unit (TPU) hardware ^[2]. Verilog is the hardware description language used to specify digital circuits before they are fabricated.

The optimization involved removing unnecessary bits from a highly optimized arithmetic circuit that performs matrix multiplications on the TPU ^[2]. AlphaEvolve identified that certain bit positions in the circuit were redundant given the constraints of the inputs the circuit would actually receive. Removing those bits produces a functionally equivalent but simpler circuit.

The proposal passed robust hardware verification methods confirming that the modified circuit behaves identically to the original for all valid inputs, and it was integrated into an upcoming TPU ^[2]. Engineers noted that the simplification was the kind of finding that synthesis tools would eventually catch during the chip design flow, but AlphaEvolve identified it earlier, potentially shortening the design cycle.

A key factor in adoption was that AlphaEvolve communicated its findings in Verilog rather than in some intermediate representation. Hardware engineers could read the proposed change directly in the language they use daily, which reduced the verification burden and built trust in the result ^[2].

Accelerating Gemini training

AlphaEvolve improved two separate kernel operations in the computational stack used to train Gemini models ^[2].

The first improvement addressed a matrix multiplication kernel that handles tiling: the problem of dividing a large matrix multiplication into subproblems that fit in fast on-chip memory. DeepMind reports that "by finding smarter ways to divide a large matrix multiplication operation into more manageable subproblems, it sped up this vital kernel in Gemini's architecture by 23%, leading to a 1% reduction in Gemini's training time" ^[2]. At the scale of multi-month training runs on tens of thousands of accelerators, a 1% reduction in training time is a substantial saving.

The second improvement targeted the FlashAttention kernel, which computes scaled dot-product attention in transformer architectures more efficiently than naive attention by fusing operations to reduce memory bandwidth. AlphaEvolve optimized lower-level XLA (Accelerated Linear Algebra) intermediate representation for the attention kernel, and DeepMind reports it "achieved up to a 32.5% speedup for the FlashAttention kernel implementation in Transformer-based AI models" ^[2].

Both results were verified by running the modified kernels against the original and confirming correctness and performance on representative workloads ^[2].

Open mathematical problems

Beyond the high-profile matrix multiplication result, AlphaEvolve was evaluated on a diverse set of more than 50 open mathematical problems drawn from analysis, combinatorics, and geometry ^[2][7]. DeepMind summarizes the outcome: "In roughly 75% of cases, it rediscovered state-of-the-art solutions, to the best of our knowledge. And in 20% of cases, AlphaEvolve improved the previously best known solutions" ^[2]. The results across this benchmark were:

• In approximately 75% of problems, AlphaEvolve rediscovered the current best-known solution ^[2].
• In approximately 20% of problems, AlphaEvolve found a strictly better solution than the previously known optimum ^[2].
• In approximately 5% of problems, the system converged on a suboptimal answer.

One notable result was the kissing number problem. The kissing number in dimension $d$ is the maximum number of non-overlapping unit spheres that can simultaneously touch a central unit sphere. For most dimensions above four, only upper and lower bounds are known, not exact values. AlphaEvolve improved the lower bound for the kissing number in 11 dimensions from 592 to 593, advancing the state of knowledge in a problem that has resisted progress for decades ^[7].

This result later prompted a human response that illustrates the competitive dynamic between AI-driven search and classical mathematics. In October 2025, mathematician Mikhail Ganzhinov published peer-reviewed lower bounds of 510 in dimension 10, 592 in dimension 11, and 1,932 in dimension 14, found by restricting the search to highly symmetric arrangements ^[9]. Ganzhinov's records bested earlier AI results in dimensions 10 and 14, while in dimension 11 his bound of 592 fell one short of AlphaEvolve's 593, which remained the leading lower bound for that dimension ^[9]. Ganzhinov explained his approach: "I reduced the problem size by looking only for arrangements with a high degree of symmetry" ^[9]. The back-and-forth shows that AI-driven search and human mathematical insight remain genuinely competitive, with advances from one side motivating responses from the other.

Other problems in the benchmark included variants of the Fourier analysis problem, the minimum overlap problem, and various extremal combinatorics questions. The team also made the mathematical results available, including a Google Colab notebook, for independent verification ^[8].

What does AlphaEvolve do at Google?

AlphaEvolve operates as an internal tool at Google, deployed across several teams and problem domains ^[2].

Scroll sideways for more →

The scheduling and hardware results are production deployments, meaning AlphaEvolve's output is running in Google's live infrastructure ^[2]. The AI training optimizations were applied to actual Gemini training runs. This distinguishes AlphaEvolve from many research systems that demonstrate capability in controlled benchmarks without deployment.

All three production results (scheduling, TPU circuit, training kernels) share a common property: the outputs are interpretable ^[2]. The scheduling heuristic is readable code that engineers reviewed before deployment. The Verilog simplification is expressed in standard hardware description language. The kernel improvements are modifications to existing compiler output that engineers could inspect. The team has emphasized this interpretability as a design goal, arguing that autonomous systems producing unreadable black-box changes would face higher adoption barriers in engineering contexts ^[2].

Is AlphaEvolve open source?

As of mid-2025, AlphaEvolve has not been released publicly ^[1][2]. Google DeepMind announced an early access program for selected academic researchers, with an application form for those wishing to participate ^[2]. The accompanying paper (arXiv:2506.13131, submitted June 16, 2025) provides detailed architectural descriptions but does not include code or model weights ^[1].

Several open-source implementations appeared in the research community following the announcement. OpenEvolve, available on GitHub and PyPI, is a community implementation of the AlphaEvolve approach that supports distributed algorithms, multi-language programs, and GPU kernel optimization. CodeEvolve is a separate open-source project that implements the high-level principles of LLM-driven evolutionary search in a reproducible framework. These implementations allow researchers to experiment with the methodology without waiting for official access.

The closed nature of AlphaEvolve has drawn some criticism. Reviewers noted that prior DeepMind releases like AlphaFold 2 shipped without training scripts, and AlphaGeometry contained bugs that the community had to patch. Whether AlphaEvolve follows a similar trajectory remains to be seen.

What are AlphaEvolve's limitations?

AlphaEvolve has several meaningful constraints that shape where it can and cannot be applied.

The most fundamental limitation is the requirement for automatic evaluation ^[1]. Every problem must have an evaluation function that scores candidate programs without human intervention. This rules out large classes of potentially valuable problems: drug discovery requires wet-lab validation, materials science needs physical synthesis and testing, and many engineering design problems require human judgment about trade-offs that are difficult to encode in a scalar metric. DeepMind has acknowledged this constraint and described it as a core architectural dependency rather than a temporary limitation ^[1].

AlphaEvolve also provides limited theoretical insight. The system finds algorithms that work, but it does not explain why they work. The matrix multiplication algorithm using 48 multiplications is verified correct, but no human has yet constructed a theoretical proof of why such an algorithm exists or what mathematical structure it exploits. For pure mathematics, where the goal is understanding rather than just finding solutions, this is a significant gap.

The system requires substantial compute to run effectively. While it uses thousands of evaluations rather than millions, each evaluation involves LLM calls and program execution, and running the system for days across a complex problem accumulates real compute costs ^[1]. This resource requirement limits accessibility for smaller research groups even if the methodology were openly available.

Finally, AlphaEvolve inherits the limitations of the LLMs it uses. Gemini models can generate syntactically incorrect code or logically flawed algorithms, and the evolutionary framework depends on the evaluator catching those errors. For domains where subtle bugs are hard to catch automatically, the system may produce solutions that appear to pass evaluation but fail in edge cases.

ELI5: AlphaEvolve explained simply

Imagine you want the fastest possible recipe for a dish, but you only have a rough first attempt. AlphaEvolve is like a tireless cook that keeps tweaking the recipe: it tries a change, tastes the result with a strict scorecard (the evaluator), keeps the changes that taste better, and throws away the ones that do not. The "cook" making the tweaks is a Gemini AI model that has read enormous amounts of code, so its guesses about what to change are smart rather than random. After thousands of rounds, the recipe (which is really a computer program) can end up better than anything people had figured out, sometimes by finding a trick humans missed for 50 years.

See also

• Google DeepMind
• Gemini (language model)
• AlphaCode
• AlphaProof
• Large Language Model
• AlphaTensor
• FunSearch
• Tensor Processing Unit
• FlashAttention

References

1. Novikov, Alexander; Vũ, Ngân; Eisenberger, Marvin; Dupont, Emilien; Huang, Po-Sen; Wagner, Adam Zsolt; Shirobokov, Sergey; Kozlovskii, Borislav; Ruiz, Francisco J. R.; Mehrabian, Abbas; Kumar, M. Pawan; See, Abigail; Chaudhuri, Swarat; Holland, George; Davies, Alex; Nowozin, Sebastian; Kohli, Pushmeet; Balog, Matej. "AlphaEvolve: A coding agent for scientific and algorithmic discovery." arXiv:2506.13131 (2025). https://arxiv.org/abs/2506.13131 ↩
2. Google DeepMind. "AlphaEvolve: A Gemini-powered coding agent for designing advanced algorithms." DeepMind Blog, May 14, 2025. https://deepmind.google/blog/alphaevolve-a-gemini-powered-coding-agent-for-designing-advanced-algorithms/ ↩
3. Hao, Karen. "Google DeepMind's new AI agent cracks real-world problems better than humans can." MIT Technology Review, May 14, 2025. https://www.technologyreview.com/2025/05/14/1116438/google-deepminds-new-ai-uses-large-language-models-to-crack-real-world-problems/
4. Romera-Paredes, Bernardino et al. "Mathematical discoveries from program search with large language models (FunSearch)." Nature, 2023. ↩
5. Fawzi, Alhussein et al. "Discovering faster matrix multiplication algorithms with reinforcement learning (AlphaTensor)." Nature, 2022. ↩
6. Wiggers, Kyle. "Google DeepMind Unveils AI Coding Agent AlphaEvolve." InfoQ, May 2025. https://www.infoq.com/news/2025/05/google-alpha-evolve/
7. "AlphaEvolve Tackles Kissing Problem & More." IEEE Spectrum, 2025. https://spectrum.ieee.org/deepmind-alphaevolve ↩
8. GitHub: google-deepmind/alphaevolve_results. https://github.com/google-deepmind/alphaevolve_results ↩
9. "Human ingenuity outpaces AI in finding new 'kissing number' bounds." Phys.org / Aalto University, October 2025. https://phys.org/news/2025-10-human-ingenuity-outpaces-ai-bounds.html ↩