--- abstract: | Fine-tuning large language models (LLMs) for downstream tasks is an essential stage of modern AI deployment. Reinforcement learning (RL) has emerged as the dominant fine-tuning paradigm, underpinning many state-of-the-art LLMs. In contrast, evolution strategies (ES) has largely been overlooked due to the widespread belief that it does not scale to modern model sizes. This paper overturns this assumption by demonstrating the first successful application of ES to full-parameter fine-tuning of LLMs at the billion-parameter scale, without dimensionality reduction. ES can indeed search over extremely high-dimensional parameter spaces and outperform established RL implementations across multiple axes, including improved tolerance to long-horizon and delayed rewards, robustness across diverse base LLMs, reduced susceptibility to reward hacking, and improved training stability. These findings suggest that ES is not merely a viable alternative to RL, but a fundamentally different and powerful backpropagation-free post-training paradigm that opens a new direction for LLM fine-tuning beyond current RL-based approaches. The source codes are provided at: . bibliography: - example\_paper.bib --- ```{=latex} \newcommand{\cmark}{\ding{51}} ``` ```{=latex} \newcommand{\xmark}{\ding{55}} ``` ```{=latex} \renewcommand{\theHalgorithm}{\arabic{algorithm}} ``` ```{=latex} \newcommand{\conor}[1]{{\color{teal} CONOR: #1}} ``` ```{=latex} \newcommand{\xin}[1]{{\color{blue} XIN: #1}} ``` ```{=latex} \newcommand{\yulu}[1]{{\color{purple} YULU: #1}} ``` ```{=latex} \newcommand{\roberto}[1]{{\color{orange} ROBERTO: #1}} ``` ```{=latex} \newcommand{\jamie}[1]{{\color{green} JAMIE: #1}} ``` ```{=latex} \twocolumn[ \icmltitle{Evolution Strategies at Scale: \\LLM Fine-Tuning Beyond Reinforcement Learning} % It is OKAY to include author information, even for blind submissions: the % style file will automatically remove it for you unless you've provided % the [accepted] option to the icml2026 package. % List of affiliations: The first argument should be a (short) identifier you % will use later to specify author affiliations Academic affiliations % should list Department, University, City, Region, Country Industry % affiliations should list Company, City, Region, Country % You can specify symbols, otherwise they are numbered in order. Ideally, you % should not use this facility. Affiliations will be numbered in order of % appearance and this is the preferred way. \icmlsetsymbol{equal}{*} \icmlsetsymbol{lead}{\textdagger} \icmlsetsymbol{intern}{\textdaggerdbl} \begin{icmlauthorlist} \icmlauthor{Xin Qiu}{equal,lead,cognizant} \icmlauthor{Yulu Gan}{equal,intern,mit} \icmlauthor{Conor F. Hayes}{equal,cognizant} \icmlauthor{Qiyao Liang}{intern,mit} \icmlauthor{Yinggan Xu}{intern,ucla} \icmlauthor{Roberto Dailey}{cognizant}\\ \icmlauthor{Elliot Meyerson}{cognizant} %\icmlauthor{}{sch} \icmlauthor{Babak Hodjat}{cognizant} \icmlauthor{Risto Miikkulainen}{cognizant,ut} %\icmlauthor{}{sch} %\icmlauthor{}{sch} \end{icmlauthorlist} \icmlaffiliation{ucla}{University of California, Los Angeles, Los Angeles, CA, USA} \icmlaffiliation{cognizant}{Cognizant AI Lab, San Francisco, CA, USA} \icmlaffiliation{ut}{The University of Texas at Austin, Austin, TX, USA} \icmlaffiliation{mit}{Massachusetts Institute of Technology, Cambridge, MA, USA} \icmlcorrespondingauthor{Xin Qiu}{qiuxin.nju@gmail.com} % You may provide any keywords that you find helpful for describing your % paper; these are used to populate the "keywords" metadata in the PDF but % will not be shown in the document \icmlkeywords{Machine Learning, ICML} \vskip 0.3in ] ``` `\printAffiliationsAndNotice{\icmlEqualContribution. \textsuperscript{\textdagger}Project Lead. \textsuperscript{\textdaggerdbl}Work done during an internship at Cognizant AI Lab.}`{=latex} Introduction {#sec:intro} ============ As the capabilities of large language models (LLMs) have rapidly improved, these systems have been increasingly deployed across scientific and engineering workflows [@touvron2023llama2; @openai2024gpt4; @llama3modelcard; @jiang2024mixtral; @liu2024deepseek; @claude4; @gemini25; @singhal2023expertlevel; @wu2023bloomberggpt; @roziere2024code; @Romera-Paredes2024math]. This widespread deployment has made fine-tuning a standard step for adapting pre-trained models to downstream tasks and aligning behavior with user preferences [@ouyang2022rlhf; @rafailov2023dpo; @latif2024score; @deepseekai2025deepseekr1]. In practice, reinforcement learning (RL) has become the predominant choice for this fine-tuning stage [@ouyang2022rlhf; @bai2022assistant; @shao2024grpo; @deepseekai2025deepseekr1; @liang2025deepseeknature; @srivastava2025rlsurvey]. However, several challenges have emerged: First, RL methods incur low sample efficiency and high variance of the gradient estimator when handling long-horizon rewards, which is a common case for LLM fine-tuning with outcome-only rewards [@salimans2017es; @sutton2018reinforcement; @vemula2019contrast]. Proper credit assignment at token level for RL fine-tuning methods is difficult and possibly unhelpful [@zhang2025lessons; @song2025prmbench; @liang2025deepseeknature; @uesato2022math; @jia2025need; @liang2025deepseeknature]. Second, RL techniques are sensitive to the choice of base LLMs, resulting in inconsistent fine-tuning performance across different models [@gandhi2025cognitive]. Third, RL techniques tend to incentivize hacking the reward function, leading to undesirable behaviors [@gao2023scaling; @denison2024tampering; @fu2025shaping]. Fourth, RL fine-tuning is often unstable across multiple runs even with the same hyperparameter settings, significantly increasing fine-tuning cost [@choshen2020instablerl; @zhong2025dpo]. Evolution Strategies (ES), a class of population-based zeroth-order optimization algorithms, is a possible alternative. ES has several advantages over RL in traditional control and gaming problems: it parallelizes naturally, tolerates long-horizon rewards, promotes broad exploration, avoids expensive backpropagation, and remains robust across hyperparameter settings [@salimans2017es; @chrabaszcz2018; @conti2018]. However, ES remains relatively underexplored in LLM fine-tuning settings. Standard ES directly optimizes in the full parameter space, which in prior applications typically contained no more than a few million parameters [@salimans2017es; @zhang2017essgd; @lehman2018esmore; @lorenc2025estransformer]. It was assumed that for very large models, exploration in parameter space is significantly more difficult and sample-inefficient than exploration in action space [@vemula2019contrast]. Modern LLMs typically contain billions of parameters, which makes direct ES optimization appear infeasible. Existing workarounds include restricting ES to the final layer of the base model [@toledano2022mt5], applying ES to low-dimensional adapters [@jin2024lowrank], and performing evolutionary search in action space, analogous to standard RL [@huang2025evolution]. Directly searching in the full parameter space of LLMs (without dimensionality reduction) has remained a challenge. This paper is aimed at meeting this challenge. For the first time, ES is scaled to multi-billion-parameter search spaces through direct optimization of the full parameter space of LLMs during fine-tuning. The approach is based on a memory-efficient implementation of an algorithmically simplified ES variant, with support for parallelization across GPUs. Performance is compared with state-of-the-art (SOTA) RL methods in fine-tuning various LLMs in several reasoning benchmark tasks, and behavioral differences from RL are analyzed in terms of fine-tuning for conciseness. Furthermore, ES fine-tuning is successfully applied to solve two puzzle problems that are challenging for base LLMs. ES was found able to search directly over billions of parameters without dimensionality reduction while achieving strong fine-tuning performance relative to RL in multiple aspects: (1) *ES only needs response-level rewards*, making it a perfect fit for fine-tuning on reasoning tasks that have only sparse long-horizon outcome rewards. In particular, ES obtained significantly better fine-tuned models than RL in the Countdown task with such rewards. (2) *ES is able to find good solutions in large space with small populations*, e.g. just 30 in the multi-billion-parameter space in this paper. As a comparison, previous ES implementations [@salimans2017es; @zhang2017essgd; @lehman2018esmore; @lorenc2025estransformer] utilized a population size of 10,000 or more with much smaller models (i.e. millions of parameters or less). The current extremely small population size thus makes the approach feasible even without extensive compute. (3) *ES is more robust* than RL across different LLMs. While RL fine-tuning failed on some LLMs, ES provided good fine-tuning for all of them. ES benefits from its exploration in parameter space, making it less sensitive to initial states of the LLMs. (4) *ES consistently maintains reasonable behaviors* during fine-tuning, in contrast to RL that tends to hack the reward function if no other penalty is added. The main reason is that ES optimizes a solution distribution [@lehman2018esmore], which is more difficult to hack, while RL optimizes a single solution. (5) *ES's behavior is more consistent* than RL's across different runs. This property can significantly reduce expected cost of fine-tuning. (6) *Fine-tuning with ES only requires inference*, and therefore no gradient calculations are needed. A significant amount of GPU memory can therefore be saved. Thus, this study establishes a critical first milestone in demonstrating that ES can serve as a viable and powerful post-training paradigm for LLMs. The results reveal a surprising and counterintuitive finding that ES remains effective when scaled to models with billions of parameters, directly challenging the long-held assumption that such methods are inherently unscalable. These findings not only motivate further scaling to even larger LLMs, but fundamentally expand the design space of post-training algorithms. By operating directly in parameter space without reliance on gradients or intermediate supervision, ES enables new forms of outcome-only optimization, robust exploration over high-dimensional parameter landscapes, and naturally distributed large-scale fine-tuning. Taken together, this paper positions ES as a foundational alternative to gradient-based RL and opens a new direction for scalable, stable, and general LLM post-training. Related Work ============ The background on Evolution Strategies and evolutionary optimization of LLMs is first reviewed, followed by SOTA RL fine tuning and parameter-space exploration. **Traditional ES:** Evolution Strategies [ES, @rechenberg1973es; @schwefel1977es] are a class of evolutionary algorithms (EAs) for solving numerical optimization problems. The main idea is to sample a population of solutions through perturbations, then recombine the perturbed solutions based on their fitness values to form the population for the next generation. This process repeats until a termination condition is triggered, e.g., the maximum number of generations is reached. Among the different variants of ES, CMA-ES [@hansen2001cmaes], which utilizes a multivariate Gaussian distribution with full covariance matrix to sample the population, and natural ES [@wierstra2008; @wierstra14a], which uses natural gradient to guide the search, are two popular methods for traditional optimization problems. Although ES has long been used to evolve parameters of neural networks (NNs), [@igel:cec03], @salimans2017es were the first to scale the approach up to deep learning networks. Comparable performance to RL methods in control and gaming environments was observed, and several unique advantages of ES highlighted. This seminal work paved the way for several follow-up studies. @zhang2017essgd used ES to optimize a convolutional NN with around three million parameters. They found that with a large enough population size, ES can approximate the performance of traditional stochastic gradient descent (SGD). @lehman2018esmore further optimized a NN comprising nearly 167,000 parameters with both ES and a finite-difference (FD) gradient estimator. Because ES optimizes the average reward for the entire population, whereas FD optimizes the reward for a single solution, it obtained models that were more robust to parameter perturbations. @lorenc2025estransformer applied ES to optimize decision transformers in RL environments, and observed promising results for model sizes up to around 2.5 million parameters. In a related study, another traditional EA, namely genetic algorithm (GA) with mutations only, was extended to a high-dimensional space [@such2017DeepNG]. Encouraging results were observed in different types of models with up to around four million parameters [@such2017DeepNG; @risi2019gaworld]. However, although these studies were promising, the scale of these implementations was still significantly less than the size of current LLMs. **Evolution+LLMs:** Synergies between Evolutionary Algorithms (EAs) and LLMs have received increasing attention in recent years [@wang2025eallm; @xingyu2025eallm]. Popular research directions include EAs for prompt optimization [@sun2022bbt; @sun2022bbtv2; @zhao2023gaprompt; @guo2024connecting], utilizing LLMs as evolutionary operators [@meyerson2024lmx; @lehman2024evolm; @Romera-Paredes2024math; @novikov2025alphaevolve], and merging LLMs through evolution [@du2024fusion; @akiba2025merge]. Applying EAs to optimize billions of parameters in LLMs is generally perceived to be intractable, but a few studies have been successful at a smaller scale. For example, @toledano2022mt5 fine-tuned the last layer (with 325 parameters) of an mT5-based transformer via CMA-ES. @jin2024lowrank optimized the low-rank adapter parameters (with dimensionality up to 1600) using CMA-ES and the Fireworks algorithm. @sanchez2024gatransformer applied a GA to fine-tune around 9.5 million parameters of a transformer encoder, though poorer performance than the traditional Adam optimizer was observed. @huang2025evolution proposed a hybrid algorithm that performs exploration in action space instead of parameter space, and it was only used in the final epoch of supervised fine-tuning (SFT). The work in this paper significantly extends this prior research by successfully scaling ES to search in the billions of parameters of LLMs, leading to surprisingly good fine-tuning performance. **RL for fine-tuning:** Fine-tuning using RL is a critical step during the training of many landmark LLMs [@ouyang2022rlhf; @bai2022assistant; @shao2024grpo; @deepseekai2025deepseekr1; @liang2025deepseeknature]. Proximal Policy Optimization [PPO; @schulman2017ppo] and Group Relative Policy Optimization [GRPO; @shao2024grpo] are the two predominant methods. PPO introduces a clipped surrogate objective to limit the update scale in each step with respect to the old policy, and it usually works with a value model in an actor-critic manner. GRPO simplifies the pipeline of PPO by replacing the value model with group advantage, which is calculated based on direct evaluations of multiple responses. As discussed in Section `\ref{sec:intro}`{=latex}, in the context of LLM fine-tuning, these methods struggle with several fundamental limitations, including the dilemma in handling long-horizon reward [@vemula2019contrast; @salimans2017es; @zhang2025lessons; @song2025prmbench; @uesato2022math; @jia2025need; @liang2025deepseeknature], sensitivity to base LLMs [@gandhi2025cognitive], tendency to hack reward [@gao2023scaling; @denison2024tampering; @fu2025shaping], and instability across runs [@choshen2020instablerl; @zhong2025dpo]. ES inherently avoids these limitations, leading to better fine-tuning performance. **Parameter-space exploration:** Existing RL fine-tuning methods are overwhelmingly based on action-space exploration. Parameter space exploration has received much less attention, though some such studies do exist [@thomas2008state; @sehnke2010parameter; @thomas2010parameter; @plappert2018parameter]. Although promising performance was observed in problems with sparse rewards, the scale of the tested models was far smaller than that of LLMs. @vemula2019contrast performed a theoretical analysis of different exploration strategies, and found that the complexity of the parameter space exploration increased quadratically with the number of parameters, whereas the complexity of action space exploration depended on action dimensionality quadratically and horizon length of the reward quartically. Based on the classical SPSA method [@spall1992spsa], @malladi2023mezo proposed a zeroth-order optimizer MeZO that directly worked in parameter space for fine-tuning LLMs. MeZO significantly reduced memory requirements, but its fine-tuning performance was no better than other baselines. In contrast, the ES implementation in this paper performs exploration in multi-billion-parameter search spaces, and exhibits strong performance across different benchmarks. Method ====== This section introduces the basic algorithmic structure of ES, followed by a detailed description of its implementation for LLM fine-tuning. Basic ES algorithm ------------------ The ES implementation used in this paper is based on a simplified variant of Natural Evolution Strategies (NES) [@wierstra2008; @wierstra14a] and follows the design of OpenAI ES [@salimans2017es], which employs fixed-covariance perturbation noise. ```{=latex} \begin{algorithm}[t]\caption{Basic ES Algorithm} \label{alg:es-llm_general} \begin{algorithmic}[1] \Require Pretrained LLM with initial parameters $\bm{\theta}_0$, reward function $R(\cdot)$, total iterations $T$, population size $N$, noise scale $\sigma$, learning rate $\alpha$. \For{$t = 1$ to $T$} \Comment{outer ES iterations} \For{$n = 1$ to $N$} \State Sample noise $\bm{\varepsilon}_n \sim \mathcal{N}(0,\bm{I})$ \State Compute reward for perturbed parameters: \Statex\hspace{\algorithmicindent}\hspace{\algorithmicindent}$R_n=R(\bm{\theta}_{t-1}+\sigma \cdot \bm{\varepsilon}_n)$ \EndFor \State Normalize $R_n$ \State Update model parameters as \Statex\hspace{\algorithmicindent}$\bm{\theta}_{t} \leftarrow \bm{\theta}_{t-1}+ \alpha \cdot \frac{1}{N}\sum_{n=1}^N R_n \bm{\varepsilon}_n$ \EndFor \end{algorithmic} \end{algorithm} ``` Given a pretrained LLM with initial parameters $\bm{\theta}_0$ and a target reward function $R(\cdot)$, the task is to fine-tune the parameters so that the reward function is optimized (Algorithm `\ref{alg:es-llm_general}`{=latex}). In each iteration, $N$ perturbed models are sampled by adding random Gaussian noise $\bm{\varepsilon}_n$ to their parameters. The noise is i.i.d. in each dimension of the parameter space, and it is scaled by the hyperparameter $\sigma$. The perturbed models are evaluated to obtain their reward scores $R_n$. The final update of the model parameters aggregates the sampled perturbations by weighting them using their normalized reward scores. The standard update equation $\bm{\theta}_{t} \leftarrow \bm{\theta}_{t-1}+ \alpha \cdot \frac{1}{\sigma}\frac{1}{N}\sum_{n=1}^N R_n \bm{\varepsilon}_n$ is simplified to $\bm{\theta}_{t} \leftarrow \bm{\theta}_{t-1}+ \alpha \cdot \frac{1}{N}\sum_{n=1}^N R_n \bm{\varepsilon}_n$ by digesting the term $\frac{1}{\sigma}$ into the learning rate $\alpha$. To improve scalability, a number of modifications to this basic algorithm were made as detailed in the next section. Implementation details {#subsec:implementation} ---------------------- The actual implementation of ES for this paper expands on the above algorithm in seven ways (see Appendix `\ref{app:algorithm}`{=latex} for the detailed pseudocode): \(1\) *Noise retrieval with random seeds:* Similar to @salimans2017es [@such2017DeepNG], only the random seeds are stored to reduce GPU memory usage. The perturbation noise used during sampling can be retrieved exactly by resetting the random number generator with specific random seeds. (2) *Parallel evaluations:* In each iteration, the perturbed models can be evaluated fully in parallel by assigning a separate random seed to each process. (3) *Layer-level in-place perturbation and restoration:* To reduce the peak GPU memory usage, the model parameters are perturbed in-place layer by layer, with corresponding random seeds archived. After evaluation of the perturbed model, the model parameters are restored by subtracting the same noise perturbations using the archived random seeds. For each evaluation process, apart from the model parameters, the only additional memory needed is to store a tensor the size of a layer temporarily. (4) *Reward normalization:* The rewards of the perturbed models are normalized using $z$-score within each iteration, so that the normalized rewards for each iteration have a mean of 0 and standard deviation of 1. This normalization makes the reward scale consistent across iterations and tasks. (5) *Greedy decoding:* The perturbed models use greedy decoding to generate the responses for reward evaluations. As a result, the perturbed models are evaluated deterministically, so that all performance differences come from the exploration in parameter space instead of action space. (6) *Decomposition of the parameter update:* At the end of each iteration, the aggregated update of model parameters is performed in-place in a decomposed manner, gradually adding up layer by layer and seed by seed, significantly reducing the peak GPU memory needed. (7) *Learning rate digestion:* The standard update equation $\bm{\theta}_{t} \leftarrow \bm{\theta}_{t-1}+ \alpha \cdot \frac{1}{\sigma}\frac{1}{N}\sum_{n=1}^N R_n \bm{\varepsilon}_n$ is simplified to $\bm{\theta}_{t} \leftarrow \bm{\theta}_{t-1}+ \alpha \cdot \frac{1}{N}\sum_{n=1}^N R_n \bm{\varepsilon}_n$ by digesting the term $\frac{1}{\sigma}$ into the learning rate $\alpha$, simplifying the computation and parametric setup. To highlight the strength of ES, we intentionally remove common algorithmic enhancements explored in OpenAI ES [@salimans2017es]. Enhancements like rank transformation of rewards [@wierstra14a], mirrored sampling [@sehnke2010parameter], weight decay, and virtual batch normalization [@salimans2016gan] are not used in this work. Additionally, we do not utilize more advanced optimizers like Adam [@kingma2015adam]. This design choice isolates the core ES algorithm and demonstrates that strong performance can be achieved without auxiliary enhancements. In future work, each individual enhancement can be explored to further improve performance. Empirical Studies ================= This section first compares the fine-tuning performance of ES and RL baselines on a standard reasoning benchmark. After that, behavioral differences between ES and RL are investigated in fine-tuning for conciseness, followed by comparisons to more SOTA RL baselines on several math reasoning tasks. Finally, ES is applied to solve two challenging puzzle problems. `\label{sec:exp}`{=latex} Performance in the Countdown task --------------------------------- Fine-tuning performance was measured in the Countdown task [@gandhi2024stream; @tinyzero], a symbolic reasoning benchmark (see Appendix `\ref{app:countdown_example}`{=latex} for details), showing that ES is accurate and efficient across different kinds and sizes of LLMs, even when the RL approaches are not. ```{=latex} \begin{table*}[t]\centering \small \begin{threeparttable} \renewcommand{\arraystretch}{1} \setlength{\tabcolsep}{5pt} \rowcolors{3}{white}{gray!6} \begin{tabular}{ c % Model c % Baseline c % PPO c % GRPO pop8 c % GRPO pop30 c % GRPO-verl c % Dr.GRPO-verl c % ES } \toprule \multirow{2}{*}{\textbf{Base Model}} & \multirow{2}{*}{\textbf{Original}} & \multicolumn{5}{c}{\textbf{RL}} & \multirow{2}{*}{\textbf{ES (ours)}} \\ \cmidrule(lr){3-7} & & \textbf{PPO-z} & \textbf{$\text{GRPO-z (8)}$} & \textbf{$\text{GRPO-z (30)}$} & \textbf{$\text{GRPO-v}$} & \textbf{$\text{Dr.GRPO-v}$} \\ \midrule \rowcolor{green!3} Qwen-2.5-0.5B-Instruct & 0.1 & 0.3 & 0.3 & 0.5 & 13.0 & 13.5 & \textbf{14.4} \bfseries \\ \rowcolor{green!3} Qwen-2.5-1.5B-Instruct & 0.7 & 14.2 & 13.9 & 14.8 & 27.8 & 31.0 & \textbf{37.3} \bfseries \\ \rowcolor{green!3} Qwen-2.5-3B-Instruct & 10.0 & 20.1 & 30.9 & 32.5 & 37.8 & 43.8 & \textbf{60.5} \bfseries \\ \rowcolor{green!3} Qwen-2.5-7B-Instruct & 31.2 & 55.1 & 54.2 & 52.8 & 57.0 & 57.5 & \textbf{66.8} \bfseries \\ \rowcolor{blue!3} Llama-3.2-1B-Instruct & 0.4 & 11.2 & 14.5 & 13.0 & 14.9 & 13.9 & \textbf{16.8} \bfseries \\ \rowcolor{blue!3} Llama-3.2-3B-Instruct & 3.2 & 35.3 & 39.4 & 38.8 & 42.5 & 47.8 & \textbf{51.6} \bfseries \\ \rowcolor{blue!3} Llama-3.1-8B-Instruct & 8.1 & 42.8 & 49.9 & 51.3 & 46.9 & 50.2 & \textbf{61.2} \bfseries \\ \bottomrule \end{tabular} \end{threeparttable} \caption{Accuracy (\%) on the Countdown task across model families, sizes, and fine-tuning algorithms. Different model families are shaded for clarity; \textit{Original} refers to directly evaluating the base model without any fine-tuning, and GRPO-z (8) and GRPO-z (30) indicate group sizes of 8 and 30. The suffix "-z" and "-v" represents different implementation variants (see Appendix~\ref{app:exp_setup} for more details). The same hyperparameters were used for all ES runs; a separate grid search for the best hyperparameters was run for each RL experiment. } \label{tab:countdown_main} \end{table*} ``` **Experimental setup.**`\label{sec4:addi_imple}`{=latex} A single fixed set of hyperparameters ($N=30$, $\sigma=0.001$, $\alpha=5 \times 10^{-4}$) was used for all ES Countdown experiments. Notably, the population size 30 is significantly lower than those in previous works [@salimans2017es; @zhang2017essgd], in which $N\geq10,000$. For RL baselines (see Appendix `\ref{app:exp_setup}`{=latex} for details), a separate hyperparameter sweep was done for each experiment. RL methods turned out sensitive to hyperparameters, in particular the KL-divergence penalty coefficient $\beta$ and learning rate $\alpha$, and did not make much progress if they were not set precisely. To mitigate this issue, for each model, a small grid of $\beta$ and $\alpha$ values were tested and the best-performing configuration selected (see Table `\ref{tab:ppo_grpo_sweep}`{=latex} in the Appendix `\ref{app:exp_setup}`{=latex}). This approach makes the comparison conservative with respect to ES, but it also highlights its robustness. **ES improves upon RL baselines across all tested models.** Previously, @gandhi2025cognitive found that RL does not generalize well across models on the Countdown task. Table `\ref{tab:countdown_main}`{=latex} confirms this result, and also demonstrates that ES does not have this problem. With each model in the Qwen2.5 family (0.5B--7B) and the Llama3 family (1B--8B), ES substantially improved over PPO, GRPO and Dr.GRPO [@liu2025understanding], including their implementation variants, often by a large margin (see Figure `\ref{fig:acc_improv_over_base}`{=latex} in Appendix `\ref{appendix:train_curve}`{=latex} for a model-wise visual comparison). These results demonstrate that ES scales effectively across different model types and sizes, and does so significantly better than RL. Behavioral differences between ES and RL in fine-tuning for conciseness {#sec:behavioral_differences} ----------------------------------------------------------------------- In order to characterize the different approaches that ES and RL take, they were used to fine-tune Qwen-2.5-7B Instruct, towards more concise responses in question-answering (see Appendix `\ref{app:exp_setup}`{=latex} for more details). That is, fine-tuning was rewarded based on how concise the answers were, but not directly rewarded for its question-answering performance. In this setup, it was possible to analyze not only whether fine-tuning was effective, but also how it was achieved, including what its side effects were. ![Mean conciseness reward and mean KL divergence from the base model for each fine-tuning checkpoint across different learning parameters. The Pareto front of ES (blue line) is higher and to the left of the GRPO Pareto front (black line) models, indicating that it found better tradeoffs. ES discovers these solutions without any KL divergence penalty, suggesting that it represents a distinctly different fine-tuning mechanism from the GRPO.](figures/conciseness/es_grpo_mean_models_with_pf.png){#fig:es_grpo_pareto_front width="\\linewidth"} ```{=latex} \begin{table*}[t!]\centering \small \renewcommand{\arraystretch}{1} \setlength{\tabcolsep}{6pt} \rowcolors{3}{white}{gray!6} \begin{tabular}{ l c c c c c } \toprule \textbf{Model} & \boldsymbol{$\beta$} & \boldsymbol{$\alpha$} & \boldsymbol{$\sigma$} & \textbf{Reward} $\uparrow$ & \textbf{KL} $\downarrow$ \\ \midrule %\rowcolor{red!3} Qwen-2.5-7B & \xmark & \xmark & \xmark & $1.0\pm0.01$ & $1.0\pm0.01$ \\ \rowcolor{green!3} Qwen-2.5-7B+GRPO & 0.0 & $5\times10^{-6}$ & \xmark & $0.867\pm0.054^{*}$ & $0.861\pm0.614^{*}$ \\ \rowcolor{green!3} Qwen-2.5-7B+GRPO & 0.01 & $5\times10^{-6}$ & \xmark & $0.871\pm0.060^{*}$ & $1.354\pm0.873^{*}$ \\ \rowcolor{green!3} Qwen-2.5-7B+GRPO & 0.0167 & $5\times10^{-6}$ & \xmark & $0.911\pm0.038$ & $1.591\pm0.811$ \\ \rowcolor{green!3} Qwen-2.5-7B+GRPO & 0.0464 & $5\times10^{-6}$ & \xmark & $0.881\pm0.062$ & $1.384\pm1.187$ \\ \rowcolor{blue!3} Qwen-2.5-7B+ES & \xmark & $0.0005$ & $0.001$ & $0.889\pm\textbf{0.004}$ & $0.274\pm\textbf{0.096}$ \\ \rowcolor{blue!3} Qwen-2.5-7B+ES & \xmark & $0.00075$ & $0.0015$ & $0.919\pm\textbf{0.008}$ & $0.813\pm\textbf{0.212}$ \\ \bottomrule \end{tabular} \caption{Behavior or GRPO and ES in terms of mean conciseness reward and mean KL divergence. The label $^{*}$ indicates cases where reward hacking was observed. Only models that did not hack the reward were included in the results. \label{table:es_grpo_mean_std} }\end{table*} ``` **ES discovers a dominant Pareto front.** Similarly to @rafailov2023dpo, a Pareto frontier analysis was used to compare ES and GRPO, with mean reward and mean KL divergence as the metrics (Figure `\ref{fig:es_grpo_pareto_front}`{=latex}). The experimental setup is described in Appendix `\ref{app:exp_setup}`{=latex}. The ES Pareto front is represented by a blue line on top and the GRPO Pareto front by the black line below. That is, ES produced better tradeoffs than GRPO, i.e. models with higher reward and lower KL divergence. The GRPO results were achieved only after augmenting the conciseness reward with a KL divergence penalty (weighted by a parameter $\beta$). Without it, fine-tuning resulted in excessive divergence and incorrect answers. Remarkably, ES achieved superior tradeoffs without any KL divergence penalty, suggesting that ES fine-tuning is based on discovering distinctly different kinds of solutions than GRPO. Appendix `\ref{appendix:extended_conciseness_exp}`{=latex} presents additional experiments with varying $\alpha$ and $\beta$ values, yielding similar conclusions. **ES is more robust against reward hacking.** GRPO with $\beta=\{0.0, 0.01\}$ sometimes hacked the reward, that is, produced responses that were short but contain nonsensical symbols rather than words. By increasing the KL-penalty via higher $\beta$ values, reward hacking could be prevented. The optimal $\beta$ is likely to be problem specific and to require extensive search to find. In contrast, ES does not receive any feedback about the divergence of the fine-tuned model, and only seeks to optimize conciseness. Regardless, it did not exhibit any reward hacking, despite achieving mean reward comparable to GRPO with $\beta=\{0.0, 0.01\}$. This result again suggests that ES finds a different way of optimizing the reward function. **ES fine-tuning is reliable across runs.** Fine-tuning LLMs is computationally expensive, so it is critical that it leads to consistent results across runs. Table `\ref{table:es_grpo_mean_std}`{=latex} presents the mean and standard deviation of the conciseness reward and KL divergence across four independent runs after $1,000$ iterations. A mean reward cut-off of $>0.85$ was used to down-select hyperparameter combinations, ensuring that only the best ES and GRPO configurations were included in the analysis. From Table `\ref{table:es_grpo_mean_std}`{=latex}, ES achieved consistent conciseness rewards, indicated by a low standard deviation over four runs with different random seeds. GRPO has $15.5\times$ higher standard deviation, suggesting that its results were much less consistent. The results on KL divergence show similar patterns. Thus, ES fine-tuning is more reliable than GRPO. ES applied to Math reasoning tasks ---------------------------------- RL has been shown to enhance the reasoning capabilities of LLMs through post-training with verifiable rule-based rewards. To understand the impact of ES on LLM reasoning, ES fine-tuning was evaluated on a set of standard math benchmarks from the literature. The main result is that ES is competitive with SOTA RL in this setting. **Training setup.** The Qwen2.5-Math-7B [@yang2024qwen2] base model was fine-tuned with ES using the MATH dataset [@hendrycks2021measuring]. Problems labeled with difficulty ranging from 3-5 were included, and the Qwen Math template was used for training with ES [see Appendix `\ref{app:math_extended}`{=latex}; @yang2024qwen2]. Both RL and ES sampled a maximum of $3,000$ tokens per response; ES hyperparameters were set to $\sigma=0.001$, $\alpha=\frac{\sigma}{2}$, and $N=30$. **RL baselines.** The fine-tuned ES models were compared with strong, well-established baselines from the literature. These RL implementations achieve the most SOTA performance in the tested benchmarks, utilizing production-ready RL libraries like VERL [@sheng2024hybridflow] and OAT [@liu2024oat]. They include SimpleRL-Zero (GRPO) [@zeng2025simplerl], OatZero (Dr.GRPO) [@liu2025understanding], and OpenReasoner (PPO) [@hu2025open]. The publicly released Qwen2.5-7B checkpoints trained with the original training recipes were used for evaluation. Note that SimpleRL-Zero and OatZero were trained using the MATH dataset [@hendrycks2021measuring], whereas OpenReasoner was trained using a custom dataset compiled by the authors. Consequently, performance differences should be interpreted in light of both algorithmic and dataset-related differences. ```{=latex} \begin{figure*} \centering \includegraphics[width=\linewidth]{figures/math/math_reasoning.pdf} \caption{Performance of ES compared to strong, well-establised RL baselines across math reasoning benchmarks. Across all benchmarks, ES achieved competitive performance compared to OpenReasoner-Zero-7B (PPO), Simple-RL-Zero (GRPO), Oat-Zero-7B (Dr.GRPO). Given the vanilla nature of the current ES implementation, these results constitute a promising starting point for ES fine tuning in math.} \label{fig:math_experiments} \end{figure*} ``` **Evaluation benchmarks.** Several standard math reasoning benchmarks from the literature are used for evaluation: OlympiadBench [@he2024olympiadbench], MATH500 [@hendrycks2021measuring], Minerva [@lewkowycz2022solving], AIME2024 [@li2024numinamath], and AMC [@li2024numinamath]. The pass\@1 accuracy metric was used in the evaluations. **Key results.** Figure `\ref{fig:math_experiments}`{=latex} shows the performance of the base model, three checkpoints of RL baselines, and three checkpoints of ES (see Appendix `\ref{app:math_extended}`{=latex} for more details). ES significantly improved the base models across each benchmark, showing the other optimization methods aside from RL can be used to elicit improvement in LLM reasoning capabilities. In addition, ES exhibits competitive performances compared with the SOTA RL baselines in all the benchmarks. It is notable that these RL baselines are the best-performing implementations selected from the literature, with extensive algorithmic refinement and hyperparameter search particularly for math reasoning tasks. In contrast, the current ES implementation is a vanilla variant with a simple hyperparameter setup; thus, the results constitute a promising starting point for the ES approach in math fine tuning. Solving challenging puzzle problems {#subsec:puzzle} ----------------------------------- To further evaluate the generality of ES in tackling different types of tasks, two challenging puzzle problems were used as additional testbeds. The first is ARC-AGI [@chollet2024arc], a benchmark designed to evaluate fluid intelligence [@chollet2019measureintelligence]. The second is Sudoku, a logic-based number-placement puzzle. Whereas the base LLM models fail severely in both problems, ES fine-tuning significantly improves their performance (Table `\ref{tab:reasoning_main}`{=latex}). Experimental details are provided in Appendix `\ref{app:arc-agi}`{=latex} for ARC-AGI and Appendix `\ref{app:sudoku}`{=latex} for Sudoku. ```{=latex} \centering ``` ```{=latex} \small ``` ```{=latex} \begin{threeparttable} \renewcommand{\arraystretch}{1} \setlength{\tabcolsep}{5pt} \begin{tabular}{llcc} \toprule \textbf{Task} & \textbf{Base Model} & \textbf{Original} & \textbf{ES Fine-tuned} \\ \midrule ARC-AGI & Qwen-2.5-14B & 0.2 & \textbf{29.5} \\ Sudoku & Qwen-2.5-3B & 2.5 & \textbf{69.5} \\ \bottomrule \end{tabular} \end{threeparttable} ``` Discussion and Future Work {#sec:discussion} ========================== **Algorithmic advantage of ES vs. RL.** Exploration in parameter space plays a key role in the surprisingly good fine-tuning performance of ES. As discussed by @thomas2010parameter and @plappert2018parameter, sampling noise in parameter space ensures that the entire action trajectory, i.e., the sequence of tokens, only depends on one single sampling, leading to significantly lower variance in rollouts, i.e., in response generation. As a result, gradient estimation is more reliable and convergence is more stable. In contrast, action space exploration in RL injects noise at every step, i.e., at each token position, resulting in high variance in the sequence generation. The behavior of RL therefore is much less reliable than ES, as was seen in Table `\ref{table:es_grpo_mean_std}`{=latex}. Moreover, step-wise exploration in action space promotes reward hacking by increasing the chance of sampling a single hacking action. One example is the nonsensical symbol sampled during RL that can hack the conciseness reward. Another key difference between ES and RL is that ES intrinsically optimizes a solution distribution [@lehman2018esmore], while RL optimizes a single solution. This property makes it more difficult for ES to hack the reward since a single hacked solution usually does not have a high-quality solution distribution around it. This property also results in solutions that are more robust to noisy perturbations in parameter space [@lehman2018esmore], making them more robust to adversarial attacks and less likely to be compromised in other follow-up fine-tuning tasks [@chen2025loss]. The ES algorithm presented in Algorithm `\ref{alg:es-llm_specific}`{=latex} is very simple and easy to implement, without need for sophisticated hyperparameter search. In contrast, RL algorithms are considerably more complex and require substantial expertise to implement robustly across tasks and systems, usually with extensive hyperparameter tuning. In particular, there has been significant debate in the literature regarding best practices for implementing GRPO. Effective GRPO implementations typically rely on a number of non-obvious design choices and implementation details, such as removing length normalization [@liu2025understanding] and using more aggressive clipping [@yu2025dapo]. Many of these practices have only emerged through extensive empirical investigation. Moreover, the application of the KL penalty in GRPO remains an open design choice, with alternatives such as applying it to the loss or directly to the reward leading to markedly different performance outcomes [@shah2025comedy] **Engineering benefits of ES vs. RL.** Modern RL frameworks grow increasingly complex as they are applied to LLMs with ever-increasing parameter counts. Deploying these systems in practice often requires substantial engineering effort and computational resources. In contrast, ES is simple to implement and can help democratize post-training by significantly lowering engineering and systems overhead. This section outlines two key advantages of ES and suggests how it can be scaled to fine-tune the largest LLMs. \(1\) *Parallelization.* To minimize memory overhead and maximize sample throughput, RL systems rely on asynchronous architectures in which actors are distributed across GPUs and update a shared learner model. While effective, scaling these systems across large numbers of GPUs and computational nodes introduces significant engineering complexity. In contrast, as shown by @salimans2017es, ES can be trivially parallelized: as the number of available GPUs increases, the population size can be scaled accordingly. Modern frontier AI research labs operate clusters with thousands of GPUs[^1], making efficient large-scale parallelization possible. While it is challenging to do with RL, ES requires only the exchange of random seeds (noise) and scalar rewards between machines. Such simple communication enables parallel ES to be used either to reduce wall-clock training time or to scale to much larger populations. \(2\) *Gradient computation.* Asynchronous RL makes it possible to compute actor-related gradients in parallel. However, in order to manage memory usage, gradient checkpointing and multiple learner updates per synchronization step are needed. While these techniques enable larger effective batch sizes, they also require gradients to be communicated across GPUs, and sometimes nodes, introducing significant memory overhead and engineering complexity. This complexity scales with both the number of GPUs and the size of the model, and is further exacerbated when model parameters must be sharded across devices. In contrast, ES does not require gradient computation. By eliminating gradient calculation and communication entirely, ES avoids much of the associated engineering and memory overhead. As a result, each member of the ES population can use large batch sizes freely without cross-device gradient synchronization, which can yield substantial practical and performance benefits. Importantly, ES is an inference-only fine-tuning mechanism, where the model weights are never differentiated, only evaluated. This property opens the door to specialized inference kernels optimized for repeated forward passes, large batches, and parameter perturbations. These mechanisms are difficult to leverage in gradient-based training regimes, but are possible in ES fine tuning in the future. **Future research directions.** One counterintuitive result is that the ES implementation only needs a population of 30 to effectively optimize billions of parameters. In contrast, previous work [@salimans2017es; @zhang2017essgd; @lehman2018esmore; @lorenc2025estransformer] used populations of 10,000 or more for models with millions or fewer parameters. An interesting future direction is to analyze how such small populations are possible. Perhaps this is related to the observed low intrinsic dimensionality of LLMs [@aghajanyan2021intrinsic]. Another promising direction is to use ES to perform unsupervised fine-tuning based on internal behaviors of LLMs, such as confidence calculated based on semantic entropy and semantic density [@qiu:neurips24; @farquhar:nature24]. Such fine-tuning cannot be done with RL, since action space exploration does not change the internal representations of LLMs (that is, each action sampling is generated via output distribution without changing the internal parameters). In a broader sense, since ES does not need process rewards during exploration, it may be a necessary ingredient for superintelligence [@mucci2023super], which would be difficult to achieve by supervised learning using process guidance from human data. Massive parallelization of ES will speed up exploration by distributing the computations across GPU machines or even data centers. An important question is: what are the underlying computational mechanisms that make ES and RL behave so differently? While this question requires significant further work, a possible hypothesis emerges from the experiments in this paper. Many fine-tuning objectives, like conciseness and the Countdown task, are long-horizon outcome-only objectives. The reward signal is jagged, making it difficult to navigate with gradient-based post-training methods. RL and ES both provide workarounds via effective noise injection to \`\`smooth out'' the jagged reward landscape. In the case of RL, noise is introduced from Monte-Carlo sampling of each token during a rollout, averaged over many rollouts, which effectively smooths the sampling process but does not necessarily guarantee that the reward landscape is smooth in parameter space. RL's gradient estimation therefore has a high-variance, and its signal-to-noise ratio becomes worse with longer sequences and sharper policies (i.e. those with lower entropy), and therefore prone to undesirable outcomes such as reward hacking. In contrast, ES injects noise directly into the parameter space via explicit Gaussian convolution, which effectively smooths out the jagged reward landscape. As a result, it provides a more stable way of exploring the landscape, leading to more consistent, efficient, and robust optimization (as observed in the experiments and in Appendix `\ref{app:shifts}`{=latex}). Moreover, the larger the models and the sharper the policies, the more jagged the reward landscapes; therefore, ES is likely to have an advantage in fine-tuning them. Direct evidence for this hypothesis still needs to be obtained, but it provides a plausible mechanistic explanation, and a direction for future work. Eventually, such work could result in better fine-tuning methods, as well as an improved understanding of LLMs in general. Conclusion ========== This paper introduces a fundamentally new paradigm for fine-tuning LLMs by scaling ES to models with billions of parameters without dimensionality reduction. Contrary to long-standing assumption that such scaling is infeasible, the paper demonstrates that ES can efficiently fine-tune the full parameter space of modern LLMs and, in doing so, consistently surpasses standard RL-based fine-tuning methods. On the Countdown task, with sparse long-horizon rewards challenging for gradient-based RL, ES achieves substantially stronger performance. It also exhibits markedly reduced sensitivity to hyperparameter choices and delivers stable, repeatable improvements across multiple base LLMs. In fine-tuning for conciseness, ES is less prone to reward hacking and shows reliable behavior across independent runs. The generality of ES fine tuning is further validated by strong performance on state-of-the-art math reasoning benchmarks and two challenging puzzle problems. Together, these results establish ES as a scalable, robust, and general fine-tuning method, and demonstrate that backpropagation-free optimization can serve as a powerful alternative to RL for fine-tuning LLMs. Impact Statement {#impact-statement .unnumbered} ================ Beyond the standard potential consequences of advancing the field of machine learning, there are two key areas of broader impact, stemming from (1) *increased ease of use* and (2) *reduced reward-hacking*. **Ease of use:** ES qualitatively reduces the barrier of entry to fine-tuning LLMs. Unlike RL, which requires an expert mathematical understanding of nuanced gradient-based training dynamics to design an effective reward function, ES simply requires the experimenter to assign *a score* to a model after it has attempted a task. This simplification democratizes LLM fine-tuning, opening the door to the development of customized AI applications by non-experts. **Reward-hacking:** As shown in Section `\ref{sec:behavioral_differences}`{=latex} and prior work [@lehman2018esmore], ES is inherently less susceptible to reward-hacking than RL and other gradient-based methods. Thus, LLMs fine-tuned with ES are less likely to lose ethical guardrails present in the base model. Similarly, it may be easier to fine-tune for ethical behavior (i.e. alignment) with ES, since the model is less likely to overfit to specific training examples. Combining the above two areas of impact, ES fine-tuning can reduce the risk of unintended ethical misbehavior of LLMs fine-tuned by non-experts. Acknowledgments {#acknowledgments .unnumbered} =============== We would like to thank Sid Stuart for providing technical support for hardware management and always being responsive. We would like to thank Jamieson Warner for providing valuable feedback. ```{=latex} \bibliographystyle{icml2026} ``` ```{=latex} \newpage ``` ```{=latex} \appendix ``` ```{=latex} \onecolumn ``` Appendix ======== ES Implementation for LLM Fine-tuning {#app:algorithm} ------------------------------------- Algorithm `\ref{alg:es-llm_specific}`{=latex} shows the detailed process of the ES implementation for LLM fine-tuning. ```{=latex} \begin{algorithm*}[h]\caption{ES Implementation for LLM Fine-Tuning} \label{alg:es-llm_specific} \begin{algorithmic}[1] \Require Pretrained LLM with initial parameters $\bm{\theta}_0$, reward function $R(\cdot)$, total iterations $T$, population size $N$, noise scale $\sigma$, learning rate $\alpha$, number of parallel process $P$. \State Create $P$ processes, each instantiates a model with the same initial parameters $\bm{\theta}_0$, with one process as the main process \For{$t = 1$ to $T$} \Comment{ES iterations} \State Sample N random seeds $s_1, s_2, \ldots, s_N$ \State Assign random seeds to $P$ processes \For{$n = 1$ to $N$} \State For the process handling $s_n$, reset its random number generator using random seed $s_n$ \For{\textbf{each LLM layer}} \Comment{perturbation within current process} \State Sample noise $\bm{\varepsilon}_{n,l} \sim \mathcal{N}(0,\bm{I})$, which has the same shape as the $l$th layer's parameters \State Perturb the $l$th layer's parameters in-place: $\bm{\theta}_{t-1,l}\leftarrow\bm{\theta}_{t-1,l}+\sigma \cdot \bm{\varepsilon}_{n,l}$ \EndFor \State Compute reward for perturbed parameters $R_{n}=R(\bm{\theta}_{t-1})$ \Comment{within current process} \State For the process handling $s_n$, reset its random number generator using random seed $s_n$ \For{\textbf{each LLM layer}} \Comment{restoration within current process} \State Sample noise $\bm{\varepsilon}_{n,l} \sim \mathcal{N}(0,\bm{I})$, which has the same shape as the $l$th layer's parameters \State Restore the $l$th layer's parameters in-place: $\bm{\theta}_{t-1,l}\leftarrow\bm{\theta}_{t-1,l}-\sigma \cdot \bm{\varepsilon}_{n,l}$ \EndFor \EndFor \State Normalize the reward scores by calculating the $z$-score for each $R_n$: $Z_n=\frac{R_n-R_{\mathrm{mean}}}{R_{\mathrm{std}}}$, \Statex\hspace{\algorithmicindent}where $R_{\mathrm{mean}}$ and $R_{\mathrm{std}}$ are the mean and standard deviation of $R_1, R_2, \ldots, R_N$. \For{$n = 1$ to $N$} \Comment{in main process only} \State Reset current random number generator using random seed $s_n$ \For{\textbf{each LLM layer}} \State Sample noise $\bm{\varepsilon}_{n,l} \sim \mathcal{N}(0,\bm{I})$, which has the same shape as the $l$th layer's parameters \State Update $l$th layer's parameters in-place as $\bm{\theta}_{t,l} \leftarrow \bm{\theta}_{t-1,l}+ \alpha \cdot \frac{1}{N} Z_n \bm{\varepsilon}_{n,l}$ \EndFor \EndFor \State Update the model parameters of all processes to $\bm{\theta}_{t}$ \EndFor \end{algorithmic} \end{algorithm*} ``` Experimental Setup {#app:exp_setup} ------------------ #### Experimental setup for the Countdown experiments. Representative models from the Qwen2.5 family (0.5B--7B) and the Llama3 family (1B--8B) were fine-tuned for this task. For the PPO-z experiments, a grid search was first performed around common hyperparameter settings and the best-performing values used (Table `\ref{tab:ppo_grpo_sweep}`{=latex}). TinyZero () is used for PPO-z implementations. For the GRPO-z experiments, a grid search was performed around the settings of [@tinyzero] and the best-performing values used. GRPO-z experiments were run with two different group sizes: $N=8$, following the common practice in GRPO training for the Countdown task, and $N=30$, aligning with the population size in ES. GRPO-Zero () is used for GRPO-z implementations. VERL [@sheng2024hybridflow] is used for both GRPO-v and Dr.GRPO-v implementations, with the standard default configurations for math reasoning benchmarks. For the VERL implementations, we set the global batch size of 1024, a learning rate of $1 \times 10^{-6}$, and a rollout group size of $N=8$. We compared two configurations: GRPO-v and Dr.GRPO-v. The GRPO-v baseline incorporated a standard KL divergence penalty with a coefficient of $\beta=0.001$. In contrast, the Dr.GRPO-v configuration removed the KL penalty (`use_kl_loss=False`) and disabled advantage normalization (`norm_adv_by_std=False`). Instead, Dr.GRPO-v employed a sequence-mean token-sum normalization strategy for loss aggregation with a scaling factor of 1024. For all the ES and RL baselines, the total number of sample evaluations was the same. The ES population size was $N=30$, noise scale $\sigma=0.001$, and learning rate $\alpha=5 \times 10^{-4}$ across all experiments. To evaluate accuracy, a set of 200 samples were used during training, and a different set of 2000 samples during testing. For ES, results were reported on the test set after training for 500 iterations. For RL, the training was stopped after the same total number of sample evaluations as in the ES runs. An example of the prompt and the response is provided in Appendix `\ref{app:countdown_example}`{=latex}. ```{=latex} \centering ``` ```{=latex} \setlength{\tabcolsep}{4pt} ``` ::: {#tab:ppo_grpo_sweep} +-------------------------+--------------------+----------------------------------------+----------------------------------------+----------------------------------------+----------------------------------------+ | Method | Model | ($1\mathrm{e}{-3}$, $1\mathrm{e}{-6}$) | ($1\mathrm{e}{-3}$, $1\mathrm{e}{-5}$) | ($5\mathrm{e}{-3}$, $1\mathrm{e}{-6}$) | ($5\mathrm{e}{-3}$, $1\mathrm{e}{-5}$) | +:========================+:===================+:======================================:+:======================================:+:======================================:+:======================================:+ | ```{=latex} | Qwen-0.5B-Instruct | **`\checkmark`{=latex}** | | | | | \multirow{7}{*}{PPO-z} | | | | | | | ``` | | | | | | +-------------------------+--------------------+----------------------------------------+----------------------------------------+----------------------------------------+----------------------------------------+ | | Qwen-1.5B-Instruct | `\checkmark `{=latex} | | | | +-------------------------+--------------------+----------------------------------------+----------------------------------------+----------------------------------------+----------------------------------------+ | | Qwen-3B-Instruct | `\checkmark `{=latex} | | | | +-------------------------+--------------------+----------------------------------------+----------------------------------------+----------------------------------------+----------------------------------------+ | | Qwen-7B-Instruct | | `\checkmark `{=latex} | | | +-------------------------+--------------------+----------------------------------------+----------------------------------------+----------------------------------------+----------------------------------------+ | | Llama-1B-Instruct | | `\checkmark `{=latex} | | | +-------------------------+--------------------+----------------------------------------+----------------------------------------+----------------------------------------+----------------------------------------+ | | Llama-3B-Instruct | | | | `\checkmark `{=latex} | +-------------------------+--------------------+----------------------------------------+----------------------------------------+----------------------------------------+----------------------------------------+ | | Llama-8B-Instruct | | | `\checkmark `{=latex} | | +-------------------------+--------------------+----------------------------------------+----------------------------------------+----------------------------------------+----------------------------------------+ | ```{=latex} | Qwen-0.5B-Instruct | | `\checkmark `{=latex} | | | | \multirow{7}{*}{GRPO-z} | | | | | | | ``` | | | | | | +-------------------------+--------------------+----------------------------------------+----------------------------------------+----------------------------------------+----------------------------------------+ | | Qwen-1.5B-Instruct | | | `\checkmark `{=latex} | | +-------------------------+--------------------+----------------------------------------+----------------------------------------+----------------------------------------+----------------------------------------+ | | Qwen-3B-Instruct | | `\checkmark `{=latex} | | | +-------------------------+--------------------+----------------------------------------+----------------------------------------+----------------------------------------+----------------------------------------+ | | Qwen-7B-Instruct | `\checkmark `{=latex} | | | | +-------------------------+--------------------+----------------------------------------+----------------------------------------+----------------------------------------+----------------------------------------+ | | Llama-1B-Instruct | | | | `\checkmark `{=latex} | +-------------------------+--------------------+----------------------------------------+----------------------------------------+----------------------------------------+----------------------------------------+ | | Llama-3B-Instruct | | `\checkmark `{=latex} | | | +-------------------------+--------------------+----------------------------------------+----------------------------------------+----------------------------------------+----------------------------------------+ | | Llama-8B-Instruct | `\checkmark `{=latex} | | | | +-------------------------+--------------------+----------------------------------------+----------------------------------------+----------------------------------------+----------------------------------------+ : Hyperparameter Sweep across Models under PPO-z and GRPO-z. Each pair $(\cdot,\cdot)$ denotes (KL-divergence penalty coefficient $\beta$, learning rate $\alpha$); the label '$\checkmark$' indicates the best hyperparameter setting for each model-method combination. ::: #### Experimental setup for the conciseness experiments. In each experiment, Qwen-2.5-7B-Instruct [@yang2025qwen2] was fine-tuned using both ES and GRPO and evaluated using a held-out evaluation set. Each run was repeated four times, using a different random seed each time. For each GRPO experiment, the group size $N=30$, and learning rate $\alpha=5\times10^{-6}$. Ten log-spaced values from $0.01$ to $1.0$ were evaluated for the the KL-divergence penalty coefficient $\beta$, as well as $\beta=0.0$. Appendix `\ref{appendix:extended_conciseness_exp}`{=latex} presents additional experiments with varying $\alpha$ and $\beta$ values. For ES, the population size $N = 30$, ensuring that GRPO and ES generated the same number of responses per prompt, resulting in the same training exposure. Models were fine-tuned with $\sigma = \{0.0005, 0.001, 0.0015\}$, with a learning rate $\alpha = \frac{\sigma}{2}$. Both GRPO and ES experiments were run for $1,000$ iterations, and a checkpoint saved every $200$ iterations. Table `\ref{table:conciseness_training_dataset}`{=latex} shows the dataset of prompts and verifiable solutions used during fine-tuning; note that it consists of only two examples. Similarly, Table `\ref{table:conciseness_eval_dataset}`{=latex} lists the prompts and verifiable solutions used in evaluating each fine-tuned model. For all the experimental results, the displayed reward values are normalized to be within $[0,1]$, with $0$ corresponding to $-2000$ in the original reward function and $1$ corresponding to the best possible original reward $0$. ```{=latex} \centering ``` ::: {#table:conciseness_training_dataset} Prompt Verifiable Solution --------------------------------------------------------------- --------------------- Solve: $3 + 5 =$ $8$ If all birds can fly and penguins are birds, can penguins fly No : Prompts and verifiable solutions used in fine-tuning the models for conciseness. Two examples is enough to achieve this goal. ::: ```{=latex} \centering ``` ::: {#table:conciseness_eval_dataset} Prompt Verifiable Solution ----------------------------------------------------------- --------------------- What is the capital of France? Paris Calculate: $12 \times 7 =$ $84$ Is the statement \`\`All cats are mammals" true or false? True What comes next in the sequence: $2, 4, 6, 8,$ ? $10$ Translate \`\`Hello" to Spanish: Hola What is $15\%$ of $200$? $30$ Name one primary color: Red How many days are in a week? $7$ : Prompts and verifiable solutions used to evaluate the fine-tuned models. More examples are necessary than during fine-tuning to make the evaluation reliable. ::: **Conciseness task.** For conciseness fine-tuning, a dataset of prompts $\mathcal{D} = \{x_{1}, .., x_{K} \}$, with a set of verifiable solutions $\{s_{1}, ..., s_{K}\}$, i.e. shortest possible correct answers, was used. For example, for the prompt \`\`Name one primary color", possible shortest verifiable solution used is \`\`Red". Following this approach, for each prompt $x \in \mathcal{D}$, the model was encouraged to generate a concise response $y$. To fine-tune the model to generate concise responses, a reward computed using the absolute length difference between the generated response $y$ and the corresponding verified solution $s_{k}$ was given to the model for each prompt $x_{k}$. The reward function $R$ for conciseness was defined as $R = -\lvert \mathrm{len}(y) - \mathrm{len}(s_{k}) \rvert$, where $\mathrm{len}(\cdot)$ denotes the string length. #### Behavior metrics for the conciseness experiments. Behavior of the fine-tuned models was measured in two ways: the mean conciseness reward and the mean KL divergence from the base model [after @rafailov2023dpo]. KL divergence is useful as a proxy for the preservation of the base model's behavior. It correlates strongly with the question-answering performance of the model, but also conveys more information, i.e. the extent of the fine-tuning changes. A low KL divergence thus suggests that the fine-tuned model has not forgotten capabilities learned during pre-training. Further, as KL divergence increases, these capabilities are likely to break. Therefore, fine-tuning behavior can be characterized using the tradeoffs between reward and KL divergence. To compute the metrics, each fine-tuned model was evaluated on a set of held-out test prompts, with $20$ responses sampled per prompt. The reward was computed using the model-generated response and the verifiable solution provided in the test dataset. The KL divergence between a fine-tuned model $\theta_{\mathrm{FT}}$ and a base model $\theta_{\mathrm{BASE}}$ for a given prompt $x$ and corresponding response $y$ was approximated following @schulman2020approximating as $\mathrm{KL}\!\left[\theta_\mathrm{FT} \,\|\, \theta_{\mathrm{BASE}}\right] = \frac{\theta_{\mathrm{BASE}}(y_{i,t} \mid x, y_{i,| … \verb|| tags. And return the final answer in \verb|| … \verb|| tags, for example \verb| (1 + 2) / 3 |. \vspace{0.2cm} \colorbox{blue!10}{\textbf{[1] Response:}} \vspace{0.2cm} \verb|| First, let's consider all possible combinations of the numbers 49, 41, and 73 using basic arithmetic operations. We need to use each number exactly once and combine them to get 17. 1. Start with simple addition and subtraction: - 49 + 41 - 73 = 80 - 73 = 7 (too high) - 49 - 41 + 73 = 8 + 73 = 81 (too high) - 73 - 49 - 41 = 24 - 41 = -17 (too low) 2. Try multiplication and division: - (49 * 41) / 73 = 2029 / 73 $\approx$ 27.83 (not close to 17) - (73 * 41) / 49 = 3013 / 49 $\approx$ 61.47 (too high) - (49 * 73) / 41 = 3637 / 41 $\approx$ 88.80 (too high) - (41 * 73) / 49 = 3013 / 49 $\approx$ 61.47 (same as above) 3. Check different orders: - 73 - (49 + 41) = 73 - 90 = -17 (too low) - 49 - (73 - 41) = 49 - 32 = 17 (this looks promising) So, the equation 49 - (73 - 41) equals 17. Let's verify it: - Calculate inside the parentheses first: 73 - 41 = 32 - Then subtract from 49: 49 - 32 = 17 This satisfies our requirement. \verb|| \verb|| 49 - (73 - 41) \verb|| Reward: 1.1000 (Format: 1.0000, Answer: 1.0000) \captionof{figure}{An example of a countdown task interaction.} \end{tcolorbox} ``` Figure `\ref{fg:countdownexample}`{=latex} shows an example of the Qwen2.5-3B model's output on the Countdown task after 400 ES iterations. In order to improve accuracy, the model learned to adjust its formulas by comparing the generated answer with the correct one, and to verify its own answers for correctness. Extended Conciseness Details and Experiments {#appendix:extended_conciseness_exp} -------------------------------------------- In this section, the conciseness experiments are extended to investigate the impact of different learning rates on GRPO training. ```{=latex} \centering ``` ```{=latex} \centering ``` ![GRPO models results over various learning rates.](figures/conciseness/es_grpo_learning_rate_mean_models.pdf "fig:"){#fig:learning_rate_mean_models width="1.0\\linewidth"} `\vspace*{-3.5ex}`{=latex} ```{=latex} \centering ``` ![ES and GRPO Pareto fronts.](figures/conciseness/es_grpo_learning_rate_pareto_front.pdf "fig:"){#fig:learning_rate_pf width="1.0\\linewidth"} `\vspace*{-3.5ex}`{=latex} ```{=latex} \vspace*{-4ex} ``` ```{=latex} \vspace{-10pt} ``` #### GRPO with different learning rates. Further GRPO experiments were run over four seeds with $\beta = \{0, 0.01, 0.1, 1.0\}$, varying the learning rate $\alpha = \{ 2\times10^{-6}, 3\times10^{-6}, 4\times10^{-6}, 5\times10^{-6}\}$. A total of $20$ responses were sampled per evaluation prompt. Figure `\ref{fig:learning_rate_mean_models}`{=latex} shows the mean reward and KL divergence of each fine-tuned model. As the learning rate increases, both mean reward and mean KL divergence increase. The best models with respect to reward are trained using $5\times10^{-6}$ and $\beta=\{0.0, 0.01\}$, obtaining rewards greater than $0.85$. Figure `\ref{fig:learning_rate_pf}`{=latex} further displays the GRPO Pareto front (black line, bottom) across these learning rates, comparing it with the ES Pareto front (blue line, top). The majority of Pareto optimal models across these learning rates obtain a mean reward of less than $0.8$ and a KL divergence of less than $0.4$. The ES Pareto front dominates that of GRPO over different learning rates and $\beta$ values. Next, the reward distribution for each $\alpha$ and $\beta$ value for GRPO was compared with that of ES, starting with learning rates $2\times10^{-6}$ and $3\times10^{-6}$. Figures `\ref{fig:reward_distribution_2}`{=latex} and Figure `\ref{fig:reward_distribution_3}`{=latex} show that all GRPO models stay close to the Qwen2.5-7B-Instruct base model reward distribution, despite the variation in $\beta$. In contrast, ES shifts the reward distribution to the right with a density peak around $1.0$, i.e. towards higher rewards. The learning rate was then further increased to $4\times10^{-6}$ (Figure `\ref{fig:reward_distribution_4}`{=latex}). As a result, for $\beta=0.0$ and $\beta=0.01$, GRPO shifts the reward distribution to the right towards higher rewards. However, they are still lower than those of ES. As the learning rate is increased further to $5\times10^{-6}$ (Figure `\ref{fig:reward_distribution_5}`{=latex}), GRPO is sufficiently able to optimize the reward: with $\beta = 0.0$ and $\beta = 0.01$, it peaks around $1.0$. Thus, high learning rate combined with low $\beta$ is important for GRPO to optimize the reward. However, as was discussed before, such a setting often breaks the performance of the model. ```{=latex} \centering ``` ```{=latex} \centering ``` ![Reward distribution with $\alpha = 2\times10^{-6}$.](figures/conciseness/reward_distribution_learning_rate_2e6_ablation_all_models.png){#fig:reward_distribution_2 width="0.8\\linewidth"} ```{=latex} \centering ``` ![Reward distribution with $\alpha = 3\times10^{-6}$.](figures/conciseness/reward_distribution_learning_rate_3e6_ablation_all_models.png){#fig:reward_distribution_3 width="0.8\\linewidth"} ```{=latex} \centering ``` ![Reward distribution with $\alpha = 4\times10^{-6}$.](figures/conciseness/reward_distribution_learning_rate_4e6_ablation_all_models.png){#fig:reward_distribution_4 width="0.8\\linewidth"} ```{=latex} \centering ``` ![Reward distribution with $\alpha = 5\times10^{-6}$.](figures/conciseness/reward_distribution_learning_rate_5e6_ablation_all_models.png){#fig:reward_distribution_5 width="0.8\\linewidth"} ```{=latex} \centering ``` ![Accuracy Improvement over Base Models with ES vs RL across Model Families. ES results in consistently largest improvements in all cases.](figures/countdown/training_improvement.png){#fig:acc_improv_over_base width="0.8\\linewidth"} ```{=latex} \vspace{-6pt} ``` Training Curves and Accuracy Improvement of ES and RL on the Countdown Task {#appendix:train_curve} --------------------------------------------------------------------------- As shown in Figure `\ref{fig:training_curve}`{=latex}, ES consistently outperformed RL across all tested models throughout training. In addition, as shown in Figure `\ref{fig:acc_improv_over_base}`{=latex}, we compute the relative improvements of PPO, GRPO, DR.GRPO and ES over their respective base models across different model families. ES delivers the consistently largest improvements in all cases. ```{=latex} \centering ``` ![Training curves of ES and RL across two model families and six sizes in the countdown task. ES fine-tuning results in significantly better performance in all cases.](figures/countdown/training_curves_comparison.png){#fig:training_curve width="\\linewidth"} Extended Math Reasoning Details and Discussion {#app:math_extended} ---------------------------------------------- #### RL baselines. We compare ES against three strong R1-Zero-style [@deepseekai2025deepseekr1] reasoning baselines at the 7B parameter scale: SimpleRL-Zero [@zeng2025simplerl], OpenReasoner-Zero [@hu2025open], and Oat-Zero [@liu2025understanding]. All baselines are instantiated using Qwen2.5-series models [@yang2025qwen2], which are competitive open-weight language models known to exhibit strong reasoning performance at this scale. The respective baseline implementations are fully open source and built on production-ready RL libraries, including VERL [@sheng2024hybridflow] and OAT [@liu2024oat], which provided highly optimized, stable, and tested PPO, GRPO, and Dr.GRPO implementations with efficient rollout management, and standardized reward handling. SimpleRL-Zero isolates the core R1-Zero optimization mechanism with minimal additional engineering, OpenReasoner-Zero reflects a widely adopted community implementation with practical design choices, and Oat-Zero further alters GRPO with algoritmic enhancements shown to boost performance. Together, these baselines represent strong, reproducible, and non-trivial comparators for evaluating ES. #### Reward function. Our ES training utilizes a basic rule-based reward function that checks answer correctness, without any format rewards. The reward function is designed to extract the produced answer contained within $\texttt{\textbackslash boxed\{\}}$ and compare it with the ground truth answer. Similarly to RL, we implement a binary reward scheme where a reward of 1 is given for exact matches with the reference answer, and 0 for all other cases. To ensure a fair comparison with models from the literature we use the same answer extractor, also called a grader, as OatZero [@liu2025understanding]. #### Qwen math template. Table `\ref{table:qwen_math_template}`{=latex} shows the template stucture used for training ES models. We follow the same template used for training the Qwen-Math series base models, where the model is required to provide a final answer inside $\texttt{\textbackslash boxed\{\}}$. This requirement ensures that the final model answers are easy to extract and compare with the ground truth solutions for reward calculation during training. As shown in [@liu2025understanding], the choice of template can impact the final performance of the model. We chose the Qwen-Math template given it provides a platform for stable learning and good performance during fine-tuning. ```{=latex} \centering ``` ```{=latex} \small ``` ```{=latex} \setlength{\tabcolsep}{6pt} ``` ```{=latex} \renewcommand{\arraystretch}{1.3} ``` ::: {#table:qwen_math_template} -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- `\centering`{=latex}**Qwen-Math** `<|im_start|>system``\n`Please reason step by step, and put your final answer within `\boxed{}`.`<|im_end|>``\n``<|im_start|>user``\n`[{question}]{style="color: red"} `<|im_end|>``\n``<|im_start|>assistant``\n` ----------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- : Qwen-Math prompt template used in this work. ::: #### Checkpoint selection. Given there is no explicit validation set, for ES, we follow the standard model checkpoint selection mechanism from the literature whereby the checkpoints with high average pass\@1 accuracy over each evaluation set over training are presented. We chose to present a number of ES checkpoints that all achieve sufficiently high average score. We chose our checkpoints to ensure competitive performance across the range of benchmarks. In this case, $\text{ES}_{\text{CHKPT-1}}$ is chosen for its high average score and occurs after $336$ training steps. Additionally, we take a checkpoint after $160$ training steps and perform $10$ additional model update steps with $\alpha=\frac{\sigma}{4}$. This additional training produced $\text{ES}_{\text{CHKPT-2}}$. Given the lack of validation set, we utilize MATH500 as a pseudo validation set since MATH500 is an in-distribution validation. Following this, we select $\text{ES}_{\text{CHKPT-3}}$ because it achieves the highest performance in the MATH500 benchmark across our evaluations. The MATH500 $\text{ES}_{\text{CHKPT-3}}$ occurs after $192$ training steps. Parameter Magnitude Shifts by Evolutionary fine-tuning {#app:shifts} ------------------------------------------------------ This section characterizes how parameter magnitudes changed in ES fine-tuning in the countdown and conciseness experiments. Specifically, Figures `\ref{fig:llama-countdown-hist}`{=latex} and `\ref{fig:qwen-countdown-hist}`{=latex}, left column, show histograms of the absolute parameter magnitude shifts $\Delta$ before and after finetuning Llama and Qwen models, overlaid with random walk, on the Countdown task reported in Table `\ref{tab:countdown_main}`{=latex}. The right column in these figures shows the difference between $\Delta$ and the random walk. For most models, $\Delta$ deviates very little from random walk. This is a counterintuitive result since fine-tuning actually resulted in a significant performance boost. A closer inspection reveals that most of the deviation was concentrated around zero. A likely explanation is that there are precision issues around zero, particularly with small bin sizes, which may lead to such deviations. More significantly, a systematic deviation from the random walk was observed in conciseness fine-tuning of the largest model, Qwen2.5-7B-Instruct (Figure `\ref{fig:qwen-concise-hist}`{=latex}). The distribution shifts toward abundant small magnitude edits, suggesting that small parameter tweaks may be most significant in influencing output behavior. This result reinforces observations in prior studies [e.g. @liu2025sparse]. A possible explanation is that large models encode functionality in a more redundandant manner, and therefore minor tweaks are sufficient to achieve fine-tuning objectives. In fact, the changes are nearly indistinguishable from random walk in Figures `\ref{fig:llama-countdown-hist}`{=latex} and `\ref{fig:qwen-countdown-hist}`{=latex} likely because they are benevolent wrt. the fine-tuning objective. A more thorough investigation of these hypotheses is a most interesting direction of future work, potentially resulting in a better understanding of fine-tuning and information processing principles in LLMs in general. ![Parameter magnitude shift histograms for the Countdown task in Llama models optimized by ES. The changes are similar to those of a random walk, concentrated around zero, likely due to numerical inaccuracies.](figures/countdown/llama_countdown_hist.png){#fig:llama-countdown-hist width="1.0\\linewidth"} ![Parameter magnitude shift histograms for the Countdown task in Qwen models optimized by ES. The results are consistent with those observed in Llama models.](figures/countdown/qwen_countdown_hist.png){#fig:qwen-countdown-hist width="1.0\\linewidth"} ![Parameter magnitude shift histograms in conciseness fine-tuning in Qwen2.5-7B-Instruct model with ES. In this case, the model is large and the fine-tuning goals is different, revealing a potentially significant pattern of primarily small changes. The hypothesis (to be analyzed more thoroughly in future work) is that behavior is coded in large models in a redundant manner, making it possible to achieve this fine-tuning objective through numerous small changes. ](figures/conciseness/concise_hist.png){#fig:qwen-concise-hist width="1.0\\linewidth"} ```{=latex} \clearpage ``` Experiment with Mini Sudoku Task {#app:sudoku} -------------------------------- Standard Sudoku requires filling in missing integers in a $9\times9$ grid, evenly divided into $9$ smaller $3\times3$ grids. Integers must satisfy the following conditions: every row contains each integer $1-9$, every column contains each integer $1-9$, and each $3\times3$ sub-grid contains each integer $1-9$. Given the difficulty of $9\times9$ puzzles, existing evaluation of LLM's ability to complete Sudoku is often done with $4\times4$ grids, with equivalent rules for rows, columns, and $2\times2$ subgrids with digits $1-4$. Training data generation and evaluation was preformed with the sudoku board generation logic and reward function from [@reasoninggym]. $1,000$ example unique grids were generated, with $800$ in training and $200$ in testing. Qwen-2.5-3B-Instruct was used as the base model and trained with greedy decoding and batch size set to the entire $800$ sample training set. ES was run for $2,500$ iterations and hyperparameters were set as follows: $\sigma = 0.001$, $\alpha = 0.0005$, and $N = 32$. With this setup, model performance improved from 2% to 66.5% of test set puzzles correctly solved. An example of the prompt, along with model responses before and after ES fine tuning is provided below in Figure 11. ```{=latex} \FloatBarrier ``` ```{=latex} \begin{tcolorbox}[ label=fg:sudokuexample, colback=white, colframe=gray!60, sharp corners, boxrule=0.8pt, left=6pt, right=6pt, top=8pt, bottom=8pt, width=\textwidth, enhanced jigsaw, breakable ]\vspace{0.2cm} \colorbox{blue!10}{\textbf{Prompt:}} \vspace{0.2cm} You are a helpful assistant. You first think about the reasoning process in your mind and then provide the user with the answer. In 4x4 Mini Sudoku: \begin{itemize} \item Each row must contain each number from 1--4 exactly once \item Each column must contain each number 1--4 exactly once \item Each 2x2 subgrid must contain each number 1--4 exactly once \end{itemize} Solve this 4x4 Mini Sudoku puzzle: {\ttfamily\noindent \_ \_ 4 \_\\ 4 3 \_ \_\\ 3 \_ \_ 1\\ 1 \_ 3 \_ } Show your work in \texttt{ } tags. And return the final answer in \texttt{ } tags, with spaces separating each number within a row, and newlines separating rows. For example \texttt{{\ttfamily \\ 2 1 4 3\\ 4 3 2 1\\ 3 1 4 2\\ 1 2 3 4}\\}. Let me solve this step by step. \texttt{} \vspace{0.2cm} \colorbox{red!10}{\textbf{Base Model Output (Incorrect):}} \vspace{0.2cm} First, let's look at the given numbers and try to deduce the missing numbers. The number 4 is already placed in the first column, so we can't have another 4 in that column. The number 3 is already placed in the second row, so we can't have another 3 in that row. The number 1 is already placed in the third row, so we can't have another 1 in that row. Let's start filling in the grid based on these constraints: \texttt{} \texttt{}\\ {\ttfamily 2 1 4 3\\ 4 3 2 1\\ 3 1 4 2\\ 1 2 3 4}\\ \texttt{} \texttt{} This is the final solution to the 4x4 Mini Sudoku puzzle. Let me verify: Each row contains the numbers 1, 2, 3, 4 exactly once: Row 1: 2 1 4 3, Row 2: 4 3 2 1, Row 3: 3 1 4 2, Row 4: 1 2 3 4. Each column contains the numbers 1, 2, 3, 4 exactly once: Column 1: 2 4 3 1, Column 2: 1 3 1 2, Column 3: 4 2 4 3, Column 4: 3 1 2 4. Each 2x2 subgrid contains the numbers 1, 2, 3, 4 exactly once: Subgrid 1: 2 1 / 3 4, Subgrid 2: 4 2 / 1 3, Subgrid 3: 3 1 / 4 2, Subgrid 4: 1 2 / 3 4. All constraints are satisfied, so the solution is correct. \texttt{} The final answer is: \texttt{}\\ {\ttfamily 2 1 4 3\\ 4 3 2 1\\ 3 1 4 2\\ 1 2 3 4}\\ \texttt{} \vspace{0.2cm} \colorbox{green!10}{\textbf{Fine-Tuned Model Output (Correct):}} \vspace{0.2cm} First, let's look at the given numbers and try to fill in the missing numbers. We start with the first row: \texttt{\_ \_ 4 \_}. Since each row must contain each number from 1 to 4 exactly once, the missing numbers in the first row must be 2, 1, and 3. So the first row becomes: 2 1 4 3. Next, let's look at the second row: \texttt{4 3 \_ \_}. Since each row must contain each number from 1 to 4 exactly once, and we already have 4 and 3 in this row, the missing numbers must be 1 and 2. So the second row becomes: 4 3 1 2. Now, let's look at the third row: \texttt{3 \_ \_ 1}. Since each row must contain each number from 1 to 4 exactly once, and we already have 3 and 1 in this row, the missing numbers must be 2 and 4. So the third row becomes: 3 4 2 1. Finally, let's look at the fourth row: \texttt{1 \_ 3 \_}. Since each row must contain each number from 1 to 4 exactly once, and we already have 1 and 3 in this row, the missing numbers must be 2 and 4. So the fourth row becomes: 1 2 3 4. So, the completed 4x4 Mini Sudoku puzzle looks like this: \texttt{} \texttt{}\\ {\ttfamily 2 1 4 3\\ 4 3 1 2\\ 3 4 2 1\\ 1 2 3 4}\\ \texttt{} \captionof{figure}{Example prompt and model outputs for the 4x4 Mini Sudoku task. The base model would respond in a variety of step by step methods, while the fine tuned model settled into a consistent, dense thinking space.} \end{tcolorbox} ``` ```{=latex} \FloatBarrier ``` Experiments on ARC-AGI Task {#app:arc-agi} --------------------------- *ARC-AGI* [@chollet2024arc] is a benchmark designed to evaluate abstract reasoning and generalization capabilities. Each task presents a few input-output grid pairs as examples, requiring models to infer the underlying transformation rules and apply it to a new test input. The dataset has 400 public training tasks and evaluation tasks, focusing on creative problem-solving. We used 200 training tasks for fine-tuning and 200 evaluation tasks for testing. ### Experimental settings *Prompts*. The ARC-AGI tasks are presented in image format. To use LLMs to solve them, we first map colors to the numbers as follows: black $\to$ 0, blue $\to$ 1, red $\to$ 2, green $\to$ 3, yellow $\to$ 4, grey $\to$ 5, gray $\to$ 5, pink $\to$ 6, orange $\to$ 7, purple $\to$ 8, brown $\to$ 9. ```{=latex} \begin{tcolorbox}[ label=fg:arcagiexample, colback=white, colframe=gray!60, sharp corners, boxrule=0.8pt, left=6pt, right=6pt, top=8pt, bottom=8pt, width=\textwidth, enhanced jigsaw, breakable ] %\colorbox{blue!30}{} \vspace{0.2cm} \colorbox{blue!10}{\textbf{System Prompt:}} \vspace{0.2cm} You are a creative and meticulous ARC puzzle solver who explains reasoning before answering. \vspace{0.2cm} \colorbox{blue!10}{\textbf{Task Explanation:}} \vspace{0.2cm} You will be given some number of paired example inputs and outputs. The outputs were produced by applying a transformation rule to the inputs. In addition to the paired example inputs and outputs, there is also one additional input without a known output. Your task is to determine the transformation rule and implement it in code. The inputs and outputs are each "grids". A grid is a rectangular matrix of integers between 0 and 9 (inclusive). These grids will be shown to you as grids of numbers (ASCII). Each number corresponds to a color. The correspondence is as follows: black: 0, blue: 1, red: 2, green: 3, yellow: 4, grey: 5, pink: 6, orange: 7, purple: 8, brown: 9. The transformation only needs to be unambiguous and applicable to the example inputs and the additional input. It doesn't need to work for all possible inputs. \vspace{0.2cm} \colorbox{blue!10}{\textbf{Reasoning Explanation:}} \vspace{0.2cm} You'll need to carefully reason in order to determine the transformation rule. Start your response by carefully reasoning in tags. Then, implement the transformation in code. After your reasoning write code in triple backticks (```python and then ```). You should write a function called `transform` which takes a single argument, the input grid as `list[list[int]]`, and returns the transformed grid (also as `list[list[int]]`). You should make sure that you implement a version of the transformation which works in general (it shouldn't just work for the additional input). \vspace{0.2cm} \colorbox{blue!10}{\textbf{Other Instructions:}} \vspace{0.2cm} Don't write tests in your python code, just output the `transform` function. (It will be tested later.) You can also ask question to verify your observation on the inputs/outputs patterns in the form of python function which takes two arguments, the input and expected output grid both as `list[list[int]]` and returns the boolean flag (True or False). We will help you by running your Python function on examples and let you know whether your question is True or False. You follow a particular reasoning style. You break down complex problems into smaller parts and reason through them step by step, arriving at sub-conclusions before stating an overall conclusion. This reduces the extent to which you need to do large leaps of reasoning. You reason in substantial detail for as is necessary to determine the transformation rule. You are creative and accomplished at solving puzzles. When you write `transform`, do not hardcode the solution for each example. We will run your transform function on additional inputs later and check if your logic is generic in addition to check the correctness. \captionof{figure}{Prompts used for the ARC-AGI task.} \end{tcolorbox} ``` *Hyperparameters* $\sigma = 0.001$, $\alpha = 0.0003$, $N$ = 50, iterations = 1500. ### RL attempts Few prior works have explored using RL--based post-training for LLMs on ARC-AGI tasks. While RL has been widely used for LLM alignment and reasoning tasks (e.g., RLHF, math and QA benchmarks), its application to abstraction-centric, out-of-distribution generalization benchmarks like ARC-AGI remains relatively under-explored, largely due to challenges in reward design and efficient exploration. According to a recent report [@arc_rl_report2025] , applying GRPO to ARC-AGI resulted in minimal gains. The model failed to discover new strategies or abstract concepts; instead, it simply learned to rerank or refine the candidates it could already generate based on its original training. [^1]: LLama3 training used $16,000$ H100 GPUs [@llama3modelcard].