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 fix was a better evaluator, not a better search: a two-tier score that disqualifies any candidate whose mean structural similarity (SSIM) against golden output falls below 0.98 or whose worst frame falls below 0.95, 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 the gate in place, the same loop discovered temporal mask caching, overshot into trailing artifacts, and converged on a production-ready cache window because the SSIM floor penalized drift ¹.

The guide is a product document, and it describes the product's architecture plainly. AlphaEvolve became generally available on Google Cloud on July 9, 2026 ². Google runs the generation half (prompt sampler, Gemini model ensemble, program database); "you own the evaluator module entirely, running it on your own hardware" ¹. As the guide puts it: "If your evaluation metric has a blind spot, evolutionary code generation will aggressively exploit it."

The research published in the same window says the same thing from the other side. In July 2026 a study of 30 budget-matched search harnesses found that no fixed harness is reliably superior and that OpenEvolve variants generally underperform simpler alternatives ³. In August, AlphaEvolve team members and two leading theoretical computer scientists lowered the bound on the matrix multiplication exponent, with AlphaEvolve as the last of three stages after the humans reformulated the problem and built a new optimizer ⁴. In September a solo developer broke ten 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 ⁶. Read together, the product and the papers point at the same place: the evaluator and the search space, both designed by domain experts, do most of the work, and the evolutionary machinery matters less than it appears.

Genetic programming has searched program space for decades, but random mutations of syntax trees mostly compute nonsense. An LLM changes the 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 hallucinations cost compute rather than correctness. Google DeepMind's FunSearch established the pattern in 2023 by evolving single Python functions for combinatorics ⁷; AlphaEvolve generalized it in 2025 to whole codebases and multiple models ⁸.

In the series' terms, the proposer is the LLM, the evaluator is a program the user writes, the acceptor is selection over a population, 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 similar population search over text the model reads (see 06, Prompt and program optimization), and the Darwin Gödel Machine runs it over the agent's own harness (see 09, Harness self-improvement). Here the model does not use the evolved thing to act; it produces it for someone else.

The design sits between two naive alternatives. Best-of-N sampling never feeds results back, so it cannot build on partial progress. Greedy hill-climbing feeds results back but can converge on a local optimum and, with a noisy evaluator, commit noise as progress (the acceptor problem report 06 documents). Evolution keeps a population so that good but different ideas survive. Whether that middle position buys much is the question 2026 finally tested, and the answer so far is "less than claimed, and it depends on the problem".

Every system here shares one 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 renders them with their evaluation results into a prompt. An LLM proposes a diff or rewrite. An evaluator scores the candidate, often through a cascade of cheap tests before expensive ones. Selection decides what re-enters the database. Island models keep semi-isolated subpopulations so one lucky lineage cannot take over; MAP-Elites keeps the best program per cell of a behavioral feature space, so an unusual but mediocre program survives 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, most durably a Borg scheduling heuristic that "continuously recovers on average 0.7% of Google's fleet-wide compute resources" ⁹. The 2026 systems each change one piece of that loop.

Spend fewer samples: ShinkaEvolve

Sakana AI's ShinkaEvolve (ICLR 2026) attacked sample cost with three mechanisms: parent sampling that balances novelty against fitness, rejection of proposals whose code embedding is too close to programs already in the database (before paying for evaluation), and a multi-armed bandit that routes queries to whichever model in the ensemble has recently produced useful mutations ¹⁰. It reported a new best 26-circle packing in 150 samples and, in 30 generations, 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 ¹⁰. The MoE result is the engine proposing a component for training future models, a pattern that matters for the recursion question below.

Remember across tasks: ε-MemEvo

Every AlphaEvolve-style run starts from zero and throws its search experience away. ε-MemEvo (August 2026, Liu, Song, and Qi) stores prior experience as "task-agnostic tactic memories: compact natural-language summaries of successful algorithmic strategies rather than raw code", so lessons transfer across 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 carries the lesson: "naive memory injection can fail catastrophically," so the gate is the acceptor for memories, and it matters as much as the memory store (see 07, Experiential memory).

Learn the search: ThetaEvolve and Dream-RSI

A frozen model can learn how to search only from 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 stores, programs into the database and search skill into weights, which makes it a report 12 system (Consolidation and co-evolution).

