When the Search Loop Meets Production
AlphaEvolve’s production cases test whether evolutionary code search can improve a live computational system without being allowed to violate the system’s essential rules. This chapter compares four applications—data-center scheduling, accelerator tiling, TPU circuit design, and compiler-generated code—through the same questions: what decision is exposed to evolution, what the evaluator measures, what remains protected, and how local gains become evidence for deployment. The comparison shows that a constrained interface can make an optimization useful, but the closer a candidate gets to underlying hardware or compiler machinery, the more verification matters.
A safe subdecision can still recover capacity
Google’s Borg scheduler assigns compute jobs to machines with limited resources. The difficulty is not only deciding whether a job can run. A machine may have free CPU but insufficient memory, or free memory but insufficient CPU. Once one resource is exhausted, the remaining capacity can become stranded even though the machine is not fully occupied. Improving the ranking of eligible machines can therefore make more work fit into the same computational footprint.
AlphaEvolve framed this decision as a two-variable vector bin-packing problem. An incoming job has CPU and memory requirements; a candidate machine has available CPU and memory. The evolved heuristic receives those quantities and returns a priority score. Borg then ranks the machines according to that score, but only among machines it has already determined are available and capable of running the job.
That interface is the important safety boundary. AlphaEvolve is not given authority to override capacity checks or assign a job to an ineligible machine. It changes the ordering within a set of permitted choices. The paper therefore describes the resulting scheduling decisions as effectively correct by construction: the heuristic can influence which valid placement is preferred, while the surrounding scheduler retains responsibility for basic eligibility.
The evaluator also mirrors the production environment rather than relying only on a toy objective. The researchers used a data-center simulator with historical snapshots of workloads and capacity. They evaluated the candidate on unseen recent workloads and capacity data to test whether the heuristic generalized beyond the examples used during evolution. After the evolved heuristic outperformed the production one in this setup, it was rolled out across Google’s fleet. Post-deployment measurements, according to the paper, showed an average recovery of 0.7% of fleet-wide compute resources that would otherwise have been stranded.
The result is operationally meaningful because a small percentage of a large fleet can represent substantial capacity. It is also narrower than a claim that AlphaEvolve solved scheduling. The heuristic optimizes one ranking decision within Borg’s larger system and under the workloads and resources described by the authors. It does not replace the scheduler, eliminate the underlying bin-packing difficulty, or guarantee that every future workload will behave like the evaluation data.
The comparison with deep reinforcement learning makes another design choice visible.