Kurzweil Scorecard: The Machines That Were Supposed to Breed

In 2005, Ray Kurzweil placed a bet on how artificial intelligence would advance. The engine, he believed, would be Darwinian: populations of candidate programs, scored, culled, mated, and mutated across thousands of generations until a solution emerged that no human had designed. He had good reason to think so. The year before, NASA had launched a small antenna into the design pipeline of an evolutionary program and watched it spit out a bent-paperclip shape that beat the contractor’s hand-built version. “Machine breeding” was a live research front, and Kurzweil treated it as a preview.

Twenty years later, the verdict is strange. Every factual claim he made was correct. The forecast underneath them was wrong — and then, two years ago, it started coming true anyway, through a door nobody was watching.

The predictions

Three claims from The Singularity Is Near (2005), all from the chapter “Response to Critics,” sit in this batch. The first is methodological: Kurzweil lays out a concrete evolutionary-algorithm schema — a population of “solution creatures,” each rated by a fitness function, with the highest ratings surviving to reproduce through recombination and small random mutation (ch. “Response to Critics”). The second is a factual report: NASA announced in 2004 that evolutionary software had automatically designed an antenna (ch. “Response to Critics”). The third is a survey claim: by 2004, evolvable hardware and machine-breeding approaches were active research topics (ch. “Response to Critics”), citing a Salon piece by Sam Williams titled “When Machines Breed.”

These are not flashy 2045 prophecies. They are quieter, and that makes them a better test. Kurzweil was describing the present and implying a trajectory. The trajectory is the thing to grade.

Where we actually are

Start with what’s verifiable, because it all checks out.

The NASA antenna was real and the story is better than the one-line version. Jason Lohn and Gregory Hornby’s team at NASA Ames ran two evolutionary algorithms — one over real-valued parameters, one over a tree-structured generative encoding — to design an X-band antenna for the Space Technology 5 mission. The evolved designs beat the hand-built antenna from the mission’s contractor. When the spacecraft’s orbit changed and the antenna requirements shifted, the team simply edited the fitness function and re-evolved a compliant design in under a month. The antenna flew on three ST5 spacecraft launched March 22, 2006 — the first computer-evolved hardware deployed in space. Kurzweil reported it accurately.

The schema is also textbook-correct. Read his step-by-step recipe next to any modern description of a genetic algorithm and they match: initialize a population, score, select survivors, recombine, mutate, repeat. Two decades on, that loop is still taught exactly as he wrote it.

And evolutionary computation as a field never died. Scientific output has roughly doubled since the book came out — from about 7,600 papers in 2005 to more than 17,000 in 2025 by our count of the literature. Genetic algorithms remain workhorses for scheduling, antenna and circuit design, drug-candidate screening, and multi-objective optimization. Recent grants show the breadth: one 2026 patent (US 12,650,510) claims genetic programming for dynamic cybersecurity; another (US 12,561,744) uses differential evolution to allocate compute resources. The mechanism Kurzweil described is alive and earning its keep.

So why grade anything “wrong”?

Because the implied forecast — that machine breeding would be the path, or a central one, to general machine intelligence — lost decisively to a rival Kurzweil mentions almost in passing. The same loop he described for evolving network topologies turned out to matter far less than the unglamorous business of nudging weights with gradient descent.

The scale of the divergence is hard to overstate. In our patent corpus, filings naming genetic algorithms, evolvable hardware, or neuroevolution have stayed essentially flat for twenty-five years — 29 in 2005, 39 in 2025, bouncing between 15 and 61 the whole time. Over the same span, patents naming neural networks or deep learning went from 82 a year to more than 4,200, a fifty-fold climb. The literature gap is wider still: deep-learning papers grew from roughly 110 in 2005 to over 125,000 in 2025 — about a thousandfold — while evolutionary computation merely doubled. Two methods, both viable in 2005. One became the foundation of a trillion-dollar industry. The other stayed a respected specialty.