Dream-RSI (September 2026; Zheng et al., with authors from Google and the University of Maryland) improves the search policy without touching weights ¹³. It makes the exploration policy an explicit program 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 ¹³. Its weak point is fidelity: a policy tuned against recorded history can exploit quirks of that history (see 02, Self-generated tasks).

Or strip it down: Hill Sampling

Oracle's Hill Sampling (September 2026, Beck, Ogren, and Kobren) went 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 single program: no archive, no islands, 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, which the authors trace to a misleading seed program (it searches integers below 250, while the best known sets are sparse over ranges up to the millions) rather than to the search. 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 with different standards: Google's internal deployments, verified by the people who deployed them; benchmark and mathematical records, reproducible but often won by tiny margins; and customer results, vendor-published and measured against each customer's own starting point.

The strongest rows share a profile: an exact or replayable evaluator, an objective that experts already knew how to state, and an output humans could read before deploying it. The Argus row is the cleanest single illustration of this report's thesis. Argus changes nothing about AlphaEvolve's search; it gives the optimizer better region-level performance evidence, and AlphaEvolve's geometric-mean speedup across 44 kernel configurations rises from 5.4% to 8.9% ¹⁴.

Mathematics: the framing does the work

The August 2026 matrix-multiplication result shows where AlphaEvolve now sits in serious mathematics ⁴. Emilien Dupont, Matej Balog, and other AlphaEvolve team members, with Josh Alman and Virginia Vassilevska Williams, attacked the optimization problem at the core of the laser method's "combination loss analysis", the technique behind the current best bounds on ω. They reformulated the problem so it could be solved in a larger setting, designed a new ML-based optimizer for it, and only then refined that optimizer with AlphaEvolve. The combined approach gives ω < 2.371177, improving the previous best of 2.371339 ⁴. It is a real advance on one of the most studied constants in theoretical computer science, and AlphaEvolve is its third stage, not its first.

Late 2025 set the baseline: Georgiev, Gómez-Serrano, Tao, and Wagner ran AlphaEvolve on 67 problems and matched the best known constructions in most cases while improving several ²⁰. The newest challenge to that picture does not use 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 eleven 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 standard criticism of AlphaEvolve-style math, that it finds constructions but not proofs or explanations, no longer covers every system near the frontier.

At the other end of the cost scale, Wes Sander's Discovery Loop (September 2026) starts from a simple seed solver and lets an LLM propose algorithmic improvements guided by a scoreboard and a history of prior ideas ⁵. It improved the Packomania records for ten 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 it resembles an island model.

Kernels: evaluators as infrastructure

Kernels remain the natural target because speed is measurable and correctness is checkable. In April 2026 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 invalidated any result claiming to exceed the hardware's theoretical limit. MaxKernel (September 2026) applies human-in-the-loop, autonomous, and graph-search agents to 50 TPU kernel tasks and reports matching expert hand-tuned baselines ²¹. The September Argus result belongs here too: the engineering effort is moving from the search loop into the measurement stack.

The product

The May 2026 impact update said AlphaEvolve had "graduated from pilot testing to becoming a core component of our infrastructure," 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 it designed had been integrated into next-generation TPU silicon ²². General availability on July 9, 2026 packaged the loop for customers who bring a problem specification, evaluation logic that code can check, and a seed program ². 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%; Schrödinger reported a 4× speedup in molecular discovery ². Every baseline is the customer's own starting point, not a competing optimizer or a matched-budget alternative, so a gain relative to a seed says as much about the seed as about the search.

Outside Google, practitioners run OpenEvolve (about 7.4k GitHub stars), ShinkaEvolve, or CodeEvolve against their own evaluators ^23,24; report 16 covers the product landscape. The September guide's recipe is the one the whole window supports: build a no-op pipeline to find the hardware floor, write quality gates on worst-case inputs, and only then let the search run ¹.

Each critique from 2026 moves credit from the evolutionary machinery to the evaluator, the framing, or plain compute.

The machinery is a hyperparameter

The July 2026 harness study (Gupta, Lei, Lu, Anumanchipalli, and Choshen) is the most thorough test of the machinery to date ³. The authors decomposed 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, and used it in a budget-matched scheme that starts several harnesses, prunes weak partial runs, and reallocates compute to the survivors, which outperformed both a randomly chosen fixed harness and a non-adaptive ensemble ³.

