Kurzweil Scorecard: The Seed AI Arrived Without the FOOM

In May 2025, a Google DeepMind coding agent named AlphaEvolve found a way to multiply two 4×4 complex matrices using 48 scalar multiplications — beating Strassen’s 1969 algorithm, the result every computer science undergrad learns. It also rewrote a matrix kernel inside Gemini’s own training pipeline, cutting end-to-end training time by 1%. It found a heuristic for Google’s Borg cluster scheduler that has been running in production for over a year and recovers, on average, 0.7% of Google’s worldwide compute — a permanent dividend in the millions of CPU-hours per day. (DeepMind blog)

This is exactly the milestone Ray Kurzweil flagged in 2005 as the trigger for the intelligence explosion: an AI that helps build better AI. And it happened years ahead of his “long-term” timeframe.

But AlphaEvolve has not improved itself. It improves other code. The seed germinated. It did not bloom.

That gap — between recursive improvement existing and recursive improvement running away — is the most interesting story in this batch.

The predictions

In The Singularity Is Near (2005), responding to skeptics in his Chapter Nine, Kurzweil staked out three linked claims about machine self-improvement:

1. “Artificial intelligence systems will eventually have the capacity to improve themselves.” (ch. “Response to Critics”)
2. “A self-improving seed AI, even if initially slow and limited, could eventually improve itself convulsively, break through architectural bottlenecks, and design or even build improved hardware if given control of fabrication tools.” (ch. “Response to Critics”)
3. “Superintelligent machines initially harnessed for human benefit could leave humans behind in capability.” (ch. “Response to Critics”)

Kurzweil’s update in The Singularity Is Nearer (2024) is more cautious than the 2005 prose suggested. He acknowledges the FOOM debate openly: “Some researchers, like Eliezer Yudkowsky, see this as more likely to happen extremely fast (a hard takeoff in minutes to months), while others, like Robin Hanson, think it will be relatively more gradual (a soft takeoff over years or longer). I fall somewhere in the middle. My view is that physical constraints on hardware, resources, and real-world data suggest limits to the speed of FOOM.”

He also sharpened the mechanism: “the most important fiber in our bundle of cognitive skills is computer programming … once we develop AI with enough programming abilities to give itself even more programming skill … there’ll be a positive feedback loop.” That feedback loop is what we now look for in the evidence.

Where we actually are

Recursive code improvement is real, and it’s not a thought experiment.

AlphaEvolve is the headline, but it is one of a cluster. In 2025 alone, three lines of work matured into something genuinely operational:

• Algorithmic discovery loops. AlphaEvolve pairs Gemini Flash for fast variant generation with Gemini Pro for deep refinement, scored by automated evaluators. Tested on 50+ open mathematical problems, it rediscovered state-of-the-art in ~75% of cases and improved the best known solution in ~20%, including a new lower bound on the kissing number in 11 dimensions. (arXiv 2506.13131)
• Self-taught optimizers. Sakana AI’s AI Scientist v2 became the first system to have a fully autonomous paper accepted through peer review, at an ICLR 2025 workshop, at a cost of roughly $6–$15 per paper. (Sakana arXiv evaluation) A separate line — NeurIPS 2025’s Self-Taught Optimizer and the ICLR 2025 “A Self-Improving Coding Agent” workshop paper — has agents that rewrite their own improvement code and empirically rediscover beam search and simulated annealing without being told they exist. (Self-Improving Coding Agent, arXiv 2504.15228)
• Self-referential agent frameworks. Gödel Agent (arXiv 2410.04444) demonstrates an LLM that modifies its own logic and prompts dynamically. (Gödel Agent)

The patent record shows the same shape. US 12,626,064, granted May 12, 2026, claims a “meta-reflection” technique where a language model is prompted to generate a self-reflection response explaining why its prior answer was wrong, then prompted again to generate “prompt improvement instructions” that are appended to all subsequent prompts. Read the dependent claims and they get sharper: the model writes both positive instructions (when its answer was right, reinforce the reasoning) and negative instructions (when wrong, encode what to avoid). The patent essentially formalizes “the model teaches the system how to prompt the model better.” It is a small, bounded version of Kurzweil’s feedback loop.

