Evolutionary program search powered by large language models has become one of the most promising routes to automated algorithm discovery. The problem is cost. Systems in this category typically burn through thousands of candidate evaluations before landing on something worth keeping, which puts real scientific use out of reach for most teams. ShinkaEvolve, released by Sakana AI, attacks that bottleneck head-on. It reaches state-of-the-art results on tasks ranging from circle packing to mixture-of-experts training, and it does so with hundreds of samples instead of thousands.
The framework is open source under Apache 2.0, ships with a WebUI for tracking evolution runs, and works with any of the major LLM providers. The name comes from the Japanese word “shinka” (進化), meaning evolution or gradual development.
Why sample efficiency is the real bottleneck
Most LLM-driven evolutionary systems work like guided brute force. They mutate code, execute it, score it against a fitness function, and repeat. The mutations are smarter than random because an LLM writes them, but the outer loop still resembles random search. When each evaluation costs compute time and API calls, wasting cycles on near-duplicates or dead ends adds up quickly.
Sakana AI’s team observed that AlphaEvolve and similar closed-source systems, while capable, tend to consume enormous sampling budgets to find strong solutions. That expense limits who can actually run these experiments and slows the pace of discovery. ShinkaEvolve is designed around a different premise: fewer evaluations, smarter selection, and open access.
Three ideas that make ShinkaEvolve efficient
ShinkaEvolve combines three technical contributions that work together in the evolutionary loop.
Adaptive parent sampling
Instead of always mutating the current best program, ShinkaEvolve maintains a population organised into islands and draws parents through a fitness- and novelty-aware policy. The sampler can follow a power law or weight candidates by performance and offspring count, which keeps the search balanced between exploiting known good solutions and exploring genuinely new directions.
Novelty-based rejection filtering
Before any candidate is actually executed, ShinkaEvolve checks whether it is meaningfully different from what has already been tried. Mutable code segments are embedded, cosine similarity is computed against previous programs, and a secondary LLM acts as a novelty judge when the similarity is high. Uninteresting variations get filtered out before they consume evaluation budget.
Bandit-based LLM ensembling
The system does not commit to a single model. It routes mutation calls across an ensemble (GPT, Gemini, Claude and DeepSeek families are supported), tracks which model is delivering the biggest fitness gains on the current task, and updates its selection with a UCB1-style rule. As the search progresses and the nature of useful mutations shifts, the routing adapts.
Together these components turn evolution from a blind sampling process into something that closer resembles a directed search with memory.
Results across four very different domains
The Sakana AI team validated ShinkaEvolve on four tasks that stress different aspects of program evolution.
Circle packing
The n=26 circle packing benchmark asks for the tightest configuration of 26 circles inside a unit square. ShinkaEvolve set a new state of the art using roughly 150 program evaluations, where earlier systems typically needed thousands. The discovered algorithm blends a golden-angle spiral initialisation, gradient-based refinement with SLSQP, simulated annealing to escape local optima, and mechanisms like temperature reheating and ring rotations. None of that structure was hand-coded upfront.
AIME mathematical reasoning
Given the task of designing an agent scaffold for competition-level math problems, ShinkaEvolve evolved a three-stage architecture in 75 generations: a diverse expert-persona generation phase, critical peer review, and final synthesis. Under strict query-budget caps it traced out a Pareto frontier of accuracy against LLM calls that beat hand-built baselines. The scaffold also transferred to AIME problems from other years and to different underlying LLMs.
Competitive programming on ALE-Bench
Starting from solutions produced by ALE-Agent for AtCoder heuristic contests, ShinkaEvolve was used as a second-stage improver. It delivered an average gain of about 2.3 percent across ten tasks. On one problem the improvement was large enough that the resulting solution would have moved from 5th to 2nd place in a counterfactual leaderboard. The changes were targeted engineering wins: kd-tree subtree caching, novel “targeted edge move” operators that shift toward misclassified items, rather than wholesale rewrites.
Mixture-of-experts load balancing
In 30 generations ShinkaEvolve produced a new load-balancing loss function for training mixture-of-experts models. It adds an entropy-modulated under-use penalty on top of the global-batch objective, reducing miss-routing between experts. The evolved loss beat DeepSeek’s widely used Global LBL on perplexity and on seven downstream benchmarks, and it generalised to larger MoE models with five times more active parameters. Given the cost of training LLMs, this is exactly the kind of result where saving evaluations matters most.
Inside the evolutionary loop
Under the hood, ShinkaEvolve keeps an archive of every evaluated program along with its fitness, public metrics and textual feedback. Each generation samples an island and parents, builds a mutation context from top-k programs plus random “inspiration” candidates, and then proposes edits through three operators: diff edits for surgical changes, full rewrites for larger restructurings, and LLM-guided crossovers that combine ideas from multiple parents. Immutable code regions are protected with explicit markers so the evolution stays inside the parts of the program that are meant to change.
A meta-scratchpad periodically summarises which strategies have been working. Those summaries are folded back into future prompts, giving later generations a running memory of what has already paid off.
Working alongside human experts
One of the more interesting real-world case studies came from the 2025 ICFP Programming Contest, where Team Unagi took first place. The team fed their manually written Rust code for a SAT encoding to ShinkaEvolve and asked it to minimise solver execution time. Across 320 trials the system delivered roughly a 6.5x speedup on 18-room maze instances and a 10x speedup on 24-room instances, opening up 30-room problems that had previously been out of reach.
The more subtle outcome was conceptual. ShinkaEvolve discovered that adding an auxiliary variable for “door 1 of vertex A first connects to vertex B” let the solver reason about which vertices connect before pinning down which doors connect. That representational insight was general enough that the human team later reapplied it manually to other problems. The AI’s search produced not just a faster solution but a transferable idea.
What this means for open-ended discovery
The most consequential thing about ShinkaEvolve is not any single benchmark number. It is that a fully open, extensible discovery engine now exists that costs hundreds rather than thousands of evaluations per breakthrough. That changes who can plausibly run these experiments. A research group without hyperscaler budgets can point the framework at a scientific problem, a training procedure, or a piece of production code and expect meaningful progress within a realistic API spend.
The natural next step is harder than optimising against a well-defined fitness function. Sakana AI has flagged a future direction where the framework generates its own problems and evaluates its own solutions in domains like medicine or design, where success is not a single number you can maximise. That is where evolutionary code search starts to look less like a benchmark chaser and more like a genuine collaborator in research.
The quiet shift underneath
ShinkaEvolve is not trying to replace human researchers, and its most striking results so far involve working alongside them. The efficiency gains matter because they push LLM-driven evolution from a demonstration into a tool people can actually integrate into daily work. The framework’s real contribution may end up being cultural rather than technical: it treats sample efficiency as a first-class design goal, and it publishes everything needed to build on it.
