LLM-guided evolutionary search

On September 23, 2026, Google Cloud published a guide to using AlphaEvolve on a live macOS streaming app, written with the consultancy DoIt ¹. The target was a Swift pipeline that runs neural segmentation on each camera frame and renders a blur, all inside a 33.3 ms frame budget at 30 fps. The first runs looked spectacular. "In our early runs, a naive fitness score weighted toward raw latency produced an astonishing speedup: the model simply bypassed blur rendering entirely and returned unmodified frames in 0 ms" ¹.

The team didn't touch the search. They rewrote the score as two tiers: any candidate whose mean structural similarity (SSIM) against golden output falls below 0.98, or whose worst frame falls below 0.95, is disqualified before latency counts. They also tested on worst-case clips, because a candidate "can easily pass an average SSIM gate on static backgrounds while failing completely during quick head turns." With that gate in place, the same loop discovered temporal mask caching, overshot into trailing artifacts, and settled on a production-ready cache window because the SSIM threshold penalized the drift ¹.

The guide is also a clear description of how the product is split. AlphaEvolve became generally available on Google Cloud on July 9, 2026 ². Google runs the generation half (prompt sampler, Gemini model ensemble, program database), and "you own the evaluator module entirely, running it on your own hardware" ¹. The guide's warning follows from that split: "If your evaluation metric has a blind spot, evolutionary code generation will aggressively exploit it." I'd put that sentence at the top of any AlphaEvolve customer's reading, because it tells them exactly which part of the work is theirs.

Research published in the same months supports the guide. A study of 30 budget-matched search harnesses in July found that no fixed harness is reliably superior and that OpenEvolve variants generally underperform simpler alternatives ³. AlphaEvolve team members and two leading theoretical computer scientists lowered the bound on the matrix multiplication exponent, but AlphaEvolve was the last of three stages, after the humans had reformulated the problem and built a new optimizer ⁴.

A solo developer broke 10 Packomania circle-packing records for $27.72 of LLM calls ⁵. And Oracle researchers showed that "Hill Sampling", which keeps only the single best program and samples edits to it, set a new state of the art on the field's standard circle-packing benchmark ⁶. Put next to the product guide, these papers say that the evaluator and the search space, both designed by domain experts, do most of the work, and the evolutionary machinery does less than the headline results suggest.

Genetic programming has searched program space for decades, but random mutations of syntax trees mostly compute nonsense. An LLM is a much better mutation operator. Because it has read a great deal of code and mathematics, its edits are usually valid and often plausible: it swaps a greedy rule for a priority queue, adds a local-search step, or tiles a loop for memory. It hallucinates freely, but an automated evaluator runs every candidate, so a hallucination costs compute and never reaches the output. Google DeepMind's FunSearch established the pattern in 2023 by evolving single Python functions for combinatorics ⁷, and AlphaEvolve extended it in 2025 to whole codebases and multiple models ⁸.

In the series' terms, the LLM proposes changes, a program the user writes evaluates them, selection over a population decides what to keep, and the improvement is stored as code in a database outside the model. The artifact is external to the agent: a scheduling heuristic, a GPU kernel, a combinatorial construction. Prompt optimizers such as GEPA and optimize_anything run a similar population search over text the model reads (see 06), and the Darwin Gödel Machine runs it over the agent's own harness (see 09). Here the model doesn't use the evolved program to act; it writes the program for someone else to run.

Evolution is a middle option between two simpler designs. Best-of-N sampling never feeds results back, so it can't build on partial progress. Greedy hill-climbing does feed results back, but it can get stuck on a local optimum and, with a noisy evaluator, keep noise as if it were progress (report 06 documents that failure in prompt optimization). A population keeps several good but different ideas alive at once. This year people finally tested whether that buys much, and from what I've read the answer is less than the original papers claimed, with a lot of variation by problem.

All the systems here run the same loop. A program database stores each evaluated candidate with its scores. A prompt sampler picks parents, usually a mix of high scorers and diverse ones, and puts them into a prompt along with their evaluation results. An LLM proposes a diff or rewrite. An evaluator scores the candidate, often through a cascade of cheap tests before expensive ones, and selection decides what goes back into the database.

