Google AlphaEvolve: AI Agent That Discovers Better Algorithms

Google AlphaEvolve — an AI agent that discovers and optimizes algorithms through evolutionary search — is now generally available on Google Cloud. After a year in private preview, the tool that helped Google optimize its own TPU chip layouts and reduce Spanner’s write amplification by 20% is open to any organization running algorithms that need to be faster, more efficient, or simply better than what human engineers have produced.

This is not a coding assistant. Google AlphaEvolve does not write your code from scratch or refactor your style. It takes a working algorithm, explores the vast space of possible optimizations, and returns human-readable code that outperforms the original. The distinction matters: this is the first AI tool specifically designed for algorithmic discovery at a level that has historically required PhD-level researchers and months of manual experimentation.

As we covered in our article on ChatGPT Work and autonomous agents, AI tools are moving beyond simple code generation. Google AlphaEvolve represents the next frontier — AI that discovers better algorithms, not just better code.

Key Takeaways About Google AlphaEvolve

Google AlphaEvolve is now generally available on the Gemini Enterprise Agent Platform for all Google Cloud customers.
It uses evolutionary search powered by Gemini models to discover optimized algorithms — not code generation from natural language.
Google has used Google AlphaEvolve internally to optimize TPU circuit layouts, reduce Spanner write amplification by 20%, and cut software storage footprints by nearly 9%.
Early external adopters include BASF, JetBrains, and Kinaxis, using it for logistics, software development, and supply chain optimization.
The tool requires only two inputs: a seed algorithm and a scoring function. Everything else is handled by the evolutionary search.
Google AlphaEvolve is available through the API, Colab notebooks, and as an IDE skill for Claude Code and Antigravity.

What Google AlphaEvolve Actually Does

To understand why Google AlphaEvolve matters, you need to understand the problem it solves.

Many of the hardest problems in computing are optimization problems. How do you route packages through a logistics network most efficiently? How do you arrange circuits on a chip to minimize signal delay? How do you schedule jobs on a manufacturing floor to maximize throughput? These problems have massive solution spaces — the number of possible approaches is so large that human engineers can only explore a tiny fraction of them.

Google AlphaEvolve approaches these problems the way biology approaches evolution: generate variations, test them against an objective, keep the best ones, and repeat. But instead of mutations happening randomly over millions of years, Google AlphaEvolve uses Gemini to make intelligent suggestions about which code changes might improve performance. It is directed evolution for algorithms.

The workflow is straightforward:

Define: You provide a seed algorithm — code that works but is not optimal — along with a problem description.
Measure: You write an evaluator that scores candidate solutions on metrics you care about: speed, accuracy, memory usage, or whatever your optimization target is.
Optimize: Google AlphaEvolve generates variations of your seed algorithm, evaluates them, and evolves the population toward better solutions over many generations.
Apply: You take the best-evolved algorithm and deploy it into production.

The key insight is that you do not need to know what a better algorithm looks like. You just need to be able to measure whether one is better. Google AlphaEvolve handles the creative work of discovering how to get there.

How Google Uses Google AlphaEvolve Internally

Before opening Google AlphaEvolve to customers, Google used it to solve problems that directly impact its infrastructure and products. The results are concrete and measurable.

TPU Circuit Optimization

Google AlphaEvolve discovered a counterintuitive circuit layout for next-generation Tensor Processing Units. The layout does not follow standard design heuristics — it is a configuration that human chip designers would not have considered, but which achieves better signal routing and power efficiency. This is the kind of optimization that saves Google millions of dollars in compute costs at scale.

Google Spanner Write Amplification

Spanner, Google’s globally distributed database, uses Log-Structured Merge-tree (LSM-tree) compaction to manage writes. Google AlphaEvolve optimized the compaction heuristics to reduce write amplification by 20%. Write amplification is a measure of how many times data must be rewritten internally — reducing it directly translates to lower storage costs and better write performance.

Compiler Optimization

Google AlphaEvolve discovered new compiler optimization strategies that reduced software storage footprints by nearly 9%. In a world where software bloat is a persistent concern, a 9% reduction at the compiler level is significant.

