AlphaEvolve in Borg before the paper: the concrete wins

Does AlphaEvolve's Evolutionary Search Work in Production?

Yes. Several AlphaEvolve outputs were running inside Google's production systems for over a year before the white paper appeared, and they were still recovering measurable compute when the work was published . AlphaEvolve was announced on the DeepMind blog on 14 May 2025 and described formally in arXiv:2506.13131 .

Quick Answer: AlphaEvolve is an evolutionary coding agent that pairs Gemini models with a programmatic evaluator. It is proven in production: its cluster-scheduling heuristic has run fleet-wide at Google for over a year, on average recovering 0.7% of worldwide compute that would otherwise be stranded.

The mechanism matters more than the label. AlphaEvolve is not "AI writes code" — it is an LLM generating candidates inside a closed, verifiable loop. Gemini Flash supplies fast, broad ideation while Gemini Pro produces deeper, higher-quality proposals; both feed a shared evolutionary program database. Each generated program is executed, scored by a programmatic evaluator, and selected for future mutation using strategies such as MAP-Elites and island-based populations . The LLM proposes; the evaluator decides what survives. That grounding in hard metrics is what suppresses hallucination.

It is also a sharp step up from DeepMind's earlier FunSearch. Where FunSearch evolved a single small Python function against one metric and needed millions of samples, AlphaEvolve:

• evolves whole files or entire codebases in any language;
• optimizes multiple objectives simultaneously;
• runs hours of parallel evaluation per candidate on accelerators;
• converges in roughly 1,000 samples rather than millions .

The constraint is the part teams should internalize before adopting it. AlphaEvolve is powerful exactly where evaluation is fully programmatic — latency, correctness, cost — and degrades where judging an output needs human judgment or physical experimentation . As the lead authors put it in the white paper:

"AlphaEvolve makes it possible to evolve entire codebases and develop much more complex algorithms," — Alexander Novikov and Matej Balog, AlphaEvolve white paper, Google DeepMind (source: arXiv:2506.13131).

In short: if you can write a fast, honest evaluator for your objective, the loop works. If you can't, the most impressive parts of AlphaEvolve don't transfer. The sections that follow trace where that fast evaluator existed — Borg, TPU kernels, hardware RTL, and open mathematics — and what each win actually delivered.

Borg Cluster Scheduling: The Fleet-Wide Heuristic Win

The clearest production win is cluster scheduling. AlphaEvolve evolved the machine-ranking heuristic inside Borg, Google's cluster manager, and the rewritten heuristic now recovers, on average, 0.7% of Google's worldwide compute that would otherwise sit stranded. Borg runs hundreds of thousands of jobs from many thousands of applications across clusters of up to tens of thousands of machines , so a sub-1% utilization gain is a large absolute result.

Quick Answer: AlphaEvolve rewrote Borg's machine-ranking heuristic, the function that scores which server should run a pending job. The evolved version has run in production for over a year and recovers on average 0.7% of Google's worldwide compute capacity from stranding .

The reason this worked maps directly to the evaluator argument: the search space was valid by construction. Borg already runs correctness filters that decide which machines can host a job given its CPU and memory requirements. AlphaEvolve only scored machines Borg had pre-approved, so the loop never had to reason about feasibility — it optimized ranking quality among options that were guaranteed runnable . The heuristic takes pending-job resource demands and per-machine free resources and emits a score; that scalar is exactly the kind of hard, automatable metric the evolutionary loop needs.

Training and rollout were staged conservatively. An early AlphaEvolve version evolved the heuristic against a simulator fed historical fleet snapshots, was then validated on unseen recent workloads, and only after it beat the incumbent was it rolled out fleet-wide . The paper is explicit that this is a deployed result, not a benchmark: the heuristic had been in production for over a year by the May 2025 announcement .

One detail worth flagging for builders: a human-readable heuristic is part of the value. The evolved function is code engineers can inspect, reason about, and maintain — not a black-box model spliced into the scheduler.

"AlphaEvolve discovered a heuristic ... that has been in production for over a year, and on average continuously recovers 0.7% of Google's worldwide compute resources." — Alexander Novikov and Matej Balog, AlphaEvolve team, Google DeepMind (source: DeepMind blog)

The takeaway is not that an LLM "wrote a scheduler." It is that a measurable objective (utilization), a fast simulator, and a feasibility filter that bounded the search were all in place — and the loop exploited them . The next section moves to a domain where the metric is wall-clock runtime: TPU kernels.

TPU Arithmetic Tiling and XLA Transformer Efficiency

