Le Critique: Privileged Value Functions for LLM Reinforcement Learning
Abstract: Reinforcement learning algorithms for LLMs are largely distinguished by their variance reduction strategy. Group-relative methods like GRPO reduce gradient variance by sampling multiple rollouts per prompt, but provide only sequence-level credit. Training is also blocked by straggler rollouts, reducing throughput and increasing off-policyness. Learned value functions theoretically address both problems, providing token-level advantages without requiring large groups. However, additional infrastructure engineering challenges combined with the practical success of critic-free methods have made it difficult to justify their inclusion in RL pipelines. We propose two complementary strategies to improve the performance of value function RL: 1) Privileged Value Functions (PVF) which provide an elegant mechanism to inject additional task-relevant token-level signal without biasing the policy objective; 2) TETHER, a baseline that adaptively interpolates between group-relative and value baselines depending on the value function accuracy. Across several reasoning tasks, both strategies consistently improve over the standard value function baseline, and are competitive with or outperform mean-baseline GRPO.
Paper Prompts
Sign up for free to create and run prompts on this paper.
Top Community Prompts
Explain it Like I'm 14
1. What is this paper about?
This paper studies how to improve the training of LLMs using reinforcement learning (RL).
Reinforcement learning is a way of teaching a system through rewards. For example, an LLM might receive a high reward for solving a math problem correctly and a low reward for giving a wrong answer.
Many recent LLM training methods, such as GRPO, compare several answers to the same question. Answers that score better than the group average are encouraged, while weaker answers are discouraged. This works well, but it has a weakness: it usually gives the same learning signal to every word in an answer.
The paper argues that another tool, called a value function, can give more detailed feedback about each individual token—or word-like piece—in a response.
The authors introduce two methods:
- Privileged Value Functions (PVFs): value functions that can use extra information unavailable to the LLM during normal decision-making.
- TetherPurple: a method that automatically combines a group-based estimate with a learned value-function estimate.
2. What questions are the researchers asking?
The paper mainly asks:
- Can value functions make LLM reinforcement learning more effective?
- Can extra information, such as a correct answer, help a value function judge partial solutions?
- Can value functions provide useful feedback for individual tokens instead of only judging a complete response?
- Can a system safely combine group-based methods like GRPO with value functions?
- Can these methods work on different reasoning tasks, including math, coding, and Sudoku?
The larger goal is to find out whether value functions are worth the extra computing and engineering work they require.
3. How did the researchers approach the problem?
A simple picture of the training process
Imagine an LLM answering a difficult question. It produces a sequence of tokens:
“First, I will…”
At the end, the answer receives a reward. For example:
- Correct answer: reward of
1 - Incorrect answer: reward of
0
The training system then decides which parts of the response should become more likely in the future.
Group-based feedback
A group-based method asks the LLM to produce several answers to the same question. It then compares their scores.
For example, suppose four answers receive these rewards:
| Answer | Reward |
|---|---|
| A | 1 |
| B | 0 |
| C | 1 |
| D | 0 |
An answer is judged partly by how it compares with the other answers. This is similar to grading students relative to the class average.
The problem is that the method may give all tokens in answer A the same positive signal, even though some tokens were helpful and others were unnecessary.
Ordinary value functions
A value function is like a progress predictor or coach. It looks at the answer so far and estimates how likely the final answer is to succeed.
For example:
- After a good first step in a math problem, it may predict a high chance of success.
- After making a contradiction, it may predict a low chance of success.
The difference between the actual final reward and the prediction is called an advantage. This tells the LLM whether its actions were better or worse than expected.
This gives more detailed, token-level feedback. It is like telling a student not only whether the final answer was correct, but also which steps in the solution helped.
Privileged Value Functions
A Privileged Value Function receives extra information during training that the LLM itself does not get to use directly.
Examples include:
- The correct answer to a problem
- A solved Sudoku grid
- Other answers produced by the LLM
- The scores of those other answers
This is like allowing a teacher to see the answer key while judging how well a student is progressing. The student still has to solve the problem normally, but the teacher can make more accurate judgments.
The important idea is that the extra information is used only by the value function to create a better baseline for learning. It is not used to directly force the LLM to copy the answer.
TetherPurple
TetherPurple combines two types of feedback:
- A group baseline, which compares an answer with other answers to the same question.
- A value baseline, which estimates how promising each partial response is.
It uses a mixing number called :
- When , it relies entirely on the group comparison.
- When , it relies entirely on the value function.
- Between
0and1, it uses both.
The system automatically changes based on which method is making better predictions. It generally starts with the group method, because the value function may be unreliable at the beginning, and then uses more value-function information as the value function improves.
4. What did the researchers find?
The researchers tested their methods on several tasks:
- General reasoning problems
- Code input-output reasoning
- Sudoku
- Formal mathematics using MiniF2F and Lean
They used LLMs with about 4 billion parameters, including Qwen models.
Main findings about Privileged Value Functions
Privileged Value Functions performed better than ordinary value functions in all the tested settings.
They also often matched or beat the group-mean method.
The strongest improvement appeared in Sudoku. This makes sense because a solved Sudoku grid helps the value function understand whether a partial solution is moving toward a valid final grid.
In the CodeIO task, the PVF did not receive a correct answer. Instead, it received information about the other answers in the group and their rewards. Even this general-purpose information helped it perform better.
The PVF also explained more of the differences in rewards than the ordinary value function. In everyday terms, it was better at predicting which partial answers were likely to succeed.
Main findings about TetherPurple
TetherPurple performed better than the ordinary value-function baseline on all four tested tasks.
Compared with the group-mean method:
- It performed better on Reasoning Gym.
- It performed better on MiniF2F.
- It matched the group method on CodeIO.
- It did not completely beat the group method on Sudoku, but it greatly reduced the gap.
This suggests that TetherPurple can provide a safer way to add value functions to systems that already use group-based RL.
Why these results matter
The findings suggest that value functions are not necessarily outdated or too difficult to use for LLM training.
They can offer two important benefits:
- More precise feedback: different tokens can receive different learning signals.
- Less need for large groups: a value function may work even when only one response is generated for a prompt.
Large groups can slow training because the system must wait for the slowest response. Value functions may help reduce this problem.
5. What could this research change?
This research could make reinforcement learning for LLMs more efficient and more detailed.
Today, a group-based method may simply say:
“This whole answer was better than average.”
A value function can instead provide information closer to:
“This step was useful, but the reasoning began to go wrong here.”
That kind of feedback may be especially valuable for:
- Long mathematical proofs
- Programming tasks
- Multi-step planning
- Tool-using AI agents
- Long conversations
- Games and other tasks with many decisions
Privileged information could also help when an answer is difficult to judge from its partial text alone. For example, knowing the correct final Sudoku solution can help the system recognize whether an intermediate move is promising.
However, the approach has limitations. Value functions require extra computer memory, processing power, and software infrastructure. The experiments were also relatively small, using 4-billion-parameter models and a limited number of tasks. Larger tests are needed to determine whether the results continue to hold for much bigger models and real-world AI agents.
Simple conclusion
The paper’s main message is that value functions can still be very useful for training LLMs, especially when they are given carefully chosen extra information.
The authors propose:
- Privileged Value Functions, which use helpful training-only clues to make better predictions.
- TetherPurple, which combines reliable group comparisons with detailed value-function feedback.
Together, these methods may help LLMs learn more efficiently, give better credit to individual parts of their reasoning, and handle longer and more complicated tasks.
Knowledge Gaps
Knowledge gaps, limitations, and open questions
The paper leaves the following issues unresolved:
- Compute-efficiency is not established: VF, PVF, TetherPurple, and group-relative baselines are matched by the number of sampled trajectories rather than total accelerator time, memory, energy, inference latency, or training cost, so their practical efficiency remains unclear.
- The scalability of PVFs is unknown: Experiments use approximately 4B-parameter policies and relatively small critics; it is unresolved whether privileged critics remain beneficial, affordable, and stable for larger LLMs and production-scale training.
- The evidence base is statistically limited: Most comparisons use only two or three random seeds, and the paper does not report confidence intervals, hypothesis tests, effect sizes, or per-task variability sufficient to establish the reliability of the reported improvements.
- Generalization across models is untested: Results rely primarily on Qwen3-4B-Instruct-2507, with Qwen3.5-4B used for MiniF2F; it is unknown whether the findings transfer across model families, parameter scales, base versus instruction-tuned models, and different value-head architectures.
- Task diversity is narrow: The experiments focus on verifiable reasoning, code input-output prediction, Sudoku, and formal mathematics; PVFs have not been evaluated on open-ended language tasks, preference-based RLHF, tool use, browsing, embodied interaction, or environments with noisy or delayed rewards.
- The benefit of different privileged signals is not disentangled: Reference answers, solved grids, sibling trajectories, sibling rewards, rubrics, and other possible inputs are not evaluated in a systematic factorial ablation, leaving unclear which information types provide the gains and why.
- The effect of privileged-information quality is unknown: The paper uses largely accurate or directly available privileged signals, but does not examine noisy, incomplete, outdated, adversarial, or distribution-shifted reference solutions and verifier information.
- Generalization beyond training-time privileged contexts is unresolved: It is unclear whether critics trained with privileged information remain useful when the privileged source changes, disappears, becomes unavailable, or differs between training and evaluation.
- Potential information leakage is not empirically stress-tested: Although the paper states admissibility conditions for unbiased baselines, it does not provide experiments that verify zero policy-gradient bias under correlated, partially dependent, or implementation-dependent privileged inputs.
- The practical boundary of admissibility is underspecified: In asynchronous and multi-turn settings, the paper does not fully characterize how stale trajectories, verifier outputs, environment state, termination events, or shared batch information can create dependence on the current token and bias the estimator.
- Off-policy effects are not quantified: The infrastructure is asynchronous, but the experiments do not measure policy lag, importance-weight distributions, critic staleness, or how PVF and TetherPurple behave as off-policyness increases.
- The claimed throughput advantage over group methods is not demonstrated: The paper motivates value functions as a way to reduce stragglers and group size, but provides no direct measurements of rollout waiting time, throughput, utilization, or wall-clock time.
- The role of group size remains unresolved: Only small values of are tested, and there is no systematic comparison across larger groups, including the compute-matched trade-off between additional rollouts, critic inference, and unique prompts.
- TetherPurple’s coefficient estimation is insufficiently characterized: The paper does not analyze whether the learned is consistently calibrated, whether it should be constrained to , or how often noisy regression produces extrapolating or unstable mixture weights.
- The EMA decay is not ablated: TetherPurple uses a fixed decay of , but the sensitivity of performance and stability to this choice is unknown across task horizons, batch sizes, policy drift rates, and asynchronous update schedules.
- A single global mixture coefficient may be inadequate: The proposed token-bucketed extension is only suggested, not evaluated; it remains unknown whether position-, state-, task-, or prompt-specific coefficients improve performance without introducing excessive estimation noise.
- The source of TetherPurple’s gains is unclear: The experiments do not isolate the contributions of the leave-one-out baseline, token-level value estimates, adaptive coefficient fitting, EMA smoothing, and delayed coefficient updates.
- Value pretraining is underexplored: Critics receive only 20 pretraining steps from data generated by a static base policy; the paper does not determine how extensive pretraining, diverse-policy data, privileged pretraining data, or critic reuse affect results.
- The bias–variance trade-off in is not systematically studied: A narrow illustrative comparison near is provided, but there is no broad or task-dependent sweep over and , nor an adaptive method based on critic accuracy.
- The interaction with other policy-optimization choices is unknown: PVF and TetherPurple are not systematically evaluated with PPO clipping, advantage normalization, KL penalties, importance weighting, token weighting, or alternative asynchronous correction methods.
- Only terminal-reward settings are substantially evaluated: The proposed methods’ behavior with dense rewards, intermediate verifier feedback, discounting, variable reward timing, reward shaping, and genuinely delayed credit assignment remains unresolved.
- The relationship between explained variance and policy performance is correlational: Higher PVF explained variance is associated with better reward in the reported experiments, but the paper does not establish that variance reduction causes the gains or identify when improved value prediction fails to improve policy learning.
- Critic capacity and architecture are not ablated: It is unclear how performance depends on critic size, shared versus separate policy parameters, value-head initialization, attention access to privileged inputs, context length, and mechanisms for encoding long auxiliary sequences.
- The computational cost of rich privileged contexts is not reported: Conditioning on complete sibling trajectories, reference solutions, or reasoning traces may substantially increase context length and inference cost, but these overheads are not quantified.
- Robustness to policy distribution shift is unknown: Since the critic is trained on returns from changing policies, the paper does not evaluate degradation when the policy changes rapidly or when the value model lags behind the current policy.
- No downstream generalization evaluation is provided: Improvements are measured mainly through training reward and final-window reward on the same task distributions; transfer to held-out problem generators, harder instances, or external benchmarks is not assessed.
- The methods’ effect on generated reasoning quality is unclear: The paper reports task rewards but does not analyze whether PVF or TetherPurple changes chain-of-thought length, diversity, correctness of intermediate steps, verbosity, or reliance on superficial reward patterns.
- Failure modes are not characterized: The paper does not identify conditions under which privileged critics underperform ordinary critics or group baselines, such as misleading references, sparse groups, critic overfitting, long contexts, reward imbalance, or rapidly changing task mixtures.
- The comparison set is incomplete: PVF and TetherPurple are not directly compared with strong contemporary actor–critic, RLOO, GAE/PPO, value-pretraining, self-distillation, or other token-level credit-assignment methods under matched settings.
- Large-scale agentic claims remain speculative: The conclusion suggests stronger benefits for long-horizon agents and partial-trajectory updates, but no experiments test unfinished-episode updates, bootstrapping before episode completion, tool interactions, or multi-stage agent trajectories.
Practical Applications
Immediate Applications
The paper’s methods are most immediately applicable to LLM post-training pipelines for tasks with verifiable outcomes, especially where long responses, sparse rewards, or rollout stragglers make critic-free reinforcement learning inefficient.
- Drop-in improvement for GRPO/RLOO-based LLM training — Industry / Software
- Integrate TetherPurple into existing group-relative RL pipelines as a replacement for a fixed leave-one-out or group-mean baseline.
- The system can begin with , relying on the robust group baseline, and progressively increase the value-function contribution as the critic becomes more accurate.
- This could be implemented in distributed training frameworks as:
- 1. sample a rollout group,
- 2. compute the leave-one-out baseline,
- 3. obtain token-level value predictions,
- 4. estimate on one batch,
- 5. use the smoothed coefficient on the next batch.
- Potential product or tool: a plug-in “adaptive critic” module for open-source RL libraries and LLM post-training platforms.
- Dependencies: reliable leave-one-out grouping, delayed use of the fitted to avoid policy-gradient bias, and sufficient value-model inference capacity.
- Token-level credit assignment for mathematical and reasoning models — Education / AI tutoring / Research
- Use Privileged Value Functions (PVFs) to assess whether intermediate reasoning steps are progressing toward a known answer, proof, or target state.
- Suitable tasks include mathematical problem solving, theorem proving, Sudoku, structured reasoning, and benchmark environments with ground-truth solutions.
- Rather than assigning the final reward uniformly to every token, the PVF can provide a more informative baseline for individual reasoning prefixes, reducing gradient variance and improving optimization.
- Potential workflow: train a reasoning model with access to a reference solution through the critic while keeping the reference hidden from the policy during generation.
- Dependencies: the reference solution must be available during training and must not contain information dependent on the current response token in a way that violates baseline admissibility.
- Reinforcement learning for code generation, repair, and program synthesis — Software / Developer tools
- Apply PVFs to code tasks using gold patches, unit-test specifications, compiler constraints, or other static task information.
- For code input-output prediction, the critic can condition on sibling trajectories and their returns, as demonstrated by the paper’s CodeIO experiments.
- This may improve training of:
- code completion models,
- automated bug-fixing systems,
- program synthesis agents,
- test-generation models,
- code-review assistants.
- Potential product: an RL training service that uses compiler results, test specifications, and candidate-program groups to create token-level value estimates.
- Dependencies: verifiable execution environments, secure sandboxing, protection against reward hacking, and careful exclusion of feedback generated by the current trajectory when it would introduce bias.
- More efficient training for long-form reasoning — Industry / Infrastructure
- Use PVFs and TetherPurple to reduce the need for very large rollout groups.
- A value function can operate with , while TetherPurple can reduce dependence on large groups by combining group-level reliability with token-level predictions.
- This could reduce:
- GPU memory and sampling requirements,
- synchronization delays,
- waiting for the slowest rollout,
- off-policy drift in asynchronous RL.
- Potential workflow: deploy asynchronous policy and value-model workers, allowing completed trajectories to update the critic without forcing all policy workers to wait for the slowest response.
- Dependencies: the paper does not provide a compute-matched comparison against critic-free methods; actual cost savings must therefore be measured at production scale.
- Improved asynchronous RL infrastructure for LLMs — Software / Cloud computing
- Adopt the paper’s asynchronous value-function infrastructure, including separate value inference and training services, in distributed post-training systems.
- This is particularly relevant for high-variance workloads involving long responses, agent trajectories, or heterogeneous task difficulty.
- Potential tool: a reusable asynchronous RL backend with rollout queues, stale-policy tracking, critic updates, and adaptive baseline monitoring.
- Dependencies: version management between policy and critic, importance weighting or other off-policy corrections, fault tolerance, and accelerator allocation for value-model inference.
- Use of explained variance as an operational critic-quality monitor — Industry / Academia
- Monitor the critic’s explained variance to determine whether a value baseline is reducing return variance more effectively than a group baseline.
- This provides a practical diagnostic for:
- deciding whether to increase ,
- detecting critic collapse,
- comparing privileged and ordinary critics,
- triggering additional value pretraining.
- Potential workflow: expose explained variance, prediction error, and as dashboards in RL training operations.
- Dependencies: sufficiently large and representative monitoring batches; explained variance can be unstable when reward variance is small.
- Training models with task-specific verifiers and rubrics — Education / Enterprise automation
- Give the critic access to verifier rubrics, static specifications, answer keys, proof targets, or structured task metadata that the policy cannot access at inference time.
- This can support models trained for:
- grading and feedback,
- compliance checking,
- document classification,
- structured extraction,
- formal verification.
- Dependencies: privileged inputs must remain unavailable to the deployed policy unless the product explicitly permits them; otherwise, training–inference mismatch may occur.
- Academic experimentation on variance reduction and credit assignment — Academia
- Use PVFTeal and TetherPurple as baselines in research comparing:
- GRPO,
- RLOO,
- PPO-style critics,
- self-distillation,
- asynchronous RL,
- long-horizon agent training.
- The open-source infrastructure cited by the paper can support reproducible experiments and ablations.
- Dependencies: the reported evidence is based mainly on 4B models, small seed counts, and reasoning tasks with verifiable rewards. Results should not yet be generalized to all LLMs or domains.
- Safer and more controlled use of privileged training data — Policy / AI governance
- PVFs provide a way to use sensitive or restricted training information—such as answer keys, internal rubrics, or private evaluation labels—without directly changing the policy objective.
- Organizations could maintain audit logs specifying:
- which privileged signals were provided,
- whether they were static or trajectory-dependent,
- how they affected critic training,
- whether they were excluded from inference.
- Dependencies: “unbiased” optimization does not guarantee privacy, fairness, or robustness. Privileged information can still leak through model parameters or affect performance unevenly across groups.
Long-Term Applications
The strongest long-term opportunities involve scaling these techniques beyond short benchmark tasks to autonomous agents, high-cost decision systems, and settings where partial trajectories have substantial operational value.
- Long-horizon autonomous software and web agents — Industry / Software
- Value functions could estimate the quality of partial agent trajectories before an entire task is completed.
- This would enable token- or action-level credit assignment for workflows such as:
- multi-step debugging,
- data analysis,
- web research,
- business-process automation,
- API orchestration.
- A critic could use privileged information such as task specifications, tool schemas, intermediate state summaries, or sibling trajectories to estimate progress.
- Potential product: an agent-training platform that scores partial plans and prioritizes promising trajectories.
- Dependencies: valid intermediate-state representations, reliable delayed rewards, resistance to reward hacking, and methods for handling feedback that depends on the agent’s own future actions.
- Robotics and embodied AI with asymmetric actor–critic systems — Robotics
- The PVF idea can transfer to robotics by allowing the critic to observe privileged simulator state, precise object poses, force measurements, or future task geometry while the policy receives only deployable sensor observations.
- This could improve training for manipulation, navigation, and multi-stage assembly.
- The paper’s contribution extends an established asymmetric actor–critic principle to LLM-style sequence policies.
- Dependencies: the privileged information must be available during training, the deployment observation gap must be controlled, and policies must be robust to real-world sensor noise and sim-to-real transfer.
- Inference-time search and planning — AI systems / Robotics / Games
- A learned value function could rank partial reasoning traces, tool-use plans, code candidates, or action sequences during best-of- sampling, beam search, or Monte Carlo tree search.
- This would extend the paper’s training-time critic beyond variance reduction into inference-time scaling.
- Potential tools: value-guided decoding, trajectory pruning, verifier-aware search, and critic-guided tool planning.
- Dependencies: the critic must be calibrated under the deployment distribution; overconfident value estimates could systematically eliminate correct but unconventional solutions.
- Healthcare decision-support agents — Healthcare
- In future systems, PVFs could use restricted clinical labels, expert plans, or validated treatment pathways during training to improve token-level or action-level credit assignment while exposing only permissible patient information to the policy.
- Applications might include:
- clinical documentation agents,
- diagnostic reasoning assistants,
- treatment-planning support,
- hospital workflow automation.
- Dependencies: extensive clinical validation, privacy compliance, distribution-shift testing, human oversight, and strict separation between training-only privileged data and information legally available at inference time. The paper provides no evidence for clinical effectiveness.
- Energy and industrial process optimization — Energy / Manufacturing
- For long-horizon control and planning, critics could use privileged simulator state, forecasts, maintenance records, or known optimal trajectories to improve policy training.
- TetherPurple could offer a conservative transition from a robust group baseline to a more informative learned value estimate as the critic improves.
- Potential products: energy-storage controllers, data-center cooling optimizers, predictive-maintenance agents, and production scheduling systems.
- Dependencies: high-fidelity simulators, safe exploration constraints, reliable reward definitions, and validation under rare failures and changing operating conditions.
- Finance and operations planning — Finance / Supply chain
- Value-guided RL could support sequential decisions such as portfolio rebalancing, inventory management, pricing, and logistics routing.
- Privileged critics might use historical outcomes, scenario simulations, or complete planning targets during training without giving the policy direct access to future realized information.
- Dependencies: strict prevention of look-ahead bias, nonstationary markets, transaction costs, regulatory requirements, risk-sensitive objectives, and the need to optimize more than average reward.
- Adaptive learning and personalized education — Education
- A tutor policy could be trained with PVFs conditioned on answer keys, curriculum graphs, pedagogical rubrics, or expert solution paths.
- The critic could estimate whether an intermediate explanation or hint is moving a learner toward mastery, enabling more precise optimization than assigning reward only after a full lesson.
- Potential product: a tutor-training workflow with hidden pedagogical evaluators and token-level progress estimates.
- Dependencies: valid measures of learning rather than superficial answer correctness, protection of student data, fairness across learners, and longitudinal validation.
- Large-scale value-function pretraining and reuse — Industry / Academia
- Pretrain value models on trajectories generated by diverse policies and include privileged context in the pretraining corpus.
- A reusable critic could then be adapted across multiple RL runs, reducing the infrastructure cost that currently discourages value-based methods.
- Potential product: a general-purpose value foundation model for reasoning, coding, and agentic tasks.
- Dependencies: coverage of future policy distributions, compatibility between tasks and reward definitions, continual recalibration, and avoidance of critic overfitting to obsolete policies.
- Adaptive and position-dependent TetherPurple — Research / Production RL
- Future systems could tune GAE and value-target parameters as a function of sequence length, critic accuracy, task type, or token position.
- Token-bucketed TetherPurple could use different values for early and late parts of a trajectory, reflecting that value prediction may be harder at the beginning of a task.
- Potential tool: an automated credit-assignment controller that jointly monitors critic error, sequence position, and reward propagation.
- Dependencies: enough samples per bucket, stable online estimation, careful handling of nonstationary policies, and safeguards against introducing bias through same-batch adaptation.
- Policy evaluation and governance of agent trajectories — Policy / Safety research
- Value functions could support auditing by estimating where an agent began to make an unrecoverable error, rather than evaluating only the final outcome.
- This may improve post hoc incident analysis for autonomous systems and help identify whether failures arose from planning, tool use, or execution.
- Dependencies: value estimates are predictive auxiliaries, not explanations or causal proofs. Their use in audits would require calibration, independent verification, and transparent uncertainty reporting.
- Real-world personal assistants with proactive planning — Daily life
- A future assistant could use value-guided planning to choose among multi-step actions such as arranging travel, managing calendars, shopping, or coordinating household tasks.
- Critics could rank partial plans and reduce wasted tool calls before the assistant commits to a full workflow.
- Dependencies: user consent, privacy-preserving state representations, reliable reversibility of actions, robust handling of ambiguous goals, and strict confirmation requirements for consequential actions. The paper’s experiments do not directly establish readiness for consumer deployment.
Glossary
- Actor–critic: A reinforcement-learning architecture that combines a policy (actor) with a value estimator (critic). “serve the role of critics in actor-critic methods”
- Advantage function: The estimated value of taking an action relative to the expected value of the current state. “each response token is assigned an advantage ”
- Asymmetric actor–critic: An actor–critic method in which the critic can access information unavailable to the policy. “this idea has been investigated before in the context of asymmetric actor--critic algorithms”
- Asynchronous reinforcement learning: Reinforcement learning in which data collection, value updates, or policy updates proceed without strict synchronization. “In asynchronous RL this worsens off-policyness”
- Baseline admissibility condition: A condition ensuring that subtracting a baseline does not bias the policy-gradient estimator. “when the privileged context satisfies the baseline admissibility condition”
- Bias–variance trade-off: The balance between systematic estimation error and sensitivity to random sampling noise. “Tuning for bias--variance trade-off”
- Bootstrap target: A target that uses a current value estimate for a later state instead of waiting for a complete observed return. “ is the one-step bootstrap target”
- Chain of thought: A sequence of intermediate reasoning steps generated by a LLM. “an intermediate chain of thought”
- Control variate: A correlated auxiliary quantity used to reduce the variance of an estimator without changing its expected value. “we improved value functions as control variates”
- Credit assignment: The process of determining which actions or tokens contributed to an eventual reward. “serve as a source of bootstrap targets for temporal credit assignment”
- Critic: A learned value estimator that predicts expected future rewards and is used to guide policy optimization. “The critic (term we use interchangeably with value function)”
- Critic-free method: A reinforcement-learning method that does not maintain a separately trained value model. “LLM RL has however shifted toward critic-free methods like GRPO”
- Deep reinforcement learning: Reinforcement learning that uses neural networks to represent policies, value functions, or other components. “deep RL's historic successes”
- Explained variance: A statistic measuring the proportion of variation in observed outcomes accounted for by model predictions. “Explained variance (EV) measures how much of the observed variation in rewards is captured by the value predictions.”
- Generalized Advantage Estimation (GAE): An estimator that combines temporal-difference residuals over multiple horizons to estimate policy advantages. “PPO estimates token-level advantages using a learned value function, typically through Generalized Advantage Estimation (GAE)”
- Gradient variance: Random variation in gradient estimates caused by stochastic sampling or noisy rewards. “GRPO reduce gradient variance by sampling multiple rollouts per prompt”
- Group-relative baseline: A baseline computed from rewards of multiple responses generated for the same prompt. “GRPO instead estimates advantages by comparing rewards across multiple responses sampled for the same prompt”
- In-context learning: Learning or adapting behavior from information supplied within the current input context rather than through parameter updates. “simplifying value prediction to an in-context learning task”
- Importance ratio: A ratio of probabilities under two policies, used to correct for data generated by a different policy. “including standardization, importance ratios, clipping, or masking”
- Inductive bias: A modeling preference or structural assumption that makes some solutions easier for a model to learn than others. “a strong inductive bias in prior work”
- Leave-one-out (LOO) baseline: A baseline computed from all sibling trajectories except the trajectory whose advantage is being estimated. “RLOO removes this dependence by forming a leave-one-out baseline from the sibling returns”
- Monte Carlo return: A return estimate computed from rewards observed over a complete sampled trajectory, without bootstrapping. “This Monte Carlo target is an unbiased sample of the conditional expectation”
- Off-policyness: The degree to which collected trajectories come from a policy different from the one currently being optimized. “reducing throughput and increasing off-policyness”
- On-policy self-distillation: Training a model to imitate a teacher distribution generated from information available during the model’s own reinforcement-learning process. “On-policy self-distillation methods similarly exploit privileged training-time information”
- Policy gradient: An optimization method that updates a policy by differentiating expected reward with respect to its parameters. “The generic token-normalized policy-gradient estimator”
- Policy optimum: The policy that optimizes the objective being used for training. “therefore changes the policy optimum”
- Privileged information: Training-time information unavailable to the policy but potentially useful for predicting rewards. “It is common to have privileged information during RL which the policy cannot directly condition on”
- Privileged Value Function (PVF): A value function conditioned on additional training-time information that the policy itself cannot access. “A privileged value function (PVFTeal) conditions the critic on both the standard policy token history and additional training-time context.”
- Return-to-go: The cumulative reward expected or obtained from a particular point in a trajectory onward. “choose the mixture ratio which best predicts the observed return-to-go”
- Score function: The gradient of the logarithm of a probability distribution, used in likelihood-based gradient estimators. “A baseline preserves an unbiased policy gradient when its contribution to the expected score is zero.”
- Self-distillation: A training procedure in which a model learns from a distribution or feedback generated by a related version of itself. “Self-distillation introduces a new distribution-matching objective”
- Straggler effect: A throughput bottleneck caused by having to wait for the slowest computation or rollout in a group. “Large groups also exacerbate straggler effects”
- Temporal-difference (TD) residual: The discrepancy between a reward-augmented next-state value estimate and the current value estimate. “the one-step TD residual is”
- Temporal credit assignment: Assigning responsibility for a reward to actions taken at different times in a trajectory. “as a source of bootstrap targets for temporal credit assignment”
- Token-level advantage: An advantage estimate assigned separately to each generated language-model token. “providing token-level advantages without requiring large groups”
- Trajectory: A sequence of states, actions, and rewards generated during an interaction with an environment. “the other independently sampled responses and even their rewards”
- Variance reduction: A technique for decreasing the sampling noise of an estimator while preserving or improving its expected result. “Critic access to appropriate privileged information helps it predict the return, which then improves value estimation thereby reducing policy gradient variance.”
- Value head: A model component that converts a language-model representation into a scalar value prediction. “typically implemented as a copy of the LLM with a scalar value head”
- Value pretraining: Preliminary training of a value function before policy reinforcement learning begins. “we initialized the value function as a copy of the base policy with a randomly initialized value head and used only 20 value pretraining steps”
- Value network: A neural network that estimates expected future reward from a state or partial trajectory. “which both used a value network alongside policy networks”
- Verifier feedback: Evaluation information produced by a program, environment, or checking system about the correctness of a generated response. “subsequent environment or verifier feedback generated by the current response”





