Source: Google Cloud Blog — 2026-07-09

Summary

AlphaEvolve, Google DeepMind's Gemini-powered evolutionary coding agent, moved from private preview to general availability on the Gemini Enterprise Agent Platform. Rather than generating code once from a prompt, AlphaEvolve runs an evolutionary loop — you supply a seed program and a deterministic evaluator, and it repeatedly generates, scores, and mutates candidate code until it converges on something measurably better than what you started with. Early adopters reported concrete gains: BASF saw an 80% improvement to supply-chain planning models, Klarna doubled ML training pipeline throughput after the agent explored 6,000 candidate programs, and JetBrains got a 15-20% IDE performance boost.

Key Takeaways

• The workflow is a fixed four-step loop — Define (baseline algorithm, problem spec, context), Measure (scoring functions for correctness/performance/constraints), Optimize (AlphaEvolve's agentic harness generates and scores mutations against those metrics), Apply (deploy the winning candidate) — which is a meaningfully different shape than "prompt an LLM for code and take the first answer."
• Correctness is enforced structurally, not by trusting the model: you provide a deterministic, client-side evaluator script that compiles, tests, and scores every mutated candidate locally, and only scalar results get sent back to guide the next generation — the agent never gets to grade its own homework.
• The reported results span very different domains with very different numbers: BASF's supply-chain digital twin improved 80%, FM Logistic's warehouse routing improved 10.4% (15,000+ km of travel saved), Kinaxis got 22% accuracy gains with a 90% runtime reduction, and Pebble cut GPU-serving relative error by 56% — evidence this is a general-purpose optimization technique, not a narrow benchmark trick.
• Klarna's case is the most striking: doubled ML training pipeline throughput after AlphaEvolve explored roughly 6,000 candidate programs, including what Google describes as "deep architectural rewrites" the team hadn't considered — the kind of non-obvious change an evolutionary search can find that a single-shot code-generation prompt typically won't.

Reel Script

Hook: One company doubled its ML training throughput and another cut GPU-serving errors by more than half — not by hiring more engineers, but by letting an AI agent evolve their code through thousands of scored mutations instead of writing it once and hoping.

Core Concept: Most coding agents work like a very fast junior engineer: you describe what you want, it writes code, you review it. AlphaEvolve works differently — it's an evolutionary search. You give it a starting program and a scoring function, and it generates a population of mutated variants, tests each one against your metric, keeps the winners, mutates again, and repeats — the same basic loop biological evolution uses, but running in code space instead of gene space, with Gemini generating the mutations instead of random chance. The key design choice is that you, not the model, define what "better" means and how to measure it — the model explores; your evaluator judges.

Hands-On: The deployment loop has four named steps. Define: hand over a baseline algorithm plus the sections open to modification. Measure: write a deterministic evaluator — a script that compiles the candidate, runs tests, and produces scalar scores for correctness, performance, and any constraints you care about; this runs on your infrastructure, not Google's, so you keep control over what "correct" means. Optimize: AlphaEvolve's harness repeatedly queries for new candidate mutations, sends them to your evaluator, and uses the returned scores to decide what to try next — Klarna's team let this run through roughly 6,000 candidate programs before landing on a rewrite that doubled their training pipeline's throughput. Apply: once a candidate clears your bar, you deploy it like any other code change. The result table published alongside GA reads like a stress test across industries — genomics (PacBio, 30% fewer variant-detection errors), logistics (FM Logistic, 10.4% routing improvement), chip/semiconductor simulation (Substrate, multi-fold runtime speedup), and IDE tooling (JetBrains, 15-20% faster).

Takeaway: If you have a well-defined optimization problem with a fast, automatable way to score "better" — not vague code review, but a real metric — an evolutionary agent like this is worth prototyping before you spend weeks hand-tuning it yourself. The catch is that it's only as good as your evaluator: garbage scoring function in, garbage-but-confident optimization out.

Discussion