Island models keep semi-isolated subpopulations so one lucky lineage can't take over. MAP-Elites keeps the best program in each cell of a behavioral feature space, so an unusual but mediocre program stays in the database if it is the best of its kind.

AlphaEvolve remains the reference architecture: users mark code blocks anywhere in a codebase and supply an evaluate() function; a Gemini Flash and Pro ensemble proposes diffs; the database combines MAP-Elites with islands; and the prompts themselves co-evolve in a second database ⁸. Its 2025 results came from Google's own infrastructure. The most durable is a Borg scheduling heuristic that "continuously recovers on average 0.7% of Google's fleet-wide compute resources" ⁹. Each of the 2026 systems below changes one part of this loop.

Fig 11.1 · Who owns which half of the loopAlphaEvolve on Google Cloud · 2026

ShinkaEvolve: fewer samples

Sakana AI's ShinkaEvolve (ICLR 2026) goes after sample cost ¹⁰. It samples parents by balancing novelty against fitness. It rejects proposals whose code embedding is too close to programs already in the database, before paying to evaluate them. And it uses a multi-armed bandit to send queries to whichever model in the ensemble has recently produced useful mutations.

It reported a new best 26-circle packing in 150 samples. In 30 generations it also found a mixture-of-experts load-balancing loss that beat DeepSeek's Global LBL, cutting inefficient token routing by 5.81% and raising average performance by 1.73% across seven benchmarks ¹⁰. That second result is a case of the search producing a component for training future models, which comes up again in the section on recursion.

ε-MemEvo: memory across tasks

Every AlphaEvolve-style run starts from nothing and throws its search experience away when it ends. ε-MemEvo (Liu, Song, and Qi, August 2026) keeps prior experience as "task-agnostic tactic memories: compact natural-language summaries of successful algorithmic strategies rather than raw code", so lessons can transfer between tasks with different APIs and evaluators ¹¹. An adaptive gate decides whether to inject a retrieved memory and how strongly. On eight optimization benchmarks, with a GPT-5 backbone and a leave-one-out protocol that excludes the target task's own memories, it improved area under the convergence curve over AdaEvolve on all eight tasks (mean relative gain +8.7%) and early convergence by 9.4% on average ¹¹.

The ablation is the part I'd pay attention to: "naive memory injection can fail catastrophically." The gate that decides whether a memory gets used is doing as much work as the memory store, the same finding 07 reports for agent memory in general.

ThetaEvolve and Dream-RSI: learning how to search

