AlphaEvolve found algorithms humans missed for 50 years — then sped up Gemini 23%

Sarah Guo of No Priors opened with a claim that would have sounded like marketing a few years ago. AlphaEvolve, built at Google DeepMind by Pushmeet Kohli, VP of science and strategic initiatives, and research scientist Matej Balog, is not a stochastic parrot or a boilerplate generator. It is an autonomous coding agent that uses Gemini models and evolutionary search to discover new algorithms, with the kind of technical creativity people still associate with AlphaGo’s Move 37.

Kohli’s one-sentence version is drier and more useful. AlphaEvolve discovers algorithms that make new findings on open scientific problems, and those same algorithms can be practical enough to run in key parts of Google’s own infrastructure. The lineage is not new for the team. DeepMind’s mission, as they frame it, is to build AI that benefits humanity; their particular route has been asking whether AI can discover better algorithms than the ones we already have.

The first proof was AlphaTensor in 2022, a reinforcement-learning system aimed at one operator: multiplying matrices, the ubiquitous step underneath computer science and neural nets. For more than fifty years, after the German mathematician Strassen showed that two n-by-n matrices need not take cubic time, the construction had stood. AlphaTensor searched a space larger than Go and improved the result. That was the thesis: agents can enter a superhuman region of algorithms. The next question was whether the trick would generalize.

Kohli rewound further than 2022. AlphaGo beat a world champion by exploring an absurdly large space of positions and finding the right move, including Move 37, a line that was not in the literature and that stunned professionals and scientists alike. People had expected that day much later. The evidence, for him, was that large neural systems can reason and explore huge search spaces well enough to produce new insights in a domain.

So the team asked a transfer question: if an agent can search Go, why not search the space of algorithms with the same philosophy? Matrix multiplication was the first target because it is fundamental and because Strassen’s 2×2 construction was already ingenious and counterintuitive. As matrices grow, the constructions get intricate and unnatural. Hitting them by chance, or by the intuition of a human computer scientist, is unlikely. AlphaTensor was purpose-built for that one family of operations. FunSearch was the first LLM-based attempt to search in the space of programs instead, and it produced, they say, the first scientific discovery from a language model. AlphaEvolve is the generalization of that agent.

Guo’s follow-up was the obvious economic one. If better matrix multiplication is this valuable, why had nobody found the new solutions? Was the space too large, or had the field gone complacent? Balog pushed back on the second half. They deliberately chose problems worked for a very long time by the very best people: decades-old open questions on the scientific side, and, on the practical side, pieces of Google infrastructure that had already been heavily optimized because they matter. Finding something new there is as strong a demonstration as he can imagine that the result is both new and hard. Kohli’s later summary of why the method works is almost the whole product: language-model agents structured with population-based evolutionary search are extremely effective in enormous spaces, and they pull out counterintuitive solutions to problems studied for years, sometimes decades.

Guo asked for the demystified walk-through: data-center scheduling, from initial code to a solution that saves millions of dollars of power. Balog’s answer is a division of labor. The user specifies the problem by providing an evaluation function, something that, given any proposed solution, says how good it is. For job scheduling, Google already had a simulator. Drop in an algorithm, run the jobs, read the score. He called that a natural object in many domains. Whenever you want to innovate, you already need a way to tell whether the innovation is any good. The hard part is writing it down.

AlphaEvolve then fills in the how. You can start from scratch and ask it to be creative, or you can hand it a strong human solution and let it climb from there. Data-center scheduling used the second path. From that seed, three pieces loop. Language models propose creative new code. The user’s evaluator filters what works from what does not. An evolutionary algorithm keeps a diverse pool so the search does not commit to one type of solution too early, and it can combine ideas from different strong candidates. Generations get stronger until the algorithm is good enough to deploy into a critical part of Google’s infrastructure.

Two scaling facts are worth keeping. First, AlphaEvolve adapts to difficulty. An unexpectedly easy problem it solves almost immediately. A decades-old open question, or a high-value production algorithm, it will keep exploring, combining, and improving for a long time. “Wait longer, get better” sounds trivial, Balog said; in practice most automated agents plateau early, and sustaining improvement is the technical difficulty. Second, you cannot predict how many generations you will need, because that is the same as asking a priori how hard the question is. Sciences are full of trivial-looking problems that turn out to be brutal, and the reverse. The consolation is continual improvement for as long as you can afford to run.

Ordinary coding agents, Guo noted, still get lost on relatively trivial autonomous tasks, blow themselves up, or plateau in frustrating ways. What should developers take from AlphaEvolve? Kohli went at the task definition rather than the model. Language models make mistakes. They also usually receive a partial specification in natural language, not a complete characterization of what you want. They may get lucky and be right, or they may hallucinate. The issue is how you know. AlphaEvolve’s answer is a good evaluator.

Once that exists, the lab can “leverage the hallucinations for a beneficial purpose.” The creative, seemingly wrong answers might be very good. Humans just do not see them that way. Evaluation depth matters too: a new idea might be worth a few instances, a thousand instances, or a full stress test. Getting that balance right is how you filter promising directions and then use them to refine later search.

