LEVI: How Smarter Evolutionary Search Beats Expensive AI Code Optimizers

The Expensive Problem with LLM-Driven Code Evolution

Google's AlphaEvolve showed that large language models can evolve code solutions through iterative mutation and selection — essentially letting AI write, test, and improve code across thousands of generations. The results were impressive. The costs were not.

Running evolutionary optimization with frontier models means thousands of LLM calls per experiment. Each call costs money. Multiply that across hundreds of evaluation cycles, and a single optimization run can burn through a significant API budget. Open-source implementations like OpenEvolve have made the approach accessible, but the fundamental cost problem remains: most evolutionary frameworks treat every mutation as equally important, throwing expensive compute at routine variations that don't need it.

Put simply: if evolution is mostly blind search with occasional breakthroughs, why pay premium prices for every single step?

What LEVI Actually Does Differently

LEVI, introduced by researcher ttanv on GitHub, tackles this with two architectural decisions that sound simple but produce outsized results.

Fingerprint-Based Diversity Instead of Pick-One Approaches

Previous frameworks forced a choice. OpenEvolve focused on structural diversity — keeping solutions that look different from each other. GEPA used performance-based diversity through Pareto fronts — keeping solutions that trade off objectives differently. Both approaches leave value on the table.

LEVI uses CVT-MAP-Elites with a behavioral fingerprint that combines both structural and performance-based diversity into a single map. The archive initializes centroids from structurally diverse seeds with noise perturbation, which prevents two common failure modes: overfitting to early strategies and wasting archive space on regions no program will ever reach.

For a non-technical analogy: imagine organizing a library. One system sorts purely by cover color (structure). Another sorts purely by reader ratings (performance). LEVI creates a map where both dimensions matter, so you never end up with a shelf full of identically-structured high-performers or a diverse collection of mediocre solutions.

Stratified Model Allocation — The Real Cost Saver

This is where the business math gets interesting. LEVI assigns cheap models to routine work and reserves expensive models for the rare moments that actually need creativity.

Most mutations in evolutionary search are incremental — small tweaks, parameter adjustments, minor restructuring. A 30-billion-parameter model like Qwen3-30B handles these perfectly well. Expensive frontier models only get called for paradigm-shift mutations where genuine novelty is needed.

The reasoning is grounded in precedent. As noted in the original discussion on r/MachineLearning, Google's FunSearch reached its breakthrough capset result using a roughly 30B-parameter model over a million mutations. Raw model intelligence isn't the primary driver of evolutionary breakthroughs — compounding blind search is.

Real Numbers: LEVI vs. the Competition

The UC Berkeley ADRS benchmark tests seven real-world systems problems: cloud scheduling, load balancing, SQL optimization, and more. Here are the controlled results — same evaluation budget (750 evaluations), three seeds per experiment:

LEVI wins or ties on every single problem. The cost savings range from 1.5x to 6.7x. On Cloudcast, it achieves a perfect score of 100 — a full 3.4 points above GEPA's 96.6 — while spending a third of the compute budget.

LEVI also beats AlphaEvolve's circle packing score while primarily using Qwen 30B, a model that costs a fraction of what Google's internal models cost to run.

Honest take: the most striking result isn't any individual score. It's that LEVI reaches competitive scores within 100 evaluations that neither OpenEvolve nor GEPA ever reached in 750. The gains come from search architecture, not from throwing a bigger model at the problem.

Why This Matters Beyond Benchmarks

For Teams Running AI-Assisted Code Optimization

OpenEvolve's own documentation lists per-iteration costs ranging from $0.01 (Gemini Flash) to $0.60 (o3), depending on model choice and code size. A typical evolution run involves hundreds to thousands of iterations. At the expensive end, a single experiment can cost hundreds of dollars. At scale — running multiple experiments across multiple problems — costs compound quickly.

LEVI's stratified approach means most of those iterations happen at the cheapest tier. Only the mutations that genuinely benefit from a stronger model get routed there. The savings aren't theoretical — they're baked into the benchmark results above.

For the Broader LLM-Agents Ecosystem

The insight generalizes beyond evolutionary code optimization. Many agentic AI workflows treat every step as equally important, routing every call through the most capable (and expensive) model available. LEVI demonstrates that intelligent task routing — cheap models for routine work, expensive models for critical decisions — can improve both performance and cost simultaneously.

This isn't a new idea in engineering. It's how every efficient system works: you don't use a crane to move a coffee cup. But in the current rush to build AI agents, the default is still "use the best model for everything."

Alternatives and Trade-Offs

OpenEvolve

OpenEvolve remains the most mature open-source AlphaEvolve implementation. It supports any OpenAI-compatible API, offers Docker deployment, and has a growing community. Its island-based population model is well-tested. For teams that already have OpenEvolve pipelines in production, the switching cost may not justify the savings on smaller-scale workloads.

GEPA

GEPA's Pareto-front approach works well for multi-objective problems where the trade-off surface itself is the deliverable — for example, when a team needs to see the full spectrum of cost-vs-performance options rather than a single best answer. LEVI subsumes this into its fingerprint, but GEPA's explicit Pareto visualization can be more interpretable for decision-makers.

AlphaEvolve (Google Internal)

Still not publicly available. The published results are strong, but they were achieved with Google-scale compute and proprietary models. LEVI matching or exceeding those results with an open-weight 30B model is the more practically relevant comparison for teams that don't have access to Google's infrastructure.

Doing Nothing (Manual Optimization)

As OpenEvolve's documentation notes, manual optimization requires weeks of domain expertise per problem, doesn't scale, and is hard to reproduce. Evolutionary approaches — whether LEVI, OpenEvolve, or GEPA — all dramatically compress that timeline to hours.

Key Takeaway for Business:

Three conclusions from LEVI's results:

1. Architecture beats brute force. A smarter search strategy with a cheap model outperforms a naive strategy with an expensive model. This applies to evolutionary code optimization specifically, but the principle holds across AI-assisted workflows. Here is what we recommend: before scaling up model size, audit whether your search or routing strategy is wasting compute on low-value steps.

2. Cost and quality are not opposed. LEVI doesn't sacrifice performance for savings — it improves both. The 6.7x cost reduction on Spot Single-Reg comes alongside a higher score. When someone claims that better results require proportionally more spend, ask for the benchmark data.

3. Open-weight models are production-viable for evolutionary workloads. Qwen3-30B driving most of LEVI's mutations — and beating systems that use frontier models — is a data point that should inform infrastructure decisions. Hosting a 30B model locally eliminates per-call API costs entirely, turning the cost advantage from 6.7x into something even larger over sustained use.

The code is available at github.com/ttanv/levi, and the technical details are documented at ttanv.github.io/levi. For teams already experimenting with LLM-driven code evolution, this is worth benchmarking against current workflows. For teams considering it for the first time, LEVI significantly lowers the entry cost.