Optimal Advantage Policy Optimization with Lagged Inference

• The paper introduces a KL-regularized advantage regression objective with a closed-form solution that mitigates variance from high lag in off-policy data.
• OAPL leverages lagged inference to handle asynchronous training, enabling robust optimization even with significant policy misalignment.
• Empirical results show up to 6% Pass@k improvement in competition benchmarks and improved sample efficiency in code generation tasks.

Optimal Advantage–based Policy Optimization with Lagged Inference Policy (OAPL) is an off-policy reinforcement learning (RL) framework for training LLMs on sequence generation tasks using reward signals, specifically designed to address the significant policy lag that arises in distributed, asynchronous training architectures. OAPL introduces an update rule and training paradigm that enable efficient and robust learning from highly off-policy data, avoiding the variance and instability common in prior importance-sampling (IS)–based methods. The algorithm’s core principle is to embrace, rather than correct, the misalignment between the data-collecting (inference) and target (training) policies, leveraging a KL-regularized advantage regression objective that admits a closed-form solution and strong theoretical guarantees (Ritter et al., 22 Feb 2026).

1. Problem Setting and Policy Lag

In the context of LLM fine-tuning via RL, OAPL operates on prompt–completion pairs $(x, y)$, where $x$ is a user prompt and $y$ a generated output sequence. The reward function $r(x, y)$ may be sparse, such as a Pass@1 indicator. Two policy networks are maintained:

• $\pi_\theta(y|x)$: the target policy being trained, parameterized by $\theta$.
• $\pi_{\mathrm{lag}}(y|x)$: the inference (behavior) policy, whose parameters lag behind $\theta$ by up to $L$ optimizer steps due to asynchronous sampling and parameter updates.

Because the samples are generated under $\pi_{\mathrm{lag}}$ but training occurs on $x$0, collected data is inherently off-policy. The lag $x$1 may reach hundreds of update steps in practice, especially in distributed or multi-GPU environments.

The OAPL objective augments the standard expected reward with a KL-divergence penalty to keep the learning stable under this significant off-policyness: $x$2 where $x$3 controls the trade-off between reward maximization and adherence to the lagged policy.

2. Closed-Form Update: Optimal Advantage Regression

The KL-regularized RL objective with lagged policy admits a closed-form optimal solution for $x$4 at each $x$5: $x$6 and the associated “optimal value” baseline: $x$7 The optimal advantage is $x$8. This establishes the identity: $x$9 Crucially, $y$0 can be consistently estimated from groupwise rollouts from $y$1, removing the need for importance weighting.

Groupwise estimation of $y$2 with $y$3 independent rollouts $y$4: $y$5

The objective for $y$6 becomes a strongly convex regression in the log-probability domain: $y$7 This regression is uniquely minimized at the optimal solution, regardless of how the $y$8 are sampled, further cementing off-policy robustness.

3. Algorithmic Implementation

The OAPL training procedure consists of alternating asynchronous data collection and policy updating, interleaved with periodic synchronization of inference and training policies. The workflow is as follows:

1. Data Collection (Async):
   • Sample minibatch prompts $y$9.
   • For each $r(x, y)$0, generate $r(x, y)$1 sequences $r(x, y)$2 using $r(x, y)$3, recording $r(x, y)$4 and $r(x, y)$5.
2. Advantage Estimation and Policy Update (Async):
   • For batch $r(x, y)$6 of prompts, compute $r(x, y)$7 via groupwise estimation.
   • Estimate $r(x, y)$8.
   • Perform gradient updates on $r(x, y)$9 using the squared regression loss.
3. Periodic Synchronization:
   • Every $\pi_\theta(y|x)$0 steps, copy $\pi_\theta(y|x)$1 to the inference engine to refresh $\pi_\theta(y|x)$2 and clear the data buffer.

Key hyperparameters include group size $\pi_\theta(y|x)$3 (to reduce estimation variance), lag interval $\pi_\theta(y|x)$4 (controls staleness of $\pi_\theta(y|x)$5), and two temperature parameters $\pi_\theta(y|x)$6 (for $\pi_\theta(y|x)$7 estimation) and $\pi_\theta(y|x)$8 (for regression loss). No clipping or extra ratio corrections are necessary.

