AlphaEvolve: DeepMind's Gemini-Powered Algorithm Agent

What AlphaEvolve actually does

At its core, AlphaEvolve is an automated algorithm discovery system. You give it a problem — say, "write a faster implementation of this linear algebra kernel" — and it iteratively generates candidate solutions, evaluates them against an automatic scoring function, selects the best-performing variants, and uses those as the basis for the next generation of mutations. The loop runs until it converges on something that genuinely outperforms the prior best-known approach.

The architecture relies on two Gemini 2.0 models playing complementary roles. Gemini 2.0 Flash handles breadth: it generates large numbers of candidate algorithm variants quickly, exploring the search space widely without dwelling on any single direction. Gemini 2.0 Pro handles depth: once Flash has identified promising directions, Pro refines those candidates more carefully, reasoning through the implications of specific implementation choices and producing higher-quality code for evaluation.

This division mirrors how skilled engineering teams work — a broad generative phase to surface ideas, followed by a focused refinement phase to turn the best ideas into production-quality implementations. By using two models optimised for different trade-offs (speed versus quality), AlphaEvolve gets the benefits of both without paying the full cost of running Pro on every generation.

The evolutionary search component is not a simple hill-climber. The system maintains a population of candidate algorithms, applies crossover (combining elements from two high-performing candidates) and mutation (making targeted modifications to a single candidate), and uses tournament selection to decide which variants survive to the next generation. This gives it the ability to escape local optima that would trap a greedy search, because a candidate that performs slightly worse in the short term may carry genetic material that enables a breakthrough several generations later.

The evaluation function is the critical ingredient. AlphaEvolve cannot use natural language feedback — it needs a deterministic, automated metric it can run thousands of times. For kernel optimisation, that metric is wall-clock runtime on target hardware. For scheduling, it is a simulation of data-centre utilisation. The quality of the metric shapes the quality of the discovered algorithms, which is also one of the system's key limitations (more on that below).

DeepMind published the full AlphaEvolve paper and blog post in April–May 2026. The blog is available at deepmind.google/blog and covers the architecture, training process, and evaluation methodology in detail.

The benchmark results

The numbers DeepMind has published are significant enough to warrant careful examination. Three results stand out: two are about ML infrastructure performance, one is about compute resource allocation at planetary scale.

Target	Speedup / Improvement	What it means in practice
Gemini training kernel	+23%	A core operation in Gemini's training loop runs 23% faster with AlphaEvolve's discovered implementation, reducing training wall-clock time and compute cost at Google's scale.
FlashAttention kernel	+32.5%	The attention computation — used in virtually every Transformer-based model — is 32.5% faster with AlphaEvolve's kernel, benefiting both training and inference across the ecosystem.
Data-centre scheduling	~0.7% global compute recovered	A new job-scheduling algorithm improved how Google assigns computational workloads to hardware, recovering approximately 0.7% of worldwide compute capacity from previously inefficient allocation.

The FlashAttention result is the one with the broadest downstream impact. FlashAttention is not a Google-proprietary implementation — it is an open algorithm used across virtually every serious ML training and inference stack. A 32.5% speedup on the attention kernel translates directly to faster training runs and lower inference latency for any system using Transformer attention, which in 2026 means essentially all frontier models.

The training kernel result is harder to assess from outside Google, because the specific kernel is not publicly specified. A 23% speedup on a key operation in Gemini's training loop is significant, but the baseline and the nature of the kernel matter. At Google's scale, however, even single-digit percentage improvements in training efficiency translate to tens of millions of dollars in annual savings.

The scheduling result is the most remarkable in some ways. Recovering 0.7% of global compute through algorithmic improvement — without adding a single server — is a demonstration that the value of better algorithms can rival the value of additional hardware at sufficient scale. It also illustrates that AlphaEvolve's applicability extends well beyond ML kernels into classical operations research problems.

How evolutionary code search works

The evolutionary search paradigm in AlphaEvolve is worth understanding in detail, both because it explains why the system works and because it illuminates where it is likely to apply beyond DeepMind's published use cases.

The loop has four phases that repeat across generations:

Generate. Gemini 2.0 Flash takes the current population of candidate algorithms as context — along with their evaluation scores — and generates a batch of new variants. Some variants are mutations (modifications of a single candidate), some are crossovers (combinations of elements from two candidates), and some are entirely fresh proposals prompted by the task description. Flash's speed makes it practical to generate hundreds of candidates per generation.

