Google's AlphaEvolve Coding Agent Just Went GA — It Already Doubled Klarna's ML Training Throughput, But the Compute Bill Is the Catch

A Research Artifact Just Became a Cloud Product

On July 9, 2026, Google Cloud announced that AlphaEvolve is now generally available to every Google Cloud customer, moving off the invite-only early access list it had run since last year and onto the Gemini Enterprise Agent Platform with a free trial available directly from the Cloud Console. AlphaEvolve is a Gemini-powered evolutionary coding agent built by Google DeepMind: instead of writing code once and moving on, it repeatedly mutates a candidate program, scores it against a deterministic evaluator, and keeps the mutations that win — closer to a genetic algorithm wearing an LLM as its mutation operator than to a chat-style coding assistant. The GA launch is the clearest signal yet that "agent that discovers algorithms" is becoming its own product category, not just a DeepMind research demo.

It Spent a Year Optimizing Google Before Anyone Outside Could Use It

AlphaEvolve wasn't built for this launch. Before Google opened it to outside customers, the same system had already been rewriting pieces of Google's own infrastructure: reclaiming compute across Google's global fleet, refining circuit layouts for Google's TPU chips, cutting write amplification in Spanner's log-structured-merge-tree compaction by roughly 20%, trimming software storage footprint by about 9% through compiler-level optimization, and discovering quantum circuits that cut error rates on the Willow quantum processor by a factor of 10. That track record inside Google's own data centers is doing a lot of the marketing work for the external launch — the case studies aren't hypothetical, they're what the tool already did to the infrastructure GA customers are now renting.

How It Actually Works: Seed, Score, Mutate, Ship

Using AlphaEvolve means supplying two things: a seed program — your baseline algorithm with the segments you want optimized marked out — and an evaluator, a deterministic script that scores any candidate solution on correctness, performance, and whatever constraints matter to you. From there the workflow follows four steps Google calls Define, Measure, Optimize, and Apply: a client-side runner queries the AlphaEvolve API for mutated candidates, evaluates them locally against your evaluator, and feeds the scores back so the next generation of mutations improves. Your proprietary code and data don't have to leave your evaluation environment — only the mutated candidate and its score cross the wire — which is the detail Google leans on hardest for enterprise buyers wary of sending algorithms to a third-party model.

The Early-Access Numbers Are Hard to Wave Away

The case studies Google published alongside the GA announcement span a genuinely wide set of industries. Klarna used AlphaEvolve to explore roughly 6,000 candidate programs over three weeks and came out with double the throughput on its ML training pipeline while improving model quality. Schrödinger got a 4x speedup on the molecular simulations it uses for drug discovery. Kinaxis reported a 22% accuracy improvement on its forecasting algorithms alongside a 90% cut in runtime. JetBrains used it to find a 15-20% performance improvement inside its IDE. FM Logistic optimized warehouse routing by 10.4%, saving its staff more than 15,000 kilometers of travel. None of these are toy benchmarks — they're production pipelines at companies with existing engineering teams who presumably already knew how to optimize their own code.

The Catch: A Single Discovery Run Can Eat 100 Compute-Hours

The number engineering teams should sit with before enabling AlphaEvolve on anything is the compute cost of evaluation, not the API call itself. Independent reporting on the GA rollout put the cost of evaluating a single new candidate solution at on the order of 100 compute-hours, which is why AlphaEvolve deployments lean so heavily on parallelizing the evaluation step. Developer commentary following the launch has been blunt about what that means in practice: an unattended run left looping overnight is exactly the kind of thing that can quietly become 80% of a monthly cloud bill, and Google's own materials are candid that enterprise teams still need clear pricing, workload boundaries, data-handling controls, and evidence of repeatability before they should treat AlphaEvolve as a standard part of their production stack rather than a research experiment with a credit card attached.

It's Positioned as a Specialist, Not a Claude Code Competitor

Google is explicit that AlphaEvolve isn't trying to replace the coding agent a team already uses day to day — its own documentation lists IDE integration via Antigravity or Claude Code as a supported path, framing AlphaEvolve as a narrow specialist you call in for a specific class of problem: well-defined optimization tasks with a cheap, deterministic way to score a candidate solution. That's a meaningfully different shape than a general-purpose coding assistant, and it's a useful signal about where the agentic-coding market is heading — not one agent that does everything, but a general-purpose orchestrator like Claude Code or Antigravity calling out to narrow, purpose-built agents like AlphaEvolve for the sliver of work they're actually good at.

What This Means for Engineering Teams Evaluating It Today

If your team is looking at AlphaEvolve after this GA launch, the case studies suggest it's genuinely good at one thing: squeezing measurable performance out of a well-scoped algorithm where you can write a cheap, deterministic evaluator — forecasting pipelines, routing logic, storage compaction, simulation kernels, the kind of code with a clear objective function. It is not a general substitute for a coding agent, and the roughly 100-compute-hour-per-candidate reality means it needs the same treatment you'd give any expensive batch job: hard caps on runtime and candidate count before the first run, not after the first surprising invoice. Start with a problem narrow enough that you can evaluate the win in a single afternoon, and only then decide whether it earns a permanent spot next to whatever agent already writes your code day to day.

Bottom Line

AlphaEvolve's move from research artifact to a generally available Google Cloud product is less a new coding-agent launch than a maturing of a category: LLM-guided evolutionary search applied to algorithm optimization, validated first inside Google's own infrastructure and now rented out to customers who can already point to Klarna's doubled throughput and Schrödinger's 4x simulation speedup as proof it works. The unresolved part is cost discipline — a single candidate evaluation running roughly 100 compute-hours means the tool rewards teams that scope tightly and punishes teams that let it run loose, and Google's own launch materials all but admit that pricing and workload guardrails are still catching up to what the product can now do.