Blog

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

Google DeepMind’s 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 isn’t a coding assistant. AlphaEvolve doesn’t 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.

Key Takeaways

  • 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 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.
  • AlphaEvolve is available through the API, Colab notebooks, and as an IDE skill for Claude Code and Antigravity.

What AlphaEvolve Actually Does

To understand why 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.

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, AlphaEvolve uses Gemini to make intelligent suggestions about which code changes might improve performance. It’s directed evolution for algorithms.

The workflow is straightforward:

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

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

How Google Uses AlphaEvolve Internally

Before opening 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

AlphaEvolve discovered a counterintuitive circuit layout for next-generation Tensor Processing Units. The layout doesn’t follow standard design heuristics — it’s a configuration that human chip designers wouldn’t 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. AlphaEvolved 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

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, 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 aren’t hypothetical improvements — they’re deployed results in production systems serving billions of users.

What Makes 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 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. 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?”

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

The Technical Architecture

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 AlphaEvolve applicable to such diverse problems.

The client library (alpha_evolve) 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.

For deployment, Google provides several options:

  • Local evaluation: Run the evaluator in a local exec() sandbox. Good for simple algorithms and prototyping.
  • Cloud Run: Deploy the evaluator as a serverless function. Scales automatically with candidate volume.
  • GKE + Ray: For large-scale optimization that requires GPU resources, such as optimizing model training pipelines.

Real-World Applications: Where AlphaEvolve Shines

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

Logistics and Supply Chain

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

Software Development

JetBrains applied 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 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 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 AlphaEvolve to optimize trading algorithms, risk calculations, and portfolio optimization routines. In finance, microseconds of latency improvement translate directly to competitive advantage.

Getting Started: What You Need

AlphaEvolve requires two inputs, and only two:

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

For example, if you’re 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.
  • 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 AlphaEvolve Is Not

It’s worth being explicit about limitations:

  • It’s not a code generator. It doesn’t take natural language descriptions and produce working code. It optimizes existing, functional algorithms.
  • It’s not a linter or style tool. It doesn’t clean up code according to best practices. It searches for performance improvements.
  • It requires measurable objectives. If you can’t define a scoring function, AlphaEvolve can’t optimize against it. Some problems — like “make this code more readable” — aren’t suitable.
  • It’s not instant. Evolutionary search takes time. Depending on the problem complexity and your evaluation budget, runs can take hours to days.
  • It’s cloud-based. The generation half runs on Google Cloud. If your code or data can’t leave your environment, AlphaEvolve may not be suitable.

Pricing and Availability

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

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. 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 isn’t whether AI-discovered algorithms will become standard practice. It’s how quickly organizations will adopt them.

Frequently Asked Questions

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

No. You need to be able to write a seed algorithm and a scoring function in your programming language of choice. 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 AlphaEvolve support?

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

How long does a typical 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. Google’s documentation includes guidance on setting appropriate budgets.

Can 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, AlphaEvolve can search for improvements.

Is the evolved code human-readable?

Yes. AlphaEvolve returns actual source code, not abstract representations. You can read, understand, and modify the evolved algorithms. This is a deliberate design choice — Google wants AlphaEvolve’s output to be inspectable and maintainable by human engineers.

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

References

Suggested Further Reading

Leave a Reply