Evaluate. Each candidate is run against the automated evaluation function. For a kernel optimisation task, this means compiling and benchmarking the candidate on the target hardware. For scheduling, it means running the candidate through a simulation of the data-centre workload. The evaluation is fully automated — no human judgement is involved in this phase. This is what makes the loop fast enough to be practical: evaluations that would take a human engineer a day can run in seconds.

Select. The population is updated using tournament selection: candidates are drawn in groups, and the highest-scoring candidate in each group survives to the next generation. This maintains diversity — weak candidates are not all eliminated at once — while ensuring that strong candidates are reliably retained and propagated.

Refine. Gemini 2.0 Pro takes the top-performing survivors and applies deeper reasoning to refine them. Where Flash generates broadly, Pro reasons carefully — checking for off-by-one errors, thinking through cache-access patterns, optimising loop structures. The refined candidates go back into the population for the next generation.

A rough pseudocode representation of the loop makes the structure clear:

# AlphaEvolve — evolutionary algorithm search (conceptual pseudocode)

population = initialise_population(task_description)

for generation in range(MAX_GENERATIONS):
    # Breadth: generate many variants quickly
    candidates = []
    for _ in range(POPULATION_SIZE):
        parent_a, parent_b = tournament_select(population, k=5)
        op = random.choice(['mutate', 'crossover', 'fresh'])
        if op == 'mutate':
            candidate = flash.generate(f"Improve this algorithm:\n{parent_a.code}")
        elif op == 'crossover':
            candidate = flash.generate(
                f"Combine the best of these two:\n{parent_a.code}\n---\n{parent_b.code}"
            )
        else:
            candidate = flash.generate(task_description)
        candidates.append(candidate)

    # Evaluate all candidates automatically
    scores = [evaluate(c, benchmark_harness) for c in candidates]
    for c, s in zip(candidates, scores):
        c.score = s

    # Select survivors (tournament selection preserves diversity)
    population = tournament_selection(candidates + population, size=POPULATION_SIZE)

    # Depth: refine top performers with Pro
    top_k = sorted(population, key=lambda c: c.score, reverse=True)[:TOP_K]
    for candidate in top_k:
        candidate.code = pro.refine(
            f"You have a high-scoring algorithm. Reason carefully and improve it further.\n{candidate.code}",
            evaluation_context=candidate.score
        )
        candidate.score = evaluate(candidate, benchmark_harness)

best = max(population, key=lambda c: c.score)
return best.code

The key insight is that the system is not trying to understand algorithms the way a human engineer does. It is searching a vast space of possible implementations using a combination of model-generated creativity and fitness-guided selection. Human engineers might explore ten or twenty approaches in a week; AlphaEvolve explores thousands per hour, evaluated against the ground truth of measured performance rather than human intuition.

Why this matters for builders

For most engineers, AlphaEvolve's most immediate relevance is not in the specific algorithms DeepMind discovered but in what the approach implies for performance-critical code more broadly. Two categories of work are most directly affected.

The first is numerical kernel development. If you are writing CUDA kernels, TPU XLA code, or any low-level numerical operations that run millions of times per second, the quality of the implementation has compounding effects on total compute cost. Hand-optimising these kernels is skilled, time-consuming work. AlphaEvolve represents a credible path to automating at least part of that search — not replacing the engineer who knows the hardware intimately, but dramatically accelerating the search over implementation variants they would have had to test one by one.

The second is infrastructure optimisation. The scheduling result — 0.7% of global compute recovered — demonstrates that algorithmic improvements to how workloads are allocated to hardware can rival the gains from buying more hardware. For teams managing significant cloud infrastructure, even a 0.5% improvement in utilisation across a large cluster translates to meaningful cost reduction. The AI-driven approach to discovering these improvements is now a demonstrated technique, not a theoretical one.

For builders in India, there is a particularly strong angle here. Indian cloud infrastructure costs remain higher per FLOP than US or European equivalents, and GPU availability in the subcontinent is still constrained compared to peak demand. Any technique that extracts more work from existing hardware — whether through better scheduling, faster kernels, or improved memory efficiency — has direct economic impact on builders who cannot simply add servers as freely as a US hyperscaler can. The combination of AlphaEvolve-style kernel optimisation with inference compression techniques could meaningfully change the economics of production AI in compute-constrained markets.