Here is where the story turns, and it turns on Kurzweil’s own update. In The Singularity Is Nearer (2024), he reframes evolution as the slow path. He maps it onto the cerebellum — the brain’s repository of hardwired, genetically tuned reflexes that change “orders of magnitude slower” than learning. “Computer scientists now sometimes use evolutionary approaches,” he writes, almost as an aside, before pivoting to the neocortex: the flexible, learning structure that “could invent new behaviors in days or even hours.” That neocortex analogy is the architecture that won — connectionist networks trained by feedback. The author who once led with machine breeding now leads with learning, and files evolution under “sometimes.”

The most pointed evidence that the wrong mechanism lost comes from setting the two against each other directly. In 2020, Esteban Real and colleagues at Google built AutoML-Zero: an evolutionary search starting from empty programs, allowed only basic math operations, hunting for a machine-learning algorithm in a space so vast that a working one is roughly one in a trillion candidates. Set loose, evolution rediscovered — from nothing — two-layer neural networks trained by backpropagation. The breeding machine, asked to invent intelligence, reinvented gradient descent. Evolution’s best trick was to find the thing that had already beaten it.

But “wrong mechanism” is not the last word, because the past two years rewrote the ending.

Evolution came back — bolted to large language models. DeepMind’s FunSearch (2023) paired an LLM with an automated evaluator in an evolutionary loop and found new solutions to open math problems. Its successor, AlphaEvolve (announced May 2025), generalized the idea from single functions to whole codebases, using an ensemble of Gemini models as the mutation operator inside a classic evolutionary search. The results are concrete. AlphaEvolve found a way to multiply two 4×4 complex-valued matrices with 48 scalar multiplications instead of 49 — the first improvement on Volker Strassen’s 1969 result in that setting in 56 years. It also rewrote scheduling heuristics for Google’s own data centers and improved circuit-design and training routines. This is Kurzweil’s “solution creatures” loop exactly — populations, fitness, selection, mutation — except the creatures are now programs written by a language model. The schema he drew in 2005 is running inside the systems that beat it.

Patent filings are catching the same wave. US 12,554,993, granted in 2026, claims a genetic-algorithm system that “generates a set of computer programs,” scores each, removes the low scorers, and breeds “offspring computer programs” from the survivors over successive generations — machine breeding for source code, almost word-for-word from the book. US 12,585,882 goes further into the present: it describes specialized agents that “collaboratively evolve” cached reasoning steps from a large language model “using genetic algorithms,” then feed the evolved thoughts to a smaller model. Evolution and deep learning, the two rivals of 2005, are now claimed in the same invention.

The scorecard

What Kurzweil missed (and what he nailed)

The pattern here is one we keep finding in this series: Kurzweil is a superb reporter of the present and a shaky forecaster of which present will matter. Every fact in this batch is correct. The antenna flew. The schema is sound. The field was active. What he could not see in 2005 was that the method sitting quietly in his own footnotes — adjusting connection strengths from labeled examples — would scale a thousandfold while the method he led with would merely hold its ground.

The deeper lesson is about how technologies actually compete. In 2005, evolutionary computation and connectionist learning looked like peers. They were not eliminated against each other by argument; they were eliminated by hardware. Gradient descent happened to be the algorithm that turned raw matrix multiplication — the one operation GPUs do obscenely fast — into learning. Evolution didn’t lose on merit. It lost on its fit to the available silicon. That is the kind of contingency no 2005 forecast could price in, and it should make anyone humble about today’s confident timelines.

And yet the most interesting verdict is the one the rubric doesn’t quite have a box for. Evolution didn’t win, didn’t die, and is now staging a return as the orchestration layer around the models that beat it — discovering algorithms, breeding code, beating a 56-year-old mathematical record. Kurzweil bet on the wrong horse, then the wrong horse learned to ride the right one. Whether that counts as a miss or a delayed hit depends on how patient you’re willing to be with a prediction. Kurzweil has always asked for patience. This batch suggests he sometimes earns it.

Method note

Trends in this piece come from full-text searches across roughly 9.3 million U.S. patent records and about 357 million scientific papers, counted by year of publication, plus a reading of the specific claims and descriptions of the patents named above. Kurzweil’s predictions are quoted from The Singularity Is Near (2005) and his updated framing from The Singularity Is Nearer (2024). The NASA antenna, AutoML-Zero, FunSearch, and AlphaEvolve details were confirmed against published research and primary reporting accessed this week. Patent counts reflect what is searchable today and undercount inventions that use these methods without naming them.