AlphaEvolve shows that LLM-guided evolutionary search can produce improved algorithms when candidate quality can be evaluated automatically. Its limits reveal an equally important lesson: an autonomous search system can only optimize for what its evaluator can recognize.
In 2025, Google DeepMind reported that AlphaEvolve found a procedure for multiplying two 4 × 4 complex-valued matrices with 48 scalar multiplications, one fewer than two recursive levels of Strassen’s method. The one-multiplication reduction made the headline. The search loop that found it explains why the result matters beyond matrix multiplication.
Now, we will explore AlphaEvolve to better understand it.
What is AlphaEvolve?
AlphaEvolve is an autonomous evolutionary AI coding agent developed by Google DeepMind that combines language-model proposals with evolutionary search. It uses two of Google’s frontier Gemini models in complementary roles:
- Gemini Flash generates high-throughput proposals, expanding the breadth of ideas explored.
- Gemini Pro adds greater depth through occasional suggestions from the more capable model.
The paper does not disclose the exact sampling mixture.
AlphaEvolve illustrates how AI has evolved from producing generic, repetitive output to building advanced systems that pair large language models (LLMs) with evolutionary-search harnesses.
The word “autonomous” needs a clear boundary. Humans define the problem, provide the initial program and evaluation code, supply optional context, and mark the code regions that AlphaEvolve may modify. The system then conducts a sustained search within those constraints. This goes well beyond asking a model for a single answer, but it does not make AlphaEvolve an independent scientist who chooses questions or standards of evidence.
AlphaEvolve extends FunSearch, DeepMind’s earlier system for evolving a selected function within a human-written program. AlphaEvolve can modify much larger regions of code, optimize multiple scores simultaneously, and run evaluations for hours in parallel. The expansion is substantial, but the underlying pattern is inherited: language-model variation followed by executable selection.
How does it work?
AlphaEvolve advanced outline. The diagram illustrates how its process works as explained below.
The loop could be demonstrated like this:
- User input A user supplies an existing algorithm or program, evaluation code, and optional context about the problem.
- Prompt sampler A prompt sampler then selects previous candidates from a program database and gives them to the Gemini models for revision.
- Gemini models Create new candidates by proposing code changes, usually returning patches instead of rewriting the whole program.
- Evaluator pool Multiple candidates can be evaluated in parallel. Inexpensive checks can filter out invalid or poor candidates before more costly evaluations are run. The evaluation code and the environment in which it runs together form the evaluator harness. This harness determines how each candidate is executed, tested, timed, and scored.
- Program database Candidates that receive strong evaluation scores are returned to the database, where they can be chosen again in further generations. The model provides variation by changing the code, while the evaluator provides the selection pressure that determines which changes remain.
AlphaEvolve generates and modifies programs, runs them through an automated evaluator, retains promising candidates, and uses their performance to guide the next generation. This process lets the system evaluate far more candidate programs than we could explore manually on a scale humans can’t examine without sacrificing accuracy, although the reliability of that search still depends on what the evaluator measures.
AlphaEvolve revolutionizes how we work by letting us formulate problems, design evaluators to test them, and constrain the search space. The evolutionary system decides which candidates survive, and human researchers decide whether the resulting score reflects meaningful progress. The evaluator is only one part of the system . In other words, the evaluator matters, but it’s only one part of a much larger human-guided system. AlphaEvolve’s limited ablation studies suggest that its performance depends on several factors, including model capability, evolutionary selection, prompt adaptation, available context, and how much of the code the system is allowed to modify. While the overall loop may appear straightforward, it is supported by several interacting components that surprisingly make the system more complex in practice (Novikov et al., 2025). For the results to be reliable, these mechanisms also need to be paired with a well-designed evaluator.
Results with evidence level distinction
AlphaEvolve’s public record contains three kinds of evidence: artifacts outsiders can verify, production measurements reported by Google, and later work that extends an artifact without reproducing the original search.
Keeping these categories separate prevents a verified mathematical construction from giving proprietary deployment claims more certainty than they warrant.
Demonstrated and checkable. DeepMind released an exact rank-48 decomposition and verification code for multiplying 4 × 4 matrices over complex coefficients. Here, rank counts the bilinear scalar multiplications in the construction. It does not measure wall-clock speed. Additions, memory traffic, numerical stability, coefficient arithmetic, and target hardware can outweigh the benefit of saving one multiplication.
DeepMind initially described the result as the first improvement in 56 years over the complex rank-49 baseline associated with Strassen’s 1969 method. The publication record complicates that priority claim. In 2024, Kaporin reported a numerical complex rank-48 scheme. AlphaEvolve’s contribution is better described as an exact, publicly checkable construction found by the system. Dumas et al. (2025) then transformed that artifact into a 48-multiplication algorithm with rational coefficients. Their work corroborates and extends the construction, but it does not reproduce DeepMind’s search system, which remains closed.
Developer-reported. Google reports that an AlphaEvolve scheduling heuristic, first validated in simulation and then deployed, recovers an average of 0.7% of its worldwide compute resources. The white paper also reports an average 23% speedup across evaluated Pallas matrix-multiplication kernel shapes and about a 1% reduction in Gemini training time. For the kernel study, realistic input shapes were divided between optimization and evaluation sets and measured on TPUs. This provides a useful generalization check, but the workloads, raw timing records, and production environment remain proprietary. These figures are therefore first-party measurements rather than independently audited results.
The same qualification applies to DeepMind’s report that AlphaEvolve matched the best-known construction on roughly 75% of more than 50 mathematical problems and improved on it in roughly 20%. The public report does not fully document the problem-selection protocol or provide a precise denominator. In a May 2026 update, DeepMind reported that AlphaEvolve had become a regular tool for designing next-generation TPUs and had produced a Spanner heuristic that cut write amplification by 20%. These claims came after the 2025 white paper and, like the earlier figures, have not been independently audited.
System Constraints & Bottlenecks
AlphaEvolve’s main boundary is automated evaluability. Tasks that require manual experiments, subjective judgment, or evidence unavailable to the harness do not fit the current loop. Even machine-gradeable tasks can fail in quieter ways. A proxy may reward the wrong behavior, public tests may invite overfitting, omitted edge cases may hide invalid programs, and noisy timing may favor a candidate that will not survive a different device or compiler version. Multi-objective scores add another judgment call because their weights determine what the search may sacrifice.
The concern is empirical, not merely philosophical. In a small 2026 circle-packing preprint (Ishibashi et al., 2026) found generated programs that exploited weaknesses in the evaluator and reported more such hacks from the more capable model they tested. The study examined another harness on one benchmark, so it is evidence of a general failure mode, not an audit of AlphaEvolve’s published results.
A stronger harness would combine exact validity checks where possible with hidden holdouts, adversarial cases, repeated measurements, cross-device tests, versioned environments, independent reimplementation, and human inspection of finalists. These controls raise costs. That cost limits how many candidates can be evaluated and which problems are economically searchable. Model quality, context, representation, compute budget, and editable scope remain bottlenecks even when the evaluator is sound.
Human Adaptation, Decision, and Judgement
Many people are afraid of AI because its capabilities have advanced far faster than expected, but fear will never help us. We should adapt, learn, and use AI as a collaborative brainstorming partner that helps us think better and strengthen our arguments. One-sided perspectives can create new mistakes even as we try to solve existing ones.
AlphaEvolve makes this distinction especially clear. Human judgment enters both before and after the search. Researchers choose the objective, decide what code may change, construct the evaluation environment, and set acceptable constraints and tradeoffs. Once the search is complete, people still have to determine whether the winning program is valid, robust, deployable, and scientifically meaningful, while considering the consequences of putting it into practice. AlphaEvolve itself relies on automated evaluators to score proposed programs, making human choices about objectives and evaluation central to what the system ultimately discovers.
A benchmark score cannot make those decisions. The evidence therefore supports treating AlphaEvolve as a research instrument that operates under human scientific judgment, not as a replacement for it.
Its value lies in expanding the range and persistence of algorithmic search, while responsibility for defining the problem, interpreting the results, and deciding what counts as a meaningful discovery remains with people.
What JAX changes
JAX can reduce the cost of repeated numerical evaluation. It cannot determine whether the evaluator represents the right scientific objective.
That distinction separates AlphaEvolve’s documented JAX use from broader hypotheses about what the pairing might eventually enable.
JAX already appears in the published work. AlphaEvolve used JAX and Optax while evolving tensor-decomposition search code, and it optimized a tiling heuristic for a Pallas kernel used in Gemini training. Pallas is an experimental JAX kernel language that gives programmers fine-grained control over code for GPUs and TPUs, including data movement through fast on-chip memory.
Three JAX transformations are especially relevant:
- jax.jit traces and compiles compatible numerical functions for a target device. Repeated calls can reuse the compiled executable when input types and relevant static arguments remain compatible.
- jax.vmap maps one function across a batch axis. It can batch evaluations over inputs or parameter settings, but it does not merge structurally different candidate programs into one computation.
- jax.grad differentiates scalar-output functions. It could support continuous optimization inside a candidate when the inner objective is differentiable, but it does not differentiate AlphaEvolve's discrete outer search.
During compilation, JAX traces a compatible Python function into an internal representation called a jaxpr, lowers it to StableHLO, and passes the lowered program to XLA to produce an executable for a CPU, GPU, or TPU. A compiler intermediate representation is simply a structured form between source code and machine instructions that allows compilers to analyze and transform it.
This stack makes a broader research program both feasible and practical. AlphaEvolve could propose new kernels, solver components, optimizers, or training-loop components, while JAX could compile and vectorize repeated evaluations for efficient execution on accelerators. For promising candidates, automatic differentiation could help tune internal parameters by supplying gradients to an optimizer, provided the inner objective is differentiable and scalar-valued. This remains a hypothesis about how the search space could be expanded, not a demonstrated path toward general intelligence.
The economics depend on how similar the candidates are. Repeated evaluations of the same jitted candidate can amortize compilation costs, while changes to the code, shapes, dtypes, or static parameters may require new tracing and compilation. Structurally heterogeneous programs may therefore erase the throughput advantage. A credible experiment would also evaluate correctness, speed, memory use, numerical stability, and behavior across unseen data, shapes, devices, and compiler versions.
AlphaEvolve combined with JAX could broaden the practical search space for numerical components when compilation costs can be amortized. That same acceleration makes evaluator quality even more consequential:
- A flawed harness can reward the wrong behavior at a greater scale.
This strengthens the case for automated algorithm search, but it is not evidence of autonomous science without human control.
References
AlphaEvolve Team. (2025, May 14). AlphaEvolve: A Gemini-powered coding agent for designing advanced algorithms. Google DeepMind. https://deepmind.google/blog/alphaevolve-a-gemini-powered-coding-agent-for-designing-advanced-algorithms/
AlphaEvolve Team. (2026, May 7). AlphaEvolve: How our Gemini-powered coding agent is scaling impact across fields. Google DeepMind. https://deepmind.google/blog/alphaevolve-impact/
Dumas, J.-G., Pernet, C., & Sedoglavic, A. (2025). A non-commutative algorithm for multiplying 4x4 matrices using 48 non-complex multiplications (arXiv:2506.13242, Version 7) [Preprint]. arXiv. https://doi.org/10.48550/arXiv.2506.13242
Google DeepMind. (2025). Results of AlphaEvolve [Data set and computer software]. GitHub. https://github.com/google-deepmind/alphaevolve_results
Ishibashi, Y., Yano, T., & Oyamada, M. (2026). Effective harness engineering for algorithm discovery with coding agents (arXiv:2605.15221, Version 1) [Preprint]. arXiv. https://doi.org/10.48550/arXiv.2605.15221
JAX Authors. (n.d.-a). Ahead-of-time lowering and compilation. JAX documentation. Retrieved August 29, 2026, from https://docs.jax.dev/en/latest/aot.html
JAX Authors. (n.d.-b). Pallas: Custom kernels in JAX. JAX documentation. Retrieved August 29, 2026, from https://docs.jax.dev/en/latest/401/pallas.html
JAX Authors. (n.d.-c). Transformations: grad and vmap. JAX documentation. Retrieved August 29, 2026, from https://docs.jax.dev/en/latest/101/transformations.html
Kaporin, I. E. (2024). Finding complex-valued solutions of Brent equations using nonlinear least squares. Computational Mathematics and Mathematical Physics, 64(9), 1881–1891. https://doi.org/10.1134/S0965542524701021
Novikov, A., Vũ, N., Eisenberger, M., Dupont, E., Huang, P.-S., Wagner, A. Z., Shirobokov, S., Kozlovskii, B., Ruiz, F. J. R., Mehrabian, A., Kumar, M. P., See, A., Chaudhuri, S., Holland, G., Davies, A., Nowozin, S., Kohli, P., & Balog, M. (2025). AlphaEvolve: A coding agent for scientific and algorithmic discovery [White paper]. arXiv. https://doi.org/10.48550/arXiv.2506.13131
Romera-Paredes, B., Barekatain, M., Novikov, A., Balog, M., Kumar, M. P., Dupont, E., Ruiz, F. J. R., Ellenberg, J. S., Wang, P., Fawzi, O., Kohli, P., & Fawzi, A. (2024). Mathematical discoveries from program search with large language models. Nature, 625(7995), 468–475. https://doi.org/10.1038/s41586-023-06924-6
Top comments (0)