For UK research computing — particularly groups with AIRR allocations or access to the UKRI national supercomputing facilities — the scheduling result is instructive. Academic HPC schedulers are notoriously conservative, often leaving significant idle capacity on the table due to poorly matched job queues and over-conservative resource reservations. An AlphaEvolve-style approach to scheduling policy discovery is a natural next application, and one that would benefit a wide range of research groups without requiring any changes to the underlying hardware.

The broader implication for AI builders is about benchmarks. AlphaEvolve discovered a 32.5% FlashAttention improvement that the research community had not found despite years of focused effort. This is a signal that automated search over implementation space can find improvements in well-studied domains that human-guided exploration misses. Understanding how to read benchmark gaps between reported and real-world performance becomes more important as AI-generated algorithms start populating performance tables.

AlphaEvolve on Google Cloud

AlphaEvolve is available on Google Cloud via an Early Access Programme, as announced at Google Cloud Next. The service is accessible through the AI Platform surface, and is initially targeted at customers with well-defined numerical or scheduling optimisation problems — the sweet spot where the automatic evaluation function is easy to specify and the search space is tractable.

The practical requirements to use AlphaEvolve are straightforward to describe but non-trivial to satisfy. You need a problem that can be expressed as: "here is an initial algorithm implementation; here is a benchmark harness that scores implementations automatically; find a better implementation." The system handles the search and refinement; you are responsible for the quality of the benchmark harness, because that is the ground truth AlphaEvolve optimises against.

Full details are available at cloud.google.com/blog. At time of writing, the service is in an early-access phase with enterprise customers, with broader availability expected later in 2026. Pricing has not been publicly disclosed; expect it to be consumption-based, likely on the number of evaluation calls and Gemini API usage the search loop consumes.

For smaller teams or researchers who want to experiment with the approach before enterprise access is widely available, the published architecture is detailed enough to build a prototype using the Gemini API directly. You would need to implement the evolutionary loop yourself, but the key components — Flash for breadth, Pro for refinement, tournament selection, automated evaluation — are all accessible via standard API calls. This is a non-trivial engineering project, but it is well within the reach of a competent ML engineer working with the published paper as a guide.

Limitations and open questions

AlphaEvolve's published results are genuinely impressive, but it is worth being clear about what the system cannot do and where the published evidence is thinner.

It requires an automatic evaluation function. This is the binding constraint. AlphaEvolve cannot improve an algorithm whose quality can only be assessed by a human. If your optimisation problem involves user experience, aesthetic judgement, or any metric that requires manual evaluation, the system as described cannot be applied directly. The practical implication is that AlphaEvolve works best for problems that are already well-quantified — runtime, memory, throughput, utilisation — and is much harder to apply to problems where the objective function itself is the hard part.

The search space needs to be bounded. Evolutionary search over arbitrary code is exponentially large. AlphaEvolve works because the problems it has been applied to — kernel implementations, scheduling policies — have natural constraints that make the search space manageable: the code must compile, must produce correct outputs (verified by test cases), and must be evaluable in reasonable time. Open-ended code generation without these constraints is a much harder problem.

Generalisation beyond Google's infrastructure is unproven at scale. The published benchmarks are for Google's specific hardware configurations and workloads. The FlashAttention result is the most broadly generalisable, since FlashAttention is hardware-independent in principle. The training kernel and scheduling results are Google-specific. Whether AlphaEvolve produces comparably significant improvements for non-Google hardware and workloads is an open question — the architecture should generalise, but the magnitude of gains is unknown.

The system is not open-source. This limits independent verification of the published results and prevents the research community from building directly on the implementation. Several groups are working on open analogues, and the published architecture description is detailed enough to guide those efforts, but the gap between a research prototype and a production system that reliably discovers 30%-class improvements is significant.

The relationship to traditional compiler optimisation is underexplored. Modern compilers — particularly LLVM and XLA — already perform substantial algorithmic search over implementation variants. AlphaEvolve operates at a higher level of abstraction (it modifies algorithmic structure, not just code-generation choices), but the interaction between AlphaEvolve-discovered algorithms and compiler back-ends is an interesting open question. It is possible that some of the gains come from discovering implementations that happen to interact well with compiler optimisations rather than from the algorithm itself — a distinction that matters for generalisability.

None of these limitations diminish the significance of what DeepMind has demonstrated. But they are important for builders thinking about where and how to apply similar techniques to their own problems. The most productive framing is: AlphaEvolve is a powerful tool for a specific class of well-defined optimisation problems, not a general solution to all algorithmic improvement tasks.