4. Theoretical Guarantees

OAPL provides several strong theoretical properties:

• Unique Minimizer: The regression objective (see above) is strongly convex in log-space, ensuring that $\pi_\theta(y|x)$9 converges to the optimal $\theta$0.
• Variance Reduction: By regressing against the log-ratio with a baseline computed via $\theta$1, the method avoids importance-sampling variance, which grows rapidly when policies diverge.
• Lag Tolerance: The KL penalty enforces proximity to $\theta$2, endowing OAPL with empirical stability for lag intervals up to $\theta$3–$\theta$4 steps, orders of magnitude beyond IS-based methods.
• Convergence: Under standard assumptions (bounded gradients, small enough learning rates), SGD on the convex surrogate converges globally.

A practical implication is that OAPL enables stable and effective use of stale, off-policy samples gathered in highly parallel workflows (Ritter et al., 22 Feb 2026).

5. Empirical Findings and Benchmarking

OAPL was evaluated on competition mathematics benchmarks (HMMT-25, AIME-25, BRUMO-25) and the LiveCodeBench code-generation benchmark.

• On competition math, OAPL outperforms GRPO with IS by approximately $\theta$5–$\theta$6 in Pass@1, $\theta$7–$\theta$8 in Pass@5, and $\theta$9–$\pi_{\mathrm{lag}}(y|x)$0 in Pass@10. Learning curves demonstrate reduced variance and no entropy collapse, even with infrequent synchronization ($\pi_{\mathrm{lag}}(y|x)$1).
• In code generation, OAPL matches or slightly outperforms DeepCoder (GRPO heuristic baseline) in Pass@k across $\pi_{\mathrm{lag}}(y|x)$2, and achieves equivalent Pass@1 using approximately $\pi_{\mathrm{lag}}(y|x)$3 fewer generations ($\pi_{\mathrm{lag}}(y|x)$4K vs. $\pi_{\mathrm{lag}}(y|x)$5K).
• OAPL exhibits enhanced sample efficiency and improved scaling in test-time Pass@k up to $\pi_{\mathrm{lag}}(y|x)$6.

The following summarizes OAPL’s empirical results:

Benchmark	Baseline	OAPL Improvement	Sample Efficiency
Competition Math	GRPO + IS	+2–6% in Pass@k across board	n/a
LiveCodeBench	DeepCoder	Matches/surpasses Pass@k	3× fewer generations needed

6. Practical Considerations and Recommendations

Batch size $\pi_{\mathrm{lag}}(y|x)$7 and group size $\pi_{\mathrm{lag}}(y|x)$8 should be selected to balance baseline variance against GPU throughput (standard $\pi_{\mathrm{lag}}(y|x)$9). Lag interval $\theta$0 controls communication frequency; $\theta$1 is effective, with larger values further reducing overhead. The temperatures $\theta$2 tune the softness of the $\theta$3 baseline and KL regularization, respectively. No outer-loop clipping or IS ratios are required, simplifying integration.

Best practices for scaling include running the inference engine asynchronously (e.g., vLLM), with periodic weight synchronization tightly controlling lag. The architecture is readily extended to multi-GPU and large-model settings without modification.

OAPL leverages the lag between training and inference as a KL-constraint, stabilizing learning from extremely stale off-policy data. Its advantage regression objective yields robust, sample-efficient training and improves performance metrics relevant in LLM deployment scenarios (Ritter et al., 22 Feb 2026).

7. Related Work and Significance

Prior approaches (PPO, GRPO) address off-policyness by manual correction—either reweighting samples via IS or modifying inference to match training more closely. OAPL’s innovation is to abandon reliance on these corrections in favor of a lag-tolerant objective whose minimizer is analytically characterized. This aligns OAPL with developments in soft actor-critic and KL–regularized RL literature, but extends these ideas to the LLM fine-tuning regime with lagged asynchronous inference.

A plausible implication is that OAPL’s high lag tolerance enables more efficient distributed training architectures, potentially reducing synchronization or communication bottlenecks, and supporting large-scale data collection without compromising stability or performance.