On TPU kernels, AlphaEvolve produced two deployed speedups by optimizing against wall-clock runtime rather than a proxy metric. The headline result is a Pallas/JAX matrix-multiplication kernel used in Gemini training: AlphaEvolve evolved the tiling heuristic — the rule that splits a large matmul into accelerator-friendly blocks — and delivered a 23% average speedup over the expert-designed baseline, measured across realistic user input shapes and pushed into production . The evaluator here is unambiguous: real runtime on real hardware over the shape distribution the kernel actually sees, so the search optimizes the thing engineers care about instead of a simplified model of it.

That kernel-level gain compounds. The 23% tiling improvement translated to roughly a 1% reduction in Gemini's overall training time . The same Gemini model family supplies the LLMs that drive AlphaEvolve's proposal step, so this is a documented loop where a model helps train its own successors — recursive self-improvement with a measured number attached, not a slogan.

The second win targets inference. AlphaEvolve rewrote the XLA-generated intermediate representation around FlashAttention for a transformer running at GPU-inference scale, reporting up to a 32.5% speedup on the target attention pass plus a 15% speedup in pre/postprocessing, and this too was deployed . Working at the compiler-IR level is notable: AlphaEvolve edits code that humans rarely touch by hand, where small structural changes can shift performance substantially.

One caveat the paper is explicit about: both results are tied to specific configurations — particular TPU input shapes and one FlashAttention setup — and it does not claim the figures transfer to arbitrary hardware or workload shapes . The method finds a strong solution for the distribution you evaluate against; change the shapes and you re-run the loop. That is a feature for teams with a fixed, measurable target, and a limit for anyone hoping for a portable kernel. AlphaEvolve's own contributors frame the approach as exactly this — LLM proposals inside a verified search loop (video: AlphaEvolve explained). The next section turns from systems engineering to pure mathematics, where the metric becomes correctness itself.

Strassen Surpassed: Tighter Bounds on 4×4 Complex Multiplication

When correctness is the metric, AlphaEvolve produces algorithmic novelty, not parameter tuning. Its headline result is a procedure to multiply two 4×4 complex-valued matrices using only 48 scalar multiplications, down from the prior best of 49 — the first improvement in that setting since Strassen's 1969 algorithm, a 56-year gap . Cutting a single multiplication may sound marginal, but matrix-multiplication exponents compound recursively, so the structural change matters more than the count.

The breadth is what makes the result credible rather than a one-off. Across more than 50 open problems in mathematics, AlphaEvolve matched the best-known solution in roughly 75% of cases and improved on the state of the art in about 20% . One of those improvements was a new lower bound for the kissing number in 11 dimensions: a configuration of 593 outer spheres against the previous 592 . These are existence results — a valid construction either checks out or it does not — which is exactly the regime where a verified search loop suppresses hallucination.

The same logic extends back into hardware. AlphaEvolve proposed a Verilog rewrite for a heavily optimized arithmetic circuit inside a TPU matrix-multiplication unit, removing unnecessary bits while preserving function under formal verification; TPU designers validated it and slated it for an upcoming chip . Notably, downstream synthesis tools independently caught the same simplification — so the contribution is timing, not discovery: AlphaEvolve surfaced the RTL change earlier in the design flow and in engineers' native Verilog.

"AlphaEvolve was able to find an algorithm to multiply 4×4 complex-valued matrices using 48 scalar multiplications, improving upon Strassen's 1969 algorithm," — Alexander Novikov and Matej Balog, Google DeepMind (source: arXiv:2506.13131).

Crucially, the mathematics is checkable on your own machine. Google released a results repository with a Colab notebook and verification code for the combinatorial discoveries . That is distinct from AlphaEvolve's execution code, which remains private — you can confirm the answers without being able to rerun the search.

OpenEvolve, Homomorphic Encryption, and Reproducibility

The execution code stays private, but the mechanism is reproducible in spirit, and independent teams are now showing it transfers. Google's public release covers only the math: a results repository with a Colab notebook and verification code for the combinatorial discoveries, explicitly excluding the code that runs AlphaEvolve's search loop . There is no general product access; DeepMind's stated path is an early-access program aimed at academics, so most builders will not run AlphaEvolve itself .

The most consequential transfer result is in cryptography, where hallucinated code is a safety hazard rather than a bug. A 2026 Google / Georgia Tech / DeepMind effort adapted the approach to fully homomorphic encryption kernels on Google Cloud TPUv5e, using hardware-in-the-loop latency measurement plus rigorous correctness tests. Within 24 hours it improved TFHE bootstrap latency by 2.5×, and CKKS rotation and multiplication latency by 1.31× and 1.18× over human-engineered state of the art . That the gains hold under formal correctness checks is the point: the verifiable loop is what keeps generated kernels trustworthy in a domain where a silent error breaks the encryption guarantee.