US 12,626,038, also granted May 12, 2026, goes a step further into Kurzweil territory: it claims a system that searches both the neural network architecture space and the hardware accelerator space jointly, with multiple controllers each using a different optimization algorithm racing to find the best architecture–hardware pair. This is exactly the “design or even build improved hardware” half of Kurzweil’s seed-AI prediction, productized into a patent claim. US 12,112,112 (October 2024) and US 12,626,119 (May 2026, “Task-adaptive architecture for few-shot learning” — meta-training a neural cell whose architecture is found by NAS) round out a clear pattern.

Patent activity in adjacent corners has gone vertical. Patents combining “automated machine learning” with “optimization” or “hyperparameter” rose from 2 in 2018 to 37 in 2023 and held steady at 32–34 through 2025. Reinforcement-learning-for-chip-design grants climbed to 17 in 2025. Patents tying “large language model” to “agent” or “autonomous” went from 1 in 2023 to 29 in 2025 and 34 in just the first five months of 2026.

But the runaway hasn’t happened, and the mechanism looks different than Kurzweil drew it.

The most striking thing about AlphaEvolve, on close reading, is what it does not do. It improves other algorithms. It has not been turned on its own evolutionary loop. The 2024 Sakana evaluation paper (arXiv 2502.14297) is even blunter about the AI Scientist: the literature-review step is shallow, the novelty checks are weak, and the system mostly produces minor variations rather than the “convulsive” leaps Kurzweil described.

The pattern across the whole 2025 corpus is bounded recursion, not runaway recursion. The loops have:

• An external evaluator (compiler, unit tests, benchmark scorer) that the agent cannot modify.
• A human gate on what gets deployed.
• Compute budgets capped at the evaluator’s serving cost.
• No path from “improved the algorithm” to “improved the agent that improves algorithms.”

Kurzweil’s seed-AI image was a single agent rewriting its own substrate. What we have instead is a factory of bounded improvement loops, each one fenced by an evaluator the loop cannot edit. The substrate that improves is the fleet of agents collectively producing better code, models, and chips — not any single seed.

That’s not nothing. The Gemini 2.5 training loop benefiting from a 23% faster matmul kernel that an AI wrote is itself a feedback loop, just one that runs at the speed of quarterly model releases rather than minutes-to-months. It is the soft takeoff Robin Hanson described, not the hard takeoff Eliezer Yudkowsky did. Kurzweil, in Nearer, hedges toward the middle. The 2025–2026 evidence has so far been kinder to Hanson.

The scorecard

What Kurzweil missed (and what he nailed)

He nailed the trigger. “Once we develop AI with enough programming abilities to give itself even more programming skill … there’ll be a positive feedback loop” (Nearer) is precisely what AlphaEvolve closed when its kernel improvements shipped into Gemini’s training run. The 2005 Near prediction that this would arrive at all, against the loud chorus of “AI can’t really write code,” is a substantial hit. The fact that this is happening more than a decade before his “long-term / 2030s” framing is, on a strict reading, an early arrival.

He missed the topology. The 2005 metaphor was a seed — a single self-modifying agent. The 2025 reality is a forest: many bounded loops, each tethered to an evaluator and a checkpoint, collectively producing better-than-human algorithms while no individual loop runs away. The “convulsive” qualifier in his second prediction is doing a lot of work; nothing convulsive has happened, and the bottlenecks (“real-world data”, “physical constraints on hardware”, an evaluator the loop cannot edit) look more durable than the FOOM camp suggested. Kurzweil, to his credit, conceded most of this in 2024.

The forecasting lesson is the one the technology forecasting literature keeps re-learning: when the qualitative direction is right, the mechanism almost always isn’t. Bet on the direction. Don’t bet on the diagram.

Method note

We checked the US patent record for grants mentioning recursive self-improvement, neural architecture search, automated machine learning, reinforcement learning for chip design, and language-model agents, with year-by-year counts since 2018 and full-text reads of four representative recent grants. We pulled academic and industry results on autonomous coding agents from primary sources at DeepMind, Sakana AI, and OpenReview/arXiv venues (ICLR 2025, NeurIPS 2025). We compared each finding against the verbatim 2005 predictions in The Singularity Is Near (Ch. 9) and Kurzweil’s restatements in The Singularity Is Nearer (2024). No claim in this post relies on counts alone; every verdict cites specific patents, papers, or production deployments.