Google made AlphaEvolve generally available on July 9, 2026, moving its Gemini-powered algorithm-discovery agent out of private preview and onto the Gemini Enterprise Agent Platform for any Google Cloud customer. AlphaEvolve does not autocomplete code the way a copilot does. It runs an evolutionary search over thousands of candidate implementations, scores each one against a metric you define, and returns the version that measurably wins. Early adopters report concrete gains: BASF cut supply-chain planning error by 80%, JetBrains sped up IDE routines 15 to 20%, and Klarna doubled the throughput of a machine-learning training pipeline.
What Happened
AlphaEvolve started as a Google DeepMind research project, first detailed in a 2025 paper on designing advanced algorithms, where it found faster matrix-multiplication routines and improved data-center scheduling. The GA release turns that research harness into a product any team can point at its own optimization problems. You supply a working baseline program and a scoring function; AlphaEvolve mutates the code, tests every mutation, keeps what scores higher, and iterates until improvement plateaus.
The key shift is that this is no longer a demo with hand-picked benchmarks. It is a supported service with documentation, IDE integrations, and a public examples repository. That matters because the value of an evolutionary optimizer is entirely in whether you can wire it to your real code and your real metric, not a toy problem.
AlphaEvolve vs a Coding Copilot
It is easy to lump AlphaEvolve in with autocomplete assistants, but they solve different problems. A copilot helps you write code faster. AlphaEvolve searches for code you would not have written at all.
| Dimension | Coding Copilot | AlphaEvolve |
|---|---|---|
| Goal | Write and complete code faster | Discover a higher-scoring algorithm |
| Input | Prompt or partial code | Seed program + scoring function |
| Verification | Human review, tests you run | Automated evaluator scores every mutation |
| Output | A plausible completion | A measurably better implementation |
| Best for | Everyday development | Hard optimization with a clear metric |
| Runtime | Seconds, interactive | Many iterations, batch search |
The practical test for whether a problem fits AlphaEvolve is simple: can you write a script that takes a candidate solution and returns a number that says how good it is? If yes, the agent can optimize against it. If the goal is subjective or unscored, a copilot or a general agent like those in our coding-model routing breakdown is the better fit.
How It Works: The Four-Step Loop
Google frames AlphaEvolve as a four-step workflow, and each step maps to something you actually write:
- Define. Provide a baseline seed algorithm, mark the code segments that are open to change, and add problem context so the agent knows the constraints.
- Measure. Write a deterministic evaluator, a client-side script that compiles, runs, and scores each candidate on correctness, performance, and any operational limits.
- Optimize. AlphaEvolve's agentic harness generates mutations, runs them through your evaluator, and evolves the population toward higher scores.
- Apply. Take the winning implementation and deploy it to production like any other reviewed code.
The evaluator is the heart of the system and the part most teams underestimate. Because the agent optimizes exactly what you score, a sloppy metric produces fast-but-wrong code. A tight metric that captures correctness, edge cases, and real constraints is what turns the search into something you can ship. Google's developer guide and examples repository both lead with evaluator design for this reason.
What the Early Numbers Show
The GA announcement includes results from organizations that ran AlphaEvolve during preview. They span logistics, forecasting, GPU serving, and molecular science, which is a useful signal that the method generalizes beyond one domain.
| Organization | Use Case | Reported Result |
|---|---|---|
| BASF | Supply-chain planning and forecasting | 80% improvement in model quality |
| Kinaxis | Forecasting and optimization | 22% accuracy gain, 90% runtime reduction |
| Klarna | ML training pipeline | 2x throughput, better model quality |
| JetBrains | IDE performance routines | 15 to 20% faster |
| FM Logistic | Warehouse routing | 10.4% gain on an already-tuned baseline |
| Schrödinger | Molecular discovery | 4x speedup |
| Pebble | GPU inference serving | 56% lower performance-model error |
Two caveats are worth stating plainly. These are vendor-reported figures from the launch, not independent benchmarks, and every result depends on the baseline the team started from. A 10.4% gain on an already-optimized routing system is a very different achievement than a 10.4% gain on naive code.
What This Enables for Builders
For anyone building AI-powered products, AlphaEvolve turns a class of "good enough" problems into ones worth revisiting. Inference-serving code, prompt-batching schedulers, retrieval ranking functions, image or video pipeline stages, and cost-versus-quality tradeoffs all share the trait that makes them a fit: there is a number you care about, and you can measure it. Pebble's 56% error reduction on GPU inference serving is directly relevant to anyone running generative models at scale, where a better serving algorithm means lower latency and cost on the same hardware.
The GA release also plugs AlphaEvolve into tools builders already use. It is available through the Gemini Enterprise Agent Platform API and integrates with IDEs including Google's own Antigravity and Anthropic's Claude Code, so the optimize step can live next to where you write and review the rest of your code rather than in a separate console.
How to Try It
If you have a Google Cloud account, the fastest path to a real result is to pick one small, well-scored function rather than your hardest problem:
- Choose a bounded routine with an obvious metric, for example a ranking or scheduling function where you already log a quality number.
- Clone the alphaevolve-on-googlecloud repo and run one of the Colab examples end to end so you understand the loop before adapting it.
- Write the evaluator first and test it by hand on a few known-good and known-bad candidates; if it does not rank those correctly, the search will not either.
- Mark the smallest possible code region as mutable, seed it with your current implementation, and run a short optimization budget.
- Review the winning candidate like any pull request before it goes near production.
Because agentic coding tools are moving fast, it helps to see where a search-based optimizer sits alongside the broader field, such as the open agentic coders in our Tencent Hy3 deep dive. AlphaEvolve is not a replacement for those; it is the specialist you reach for when the win is measurable.
Frequently Asked Questions
Is AlphaEvolve free?
It is available through the Gemini Enterprise Agent Platform on Google Cloud. Google did not publish a standalone price at GA; usage falls under Gemini Enterprise Platform billing, so cost depends on your search budget and iterations.
How is AlphaEvolve different from a coding assistant like Claude Code or Copilot?
A coding assistant helps you write code interactively. AlphaEvolve runs an automated evolutionary search that scores thousands of candidate implementations against a metric you define and returns the highest-scoring one. It optimizes; assistants author.
What kinds of problems is it good for?
Any problem where you can write a deterministic script that scores a candidate solution: scheduling, routing, ranking, forecasting, inference serving, and similar optimization tasks. If the goal cannot be reduced to a number, it is not a fit.
What do I actually have to provide?
Two things: a seed program with the code regions you want optimized marked as mutable, and an evaluator script that compiles, runs, and scores each mutation. The quality of the evaluator determines the quality of the result.
Can I use it inside my existing IDE?
Yes. AlphaEvolve is accessible via API and integrates with IDEs including Google Antigravity and Claude Code, so you can run the optimize step near your normal development and review workflow.
Are the reported gains independently verified?
No. The 80% and 2x-style figures are self-reported by launch customers and depend heavily on each team's starting baseline. Treat them as directional evidence that the method works, not guaranteed outcomes for your workload.