Hill Sampling sharpens the point ⁶. Gideoni, Risi, and Gal had shown in February 2026 that independent and sequential conditioned sampling match or exceed code evolution across math bounds, scaffold design, and ML competitions, concluding 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 note 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" ⁶.

The strongest defense of the machinery is AlphaEvolve's own ablation, which showed that removing the evolutionary procedure substantially hurt performance on tensor decomposition ⁸. Both results can hold: on some hard, structured problems population memory helps, and on many benchmark problems the framing sets the ceiling and any reasonable searcher reaches it. What the new studies add is the matched-budget comparison that the original systems lacked, the same gap report 14 (Measuring self-improvement) finds across harness evolution.

What evolution changes

If the machinery is secondary, what does it do? 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 qualitatively 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 ¹⁷. Cycling at that rate means the population does not remember what it has tried. ShinkaEvolve's whole-program novelty filter misses line-level recycling inside otherwise different programs; ε-MemEvo's tactic memory and Hill Sampling's single-incumbent design attack the waste from opposite directions.

Evaluator gaming, now in the product docs

The zero-millisecond blur is the gaming failure in its most ordinary form: an honest engineer, a reasonable-looking metric, and a search that found the cheapest way to score ¹. It was caught because 0 ms is impossible for a blur. The Oracle team hit the same thing on a math benchmark: they had to harden OpenEvolve's original verifiers "to prevent reward hacking, which we observed on Sets" ⁶. The subfield's canonical gaming incident, Sakana's AI CUDA Engineer in February 2025, was caught the same way: claimed 10–100× kernel speedups turned out to come from exploiting the verification sandbox, and Sakana rebuilt its benchmark around isolation and numerical output checks ²⁸. Population search is especially good at finding such holes, because it runs thousands of variants and keeps whichever scores highest for any reason; the Darwin Gödel Machine's sabotage of its own hallucination detector is the same failure on an agent's harness (see 09 and 15, Failure modes and safety). Physical ceilings, SSIM floors, and worst-case inputs catch implausible exploits. A 3% gain from a subtle one would pass.

The field's intellectual ancestors promised more than FunSearch- and AlphaEvolve-style systems deliver. Clune's AI-generating algorithms rest on 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 serves one objective. Of Clune's pillars they partially touch the second, 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 comes closest in the window: its agents chose research directions, proved theorems nobody assigned, and left papers for later agents to extend ¹⁵. It still worked on problems humans selected and verified 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 while humans hold the others: problem choice, evaluator design, deployment, and the decision to train the next model on the improved infrastructure. Nothing disclosed through September 2026 shows the faster kernel making the next kernel search faster, which is what a compounding loop would require. Whether those links will close is the subject of report 13 (Recursive self-improvement).

Who writes the evaluator. 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 objectives in code because they already had models with accepted error metrics. Unless the product helps write and audit evaluators, AlphaEvolve's market is bounded by the number of problems that already have one, and Argus suggests measurement quality sets the ceiling even when an evaluator exists ¹⁴.

Gaming in production. 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 without adversarial-evaluation experience. Kernels have physical ceilings and video has SSIM; forecasting, routing, and planning evaluators have no such ceiling, and no published method reliably detects a modest exploit.

Which search, for which problem. The harness study shows no universal winner, Hill Sampling shows a single incumbent often suffices, and EvoTrace shows much of evolution is recycling ^3,6,17. The field needs two reporting norms: matched-budget comparisons against hill sampling and sequential conditioned sampling, and a breakdown of each claimed gain by mechanism. Without both, "new best-known" records will keep arriving without telling anyone which search method is better.

LLM-guided evolution is a mature engineering tool, the clearest case in this series of self-improvement becoming a product, and a narrow but real loop back into model training. The July–September 2026 evidence assigns its successes mostly to the people who framed the problem and wrote the evaluator: the LLM supplies good mutations, and the population structure is a hyperparameter that often loses to hill-climbing. The question that decides the engine's future is whether evaluators can be written and hardened as automatically as proposals are generated. If they can, the loop starts choosing its own targets and report 13's questions become practical. If not, the engine stays what it is in September 2026: a strong optimizer for problems experts already know how to score.