Summary

AlphaEvolve broke a 56-year benchmark by finding a 48-multiplication algorithm for general 4×4 matrix multiplication, beating the 49 obtained by recursively applying Strassen’s 1969 method. The team ran the case largely “for completeness” after AlphaTensor had failed to improve the general-number result; Matej Balog’s first response was disbelief: “Let’s triple-check it.” The algorithm uses complex numbers but also applies to real matrices, including the kind used in neural-network training.
The immediate economic evidence is inside Google: one evolved scheduling heuristic recovered an average 0.7% of fleet-wide compute that would otherwise have been stranded, while another change sped training of the next Gemini version by 1%. These gains came in already heavily optimized Google infrastructure. Yet Matej qualifies any dramatic shorthand of instant recursive self-improvement: the feedback cycle is currently “on the order of months.”
AlphaEvolve’s edge comes from compounding verified partial improvements, not merely sampling an LLM more times. Language models propose code—“some of them will be stupid, some of them will be amazing, some of them will be really weird”—while automated evaluators filter results and an evolutionary loop preserves diversity, selects promising programs, and asks the models to build on what worked. Paper ablations showed that removing evolution performed “much, much worse.”
The addressable domain is broad but bounded by the availability and cost of reliable evaluators. A program can be given a 10-minute evaluation budget, but Keith Duggar’s pushback is fundamental: terminating slow candidates may discard the “godly algorithm” or a temporarily inferior stepping stone to a breakthrough. Physical experiments add another bottleneck, so the proposed bridge is an evaluation cascade that filters many candidates cheaply before spending scarce laboratory or real-world trials on perhaps 10 finalists.
AlphaEvolve appears unusually portable across mathematical discovery and production software, although its 6×6 matrix result shows that generality does not erase domain knowledge. The system searched unrestricted algorithms and missed the best-known 6×6 method, whose symmetry imposes a valuable inductive bias and sharply reduces the search space. “General purpose” therefore means adaptable search machinery, not automatic dominance over specialized methods.
Better base models directly improve AlphaEvolve, creating leverage above the model layer rather than independence from it. Matej says adding Gemini 2.0 Pro to the ensemble improved results over Gemini 2.0 Flash alone, while the host’s question about 2.5 remained forward-looking. The larger opportunity is to distill discoveries made with evolutionary test-time compute back into future base models, though the team has not yet closed that reinforcement-learning loop.
The authors see human judgment—not full autonomy—as a central feature and a potential source of durable differentiation. Researchers choose questions, representations, seeds, evaluators, and follow-up experiments; the system then “squeezes all the juice out of the idea” and improves the human’s intuition for asking the next question. Alexander Novikov prefers this “back and forth between humans and machines,” while the discussion’s broader warning is that AI may flood the world with mediocrity even as it disproportionately raises expert productivity.

Deep dive

1. AlphaEvolve turns LLM creativity into cumulative, verified search

Alexander Novikov’s architectural starting point is non-negotiable: AlphaEvolve tackles problems where any proposed code can be tested automatically and assigned a measure of quality. That evaluator restricts the eligible problem set, but also enables rapid iteration and filters an LLM’s wide distribution of ideas—“some of them will be stupid, some of them will be amazing, some of them will be really weird.”
The evolutionary pipeline repeatedly selects promising programs, preserves a diverse population, and returns evidence to the model: “Here’s what you tried before. This thing worked. This thing doesn’t work. Please try to propose a new thing.” Parallel execution supplies the final ingredient, scale, letting many candidate lineages advance simultaneously.
Matej Balog argues that evolutionary algorithms naturally fit scientific discovery because “a priori there is no way of knowing” the right approach. Diversity prevents the search from prematurely zooming in on a locally attractive but ultimately suboptimal family of solutions.
The episode frames AlphaEvolve as an expansion of FunSearch: instead of evolving one function, it can modify demarcated adaptable regions across a codebase and optimize their interactions. Alexander adds a practical preference: evolutionary algorithms are comparatively quick and “very fun to play with,” whereas setting up reinforcement learning can take considerably more time.

2. Evaluators create both the capability and its hardest boundary

Keith Duggar presses on the halting problem: code may compile and run for an hour without revealing whether it will terminate, yet stopping five minutes early could discard “the godly algorithm.” In theory, Matej concedes, no procedure can reveal what a longer run would have done.
Matej’s practical answer is to make time part of the task itself. If the goal is a search algorithm that makes progress in 10 minutes, every candidate receives exactly 10 minutes; this deliberately explores algorithms useful within that budget, while potentially missing ones that mature later.
Keith’s sharper objection is that fixed cutoffs constrain open-ended discovery: a currently slower program might be the stepping stone that eventually “hops you over to something more efficient.” The discussion notes that this restriction did not bite much on the paper’s well-chosen problems; Tim Scarfe calls the limitation “massive.”
Alexander turns the limitation back toward human research: “How do you know that you should stop working on your problem as a human?” Another month might solve it, but neither researchers nor machines can know that in advance.

3. Seeds determine whether the system exploits an idea or searches broadly

