Every method described below shares one property before it shares anything else: nobody wrote the artifact it produced. A population of candidate programs or networks was generated, tested against a task, thinned by the result, varied again, and tested again, for as many generations as it took — and the thing that survived was read out of the population rather than typed into an editor. That is a different relationship between a builder and a result than software has mostly had, and it is old enough to have a paper trail running back to 1975, not a speculative one invented for this article.
The claim under examination here is narrow and mechanical, not a claim about general intelligence: that evolutionary search over programs — variation, selection, retention, repeated across a population — is a demonstrated way to produce software that works, that it has already produced components running in named production systems, and that the open, contested question is how much further up the stack, from a component to a whole system to a continuously self-modifying population, that method plausibly goes. Some of that is settled by result. Some of it is Kenneth Stanley and Joel Lehman’s specific, disputed argument that stated objectives themselves can block discovery. And some of it is not settled at all, which is why the second half of this article is a scenario with named falsifiers rather than a forecast dressed up as one.
Evolutionary computation is AI’s other founding idea, and it never stopped producing results
John Holland’s 1975 book formalized a claim that reads, five decades on, almost too simple to have needed formalizing: a population of candidate solutions, each scored by a fitness function, can be made to improve across generations through selection, recombination and mutation, without anyone specifying in advance what an improved solution looks like structurally [1]. Holland’s genetic algorithms and Ingo Rechenberg’s roughly contemporaneous evolution strategies, developed from wind-tunnel shape-optimization experiments at the Technical University of Berlin, gave the same basic mechanism two independent starting points on two sides of the Atlantic. Both trace to the same underlying claim, and this publication’s own coverage of the field’s history has already traced that lineage in full; what matters for this article is the mechanism itself, carried forward.
That mechanism is a lineage in the literal, not metaphorical, sense used throughout this article: each method below descends from a specific prior method, inherits its selection procedure with a modification, and is itself superseded by a descendant that changes one further thing. Genetic algorithms selected over fixed-length strings; evolution strategies selected over continuous parameter vectors; the neuroevolution methods below select over network topologies; program-search methods select over executable code. The claim that survives across every branch of that lineage is Holland’s original one — selection over a population is a general search procedure — and the branches differ only in what is being varied and how the fitness of a variant gets measured.
The field spent several decades producing steady, unglamorous results in robotics, scheduling and circuit design before deep learning’s success with gradient descent made evolutionary methods look, to much of the field, like a historical detour. The four demonstrations below are the evidence that the detour reading was wrong: evolutionary search kept producing results that gradient-based methods either could not produce the same way or had not yet been shown to produce, right through the period gradient descent was winning every headline benchmark.
NEAT let a network’s own structure become a product of selection, not a designer’s choice
Kenneth Stanley and Risto Miikkulainen’s 2002 paper on NeuroEvolution of Augmenting Topologies addressed a specific, previously unsolved problem in neuroevolution: earlier methods that evolved both a network’s weights and its topology together tended to destroy useful structure through crossover, because two networks with different topologies have no principled way to align their genes. NEAT solved this with historical markings that track which gene came from which original innovation, letting two differently structured networks be recombined without shredding the substructures that made either of them work [2]. On top of that, NEAT protects a newly emerged structural innovation by placing it in its own species, shielded from having to immediately outcompete an already-optimized topology, and starts every population from minimal structure, adding complexity only when a variation is retained by selection. The paper reports that this combination outperformed the strongest fixed-topology neuroevolution method it was tested against on a demanding benchmark reinforcement-learning task, and states plainly why: fixed-topology methods search a mismatch between a designer’s prior guess at network structure and whatever structure the task actually rewards, while NEAT lets selection discover the structure instead [2].
The mechanism worth naming precisely here is speciation as a defense against a specific kind of lock-in. A designer who fixes a network’s topology in advance has locked in a hypothesis about what shape of computation the task needs, and every later result is conditioned on that hypothesis being close enough to correct. NEAT’s speciation does the equivalent of protecting a young lineage from a mature one long enough for the young lineage’s adaptive value to become visible — a dynamic evolutionary biology has a name for because it is the same dynamic, not an analogy borrowed from it. A structural innovation that would lose a head-to-head fitness comparison against an already-refined competitor on its first generation gets a temporary reprieve, and some fraction of those reprieved innovations go on to displace what came before them. The descendants of this idea — HyperNEAT’s extension to indirectly encoded, very large networks, and the deep neuroevolution work described next — inherited exactly this insight: the search needs a way to keep a new idea alive past the generation where it first looks worse than average, or every new idea dies before it can be judged fairly.
Removing the gradient did not remove the result: evolution strategies reached reinforcement learning’s own benchmarks
In 2017, a team at OpenAI showed that evolution strategies — a black-box optimization method that perturbs a policy’s parameters, scores each perturbation’s resulting reward, and moves the parameters toward the perturbations that scored best, without ever computing a gradient — could match deep reinforcement learning on its own standard benchmarks. Their paper reports solving 3D humanoid locomotion in ten minutes and reaching performance competitive with standard reinforcement-learning methods on most Atari games within an hour of training, using a communication scheme based on common random numbers that let workers coordinate with only scalar messages rather than full parameter updates, scaling the method past a thousand parallel workers [3].
The same year, a separate team including two of NEAT’s intellectual descendants showed the more radical version of the same claim: a genetic algorithm with no gradient anywhere in the procedure, using simple parameter mutation and truncation selection rather than evolution strategies’ smoothed gradient estimate, trained networks with more than four million parameters to competitive performance on Atari and humanoid locomotion tasks, which the authors describe as the largest neural networks evolved by a traditional evolutionary algorithm at the time of publication, training an Atari policy in roughly four hours on a single desktop machine [4]. The same paper reports that combining their genetic algorithm with novelty search — selecting partly for behavioral difference from what has already been tried, not only for reward — solved a high-dimensional deceptive-reward maze task that reward-only algorithms, evolutionary or gradient-based, failed to solve at all [4]. Both results matter for the same reason: they demonstrate that gradient descent’s dominance in deep learning was a claim about efficiency on the problems tried so far, not a claim that gradients are necessary to train a large network at all. Selection pressure applied directly to behavior, with no derivative computed anywhere in the loop, reached comparable results by a mechanically different route.
AutoML-Zero rediscovered a learning algorithm instead of assuming one
Esteban Real and colleagues’ 2020 AutoML-Zero, accepted at ICML that year, pushed the search one level further up the stack than either of the two demonstrations above: instead of evolving a network’s weights or its topology, it evolves the machine learning algorithm itself, starting from a small set of basic mathematical operations and building three-part programs — a setup procedure, a prediction procedure, and a learning-update procedure — with almost no machine learning structure assumed in advance [5]. The paper’s central result is that this search, given nothing but arithmetic primitives, rediscovered something close to a two-layer neural network trained by a form of gradient descent, without ever being told that neural networks or gradient descent existed as concepts. Evolved algorithms went on to incorporate techniques the authors identify as resembling bilinear interactions, gradient normalization and weight averaging, and, notably, the search spontaneously produced a dropout-like regularization procedure specifically when trained on a task with a scarce amount of data, without regularization being named as a goal anywhere in the fitness function [5].
The lock-in this demonstration escapes is the shape of a standard machine learning pipeline itself: the assumption, built into essentially every hand-designed model, that there is a fixed division of labor between initializing parameters, computing a prediction and updating weights, using operations a human ML researcher already considers natural. A search that starts from raw arithmetic has no access to that division of labor as a prior, and cannot inherit whatever blind spots it carries. That the search reconstructed something recognizable as backpropagation is evidence the division of labor is close to load-bearing for this class of problem; that it also invented an unscheduled regularization step under a condition (data scarcity) that the humans specifying the fitness function never named as a target is evidence the search found something the standard pipeline’s designers had to notice and add by hand, arrived at instead as an unplanned byproduct of selection pressure.
POET evolves the test alongside the thing being tested for it
Rui Wang, Joel Lehman, Jeff Clune and Kenneth Stanley’s 2019 Paired Open-Ended Trailblazer removes an assumption every demonstration above still makes: that the task itself is fixed while only the solution evolves. POET instead maintains a growing population of paired environments and solvers, generating new, more difficult environments as a byproduct of the same evolutionary process that trains solvers to handle them, and periodically transferring a solver from one environment to a different one in the population when that transfer improves performance in the new environment [6]. The paper’s central claim is that this joint process produces solvers handling environment challenges that direct optimization against a fixed final environment, attempted on its own, fails to solve — because a fixed hard environment offers no intermediate curriculum for a solver to climb through, while POET’s growing population of environments supplies one as an emergent property of the search rather than a curriculum a human had to design [6].
This is the clearest instance in this article of evolutionary radiation as an operative mechanism rather than a decorative one: POET does not converge toward one increasingly optimized environment-solver pair, it radiates outward into a growing set of environment niches, each holding a solver adapted to it, some lineages of which turn out to be dead ends and some of which turn out to seed a harder niche’s eventual solution. The population’s diversity is not a side effect the authors tolerate; it is the mechanism that produces the curriculum. A single-objective search that tried to define “difficulty” in advance and optimize toward it directly would have to specify the curriculum by hand, reintroducing exactly the design bottleneck the rest of this article’s demonstrations remove one at a time.
Quality-diversity search catalogs a landscape instead of climbing toward one peak
Jean-Baptiste Mouret and Jeff Clune’s MAP-Elites, described in a 2015 paper, changes what a population’s fitness function is even asked to produce: rather than converging a population toward the single highest-scoring solution, MAP-Elites divides a space of user-chosen behavioral dimensions into cells, and maintains, in each cell, the best solution found so far for that specific combination of traits — producing, as an output, a map of many high-performing but qualitatively different solutions rather than one winner [7]. The paper reports the counterintuitive finding that searching this way, across modular neural network, simulated soft-robot and physical-robot design domains, sometimes finds a better single best solution than an algorithm optimizing directly for the best solution alone — exploring the whole landscape occasionally locates a peak that direct hill-climbing missed [7]. A 2016 paper by Justin Pugh, Lisa Soros and Kenneth Stanley names this family of methods quality diversity and states its reframing explicitly: the objective changes from finding an optimum to illuminating a search space, cataloguing what is possible across it rather than climbing toward one summit within it [9].
The most concrete demonstration of why a catalog is worth having, rather than a single optimum, comes from a 2015 paper by Antoine Cully, Jeff Clune, Danesh Tarapore and Jean-Baptiste Mouret, which used a MAP-Elites-style archive, built offline before any damage occurred, to let a legged robot adapt to five different kinds of leg damage, and a robotic arm adapt to fourteen different broken-joint configurations, in under two minutes per case, by searching the pre-built archive for a compensating behavior rather than re-optimizing a control policy from scratch after the damage happened [8]. This is the evolutionary lens applied to time itself: a MAP-Elites archive is a radiation captured and frozen at one moment, and the value it provides later comes precisely from having filled out many niches in advance rather than having driven hard toward the one niche that seemed important when the archive was built. A single-objective search that had instead spent its whole budget optimizing one undamaged gait would have had nothing to query when the robot’s situation changed.
Objectives themselves can block discovery — Stanley and Lehman’s argument, and its strongest limit
Kenneth Stanley and Joel Lehman’s 2015 book states the argument this article has been building toward in its most general and most contested form: that stating an objective and searching directly for it can actively prevent a search from finding a stepping stone that looks unpromising by the objective’s own measure but is required to reach a much better solution later, a phenomenon they call deception, and that in a genuinely open-ended or creative search, abandoning the objective in favor of searching for novelty or for a diverse catalog of behavior can outperform searching for the objective directly [10]. The clearest experimental support for this claim in the demonstrations already covered above is the deceptive maze result: Such and colleagues report that adding novelty search — rewarding behavioral difference from everything already tried, independent of the task’s own score — to their genetic algorithm solved a high-dimensional deceptive task that a fitness-only version of the identical algorithm could not solve at all [4]. That is a controlled, direct comparison, not an anecdote: the only variable changed was whether the search used the stated objective or searched for novelty instead, and the novelty-driven version won on a task purpose-built to punish objective-driven search.
The strongest case against generalizing this claim further than that comparison supports is visible in the rest of this article’s own evidence. NEAT, evolution strategies, AutoML-Zero, POET and MAP-Elites — every headline production-relevant result surveyed here except the one maze experiment above — use an explicit fitness function tied directly to task performance, not novelty search in its pure form. POET pairs its environment generation with a solver fitness that is still task performance inside each environment; MAP-Elites still ranks candidates within each cell by an explicit performance score, and only replaces the cataloguing dimension, not the fitness measure, with something objective-free. Quality diversity’s own reframing, in other words, keeps an objective and adds diversity alongside it, rather than removing the objective the way pure novelty search does. A fair reading of the evidence is narrower than “abandon objectives”: stated objectives demonstrably create deceptive local optima that block search on some class of problems with sparse or misleading reward, and adding a novelty or diversity pressure demonstrably helps on that class of problem, but the field’s own most cited, most reproduced results — the ones cited throughout this article — mostly kept an explicit objective and used it well, rather than dispensing with one. There is a further, harder-to-resolve tension inside quality diversity itself: choosing which behavioral dimensions define the archive’s cells is itself a design decision made by a human before the search runs, which means quality diversity relocates a designer’s judgment rather than eliminating it, even as it removes the designer’s judgment about which single solution is best. Stanley and Lehman’s own writing acknowledges the difficulty of choosing good behavioral dimensions without smuggling the original objective back in through that choice; this article treats that as a live, unresolved tension in the argument rather than a flaw either side has a settled answer to.
Breeding beats designing exactly where a system exceeds what its builder can verify by construction
The reason this distinction matters for where the field goes next, rather than only for how these particular results should be read, is a change in what “verifying that software works” means once a system is produced by search instead of by specification. A hand-written program can, in principle, be checked against its specification by inspecting the code: a reviewer can trace how each part of the output follows from each part of the input, because a human decided that structure on purpose. None of the systems surveyed above admit that kind of check. Nobody can trace, by reading NEAT’s evolved topology or AutoML-Zero’s evolved learning-update procedure, a chain of reasoning from specification to implementation, because no such chain of reasoning produced them — a population of variants was scored and thinned, repeatedly, and the survivor is verified to work only by observing that it does, in trial after trial, not by anyone having proven from its structure that it must.
That is the same standard applied to a biological product rather than an engineered one: a new drug is not approved because a chemist can prove from its molecular structure that it will be safe and effective, but because it was tested, empirically, against the outcome that matters, across enough independent trials to make the result trustworthy despite nobody fully understanding the mechanism at the molecular level in advance. A bred piece of software gets the same treatment by necessity, not by choice: it is tested against held-out data, against benchmark suites, against live deployment metrics, because the alternative — proving it correct from its own construction — is not available when nothing about its construction was designed for provability in the first place.
Google DeepMind’s 2025 AlphaEvolve is the clearest 2026-era instance of this verification model running in production rather than in a research paper. AlphaEvolve pairs a large language model with an evolutionary search procedure and an automated evaluator, and reports several results verified purely by that empirical loop rather than by proof: a discovered algorithm for multiplying four-by-four complex-valued matrices in 48 scalar multiplications, improving on a bound from Volker Strassen’s 1969 algorithm that had stood in that specific setting for decades; a scheduling heuristic for Google’s Borg cluster-management system that had been running in production for more than a year at the time of the report, continuously recovering an average of 0.7 percent of Google’s worldwide compute fleet; and a 23 percent speedup to a matrix-multiplication kernel inside Gemini’s own training stack, contributing a reported 1 percent reduction in Gemini’s total training time [14]. None of those results was proven correct from the structure of the discovered code; each was verified by running it and measuring what happened, exactly the standard this section describes, and the Borg scheduling heuristic is a bred component operating for over a year inside an otherwise hand-designed production system without that system having been redesigned around it. AlphaEvolve’s own immediate predecessor, DeepMind’s 2023 FunSearch, established the same pattern at smaller scale, pairing a language model with an evolutionary loop and an automated checker to find new bounds on the cap set problem in combinatorics and improved heuristics for bin packing, with every candidate verified by direct execution against the automated checker rather than by proof of the discovered program’s structure [15].
Two further 2026-adjacent examples show the same verification pattern spreading rather than staying confined to one lab. Real and colleagues’ 2019 regularized evolution method, which modified tournament selection to favor younger genotypes, produced the AmoebaNet-A architecture through an evolutionary neural architecture search and reported it reaching accuracy comparable to the best contemporary hand-designed and reinforcement-learning-searched ImageNet classifiers, at 83.9 percent top-1 and 96.6 percent top-5 accuracy at its largest configuration — a result the paper frames as evidence that evolution finds competitive architectures more efficiently than reinforcement-learning-based search under a constrained compute budget [11]. And Takuya Akiba and colleagues’ 2024 evolutionary optimization of model-merging recipes, from Sakana AI, used an evolutionary search over how existing open-weight language and vision-language models are combined, in both parameter space and data-flow space, to produce a released Japanese-language model with mathematical reasoning ability the authors report outperforming larger models on Japanese-language benchmarks, and a released culturally specific Japanese vision-language model — both verified by benchmark evaluation of the merged result, not by any argument about why the merge recipe should work [13]. In each case, the discipline that actually did the verifying was the fitness function and the evaluation harness around it, not a proof of construction, because none of these systems were built by a process a proof of construction could even apply to.
A three-rung scenario to 2100, and what would falsify each rung
Jeff Clune’s 2019 position paper names the most specific public forecast of where this trajectory could go: he argues for pursuing what he calls AI-generating algorithms, organized around three concrete pillars that map directly onto the demonstrations above — meta-learning a system’s own architecture, meta-learning the learning algorithm a system uses, and generating the learning environments a system is trained against — and argues, without committing to a date, that this composite approach may prove to be the more effective path precisely because each of its pillars has already been demonstrated separately in the results this article has surveyed [12]. Clune’s paper deliberately withholds a timeline; what follows is this article’s own scenario, built to be checked against Clune’s three pillars and against the evidence above, not a restatement of any date Clune himself proposed.
Rung one: evolved components inside designed systems. This rung is already demonstrated, not projected — AmoebaNet-A’s architecture-search result inside an otherwise conventionally engineered image-classification pipeline [11], AlphaEvolve’s Borg scheduling heuristic running for over a year inside Google’s hand-designed cluster manager [14], and NASA’s genetic-algorithm-designed antenna flown as one component of an otherwise conventionally engineered spacecraft are three independent, named instances already public. What is not yet established is whether this stays a small set of anecdotes or becomes a routine engineering option. Disconfirmation: if, by the end of 2029, no additional named production system beyond the ones already public here has disclosed shipping an evolved subcomponent inside a conventionally designed system, that would indicate rung one is a fixed set of special cases rather than an expanding practice.
Rung two: whole systems substantially produced by search, verified by a designed empirical harness rather than by proof of construction. This rung requires more than a kernel, a heuristic or an antenna — it requires a complete pipeline or product, comparable in scope to a hand-engineered alternative it replaces, whose developers state that its correctness case rests on the empirical evaluation harness around it rather than on an argument from its internal structure. AlphaEvolve and FunSearch’s discovered algorithms are a partial instance of this at the scale of a single function or kernel [14, 15]; Akiba and colleagues’ merged models are a partial instance at the scale of a full deployed model [13]; neither yet constitutes a full production system whose builders describe the whole system, rather than one internal component, as evolved. Disconfirmation: if, by the end of 2032, no organization has publicly shipped a complete system of this kind, or if organizations that could plausibly do so instead report choosing not to on the grounds that empirical verification alone is judged insufficient for systems at that scope, rung two should be read as further off than the pace of rung one would suggest.
Rung three: self-modifying populations under continuous selection, requiring no human to re-specify the search each generation. This is the rung closest to Clune’s full three-pillar argument taken together, and the furthest from anything demonstrated above: every result in this article, including AlphaEvolve’s, is a bounded search run that a human started, configured and eventually stopped, not a population that keeps varying and getting selected against live conditions indefinitely on its own initiative. This article does not treat any current trend toward more autonomous machine learning pipelines as established fact; the claim here is only that such continuous, unattended evolutionary operation has not yet been demonstrated even at research scale, and that its absence or presence is checkable. Disconfirmation, set against the 2100 horizon named in this article’s own scenario: if, by 2045, no research-scale (not necessarily production) demonstration exists of a deployed system continuing to vary and be selected against live tasks over an extended period without a human re-initiating each generation’s search, that would indicate rung three is not on a trajectory compatible with reaching general practice by 2100, and that everything described in this article remains, even decades on, an offline tool a human operates rather than a continuously operating population.
When software breeds, engineering becomes husbandry, and the fitness function is the whole discipline
The lineage traced in this article runs from Holland’s formal population-and-selection procedure through NEAT’s protection of young structural lineages, through evolution strategies’ and deep neuroevolution’s demonstration that a gradient was never strictly necessary, through AutoML-Zero’s search escaping the lock-in of a hand-designed pipeline’s own division of labor, through POET’s radiation into a growing set of environment-solver niches, through quality diversity’s cataloguing of a landscape instead of a single peak, to AlphaEvolve’s fitness-harness-verified components now running inside production infrastructure. Each step changed what was being varied and what was measuring fitness; none of them changed the underlying claim Holland stated in 1975, that a population under selection is a general search procedure whose results have to be checked empirically because nothing about how they were produced makes them checkable any other way.
What that leaves an engineer, once a system is bred rather than designed, is not less work but differently distributed work. A hand-designed system concentrates skill in specification and construction, and treats testing as confirmation of a plan already known to be sound. A bred system concentrates skill in one place instead: the fitness function, the selection procedure, and the verification harness that decides, generation after generation, what gets to reproduce. Every demonstrated result surveyed here — NEAT’s speciation criterion, POET’s minimal-criterion transfer rule, MAP-Elites’ choice of behavioral dimensions, AlphaEvolve’s automated evaluator — is, underneath its specific mechanism, a decision about what to select for, made by a person who never specified the resulting structure directly but specified, with total consequence, the terms under which structure would be allowed to survive. That is the discipline this shift actually demands, and it is a narrower, harder and more consequential discipline than writing code ever was: not designing the organism, but designing the pressure that decides which organisms live.