A frozen model can only learn how to search through its prompt. ThetaEvolve (November 2025) runs reinforcement learning on a small open model, DeepSeek-R1-0528-Qwen3-8B, during the search itself, and reported new best-known values on circle packing (2.63598308, against ShinkaEvolve's 2.63598283) and the first autocorrelation inequality ¹². It writes to both places at once, programs into the database and search skill into the weights, so it is also a case of the context-and-weights co-evolution discussed in 12.

Dream-RSI (Zheng et al., with authors from Google and the University of Maryland, September 2026) improves the search policy without touching weights ¹³. It writes the exploration policy as an explicit program that runs above an unchanged coding agent, turns the accumulated discovery history into a replay simulator, "dreams" alternative policies against that history offline, and deploys the best one online. The paper reports competitive discovery quality at substantially lower discovery cost across algorithm engineering, mathematical optimization, and GPU kernel engineering ¹³. The weak point is fidelity: a policy tuned against recorded history can learn to exploit quirks of that history (a failure 02 describes for self-generated tasks).

Hill Sampling: keeping one program

Oracle's Hill Sampling (Beck, Ogren, and Kobren, September 2026) goes the other way ⁶. Built on OpenEvolve, it keeps only the best program found so far, samples candidate edits to it from a frozen open-weight model, and conditions every new sample on that one program. It has no archive, no islands and no diversity mechanism.

With gpt-oss-20b it set a new state of the art on 26-circle packing among published methods in under five hours on eight H100 GPUs. With Mistral-Small-3.1-24B it reached 0.38089767 on Erdős's minimum-overlap problem in 12 hours, beating the AlphaEvolve reference of 0.38092303 (lower is better), though not the best published value ⁶.

On sums and differences of finite sets it reached about 95% of AlphaEvolve's score, as did every other baseline. The authors trace that to a misleading seed program: it searches integers below 250, while the best known sets are sparse over ranges up to the millions. The same paper ran what it calls the largest test, by parameter count, of evolution strategies applied directly to LLM weights at test time, and found that "learning the weights is worse than setting the ES learning rate to zero" ⁶.

The evidence comes in three kinds, and they deserve different amounts of trust. Google's internal deployments are verified by the people who deployed them. Benchmark and mathematical records are reproducible but often won by tiny margins. Customer results are published by the vendor and measured against each customer's own starting point.

The rows I trust most have three things in common: an exact or replayable evaluator, an objective that experts already knew how to write down, and an output humans could read before deploying it. Argus shows what I mean by the evaluator doing the work. It changes nothing about AlphaEvolve's search. It gives the optimizer better region-level performance measurements, and AlphaEvolve's geometric-mean speedup across 44 kernel configurations rises from 5.4% to 8.9% ¹⁴.

Fig 11.1 · Better measurements, same searchArgus + AlphaEvolve · Sep 2026

The matrix-multiplication result from August shows how AlphaEvolve is used in serious mathematics now ⁴. Emilien Dupont, Matej Balog and other AlphaEvolve team members, working with Josh Alman and Virginia Vassilevska Williams, attacked the optimization problem inside the laser method's "combination loss analysis", the technique behind the current best bounds on ω.

First they reformulated the problem so it could be solved in a larger setting. Then they designed a new ML-based optimizer for it. Only then did they refine that optimizer with AlphaEvolve. The combined approach gives ω < 2.371177, improving the previous best of 2.371339 ⁴. That is a real advance on one of the most studied constants in theoretical computer science, and AlphaEvolve came in at the third stage.

The late-2025 baseline was Georgiev, Gómez-Serrano, Tao, and Wagner running AlphaEvolve on 67 problems, matching the best known constructions in most cases and improving several ²⁰. A different design challenged that picture this year without using a program database at all.

The Station (Chung, Du, and Wesley, August 2026) is an open-world environment where agents from different model families choose their own research directions, run experiments, and publish papers that later agents read and cite ¹⁵. On 12 construction problems from the AlphaEvolve study it produced results novel relative to prior literature on five, including a new infinite family of finite-field Kakeya sets, new exact 604-point kissing configurations in 11 dimensions, and a substantially improved bound for Erdős's minimum-overlap problem.

"All presented discoveries are supported by exact constructions or proofs formally verified in Lean," and the agents "proved theorems outside the assigned tasks" ¹⁵. The usual complaint about AlphaEvolve-style math is that it finds constructions but not proofs or explanations. That complaint doesn't apply to The Station.

At the other end of the cost scale, Wes Sander's Discovery Loop starts from a simple seed solver and has an LLM propose algorithmic improvements, guided by a scoreboard and a history of prior ideas ⁵. It improved the Packomania records for 10 values of N between 101 and 114 by 2.4% to 5.4%, all within 15 iterations and $27.72 of LLM spend, and Packomania accepted the results. Nothing in the loop resembles an island model.

Kernels are the natural target because speed is measurable and correctness is checkable. In April, Cursor and NVIDIA ran a planner and autonomous workers for three weeks on 235 CUDA kernels for B200 GPUs and reported a 38% geomean speedup over per-problem SOL-ExecBench baselines, with 149 of 235 problems beating their baseline ¹⁸. The system had no program database, and its evaluator threw out any result claiming to exceed the hardware's theoretical limit.

MaxKernel applies human-in-the-loop, autonomous, and graph-search agents to 50 TPU kernel tasks and reports matching expert hand-tuned baselines ²¹. I read the Argus result from the previous section as a sign of where kernel work is heading: the engineering effort is moving out of the search loop and into the measurement stack.

Google's May 2026 impact update said AlphaEvolve had "graduated from pilot testing to becoming a core component of our infrastructure." It reported a 30% error reduction in genomics, 10× lower error in quantum computing, and power-grid feasibility rising from 14% to 88%, and said a circuit AlphaEvolve designed had been integrated into next-generation TPU silicon ²². General availability on July 9 packaged the loop for customers who bring a problem specification, evaluation logic that code can check, and a seed program ².

The launch came with customer numbers. BASF reported "more than 80% relative improvement in accuracy compared to the initial seed model" for a supply-chain planning and forecasting digital twin ¹⁶. Coolblue improved its 28-day demand forecast by more than 5% on WMAPE in about 200 iterations; FM Logistic improved warehouse routing by 10.4%; JetBrains improved IDE performance by 15–20%; PacBio cut DNA variant-detection errors by 30%; and Schrödinger reported a 4× speedup in molecular discovery ².

The customer numbers say little about the search method. Every baseline is the customer's own starting point, with no competing optimizer and no matched-budget alternative, so a gain over the seed tells you as much about how good the seed was as about the search.

Outside Google, practitioners run OpenEvolve (about 7.4k GitHub stars), ShinkaEvolve, or CodeEvolve against their own evaluators ^23,24. The September guide's recipe matches what the other evidence here supports: build a no-op pipeline to find the hardware's minimum latency, write quality gates on worst-case inputs, and only then let the search run ¹. The other systems published in the window:

Every serious critique this year moved credit away from the population machinery and toward the evaluator, the problem framing, or plain compute. Two papers make the case, and one older ablation argues the other side.

Budget-matched comparisons

The July harness study by Gupta, Lei, Lu, Anumanchipalli, and Choshen tests the machinery directly ³. The authors broke OpenEvolve-style evolutionary search and the TTT-Discover harness into components and evaluated 30 budget-matched harnesses across 12 model-problem pairs, using more than 3.1 million LLM rollouts and repeated-trial statistics. "No fixed harness is reliably superior across the evaluated model-problem pairs, and variants of OpenEvolve generally underperform simpler alternatives." Harness choice, they conclude, "is better viewed as a hyperparameter rather than as a universal recipe."

They also found that early progress predicts final performance. They used that in a budget-matched scheme that starts several harnesses, prunes the weak partial runs, and gives their compute to the rest, and it beat both a randomly chosen fixed harness and a non-adaptive ensemble ³.

Hill Sampling pushes the point further ⁶. Gideoni, Risi, and Gal had shown in February that independent and sequential conditioned sampling match or exceed code evolution across math bounds, scaffold design, and ML competitions, and concluded that "the primary challenge in finding improved bounds is designing good search spaces, which is done by domain experts, and not the search itself" ¹⁹.

The Oracle authors point out that those baselines did not consistently surpass both AlphaEvolve and ShinkaEvolve on any domain Gideoni et al. evaluated. Hill Sampling beats AlphaEvolve's reference on two of its three problems. Its authors' recommendation is blunt: "repeatedly sample edits to the best verified solution found so far, before introducing additional complexity such as adding archives, diversity mechanisms, evolutionary scaffolds, or test-time parameter learning" ⁶.

AlphaEvolve's own ablation argues for the machinery: removing the evolutionary procedure substantially hurt performance on tensor decomposition ⁸. I think both findings are true. On some hard, structured problems a population's memory of different ideas helps. On many benchmark problems, any reasonable searcher reaches the best score the framing allows. The new studies add the matched-budget comparison that the original systems never ran, and report 14 finds the same comparison missing across harness evolution.

On a new problem, I would run Hill Sampling first and add islands or archives only when a budget-matched run showed they helped.

What the edits look like

If the machinery is secondary, what is the search spending its samples on? EvoTrace (Pelleriti et al., May 2026) recorded full traces across four evolutionary frameworks, reasoning and non-reasoning models, and 16 tasks ¹⁷. Benchmark gains came from very different mechanisms: new algorithmic structure, re-tuning an existing strategy, recombining ideas the model already knew, or overfitting to the evaluator.

About 30% of added code lines were byte-identical re-introductions of lines deleted earlier in the same search, in nearly every run, and most gains came from a small subset of nine edit types ¹⁷. At that rate of cycling, the population is not keeping track of what it has already tried. ShinkaEvolve's novelty filter works on whole programs, so it misses line-level recycling inside programs that are otherwise different. ε-MemEvo's tactic memory and Hill Sampling's single incumbent attack the waste from opposite directions, one by remembering more and the other by keeping almost nothing.

The zero-millisecond blur is evaluator gaming in its most ordinary form: a well-meaning engineer, a reasonable-looking metric, and a search that found the cheapest way to score ¹. It was caught because a 0 ms blur is impossible. The Oracle team hit the same problem on a math benchmark and had to harden OpenEvolve's original verifiers "to prevent reward hacking, which we observed on Sets" ⁶. Sakana's AI CUDA Engineer, the subfield's well-known incident from February 2025, was also caught because the numbers were implausible: its claimed 10–100× kernel speedups came from exploiting the verification sandbox, and Sakana rebuilt its benchmark around isolation and numerical output checks ²⁸.

Population search is especially good at finding holes like these, because it runs thousands of variants and keeps whichever scores highest for any reason. The Darwin Gödel Machine sabotaging its own hallucination detector is the same failure on an agent's harness (see 09 and 15). Physical limits, SSIM thresholds and worst-case inputs catch exploits that produce impossible numbers. A 3% gain from a subtle exploit would pass all of them, and this is the failure I worry about most as the product spreads.

The field's intellectual ancestors promised more than these systems deliver. Clune's AI-generating algorithms have three pillars: meta-learning architectures, meta-learning the learning algorithms themselves, and generating effective learning environments ²⁹. Hughes et al. define open-endedness through novelty and learnability with respect to an observer and argue it is essential for superhuman AI ³⁰.

FunSearch- and AlphaEvolve-style systems are goal-directed. The evaluator is fixed, and diversity exists to serve one objective. Of Clune's pillars they touch the second in part, through ε-MemEvo's cross-task tactics, Dream-RSI's learned exploration policy and ThetaEvolve's trained searcher, and they never invent their own problems. The Station came closest this year: its agents chose research directions, proved theorems outside their assigned tasks, and left papers for later agents to build on ¹⁵. It still worked on problems humans selected, and humans checked the results in Lean.

On recursion the facts are narrow. In May 2025 Google DeepMind disclosed that AlphaEvolve sped up a kernel in Gemini's architecture by 23%, cutting Gemini training time by 1%, and that this "accelerated the training of the LLM underpinning AlphaEvolve itself" ^9,8. ShinkaEvolve found a training loss component for MoE models ¹⁰. ThetaEvolve updates the searcher's weights from search outcomes ¹², and Dream-RSI improves its exploration policy from its own history ¹³.

Each closes one link in the loop, and humans still hold the others: choosing the problem, designing the evaluator, deploying the result, and deciding to train the next model on the improved infrastructure. Nothing disclosed through September 2026 shows a faster kernel making the next kernel search faster, which is what a self-accelerating loop would need.

Can the product help customers write evaluators? General availability moved the hardest part of the loop to the customer, and Google's own guide spends most of its length on evaluator craft ¹. BASF and Coolblue could state their objectives in code because they already had models with accepted error metrics. Unless the product helps write and audit evaluators, AlphaEvolve's market is limited to problems that already have one, and Argus suggests that even with an evaluator, the quality of the measurements limits how far the search gets ¹⁴.

The engine's future depends on whether evaluators can be written and hardened as automatically as proposals are generated. If they can, the loop can start choosing its own targets and the recursion questions in 13 become practical. If they can't, it stays a strong optimizer for problems experts already know how to score.

How would anyone catch a modest exploit in a business metric? Every published gaming case in this subfield was caught because the claimed gain was implausible. Enterprise deployments optimize business metrics over months, with evaluators written by teams that have no experience with adversarial evaluation. Kernels have physical limits and video has SSIM. Forecasting, routing and planning evaluators have no equivalent bound, and I couldn't find a published method that reliably detects a modest exploit.

Which search should I use for my problem? The harness study found no universal winner, Hill Sampling found a single incumbent is often enough, and EvoTrace found that much of evolution is recycling ^3,6,17. Two reporting habits would help: comparing every new method at a matched budget against hill sampling and sequential conditioned sampling, and breaking each claimed gain down by mechanism. Without both, new best-known records will keep arriving without telling anyone which search method is better.