If automated evaluators are the limiting constraint, Guo asked, how do you get around it? Can models help write them? Better simulators? Should a product manager sit with an assistant and complete the spec? Balog gave two layers. Strict evaluators are extremely high value today: many important problems have no precise definition of a good solution, and writing one unlocks the chance that an agent discovers something beyond your best developers. That is not, he was more excited to say, a conceptual ceiling. Precise functions were simply the easiest on-ramp. The assumption can be relaxed. DeepMind’s parallel AI co-scientist work already shows language models giving meaningful critiques of natural-language hypotheses and separating the ones that should propagate. Between a perfect scorer and a vibes-based LLM judge sits a spectrum of imperfect simulators and auxiliary functions. If they correlate with the true signal, the evolutionary scaffolding can still make progress, at the cost of more iterations.

Kohli added the rest of the toolkit. Even a simulator is not a perfect evaluator, because it scores a specific distribution of instances. If you need to prove a property — the solution always has certain performance — you may want a proof agent. If nobody has built a simulator, an LLM can still guess how good a candidate looks, and that approach works surprisingly well. In the co-scientist multi-agent setup, models themselves decide which hypotheses are more novel, significant, and worth keeping. The whole process, he said, produces much better results than the base language model alone, which may surprise people who think a committee of LLMs cannot add information.

Guo asked the meta-question the demo invites. AlphaEvolve optimized systems used to train AlphaEvolve’s own stack: a 23% speedup in part of the training infrastructure, as she recalled it. Are we witnessing the early stages of recursive self-improvement? Kohli’s answer was a careful yes. What they have seen so far is improvement in computation time. Training got more efficient. The further question — can you change the training process so the underlying model is not only faster to train but fundamentally better at certain cognitive tasks — is appealing, actively studied, and not yet validated.

Does he have a reason to believe it will not work? No. It should work, if you have an evaluator that can say whether a proposed change to the training process will yield a good result. There is no reason such an evaluator does not exist. Someone has to build it. Balog agreed they may be seeing a first sign of self-improvement, then narrowed the claim. The result is a speedup in training the next Gemini generation. The feedback loop is fairly long, currently on the order of months.

How that extrapolates is open. Self-improvement might be a one-off benefit. It might continue with shrinking marginal gains until it hits a limit. Or the gains might keep accumulating. That, he said, is a big open question they do not have an answer to today.

Balog is blunt about why this is the application of AI that excites him most: advancing the frontier of human knowledge. Math and computer science are AlphaEvolve’s home field because automated evaluation functions often come almost for free. That is not a claim that biology and chemistry cannot play. Design a molecule, score it with a simulator or a predictive model, and you are in the same regime the current system can already address. He does not think the journey finishes here, and he expects applications across many branches of science, alongside agents such as AI co-scientist.

Kohli flattened science into a search problem: the right idea, the right construction, the right drug candidate. Scientists have been trying to make that process repeatable and to squeeze out serendipity. Rational material discovery and rational drug discovery already lean on computational approaches and systematic evaluation. A system like AlphaEvolve is a superpower for searching complex, counterintuitive solution spaces once those evaluations exist.

Near-term, Guo asked, what is left for the human if labs grow robotic arms and automated assays? Plenty, Kohli said. Define the evaluation. Specify properties the solution must have: a drug that treats the disease, does not kill the patient, has low side effects, and has a delivery mechanism. Some of that goes in the evaluator; some you hard-constrain so the agent explores the right space. Hints, starting points, and search-space boundaries are still human work. In the right hands the tool is already powerful. Mathematicians who can specify the type of solution they want become more productive at finding it.

In practice the agent is surprisingly collaborative. It does not only hand you a solution; it searches for an algorithm that constructs the solution, and that algorithm is often the valuable object, especially in mathematics, where understanding how a thing is built is the point. Collaborators stare at the code, watch one piece do this and another do that, and suddenly see why it works. Balog finds the programs human-like: something you could have written, except you would not have thought to write it that way. That readability is also an engineering feature. Experts can inspect the artifact before it hits production, which he put in a completely different league from dropping a neural net into a live system and hoping it behaves. Kohli was careful: not all code is interpretable. The programs AlphaEvolve finds happen to be. What we can learn from them is future work. An early version, with mathematician Jordan Ellenberg on the cap set problem, produced programs whose symmetries mathematicians did not know about. The construction was interesting. The structure of the algorithm that produced it was interesting too.

For listeners who are not professional mathematicians, Guo asked about accessibility. DeepMind has started a trusted-tester program and is taking proposals, in part to learn how people can actually leverage the system. Internally it is already in use across Google. Two requirements travel with it. You need a function evaluator, and you need significant compute. This is not one language-model call. Hard problems with large search spaces want a long evolutionary run; easy ones finish quickly. How to package that into something people can use efficiently is an open product question that will shape the later release strategy.

The white paper was written to show range, not a single trick: data-center efficiency, hardware design, and the most important pieces of software inside Google. Balog said the tool is already pointed at many problems, including ones he is not ready to name. There will be more results, in AI and outside it. Recursive self-improvement, in what shape, they would not guarantee. What they did leave is a checklist worth watching: the feedback loop is still months, the wins are still mostly compute, and the evaluator is still the ticket in.