AI Improves at Self-improving

Alpha Evolve, a coding agent from Google DeepMind, is built to iteratively improve the code it receives from humans—using automated evaluation metrics—then feed the best results back into the next generation of models. The practical punchline is that this recursive loop has already produced measurable gains in real systems (including Google data-center efficiency) and yielded major algorithmic progress, while also offering a plausible path for turning “good code” into “better base models” through distillation.

In the core workflow, a human supplies a target problem, an initial codebase (often something already tried), and—critically—evaluation metrics that can automatically score whether an output is good. With those guardrails, Alpha Evolve runs prompt and code iterations: it samples candidate prompts from a database of historically successful ones, uses Gemini (a faster “Flash” variant for generating many ideas and Gemini 2 Pro for stronger suggestions), and repeatedly refines the submitted code against the metrics. The system returns code diffs that, in reported results, reach about 75% of state-of-the-art performance on a set of tasks most of the time, and exceed state-of-the-art performance about 20% of the time.

DeepMind’s emphasis on the “evolve” component matters because the agent doesn’t just try different prompts—it also stores and samples the best-performing LLMs for the task, then uses those to drive further search. The approach is framed as an optimization process over a high-dimensional space of candidate programs and prompt strategies, with the evaluation metrics acting as the fitness function. The agent’s outputs are not only useful as end products; they also become training signal. The natural next step described is distilling Alpha Evolve’s augmented performance back into the next base model, so future versions of the underlying LLM can generate better code and better prompts sooner.

That recursive loop is positioned as a rebuttal to “permanent data war” narratives: improved programs become better data for training, which then improves the next iteration of the agent. The transcript also highlights that Alpha Evolve has already demonstrated both scientific and operational impact. Most prominently, it found a rank-48 tensor decomposition for 4×4 complex matrix multiplication—an unexpected improvement over a 50-year-old record—offering a more efficient recipe that can be reused recursively for large matrix multiplications. On the engineering side, it helped optimize Google’s Borg data-center systems, recovering about 0.7% of worldwide compute resources, and it contributed to kernel and training-time efficiency improvements tied to Gemini and Google’s Ironwood TPUs.

Still, the system isn’t portrayed as a fast-takeoff guarantee. Its main bottleneck is the requirement for automated evaluators; domains where experiments can’t be easily simulated or scored by software will be harder to iterate on at Alpha Evolve’s pace. Even so, the transcript argues the direction is significant: it favors interpretability, debugability, predictability, and deployment ease over deep reinforcement learning, and it points to a broader shift toward building robust evaluation environments. The result is a concrete example of “AI improving AI” that looks less like science fiction and more like an engineering flywheel—one where better search and better evaluation functions compound over time.