Matej distinguishes two operating modes. A detailed prompt or strong initial program causes AlphaEvolve to “squeeze out the juice of that idea” through local refinements; by default, the team instead provides nearly empty functions returning zero or false and lets the base models explore broadly.
For matrix multiplication, AlphaEvolve did not directly emit the final multiplication scheme. Starting from little more than “use gradients,” it evolved a gradient-based search algorithm with complex loss functions, update rules, penalties, and unexpected injections of randomness—“human-like,” Matej says, but not code a human would obviously choose to try.
An unpublished experiment varied the quality of human guidance: contributors studied a problem for either two minutes or 30 minutes, recorded their ideas, and passed those notes into the system. AlphaEvolve preserved the idea’s essence while optimizing numerous details—sometimes intelligently, sometimes by trying enough variants until one stuck.

4. Execution, meta-prompts, and reusable libraries expand the knowledge base

Keith initially identifies two knowledge sources: the pretrained model’s compressed corpus and the starting program. Matej adds a third: execution itself, because the system can choose an algorithm to run and thereby acquire the empirical fact of what that algorithm actually does.
AlphaEvolve already implements meta-prompting. Before solving a task, the model is told which prompt it will receive and asked to modify that prompt; the system then curates prompts that empirically generate stronger evolutionary runs.
Tim’s proposed “next trillion-dollar business” is a robust cross-domain program library—the “new oil”—whose modules transfer by analogy. Matej sees an early version in matrix experiments: independently discovered algorithms differ, and using them to initialize later runs provides useful inspiration.
Alexander says the human operators are becoming a library too: collaborating with many Google teams feels like a consultancy, accumulating intuition about what works and what to try next. Technically, Matej sees no barrier to programs optimized across broader task families; maintaining a shared AlphaEvolve repository is more an organizational question.

5. A 48-multiplication construction breaks the 4×4 benchmark

The schoolbook method for multiplying two 2×2 matrices computes four output entries with two scalar multiplications each, totaling eight. In 1969, Volker Strassen shocked mathematicians by arranging “magical cancellations” that require only seven; seven was subsequently proved optimal for that case.
Even 3×3 remains unresolved: the known lower bound is 19 multiplications, while the best available algorithm uses 23 rather than the schoolbook 27. The gap survives because the space of possible algorithms becomes immense long before the matrices look large.
For 4×4 matrices, the longstanding general algorithm recursively applied Strassen to 2×2 blocks, producing 7×7, or 49, multiplications. AlphaTensor had improved only the special Boolean, modulo-two case; after years without a general improvement, AlphaEvolve found 48 during a run performed largely “for completeness.” Matej recalls: “I just couldn’t believe it. Let’s triple-check it.”
The construction’s counterintuitive feature is its use of complex numbers. Searching over complex algorithms appears harder because they must work for both complex and real inputs, yet that enlarged formulation produced the breakthrough; real matrices, including those used in neural-network training, remain a valid special case.

6. Small constructions scale recursively, but search complexity explodes

These discoveries are not confined to tiny inputs. Just as Strassen can operate recursively on blocks of a large matrix, an algorithm discovered for 4×4 blocks can be recursively embedded into multiplication of much larger matrices.
The underlying tensor grows brutally: the 4×4 task requires decomposing a 16×16×16 tensor, while 5×5 becomes 25×25×25—growth Matej describes as “an exponential with a quadratic in the exponent.” AlphaEvolve scales farther than AlphaTensor, but no method escapes the eventual wall.
At 6×6, AlphaEvolve did not match the best-known result. The team intentionally supplied no matrix-specific tricks and searched unrestricted forms, whereas the leading method assumes a particular symmetry and regularity, shrinking the space dramatically. Matej calls that missing inductive bias the clearest explanation, not evidence that the evolutionary machinery had found the optimum.

7. Choosing the representation remains an unsolved research judgment

Matej’s candid starting point is, “We ourselves don’t have all the answers here.” AlphaEvolve may search directly for a solution, evolve a short constructor that generates it, discover a search algorithm that finds it, or co-evolve a sequence of algorithms that progressively refines it.
His concrete analogy is a fractal: representing it as a pixel grid wastes its regularity, while a short generating function captures the structure. Less regular targets may instead demand direct representation or a complex search procedure, and the correct abstraction is not knowable a priori.
Co-evolution offers another axis: multiple algorithms can gradually refine a candidate rather than one program producing a terminal answer. The practical consolation is cheap reformulation—teams can try several representations and observe which one works best.
Keith connects these modes to mathematical deduction, construction, and enumeration. Matej says constructive problems fit AlphaEvolve directly; some impossibility claims can be dualized into constructions, but proof search is harder because correctness is binary. LLM-generated “soft scores” might judge whether a partial proof appears to make progress, but that path was not demonstrated in this paper.

8. Evolution compounds nuggets that brute-force sampling leaves isolated