Scientific Research Contributions

Beyond infrastructure, Google AlphaEvolve has made contributions to scientific research. It improved predictive accuracy across 20 natural disaster risk categories by 5%, and discovered quantum circuits with 10x lower error rates for molecular simulations on Google’s Willow quantum processor.

These are not hypothetical improvements — they are deployed results in production systems serving billions of users.

What Makes Google AlphaEvolve Different From Other AI Coding Tools

The market is crowded with AI coding assistants. GitHub Copilot autocompletes code. Cursor provides an AI-native IDE. Claude Code and Codex handle agentic coding workflows. So why is Google AlphaEvolve different?

The difference is in what it optimizes for. Other AI coding tools optimize for developer productivity — writing code faster, reducing boilerplate, suggesting implementations. Google AlphaEvolve optimizes for algorithmic quality — finding code that performs better on measurable metrics than what a human would write.

This distinction matters because the two problems require fundamentally different approaches:

Code generation takes a description and produces functional code. The quality metric is “does it work correctly?”
Algorithm discovery takes working code and finds a better version. The quality metric is “does it perform better on specific measurements?”

Google AlphaEvolve is not a replacement for Copilot or Cursor. It is a complementary tool for a different kind of problem. You use Copilot when you need to write code. You use Google AlphaEvolve when you have code that works but needs to be faster, more efficient, or more accurate.

The Technical Architecture of Google AlphaEvolve

Google AlphaEvolve operates as a closed evolutionary loop with two halves:

Generation (cloud-side): A managed service runs the evolutionary heuristic. It uses a configurable mixture of Gemini models — currently gemini-3.5-flash and gemini-3.1-pro-preview — to propose code mutations. The models analyze the current population of candidate programs and suggest modifications that might improve performance.
Evaluation (your side): You provide an evaluator that runs each candidate and returns scalar metrics. The evaluator can be anything: a Python function, a compiled C++ binary, a full model-training run on a GPU cluster. The flexibility here is what makes Google AlphaEvolve applicable to such diverse problems.

The client library runs the loop that connects these two halves. It acquires candidates from the service, runs your evaluator, and submits scores and insights back. The service uses those scores to shape the next generation of candidates.

Real-World Applications: Where Google AlphaEvolve Shines

During the private preview, early adopters applied Google AlphaEvolve to several classes of problems:

Logistics and Supply Chain

Kinaxis, a supply chain management company, used Google AlphaEvolve to optimize routing and scheduling algorithms. The specific improvements are not public, but the general class of problem — NP-hard optimization with real-world constraints — is exactly what Google AlphaEvolve is designed for.

Software Development

JetBrains applied Google AlphaEvolve to optimize internal algorithms. For a company that builds developer tools where performance directly impacts user experience, even small algorithmic improvements compound across millions of users.

Chemical Engineering

BASF, the chemical company, used Google AlphaEvolve for optimization problems in chemical process design. The chemical industry involves complex simulations where computational efficiency directly affects research timelines.

High-Performance Computing

The HPC community has embraced Google AlphaEvolve for optimizing numerical algorithms, matrix operations, and parallel computation patterns. These are problems where the difference between a good algorithm and an optimal one can mean hours or days of saved compute time.

Financial Services

Financial firms have used Google AlphaEvolve to optimize trading algorithms, risk calculations, and portfolio optimization routines. In finance, microseconds of latency improvement translate directly to competitive advantage.

Getting Started with Google AlphaEvolve

Google AlphaEvolve requires two inputs, and only two:

A seed program: Your initial algorithm, written in code. It should be functionally correct — Google AlphaEvolve does not fix broken code. Mark which parts of the code are open to optimization using special comment markers.
An evaluator: A deterministic function that compiles, tests, and scores each candidate solution. The evaluator returns one or more scalar metrics that Google AlphaEvolve will maximize.

For example, if you are optimizing a scheduling algorithm:

Your seed program is the current scheduling logic.
Your evaluator runs the algorithm against a set of test cases and measures total completion time, resource utilization, or whatever metrics matter for your use case.
Google AlphaEvolve proposes variations of the scheduling logic, you evaluate them, and the best ones evolve into the next generation.

Google provides Colab notebooks with working examples, including circle packing, Travelling Salesman heuristics, and bin packing problems. These are good starting points for understanding how the system works before applying it to your own problems.

What Google AlphaEvolve Is Not

It is worth being explicit about limitations:

It is not a code generator. It does not take natural language descriptions and produce working code. It optimizes existing, functional algorithms.
It is not a linter or style tool. It does not clean up code according to best practices. It searches for performance improvements.
It requires measurable objectives. If you cannot define a scoring function, Google AlphaEvolve cannot optimize against it.
It is not instant. Evolutionary search takes time. Depending on the problem complexity and your evaluation budget, runs can take hours to days.
It is cloud-based. The generation half runs on Google Cloud. If your code or data cannot leave your environment, Google AlphaEvolve may not be suitable.

Google AlphaEvolve Pricing and Availability

Google AlphaEvolve is available through the Gemini Enterprise Agent Platform on Google Cloud. Pricing follows the Gemini Enterprise model — you pay for the Gemini API calls made during the generation phase, plus any compute resources used for your evaluator.

The client library is open-source and available on GitHub. Google provides examples for local evaluation, Cloud Run deployment, and GKE-based GPU workloads.

The Bigger Picture: AI-Optimized Code as Infrastructure

Google AlphaEvolve represents a shift in how we think about code quality. For decades, the best algorithms were those that human researchers and engineers could conceive. Google AlphaEvolve suggests that for certain classes of problems, AI-discovered algorithms can outperform human-designed ones.

This has implications beyond individual optimization tasks. If AI can discover better algorithms for chip design, database compaction, and quantum error correction, it can likely do the same for thousands of other computational problems across industry. The organizations that adopt algorithmic optimization early will have a compounding advantage — better algorithms mean faster computation, which means lower costs, which means more resources for further optimization.

Google’s own results — 20% reduction in Spanner write amplification, 9% storage reduction, improved TPU layouts — demonstrate that the technology is ready for production workloads. The question is not whether AI-discovered algorithms will become standard practice. It is how quickly organizations will adopt them.

Frequently Asked Questions About Google AlphaEvolve

Do I need to be a machine learning expert to use Google AlphaEvolve?

No. You need to be able to write a seed algorithm and a scoring function in your programming language of choice. Google AlphaEvolve handles the evolutionary search and code mutation internally. Domain expertise in your optimization problem is more valuable than ML expertise.

What programming languages does Google AlphaEvolve support?

The seed program can be in any language that your evaluator can compile and run. The Google AlphaEvolve client library is Python, but the actual algorithm being optimized can be C++, Rust, Go, or any other language.

How long does a typical Google AlphaEvolve optimization run take?

It depends on the complexity of the problem, the size of the solution space, and your evaluation budget. Simple problems can show improvements in minutes. Complex optimization tasks with expensive evaluators may take hours or days.

Can Google AlphaEvolve optimize machine learning training pipelines?

Yes. One of the example deployments uses GKE + Ray for GPU-based evaluation, specifically for optimizing model training. If your training pipeline is slow and you can measure what “better” looks like, Google AlphaEvolve can search for improvements.

Is the evolved code from Google AlphaEvolve human-readable?

Yes. Google AlphaEvolve returns actual source code, not abstract representations. You can read, understand, and modify the evolved algorithms.

How does Google AlphaEvolve compare to AutoML or neural architecture search?

Google AlphaEvolve is broader than AutoML, which focuses specifically on machine learning model architectures and hyperparameters. Google AlphaEvolve can optimize any code that can be scored — from sorting algorithms to logistics routing to chip design. It is a general-purpose algorithmic optimization tool, not a machine learning-specific one.

Google AlphaEvolve Goes Public: The AI Agent That Discovers Better Algorithms Than Humans Can Write

Key Takeaways About Google AlphaEvolve

What Google AlphaEvolve Actually Does