Open-source reimplementations have moved faster than Google's release. OpenEvolve rebuilds the pattern with distributed evolution, multi-language and multi-provider support, and GPU-kernel discovery; AMD's ROCm team has deployed it as an MCP tool for HPC code optimization . CodeEvolve, revised 28 May 2026, claims an open-source framework that matched or surpassed reported AlphaEvolve results on 5 of 9 benchmark problems .

Read that carefully: independent reproduction is partially underway, not confirmed end to end. Matching 5 of 9 published benchmarks is a credible signal that the loop generalizes, but it is not the same as rerunning Google's production results. For now, the honest summary is that the idea is portable and the original system is not.

Applying the Pattern: When Evolutionary Search Helps Your Project

The transferable lesson from AlphaEvolve is structural, not magical: it works wherever you can write a fast, programmatic evaluator. The enabling condition is a cheap automated metric — a latency measurement, a correctness test suite, or a cost function — that scores each generated variant without a human in the loop. Without that, the evolutionary selection loop cannot close, because there is nothing to select on. AlphaEvolve reframes the LLM as a component inside an optimization harness rather than an end-to-end code generator: Gemini proposes variants, an evaluator scores them against a hard metric, the best survive, and the cycle repeats . Any team with a measurable objective and a reliable evaluator can replicate that shape.

Be honest about the open questions before you budget time for it. The white paper does not disclose the compute cost of the LLM-plus-orchestration loop, so the price of a run is unknown . Transferability outside domains with cheap, high-fidelity evaluators is unproven at scale. And the Borg result carries a hidden variable: the heuristic was evolved against simulator feedback from historical fleet snapshots before fleet-wide rollout, so simulator-versus-real-hardware fidelity matters for anyone copying that setup .

As one practitioner summarizing the design put it, "the breakthrough isn't that an LLM writes code — it's that the code is graded by a machine before anything ships" (video: AlphaEvolve explained). That captures the practical bar precisely.

Concrete starting points as of June 2026: OpenEvolve, an open-source, MCP-compatible re-implementation already used by AMD's ROCm team for HPC code optimization , and the Google Colab verification notebook for inspecting the published math discoveries. The AlphaEvolve execution environment itself stays inaccessible outside a planned academic early-access program . The takeaway: don't wait for Google's system. Pick one objective you can score automatically, wire an LLM into a generate-evaluate-select loop with OpenEvolve, and let the metric — not the model — decide what ships.

참고 영상 / Watch / Sources

• AlphaEvolve explained — AlphaEvolve: Using LLMs to solve Scientific and Engineering Challenges
• Veritasium — AlphaFold - The Most Useful Thing AI Has Ever Done

Frequently asked questions

How is AlphaEvolve different from just prompting an LLM to optimize code?

AlphaEvolve uses Gemini models only to generate candidate programs; a separate programmatic evaluator executes and scores each one, and that score — not the model's confidence — feeds back into evolutionary selection . The LLM never treats its own output as ground truth, so in any domain where correctness or performance can be measured automatically (latency, scalar-multiply count, kernel runtime), hallucinated code is simply selected out. A raw "optimize this" prompt has no such loop: it returns plausible text with no verification, no scoring, and no iterative pressure toward a hard metric.

What is the 0.7% compute recovery in Borg, and why does it matter?

AlphaEvolve evolved the machine-ranking heuristic inside Borg, Google's cluster manager, that scores which capable machine should run a pending job, reducing resources that would otherwise be stranded. It recovers on average 0.7% of Google's worldwide compute fleet-wide . Across clusters of up to tens of thousands of machines, a sub-1% utilization gain is a material infrastructure result. It is not a benchmark: the heuristic has run in production for over a year, predating the paper's June 2025 publication .

Is AlphaEvolve's code publicly available?

No. Google released a results repository with a Colab notebook and verification code for the mathematical discoveries, but it explicitly excludes the code needed to run AlphaEvolve itself . Broad product access is limited to a planned early-access program for academics. The closest you can run today is OpenEvolve, an open-source re-implementation with the same generate-evaluate-select architecture plus distributed evolution and multi-provider support .

What kinds of problems is AlphaEvolve suited to?

AlphaEvolve fits problems with fast, programmatic evaluation — where a candidate program can be executed and scored automatically against a hard metric. Demonstrated cases include cluster-scheduling heuristics, TPU kernel tiling, combinatorial optimization across more than 50 open math problems, and fully homomorphic encryption kernel tuning . It is weaker where evaluation is slow, subjective, or requires human judgment or physical experiments, because the evolutionary loop depends on cheap, high-fidelity feedback to drive selection.

What exactly did AlphaEvolve improve about Strassen's algorithm?

AlphaEvolve found a procedure to multiply two 4×4 complex-valued matrices using 48 scalar multiplications, down from 49 — the first improvement in that specific setting since Strassen's 1969 result, a 56-year gap . The result is independently checkable: Google's released Colab notebook includes verification code that confirms the construction .