Matej says repeatedly questioning a chatbot gives “completely the wrong idea” about scaled capability. A billion independent samples might contain useful nuggets, but not the full solution; evolutionary selection identifies those nuggets and builds on them across subsequent generations.
The paper’s ablations support that distinction: removing evolution made performance “much, much worse.” AlphaEvolve is therefore not merely inference-volume arbitrage; its value comes from retaining discoveries, revisiting neighborhoods, and accumulating improvements.
Alexander’s CAPSET example from FunSearch used a small model without even explaining the mathematical problem. The target was roughly 50 lines of Python—far too specific to appear accidentally—so success was “completely essential to hill climb,” modifying partial programs and retaining whatever measurably worked.
Matrix search likewise required engineered intermediate signals. The system could run an algorithm 10 times and optimize how often it succeeded, first mastering 2×2 and then moving to 3×3; related matrix sizes also preserve ideas that may be useless initially on the target size but become transferable after refinement elsewhere.

9. Program synthesis can expose mechanisms, not just output scores

AlphaEvolve sometimes returns code simple enough for a human to verify across all inputs and deploy almost immediately. Matej contrasts that with neural networks requiring hosting, inference resources, retraining, and other operational considerations.
In the CAPSET work, researchers noticed repeated use of four: loop indices were taken modulo four, while array accesses used positions i, i+4, and i+8. Inspecting this pattern produced a mathematical hypothesis, which the team fed into the next run and used to achieve substantially better results.
The matrix-search code produced a stranger but still inspectable insight. Humans might tune the weight or schedule of a quantization loss that drives approximate solutions toward exactly verifiable integers or fractions; AlphaEvolve instead created an entire time-varying shape for that loss—too elaborate for researchers to be likely to try manually.
Alexander’s distinction is that many machine-learning ideas sound sensible after the fact: “Ideas are sort of cheap.” The difficult part is identifying which five plausible ideas actually work. For other tasks, the system can intentionally favor performance over legibility and evolve complex heuristics whose holistic mechanism remains unclear.

10. Production gains validate the system beyond benchmark mathematics

Google engineers supplied a candidate scheduling method for assigning jobs to machines, then evolved a remarkably simple heuristic. Fleet measurements after deployment showed it continuously recovered an average 0.7% of compute resources that otherwise would have remained stranded—a small percentage with large absolute value at Google’s scale.
Another AlphaEvolve result sped training of the next Gemini version by 1%. Matej emphasizes the specificity: this is not an autonomous intelligence redesigning itself instantly, but a concrete optimization to already heavily optimized infrastructure.
The breadth surprised Matej most. Research tools normally require an additional body of work before becoming operationally useful; AlphaEvolve could both advance mathematical constructions and generate algorithms deployed directly into Google’s critical compute stack “out of the box.”
That dual use depends on executable artifacts. The same machinery can emit a direct solution, or—as in matrix multiplication—“an algorithm that finds an algorithm,” allowing improvements to land at different layers of a production or research pipeline.

11. Expensive physical validation demands a cascade of evaluators

Alexander suggests translating fuzzy objectives into executable rewards. A desired final image or natural-language description could become Python scoring code, while a vision-language model verifies the binary outcome and evolved auxiliary rewards provide the smoother signal needed to train a robot.
Keith stresses the gulf between rejecting code that crashes immediately and testing a robot that may be damaged, a biological hypothesis in a laboratory, or a medical idea through clinical trials. Simulator success cannot make those later evaluations cheap or consequence-free.
Alexander’s answer is a ladder of increasingly expensive tests, with LLM feedback, Elo-style comparisons, or other prioritization deciding which candidates advance. He cites Google’s Co-Scientists as a related effort to rank ideas when hard feedback is difficult.
Matej says AlphaEvolve already supports evaluation cascades: score many programs quickly, inspect fewer for longer, then send perhaps 10 candidates into real-world experiments. This mirrors ordinary research under finite budgets—cheap filters first, scarce definitive trials last.

12. Better models, human collaboration, and elastic compute set the frontier

The system benefits directly from stronger base models. Tim describes an ensemble of Gemini 2.0 Flash and Gemini 2.0 Pro and asks what 2.5 might unlock; Matej’s ablation wording is that adding Gemini 2.0 Pro improved results over Gemini 2.0 Flash alone. He says AlphaEvolve is currently “riding the wave” of frontier-model improvement.
Evolutionary test-time compute can lift capability beyond a base model far enough to make a scientific discovery. Matej’s open question is whether that improvement can be distilled back into the model by closing a reinforcement-learning loop; “the possibility is clearly on the table,” but the team has not done it.
Alexander resists treating greater autonomy as the sole destination. He favors richer human intervention—commenting on candidates, injecting ideas, refining questions—and plans trusted testing with academics while the team explores interfaces for this “symbiosis space.”
Cost remains deliberately unresolved. Tim cites “on the order of 100 compute hours” from section 2.3, but Matej gives no universal figure: easy problems may resolve almost immediately, hard decades-old questions can absorb sustained scaling, and open problems are often impossible to price beforehand. AlphaEvolve’s claim is elasticity and continued improvement, not predictable discovery on a fixed budget.

20VC: Tiger Global Saved by OpenAI & Coatue's Fund: Hype or Substance Random Ramblings May 2025