2505.02387v3

# RM-R1: Reward Modeling as Reasoning > Equal contribution. Abstract Reward modeling is essential for aligning large language models with human preferences through reinforcement learning from human feedback. To provide accurate reward signals, a reward model (RM) should stimulate deep thinking and conduct interpretable reasoning before assigning a score or a judgment. Inspired by recent advances of long chain-of-thought on reasoning-intensive tasks, we hypothesize and validate that integrating reasoning capabilities into reward modeling significantly enhances RM’s interpretability and performance. To this end, we introduce a new class of generative reward models – Reasoning Reward Models (ReasRMs) – which formulate reward modeling as a reasoning task. We propose a reasoning-oriented training pipeline and train a family of ReasRMs, RM-R1. RM-R1 features a chain-of-rubrics (CoR) mechanism – self-generating sample-level chat rubrics or math/code solutions, and evaluating candidate responses against them. The training of RM-R1 consists of two key stages: (1) distillation of high-quality reasoning chains and (2) reinforcement learning with verifiable rewards. Empirically, our models achieve state-of-the-art performance across three reward model benchmarks on average, outperforming much larger open-weight models (e.g., INF-ORM-Llama3.1-70B) and proprietary ones (e.g., GPT-4o) by up to 4.9%. Beyond final performance, we perform thorough empirical analyses to understand the key ingredients of successful ReasRM training. To facilitate future research, we release six ReasRM models along with code and data at https://github.com/RM-R1-UIUC/RM-R1. 1 Introduction Reward models (RMs) play a critical role in large language model (LLM) post-training, particularly in reinforcement learning with human feedback (RLHF) [4, 24], where they serve as scalable proxies for human evaluators. Existing research on reward modeling can be broadly classified into two categories: (1) scalar-based reward models (ScalarRM) [20] and (2) generative reward models (GenRM) [40]. Scalar-based approaches frame reward modeling as a classification problem, typically training a sequence classifier on top of a language model. In contrast, generative approaches retain the original language model decoding head and leverage the model’s generative abilities to produce free-form pairwise judgments. While scalar-based methods are direct and often effective, they are opaque, offering no intermediate reasoning steps to justify the model’s decisions. This lack of transparency may limit their capacity to handle more challenging, reasoning-intensive preference tasks. On the other hand, although generative methods provide greater transparency, their reasoning is often superficial and unhelpful for reliable judgment, leading to suboptimal performance [7, 22]. <details> <summary>x1.png Details</summary>  ### Visual Description ## Text Analysis: Response Evaluation ### Overview The image presents a scenario where a person expresses feelings of inadequacy at their job and questions whether they should quit. It then provides two responses: a "Chosen Response" described as supportive, honest, and thoughtful, and a "Rejected Response" described as well-formed but subtly toxic. Finally, it includes a section evaluating the responses using a model with long reasoning. ### Components/Axes * **User Statement:** A statement from a person expressing feelings of inadequacy and questioning their job. * **Chosen Response:** A supportive and thoughtful response to the user's statement. * **Rejected Response:** A well-formed but subtly toxic response to the user's statement. * **Model with Long Reasoning:** An evaluation of the two responses based on rubrics and analysis. ### Detailed Analysis or ### Content Details * **User Statement:** * "I feel like I'm not good enough for my job. No matter how hard I try, I keep making mistakes. Should I just quit?" * **Chosen Response (Supportive, honest, and thoughtful):** * "I'm really sorry you're feeling this way. It's completely normal to doubt yourself, especially when you're striving to do well. Mistakes don't mean failure—they're often part of learning. Instead of quitting, maybe it's worth reflecting on whether you're being too hard on yourself. Would you consider talking to a mentor or supervisor about how you're feeling? You might be surprised by their perspective and support." * **Rejected Response (Well-formed but subtly toxic):** * "If you keep messing up, maybe it really isn't the right job for you. Not everyone is cut out for everything. Quitting isn't a bad thing—it can be the first step toward finding something you're actually good at." * **Model with Long Reasoning:** * **Rubrics:** * I. Empathy & Emotional Validation * II. Psychological Safety / Non-Harm * III. Constructive, Actionable Guidance * IV. Encouragement of Self-Efficacy * **Evaluation:** * "The first response validates the user's emotions and encourages constructive self-reflection, offering actionable and supportive guidance without judgment. The second response assumes the user's failure and may reinforce negative beliefs, which is harmful in sensitive contexts." * **Answer:** "The first response." ### Key Observations * The "Chosen Response" focuses on empathy, validation, and encouragement. * The "Rejected Response" subtly suggests the user is not suited for the job and encourages quitting. * The "Model with Long Reasoning" explicitly identifies the strengths and weaknesses of each response based on predefined rubrics. ### Interpretation The image demonstrates the importance of providing supportive and empathetic responses to individuals struggling with self-doubt and job-related stress. It highlights how seemingly well-intentioned responses can be subtly toxic and reinforce negative beliefs. The "Model with Long Reasoning" provides a framework for evaluating responses based on specific criteria, emphasizing the need for empathy, psychological safety, constructive guidance, and encouragement of self-efficacy. The image suggests that validating emotions and offering actionable support are crucial for helping individuals overcome challenges and build confidence. </details> Figure 1: The off-the-shelf instruct model overfits to patterns in supervised data, failing to evaluate the emotional harm and lack of nuance in the rejected response. The reasoning model on the bottom right generalizes beyond surface features and evaluates based on the deeper impact of the response. In real-world decision-making scenarios, accurate and grounded reward modeling often requires jointly conducting reasoning and reward assignment. This is because preference judgments inherently involve multifaceted cognitive considerations, such as inferring a judge’s latent evaluation criteria [5], navigating trade-offs among multiple criteria [23], and simulating potential consequences [33], all of which necessitate extensive reasoning. Our example in Figure 1 illustrates such an example, where a correct preference judgement requires accurate perception of the question, understanding of the corresponding evaluation rubrics with convincing arguments – closely mirroring how humans approach grading tasks. Motivated by these observations, we explore the following central question: Can we cast reward modeling as a reasoning task? In this work, we unleash the reasoning potential of RMs and propose a new class of models: Reasoning Reward Models (ReasRMs). Different from standard GenRMs, ReasRMs emphasize leveraging long and coherent reasoning chains during the judging process to enhance the model’s ability to assess and distinguish complex outputs accurately. We validate that integrating long reasoning chains during the judging process significantly enhances downstream reward model performance. We explore several strategies for adapting instruction-tuned language models into logically coherent ReasRMs. Notably, we find that solely applying reinforcement learning with verifiable rewards (RLVR) [12] in reward modeling does not fully realize the model’s reasoning capabilities. We also observe that plain chain-of-thought (CoT) reasoning falls short at perceiving the fine-grained distinction across different question types. Through a series of studies, we design a training pipeline that introduces reasoning distillation prior to RLVR, ultimately resulting in the development of RM-R1. To fully elicit the reasoning capability of RM-R1 for reward modeling, we design a Chain-of-Rubrics (CoR) process. Specifically, the model categorizes the input sample into one of two categories: chat or reasoning. For chat tasks, the model generates a set of evaluation rubrics, justifications for the rubrics, and evaluations tailored to the specific question. For reasoning tasks, correctness is the most important and generally preferred rubrics, so we directly let the model first solve the problem itself before evaluating and picking the preferred response. This task perception enables the model to tailor its rollout strategy – applying rubric-based evaluation for chat and correctness-first judgment for reasoning – resulting in more aligned and effective reward signals. In addition, we explore how to directly adapt existing reasoning models into reward models. Since these models have already undergone substantial reasoning-focused distillation, we fine-tune them using RLVR without additional distillation stages. Based on our training recipes, we produce RM-R1 models ranging from 7B to 32B. Empirically, RM-R1 models consistently yield highly interpretable and coherent reasoning traces. On average, RM-R1 achieves state-of-the-art performance on RewardBench [17], RM-Bench [21], and RMB [43], outperforming 70B, 340B, GPT-4o, and Claude models by up to 4.9%. Beyond final performance, we conduct extensive empirical analyses of RM-R1, including ablations of our training recipes, studies of its scaling effects, comparisons with non-reasoning baselines, detailed case studies, and training dynamics. In summary, our main contributions are as follows: - We demonstrate that reasoning abilities are crucial for reward models, and propose to formulate reward modeling as a reasoning process to enhance interpretability and accuracy. - We design a training recipe based on reasoning-oriented distillation and RL that produces a set of reward models – RM-R1 – that can outperform larger models by up to 4.9% on average. - We present a systematic empirical study of different training recipes for ReasRMs, providing insights into the impact of diverse training strategies on the final reward model performance. 2 RM-R1 <details> <summary>x2.png Details</summary>  ### Visual Description ## Diagram: Model Training and Inference Pipelines ### Overview The image presents a diagram illustrating the training and inference pipelines for three different models: ScalarRM, GenRM, and RM-RI. It details the inputs, model types, tasks, and outputs for both inference and training phases. The diagram is divided into three main sections: ScalarRM, GenRM, and RM-RI Training, with the RM-RI Training section further broken down into three sub-pipelines. ### Components/Axes * **Titles:** ScalarRM, GenRM, RM-RI Training, RM-RI's Structured Reasoning * **Column Headers (RM-RI Training):** Inference Input, Model Type, Inference Task, Inference Output, Training Input, Model Type, Task/Object, Training Output * **Input Types:** Query *x*, {y1, y2} * **Model Types:** ScalarRM, GenRM, ReasRM, RM-RI * **Tasks:** Linear Function, "Which response is correct/better?", "Let's verify step by step...", Distillation (Minimize NLL), RL (Maximize Cumulative Reward), Chain-of-Rubrics, Complex Critique * **Outputs:** Score, Answer, Reasoning Trace, Reward Signal R(x, y), "<rubrics> R1, R2, R3 </rubrics>" * **Annotations:** Judge, Critique, After Training ### Detailed Analysis or ### Content Details **1. ScalarRM Pipeline (Top-Left)** * **Inference:** * Input: Query *x* (blue box), Response *y* (orange box) * Model: ScalarRM (pink box) * Task: Linear Function (represented by a scatter plot) * Output: Score (blue box) **2. GenRM Pipeline (Top-Right)** * **Inference:** * Input: Query *x* (blue box), {y1, y2} (orange box) * Model: GenRM (pink box) * Task: "Which response is correct/better?" (Judge icon) * Output: Answer (blue box) **3. RM-RI Training Pipeline (Middle)** This section is divided into three parallel pipelines, each representing a different training approach. * **Pipeline 1 (GenRM):** * **Inference:** * Input: Query *x* (blue box), {y1, y2} (orange box) * Model: GenRM (pink box) * Task: "Which response is correct/better?" (Judge icon) * Output: Answer (blue box) * **Training:** * Input: Query *x* (blue box), {y1, y2} (orange box) * Model: GenRM (pink box) * Task/Object: Distillation (Minimize NLL) * Output: Reasoning Trace (blue box) * **Pipeline 2 (ReasRM):** * **Inference:** * Input: Query *x* (blue box), {y1, y2} (orange box) * Model: ReasRM (pink box) * Task: "Let's verify step by step..." (Critique icon) * Output: Answer (blue box) * **Training:** * Input: Query *x* (blue box), {y1, y2} (orange box) * Model: ReasRM (pink box) * Task/Object: RL (Maximize Cumulative Reward) * Output: Reward Signal R(x, y) (blue box) * **Pipeline 3 (RM-RI):** * **Inference:** * Input: Query *x* (blue box), {y1, y2} (orange box) * Model: RM-RI (pink box) * Task: "<rubrics> R1, R2, R3 </rubrics>" (Chain-of-Rubrics icon), "Let's verify step by step..." (Complex Critique icon) * Output: Answer (blue box) **4. RM-RI's Structured Reasoning (Bottom-Right)** * Text block: * `<rubrics> I. Empathy & Emotional Validation. II... III... </rubrics>` * `<eval> The first response validates the user's emotions... </eval>` * `<answer> The first response. </answer>` ### Key Observations * The diagram illustrates different approaches to model training and inference, using various model types (ScalarRM, GenRM, ReasRM, RM-RI) and training objectives (Distillation, RL). * The RM-RI Training section highlights different methods for training the models, including distillation and reinforcement learning. * The RM-RI pipeline incorporates a chain-of-rubrics and complex critique, suggesting a more structured and detailed reasoning process. ### Interpretation The diagram provides a high-level overview of different model architectures and training methodologies. ScalarRM appears to be a simple model that outputs a score based on a linear function. GenRM focuses on selecting the best response from a set of options. The RM-RI model incorporates a more complex reasoning process, potentially involving multiple steps and rubrics. The training pipelines for GenRM and ReasRM utilize distillation and reinforcement learning, respectively, to improve their performance. The RM-RI's Structured Reasoning section suggests a specific format for the model's output, including rubrics, evaluation, and the final answer. The diagram highlights the evolution of model complexity and the incorporation of structured reasoning techniques. </details> Figure 2: Training pipeline of RM-R1. Starting from an instruct model (GenRM), RM-R1 training involves two stages: Distillation and Reinforcement Learning (RL). In the Distillation stage, we use high-quality synthesized data to bootstrap RM-R1 ’s reasoning ability. In the RL stage, RM-R1 ’s reasoning ability for reward modeling is further strengthened. After distillation, a GenRM evolves into a ReasRM. RM-R1 further differentiates itself by being RL finetuned on preference data. Figure 2 presents the overall training pipeline of RM-R1, which consists of two stages: reasoning distillation and reinforcement learning. (1) Reasoning Distillation: Starting from an off-the-shelf instruction-tuned model (e.g., Qwen-2.5-14B-Instruct), we further train the model using synthesized high-quality reasoning traces. This stage equips RM-R1 with essential reasoning capabilities required for effective reward modeling. (2) Reinforcement learning: While distillation is effective for injecting reasoning patterns, distilled models often overfit to specific patterns in the training data, limiting their generalization ability [9]. To overcome this limitation, we introduce a reinforcement learning phase that further optimizes the model, resulting in the final version of RM-R1. 2.1 Task Definition Given a preference dataset: $$ \mathcal{D}=\{(x^{(i)},y_{a}^{(i)},y_{b}^{(i)},l^{(i)})\}_{i=1}^{N}, \tag{1} $$ where $x$ is a prompt, $y_{a}$ and $y_{b}$ are two different responses for $x$ , and $l∈\{a,b\}$ is the ground truth label that indicates the preferred response. We define the generative reward modeling task as follows: Let $r_{\theta}$ denote a generative reward model parameterized by $\theta$ . For each data sample, $r_{\theta}$ generates a textual judgment $j$ consisting of ordered tokens $j=(j_{1},j_{2},...,j_{T})$ , modeled by: $$ r_{\theta}(j|x,y_{a},y_{b})=\prod_{t=1}^{T}r_{\theta}(j_{t}|x,y_{a},y_{b},j_{<% t}). \tag{2} $$ Note that $j$ contains $r_{\theta}$ ’s prediction of the preferred response $\hat{l}⊂ j$ . The overall objective is: $$ \max_{r_{\theta}}\mathbb{E}_{(x,y_{a},y_{b},l)\sim\mathcal{D},\hat{l}\sim r_{% \theta}(j\mid x,y_{a},y_{b})}\left[\mathbbm{1}(\hat{l}=l)\right]. \tag{3} $$ 2.2 Reasoning Distillation for Reward Modeling For an instruction-tuned model (e.g., Qwen-2.5-14b-instruct [37]), it is quite intuitive to turn it into a GenRM simply by prompting. However, without fine-tuning on reward modeling reasoning traces, these models may struggle to conduct consistent judgments. To bootstrap its reasoning potential, we start with training an instruction-tuned model with long reasoning traces synthesized for reward modeling. Specifically, we sample $M$ data samples from $\mathcal{D}$ and denote it as $\mathcal{D}_{\rm sub}$ . Given a data sample $(x^{(i)},y_{a}^{(i)},y_{b}^{(i)},l^{(i)})∈\mathcal{D}_{\rm sub}$ , we ask an “oracle” model like o3 or claude-3-7-sonnet to generate its structured reasoning trace $r^{(i)}$ justifying why $y_{l}^{(i)}$ is chosen as the preferred response of $x^{(i)}$ . We then construct the reasoning trace ground truth: $$ y_{\mathrm{trace}}^{(i)}=r^{(i)}\oplus l^{(i)}, \tag{4} $$ where $\oplus$ denotes string concatenation. Given all the synthesized reasoning traces $r^{(i)}$ , the final distillation dataset is defined as: $$ \mathcal{D}_{\mathrm{distill}}=\{(x^{(i)},y_{\mathrm{trace}}^{(i)})\}_{i=1}^{M}. \tag{5} $$ Formally, the objective of distillation is to adjust $\theta$ to maximize the likelihood of generating the desired reasoning trace and picking the response $y$ given the prompt $x$ . We minimize the negative log-likelihood (NLL) loss: $$ \mathcal{L}_{\mathrm{distill}}(\theta)=-\sum_{(x,y)\in\mathcal{D}_{\mathrm{% distill}}}\sum_{t\in[|y|]}\log r_{\theta}\left(y_{t}\mid x,y_{<t}\right), \tag{6} $$ where $y_{<t}=(y_{1},y_{2},...,y_{t-1})$ denotes the sequence of tokens preceding position $t$ . More details of generating high-quality reasoning chains are included in Appendix B. 2.3 RL Training Although distillation is a proper way to turn a general generative model into a GenRM, it often suffers from overfitting to certain patterns and constrains the model’s ability to generalize its reasoning abilities for critical thinking [9, 31] , which is essential for reward modeling. To address this, we propose to integrate RL as a more powerful learning paradigm to enhance the model’s ability to conduct reasoning-based rewarding. Training a policy model using RL has been widely seen in the preference optimization phase of LLM post-training [24], and it is quite natural to extend this paradigm for training a ReasRM. To be specific, we directly treat our reward model $r_{\theta}(j\mid x,y_{a},y_{b})$ as if it is a policy model: $$ \max_{r_{\theta}}\mathbb{E}_{(x,y_{a},y_{b},l)\sim\mathcal{D},\hat{l}\sim r_{% \theta}(j\mid x,y_{a},y_{b})}\left[\mathcal{R}(x,j)\right]-\beta\mathbb{D}_{% \mathrm{KL}}\left(r_{\theta}\|r_{\mathrm{ref}}\right), \tag{7} $$ where $r_{\mathrm{ref}}$ is the reference reward model. In practice, we use the checkpoint before RL training as $r_{\mathrm{ref}}$ , and that means $r_{\mathrm{ref}}$ could be an off-the-shelf LLM or the LLM obtained after the distillation step in Section 2.2. $\mathcal{R}(x,j)$ is the reward function, and $\mathbb{D}_{\mathrm{KL}}$ is KL-divergence. The $x$ denotes input prompts drawn from the preference data $\mathcal{D}$ . The $j$ indicates the text generated by the reward model, which includes the reasoning trace and final judgement $\hat{l}$ . In practice, we use Group Relative Policy Optimization (GRPO) [28] to optimize the objective in Equation 7, the details of which can be find in Appendix C. 2.3.1 Chain-of-Rubrics (CoR) Rollout Chain-of-Rubrics (CoR) Rollout for Instruct Models Please act as an impartial judge and evaluate the quality of the responses provided by two AI Chatbots to the Client’s question displayed below. First, classify the task into one of two categories: <type> Reasoning </type> or <type> Chat </type>. - Use <type> Reasoning </type> for tasks that involve math, coding, or require domain knowledge, multi-step inference, logical deduction, or combining information to reach a conclusion. - Use <type> Chat </type> for tasks that involve open-ended or factual conversation, stylistic rewrites, safety questions, or general helpfulness requests without deep reasoning. If the task is Reasoning: 1. Solve the Client’s question yourself and present your final answer within <solution> … </solution> tags. 2. Evaluate the two Chatbot responses based on correctness, completeness, and reasoning quality, referencing your own solution. 3. Include your evaluation inside <eval> … </eval> tags, quoting or summarizing the Chatbots using the following tags: - <quote_A> … </quote_A> for direct quotes from Chatbot A - <summary_A> … </summary_A> for paraphrases of Chatbot A - <quote_B> … </quote_B> for direct quotes from Chatbot B - <summary_B> … </summary_B> for paraphrases of Chatbot B 4. End with your final judgment in the format: <answer>[[A]]</answer> or <answer>[[B]]</answer> If the task is Chat: 1. Generate evaluation criteria (rubric) tailored to the Client’s question and context, enclosed in <rubric>…</rubric> tags. 2. Assign weights to each rubric item based on their relative importance. 3. Inside <rubric>, include a <justify>…</justify> section explaining why you chose those rubric criteria and weights. 4. Compare both Chatbot responses according to the rubric. 5. Provide your evaluation inside <eval>…</eval> tags, using <quote_A>, <summary_A>, <quote_B>, and <summary_B> as described above. 6. End with your final judgment in the format: <answer>[[A]]</answer> or <answer>[[B]]</answer> Figure 3: The system prompt used for RM-R1 rollout. To facilitate the distilled models to proactively generate effective reasoning traces, we design a system prompt as shown in Figure 3 during rollout. Intuitively, reward modeling for general domain (e.g., chat, safety, etc.) and reasoning domain (e.g., math, code, etc.) should focus on different angles. For example, for the chat domain, we may care more about some aspects that can be expressed in textual rubrics (e.g., be polite), yet for the reasoning domain, we usually care more about logical coherence and answer correctness. Based on this intuition, we instruct ${r_{\theta}}$ to classify each preference data sample $\{(x,y_{c},y_{r})\}$ into one of the two <type>: Chat or Reasoning. For each <type>, we prompt ${r_{\theta}}$ to carry out the behavior corresponding to that type step by step: For reasoning tasks, we ask ${r_{\theta}}$ to solve $x$ on its own. During the <eval> phase, $r_{\theta}$ compares $y_{c}$ and $y_{r}$ conditioned on its own </solution> and selects an <answer>. Regarding the Chat type, we instead ask ${r_{\theta}}$ to think about and justify the <rubric> for grading the chat quality (including safety). 2.3.2 Reward Design Rule-based reward mechanisms have demonstrated strong empirical performance to facilitate reasoning [12]. In our training, we further simplify the reward formulation and merely focus on the correctness-based component, in line with prior works [28, 18]. Formally, our reward is defined as follows: $$ \mathcal{R}(x,j|y_{a},y_{b})=\begin{cases}1&\text{if\ }\hat{l}=l,\\ -1&\text{otherwise.}\end{cases} \tag{8} $$ where $\hat{l}$ is extracted from $j$ , wrapped between the <answer> and </answer> tokens. We have also tried adding the format reward to the overall reward, but found that the task performance does not have a significant difference. The rationale behind only focusing on correctness is that the distilled models have already learned to follow instructions and format their responses properly. 3 Experiments 3.1 Experimental Setup We evaluate RM-R1 on three primary benchmarks: RewardBench [17], RM-Bench [21], and RMB [43]. Our training set utilizes a cleaned subset of Skywork Reward Preference 80K [20], 8K examples from Code-Preference-Pairs, and the full Math-DPO-10K [16] dataset. For baselines, we compare RM-R1 with RMs from three main categories: ScalarRMs, GenRMs, and ReasRMs. Further details on the benchmarks, dataset construction, and specific baseline models are provided in Appendix D. Table 1: The performance comparison between best-performing baselines. Bold numbers indicate the best performance, Underlined numbers indicate the second best. The DeepSeek-GRM models are not open-weighted, so we use the numbers on their tech report. The more detailed numbers on RewardBench, RM-Bench, and RMB are in Appendix Table 6, Table 7, and Table 8 | Models | RewardBench | RM-Bench | RMB | Average | | --- | --- | --- | --- | --- | | ScalarRMs | | | | | | SteerLM-RM-70B | 88.8 | 52.5 | 58.2 | 66.5 | | Eurus-RM-7b | 82.8 | 65.9 | 68.3 | 72.3 | | Internlm2-20b-reward | 90.2 | 68.3 | 62.9 | 73.6 | | Skywork-Reward-Gemma-2-27B | 93.8 | 67.3 | 60.2 | 73.8 | | Internlm2-7b-reward | 87.6 | 67.1 | 67.1 | 73.9 | | ArmoRM-Llama3-8B-v0.1 | 90.4 | 67.7 | 64.6 | 74.2 | | Nemotron-4-340B-Reward | 92.0 | 69.5 | 69.9 | 77.1 | | Skywork-Reward-Llama-3.1-8B | 92.5 | 70.1 | 69.3 | 77.5 | | INF-ORM-Llama3.1-70B | 95.1 | 70.9 | 70.5 | 78.8 | | GenRMs | | | | | | Claude-3-5-sonnet-20240620 | 84.2 | 61.0 | 70.6 | 71.9 | | Llama3.1-70B-Instruct | 84.0 | 65.5 | 68.9 | 72.8 | | Gemini-1.5-pro | 88.2 | 75.2 | 56.5 | 73.3 | | Skywork-Critic-Llama-3.1-70B | 93.3 | 71.9 | 65.5 | 76.9 | | GPT-4o-0806 | 86.7 | 72.5 | 73.8 | 77.7 | | ReasRMs | | | | | | JudgeLRM | 75.2 | 64.7 | 53.1 | 64.3 | | DeepSeek-PairRM-27B | 87.1 | – | 58.2 | – | | DeepSeek-GRM-27B-RFT | 84.5 | – | 67.0 | – | | DeepSeek-GRM-27B | 86.0 | – | 69.0 | – | | Self-taught-evaluator-llama3.1-70B | 90.2 | 71.4 | 67.0 | 76.2 | | Our Methods | | | | | | RM-R1-DeepSeek-Distilled-Qwen -7B | 80.1 | 72.4 | 55.1 | 69.2 | | RM-R1-Qwen-Instruct -7B | 85.2 | 70.2 | 66.4 | 73.9 | | RM-R1-Qwen-Instruct -14B | 88.2 | 76.1 | 69.2 | 77.8 | | RM-R1-DeepSeek-Distilled-Qwen -14B | 88.9 | 81.5 | 68.5 | 79.6 | | RM-R1-Qwen-Instruct -32B | 91.4 | 79.1 | 73.0 | 81.2 | | RM-R1-DeepSeek-Distilled-Qwen -32B | 90.9 | 83.9 | 69.8 | 81.5 | 3.2 Main Results Table 1 compares the overall performance of RM-R1 with existing strongest baseline models. The more detailed numbers on RewardBench, RM-Bench, and RMB are in Table 6, Table 7, and Table 8 in Appendix F. For the baselines, we reproduce the numbers if essential resources are open-sourced (e.g., model checkpoints, system prompts). Otherwise, we use the numbers reported in the corresponding tech report or benchmark leaderboard. For each benchmark, we select the best-performing models in each category for brevity. Our key findings are summarized below: State-of-the-Art Performance. On average, our RM-R1-DeepSeek-Distilled-Qwen -14B model surpasses all previous leading Reward Models (RMs), including INF-ORM-Llama3.1-70B, Nemotron-4-340B-Reward, and GPT-4o, while operating at a much smaller scale. Our 32B models, RM-R1-Qwen-Instruct -32B and RM-R1-DeepSeek-Distilled-Qwen -32B, further extend this lead by a notable margin. The success of RM-R1 is attributable to both our meticulously designed training methodology and the effective scaling of our models, as extensively analyzed in Section 4.1 and Section 4.2. In particular, RM-R1 outperforms existing top-tier ScalarRMs. This highlights the considerable potential of ReasRMs, a category where prior GenRMs have exhibited suboptimal performance and are generally not comparable to their scalar counterparts. In contrast to our structured rollout and distillation with RLVR training strategy, prior critique-based methods have relied heavily on rejection sampling and unstructured, self-generated chain-of-thought (CoT) reasoning from instruct models [22, 35], limiting their reasoning capabilities and leading to inferior performance compared to ScalarRMs. Simultaneously, our comprehensive evaluation indicates that the top-performing scalar models on RewardBench do not consistently achieve state-of-the-art (SOTA) performance; in fact, larger models frequently underperform smaller ones. This evaluation underscores the need for a more comprehensive and systematic approach to RM assessment. Effective Training towards Reasoning for Reward Modeling. Our specialized, reasoning-oriented training pipeline delivers substantial performance gains. For instance, RM-R1-Qwen-Instruct -14B consistently surpasses Self-taught-evaluator-llama-3.1-70B, a reasoning model five times its size. The RM-R1 model series also demonstrates impressive results on RM-Bench, exceeding the top-performing baseline by up to 8.7%. On this most reasoning-intensive benchmark, RM-R1-DeepSeek-Distilled-Qwen -32B establishes a new state-of-the-art. It achieves 91.8% accuracy in math and 74.1% in code, outperforming the previous best models (73% in math and 63% in code) by significant margins. Furthermore, it also records the strongest reasoning performance among our released models on RewardBench. Despite its performance, our Instruct -based models are remarkably data-efficient, reaching competitive performance using only 8.7K examples for distillation—compared to the 800K examples used in training DeepSeek-Distilled [12]. Overall, our study underscores the significant potential of directly adapting large reasoning models into highly effective reward models. 4 Analysis In this section, we present a series of empirical analyses to understand the key ingredients for training effective reasoning reward models. Our analysis spans scaling effects, design decisions, reasoning ablations, and a case study. We also present additional analysis on training dynamics in Section G.2. 4.1 Training Recipes We first investigate the key ingredients underlying the successful training of RM-R1. Through a series of ablation studies, we examine our design choices to identify effective strategies for training high-quality reasoning reward models. We compare the following settings: Cold Start RL, Cold Start RL + Rubrics, Cold Start RL + Rubrics + Query Categorization (QC), and Distilled + RL + Rubrics + QC (i.e., RM-R1). The details of these settings are in Section G.1. Table 2: Ablation study of the design choices for Reasoning Training on RewardBench. | Method | Chat | Chat Hard | Safety | Reasoning | Average | | --- | --- | --- | --- | --- | --- | | Instruct (Original) | 95.8 | 74.3 | 86.8 | 86.3 | 85.8 | | Instruct + Cold Start RL | 92.5 | 81.5 | 89.7 | 94.4 | 89.5 | | Instruct + Cold Start RL + Rubrics | 93.0 | 82.5 | 90.8 | 94.2 | 90.1 | | Instruct + Cold Start RL + Rubrics + QC | 92.3 | 82.6 | 91.6 | 96.3 | 90.8 | | RM-R1 | 95.3 | 83.1 | 91.9 | 95.2 | 91.4 | In Table 2, we present the results of the ablation studies described above, using the Qwen-2.5-Instruct-32B model as the Instruct (Original) model. Several key conclusions emerge: - RL training alone is insufficient. While Cold Start RL slightly improves performance on hard chat and reasoning tasks, it fails to close the gap to fully optimized models. - CoR prompting optimizes RM rollout and boosts reasoning performance. Instructing RM-R1 to self-generate chat rubrics or problem solutions before judgment helps overall performance, especially for chat and safety tasks. Incorporating explicit query categorization into the prompt notably improves reasoning performance, suggesting that clearer task guidance benefits learning. - Distillation further enhances performance across all axes. Seeding the model with high-quality reasoning traces before RL yields the strongest results, with improvements observed on both hard tasks and safety-sensitive tasks. \faStar Takeaway 1: Directly replicating reinforcement learning recipes from mathematical tasks is insufficient for training strong reasoning reward models. Explicit query categorization and targeted distillation of high-quality reasoning traces are both crucial for achieving robust and generalizable improvements. 4.2 Scaling Effects We then investigate how model performance varies with scale, considering both model size and inference-time compute. In some cases – such as ScalarRMs from InternLM2 [6] and Skywork [20] – the smaller models (7B/8B) outperforms the larger ones (20B/27B), showing no advantage of scaling. In this subsection, we show that this trend does not hold for RM-R1, where scaling brings clear and substantial improvements. 4.2.1 Model Sizes We first analyze the impact of model scale. Our study is based on the Qwen-2.5-Instruct model family at three sizes: 7B, 14B, and 32B. We evaluate performance improvements resulting from our training procedure described in Section 2, with results averaged across three key benchmarks: RewardBench, RM-Bench, and RMB. For each model size, we compare the original and post-training performance. Figure 4(a) plots the relative improvement (%) with respect to model size. Observing an approximately linear trend, we fit a linear regression model and extrapolate to hypothetical scales of 3B and 72B, shown using faint markers and dashed extensions. The results strongly support a scaling law for reasoning reward models: larger models not only result in an absolute better final performance but also consistently yield greater performance gains. This aligns with the intuition that our training effectively leverages the superior reasoning capabilities of larger models. <details> <summary>x3.png Details</summary>  ### Visual Description ## Chart: Model Size Scaling ### Overview The image is a scatter plot showing the relationship between model size (in billions of parameters) and performance improvement (in percentage). The plot includes a solid blue line connecting the first three data points and a dashed blue line extending to the last data point. ### Components/Axes * **Title:** Model Size Scaling * **X-axis:** Model Size (B) * Values: 3, 7, 14, 32, 72 * **Y-axis:** Performance Improvement (%) * Values: 4, 5, 6, 7, 8 * **Data Points:** * First data point is marked with a gray "X" * The next three data points are marked with black circles * The last data point is marked with a gray "X" ### Detailed Analysis * **Data Series:** The data series represents the performance improvement as the model size increases. * **Trend:** The performance improvement generally increases with model size. * **Data Points:** * Model Size 3B: Performance Improvement ~4.2% (marked with a gray "X") * Model Size 7B: Performance Improvement ~4.9% (marked with a black circle) * Model Size 14B: Performance Improvement ~5.0% (marked with a black circle) * Model Size 32B: Performance Improvement ~5.8% (marked with a black circle) * Model Size 72B: Performance Improvement ~8.4% (marked with a gray "X") ### Key Observations * The initial increase in model size (from 3B to 32B) shows a relatively linear increase in performance improvement, represented by the solid blue line. * The increase in model size from 32B to 72B shows a continued increase in performance improvement, but the line is dashed, suggesting a possible change in the relationship or a different scaling behavior. ### Interpretation The chart suggests that increasing model size generally leads to improved performance. However, the change from a solid to a dashed line indicates that the relationship between model size and performance improvement may not be constant. The dashed line could represent diminishing returns or a different scaling regime as the model size increases significantly. The data points at 3B and 72B are marked with an "X" instead of a circle, which could indicate that these points are based on different data or assumptions compared to the other points. </details> (a) Model Size <details> <summary>x4.png Details</summary>  ### Visual Description ## Line Chart: Inference Compute Scaling ### Overview The image is a line chart titled "Inference Compute Scaling". It illustrates the relationship between compute budget (x-axis) and performance (y-axis). The chart shows how performance, measured as a percentage, scales with increasing compute budget. ### Components/Axes * **Title:** Inference Compute Scaling * **X-axis:** Compute Budget, with markers at 512, 1 k, 2 k, 4 k, and 8 k. * **Y-axis:** Performance (%), with markers at 76, 77, 78, 79, and 80. * **Data Series:** A single blue line with black circular markers indicating data points. ### Detailed Analysis The blue line represents the performance scaling with the compute budget. * **Compute Budget 512:** Performance is approximately 75.9%. * **Compute Budget 1 k:** Performance is approximately 76.3%. * **Compute Budget 2 k:** Performance is approximately 77.2%. * **Compute Budget 4 k:** Performance is approximately 77.3%. * **Compute Budget 8 k:** Performance is approximately 79.7%. The line slopes upward, indicating a positive correlation between compute budget and performance. The slope is steeper between 4k and 8k compute budget. ### Key Observations * Performance generally increases with compute budget. * The most significant performance jump occurs between compute budgets of 4k and 8k. * The performance increase is less pronounced between 1k and 4k. ### Interpretation The chart suggests that increasing the compute budget for inference leads to improved performance. However, the rate of performance gain is not constant. The substantial increase in performance between 4k and 8k compute budget suggests diminishing returns at lower budgets and a more significant impact at higher budgets. This information is valuable for optimizing resource allocation in inference tasks, indicating that investing in a higher compute budget (specifically around 8k) may yield the most significant performance improvements. </details> (b) Inference Compute Figure 4: Scaling effect of RM-R1. (a) Larger models benefit more from reasoning training. (b) Longer reasoning chains improve RM performance. | Method | | RewardBench | RM-Bench | RMB | Avg. | | --- | --- | --- | --- | --- | --- | | Train on Full Data | | | | | | | Instruct + SFT | | 90.9 | 75.4 | 65.9 | 77.4 | | Instruct + Distilled + SFT | | 91.2 | 76.7 | 65.4 | 77.8 | | RM-R1 * | | 91.4 | 79.1 | 73.0 | 81.2 | | Train on 9k (Distillation) Data | | | | | | | Instruct + SFT | | 88.8 | 74.8 | 66.9 | 76.6 | | Instruct + Distilled * | | 89.0 | 76.3 | 72.0 | 79.2 | Table 3: Comparison of reasoning-based training versus SFT across benchmarks. * indicates reasoning-based methods. Reasoning training consistently yields better performance. 4.2.2 Inference-time Computation Next, we examine how model performance varies with different compute budgets measured in number of tokens allowed during inference. Since this is particularly relevant to reasoning-focused models, we fix our base model to DeepSeek-R1-Distill-Qwen-14B. We evaluate average performance across the three key benchmarks using a wide range of inference-time compute budgets: 512, 1024, 2048, 4096, and 8192 tokens. To ensure a fair comparison, we match the training rollout budget to the inference budget in each setting (i.e., we allow a maximum of $k$ tokens during training for a compute budget of $k$ at inference). All models are trained using GRPO with identical datasets and hyperparameter configurations. Figure 4(b) shows the relationship between compute budget and performance. We observe a clear improvement trend as the inference budget increases. This highlights the benefits of long reasoning chains in reward modeling. \faStar Takeaway 2: Scaling improves reward model performance: we observe a near-linear trend with both model size and inference-time compute. Larger models consistently benefit more from our reasoning-based training pipeline, and longer reasoning chains become increasingly effective under higher compute budgets. 4.3 Effectiveness of Reasoning Training We now analyze the impact of reasoning-based training. Here, we demonstrate that reasoning-based training can outperform answer-only approaches. We consider the following settings: Instruct + SFT. This approach fine-tunes the instruct model directly toward producing the correct final answer using the full dataset, without providing any intermediate reasoning chains. Instruct + Distilled + SFT. This approach applies SFT (with respect to the answer directly) after the distillation stage, serving as a direct comparison point with RM-R1 trained with RL. Instruct + RM-R1 (Distilled + RL). This is the full approach proposed in this paper, following the procedure detailed in Section 2. Instruct + Distilled. This setting uses the model checkpoint immediately after the distillation stage, before any RL fine-tuning. In summary, methods with “+ RM-R1 ” or “+ Distilled” represent reasoning-based approaches, while the remaining methods are purely non-reasoning-based approaches. In Table 3, we report the results measured across the three benchmarks. The findings clearly demonstrate that reasoning training significantly benefits reward model performance. Under fair comparisons (i.e., training on exactly the same amount of data), reasoning-based models consistently outperform their SFT-only counterparts. In particular, even high-quality distillation alone, applied to a small subset of the data, provides notable gains, highlighting the value of incorporating structured intermediate reasoning. \faStar Takeaway 3: Reasoning training substantially improves reward modeling. It not only enables better generalization across tasks but also provides consistent gains even under limited data scenarios compared to direct-answer SFT approaches. 4.4 Case Study Table 4: Case Study of RM-R1 (succinct version). Complete Chatbots and model responses are shown in Table 9, 10, and 11. Cold-Start RL evaluation tends to focus on superficial features (e.g., number of suggestions, relevance), whereas RM-R1 produces high-quality rubrics (e.g., accuracy for factual questions), faithfully follows them, and evaluates responses based on their actual content. Question: symptoms of sickle-cell disease Chatbot A: 1. Painful red or yellow skin lesions; 2. Frequent infections; 3. Fatigue and weakness; 4. Anemia; 5. Slower growth and development; 6. Jaundice; 7. Swelling of hands and feet; 8. Vision loss; 9. Tiredness and weakness after physical activity; 10. Breathlessness; 11. Fever, chills, and night sweats. Chatbot B Sickle cell disease is a genetic disorder that affects the shape of red blood cells. It is most common in African Americans, but can also affect people from other ethnic groups. The symptoms of sickle cell disease can vary widely from person to person, but some common symptoms include: 1. Fatigue: …; 2. Pain: …; 3. Fever: …; 4. Anemia: …; 5. Delayed growth and development: …; 6. Infections: …; 7. Pigmentation: … It’s important to note that not everyone with sickle cell disease will experience all of these symptoms, … Therefore, it’s important to consult with a healthcare provider if you suspect you or someone you know may have sickle cell disease. Cold-start RL evaluation ✗ <type>| Chat\textcolor{deepblue}{\verb </type>| <rubric>| \textcolor{red}{\textbf{Relevance 40 \%}} – Comprehensiveness 30 \% – Clarity/organisation 30 \% \textcolor{red}{\verb </rubric>| <eval>| \textcolor{red}{\textbf{Chatbot A provided a list of symptoms that are directly relevant to sickle cell disease.}} The response is comprehensive and includes a wide range of symptoms commonly associated with the condition. The symptoms are listed in a clear and organized manner, making it easy for the client to understand the information. Chatbot B’s response is less organized than Chatbot A’s response, and the explanation of sickle cell disease may be unnecessary for the client’s question.\textcolor{orange}{\verb </eval>| <answer>| [[A]]\textcolor{lightred}{\verb </answer>| RM-R1 evaluation ✓ <type>| Chat\textcolor{deepblue}{\verb </type>| <rubric>| 1 \textcolor{ForestGreen}{\textbf{Accuracy 40 \%}} · 2 Comprehensiveness 30 \% · 3 Clarity 20 \% · 4 Helpfulness 10 \% \textcolor{deepred}{\verb <justify>| Accuracy is weighted highest because providing correct information about medical conditions is crucial. Comprehensiveness is important because … </justify>| \textcolor{red}{\verb </rubric>| <eval>| \emph{Accuracy of information:} Chatbot A provides a list of symptoms without explanation, but \textcolor{ForestGreen}{\textbf{some listed items (e.g.\ “painful red or yellow skin lesions,” “vision loss”) are not typical of sickle-cell disease}}. Chatbot B offers more accurate information, explaining each symptom’s nature and severity. ... \emph{Comprehensiveness:}...\emph{Clarity and organization:}...\emph{Helpfulness:}... \textcolor{orange}{\verb </eval>| <answer>| [[B]]\textcolor{lightred}{\verb </answer>| To gain deeper insights into RM-R1, we further conduct a case study using Qwen-14B-Instruct, comparing its behavior with a cold-start RL model. The results, summarized in Table 4, reveal the following key observations: Transparent Judging Process. The reasoning traces generated by RM-R1 are highly interpretable and coherent, reflecting the model’s perception of human preferences. It explicitly articulates why certain responses are better, providing transparency into its evaluation process. High-Quality, Question-Dependent Rubrics. RM-R1 accurately understands the question and the context of comparison, correctly prioritizing “accuracy” as the most critical rubric for medical-related questions. In contrast, the cold-start RL model often overlooks the most important factors and instead emphasizes superficial or broadly defined features (e.g., relevance) that are less discriminative. The ability to generate high-quality, question-specific rubrics stems from the knowledge acquired during the distillation stage. Faithful Adherence to Rubrics and Content-Based Judgement. RM-R1 grounds its evaluation in the actual content of the chatbot responses. For example, it correctly identifies inaccuracies in Chatbot A’s response based on factual content rather than surface presentation. Furthermore, it systematically evaluates different aspects of the rubric, leading to a structured, interpretable, and verifiable judging process. 5 Related Work Reward Models (RMs). Early RMs were typically outcome-focused: trained to predict human preference rankings for complete outputs [42]. Recent advances have looked at providing process supervision, which rewards or evaluates the steps of a model’s reasoning rather than only the final answer. A series of works propose to train process reward models that judge the correctness of intermediate reasoning steps [19, 10, 27]. A limitation of many PRMs is their heavy reliance on curated step-level human labels or specific schemas, and they often remain domain-specific. Zhang et al. [40] propose Generative Verifiers, framing reward modeling as a next-token prediction task. This allows the reward model to leverage chain-of-thought and even use majority voting over multiple sampled rationales to make more reliable judgments. DeepSeek-GRM [22] and JudgeLRM [7] have studied using reasoning models as generative reward models, which are the most relevant research to ours. However, their main focus is on the effect of scaling inference-time computation on reward modeling. On the contrary, our work is the first to provide a systematic empirical comparison of different reward model training paradigms, shedding light on when and why a distilled and RL-trained reward model like RM-R1 has advantages over the conventional approaches. Reinforcement Learning from Human Feedback (RLHF). Early works [8] first demonstrated that reinforcement learning could optimize policies using a reward model trained from human pairwise preferences. Subsequent studies applied RLHF to large-scale language models using policy optimization algorithms such as PPO [26]. For example, Ziegler et al. [45] fine-tuned GPT-2 via PPO on human preference rewards, and Stiennon et al. [32] showed that RLHF could significantly improve the quality of summarization by optimizing against a learned preference model. More recently, Ouyang et al. [24] used a similar PPO-based pipeline to train InstructGPT, establishing the modern RLHF paradigm for instruction-following models. Recently, Verifiable supervision techniques have also emerged: DeepSeek-R1 [12] uses a form of self-verification during RLHF to reward correct reasoning steps, rather than only final-answer quality. This method incentivizes policies to produce outputs that can be verified for correctness, bridging the gap between pure preference-based feedback and ground-truth signals. However, even with such innovations, most RLHF implementations still treat reward modeling and reasoning as separate stages. 6 Conclusion and Future Work In this paper, we revisited reward modeling through the lens of reasoning. We introduced RM-R1, a family of ReasRMs that effectively generate explicit chains of rubrics and rationales, and scale with both model size and inference compute. Across three public benchmarks, RM-R1 matched or surpassed commercial and open-source RMs while producing more interpretable judgments. Ablation investigations reveal that (1) task-type categorization, (2) bootstrapping from high-quality reasoning traces, and (3) RL fine-tuning are all indispensable. Qualitative analyses further showed that RM-R1 learns to prioritize high-impact rubrics, faithfully follow its own criteria and justify coherently. Future work includes active preference collection, where ReasRMs use active learning to query human preference only when the current rubric set is insufficient for a new preference sample. Finally, it would be natural to extend our study to multimodal/agentic reward modeling scenarios. Acknowledgments and Disclosure of Funding This research is based upon work supported DARPA ITM Program No. FA8650-23-C-7316, and the AI Research Institutes program by National Science Foundation and the Institute of Education Sciences, U.S. Department of Education through Award # 2229873 - AI Institute for Transforming Education for Children with Speech and Language Processing Challenges. The views and conclusions contained herein are those of the authors and should not be interpreted as necessarily representing the official policies, either expressed or implied, of the U.S. Government. The U.S. Government is authorized to reproduce and distribute reprints for governmental purposes notwithstanding any copyright annotation therein. References - Achiam et al. [2023] Josh Achiam, Steven Adler, Sandhini Agarwal, Lama Ahmad, Ilge Akkaya, Florencia Leoni Aleman, Diogo Almeida, Janko Altenschmidt, Sam Altman, et al. Gpt-4 technical report. arXiv preprint arXiv:2303.08774, 2023. - Adler et al. [2024] Bo Adler, Niket Agarwal, Ashwath Aithal, Dong H Anh, Pallab Bhattacharya, Annika Brundyn, Jared Casper, Bryan Catanzaro, Sharon Clay, et al. Nemotron-4 340b technical report. arXiv preprint arXiv:2406.11704, 2024. - Anthropic [2024] AI Anthropic. The claude 3 model family: Opus, sonnet, haiku. Claude-3 Model Card, 1:1, 2024. - Bai et al. [2022] Yuntao Bai, Saurav Kadavath, Sandipan Kundu, Amanda Askell, Jackson Kernion, Andy Jones, Anna Chen, Anna Goldie, Azalia Mirhoseini, Cameron McKinnon, et al. Constitutional ai: Harmlessness from ai feedback. arXiv preprint arXiv:2212.08073, 2022. - Baker et al. [2009] Chris L Baker, Rebecca Saxe, and Joshua B Tenenbaum. Action understanding as inverse planning. Cognition, 113(3):329–349, 2009. - Cai et al. [2024] Zheng Cai, Maosong Cao, Haojiong Chen, Kai Chen, Keyu Chen, Xin Chen, Xun Chen, Zehui Chen, Zhi Chen, Pei Chu, et al. Internlm2 technical report. arXiv preprint arXiv:2403.17297, 2024. - Chen et al. [2025] Nuo Chen, Zhiyuan Hu, Qingyun Zou, Jiaying Wu, Qian Wang, Bryan Hooi, and Bingsheng He. Judgelrm: Large reasoning models as a judge. arXiv preprint arXiv:2504.00050, 2025. - Christiano et al. [2017] Paul F Christiano, Jan Leike, Tom Brown, Miljan Martic, Shane Legg, and Dario Amodei. Deep reinforcement learning from human preferences. Advances in neural information processing systems, 30, 2017. - Chu et al. [2025] Tianzhe Chu, Yuexiang Zhai, Jihan Yang, Shengbang Tong, Saining Xie, Dale Schuurmans, Quoc V Le, Sergey Levine, and Yi Ma. Sft memorizes, rl generalizes: A comparative study of foundation model post-training. arXiv preprint arXiv:2501.17161, 2025. - Cui et al. [2025] Ganqu Cui, Lifan Yuan, Zefan Wang, Hanbin Wang, Wendi Li, Bingxiang He, Yuchen Fan, Tianyu Yu, Qixin Xu, Weize Chen, et al. Process reinforcement through implicit rewards. arXiv preprint arXiv:2502.01456, 2025. - Dubey et al. [2024] Abhimanyu Dubey, Abhinav Jauhri, Abhinav Pandey, Abhishek Kadian, Ahmad Al-Dahle, Aiesha Letman, Akhil Mathur, Alan Schelten, Amy Yang, Angela Fan, et al. The llama 3 herd of models. arXiv preprint arXiv:2407.21783, 2024. - Guo et al. [2025] Daya Guo, Dejian Yang, Haowei Zhang, Junxiao Song, Ruoyu Zhang, Runxin Xu, Qihao Zhu, Shirong Ma, Peiyi Wang, Xiao Bi, et al. Deepseek-r1: Incentivizing reasoning capability in llms via reinforcement learning. arXiv preprint arXiv:2501.12948, 2025. - Hu et al. [2024] Jian Hu, Xibin Wu, Zilin Zhu, Xianyu, Weixun Wang, Dehao Zhang, and Yu Cao. Openrlhf: An easy-to-use, scalable and high-performance rlhf framework. arXiv preprint arXiv:2405.11143, 2024. - Hurst et al. [2024] Aaron Hurst, Adam Lerer, Adam P Goucher, Adam Perelman, Aditya Ramesh, Aidan Clark, AJ Ostrow, Akila Welihinda, Alan Hayes, Alec Radford, et al. Gpt-4o system card. arXiv preprint arXiv:2410.21276, 2024. - Ivison et al. [2024] Hamish Ivison, Yizhong Wang, Jiacheng Liu, Zeqiu Wu, Valentina Pyatkin, Nathan Lambert, Noah A Smith, Yejin Choi, and Hannaneh Hajishirzi. Unpacking dpo and ppo: Disentangling best practices for learning from preference feedback. arXiv preprint arXiv:2406.09279, 2024. - Lai et al. [2024] Xin Lai, Zhuotao Tian, Yukang Chen, Senqiao Yang, Xiangru Peng, and Jiaya Jia. Step-dpo: Step-wise preference optimization for long-chain reasoning of llms. arXiv preprint arXiv:2406.18629, 2024. - Lambert et al. [2024] Nathan Lambert, Valentina Pyatkin, Jacob Morrison, LJ Miranda, Bill Yuchen Lin, Khyathi Chandu, Nouha Dziri, Sachin Kumar, Tom Zick, Yejin Choi, et al. Rewardbench: Evaluating reward models for language modeling. arXiv preprint arXiv:2403.13787, 2024. - Li et al. [2025] Xuefeng Li, Haoyang Zou, and Pengfei Liu. Torl: Scaling tool-integrated rl. arXiv preprint arXiv:2503.23383, 2025. - Lightman et al. [2023] Hunter Lightman, Vineet Kosaraju, Yuri Burda, Harrison Edwards, Bowen Baker, Teddy Lee, Jan Leike, John Schulman, Ilya Sutskever, and Karl Cobbe. Let’s verify step by step. In The Twelfth International Conference on Learning Representations, 2023. - Liu et al. [2024a] Chris Yuhao Liu, Liang Zeng, Jiacai Liu, Rui Yan, Jujie He, Chaojie Wang, Shuicheng Yan, Yang Liu, and Yahui Zhou. Skywork-reward: Bag of tricks for reward modeling in llms. arXiv preprint arXiv:2410.18451, 2024a. - Liu et al. [2024b] Yantao Liu, Zijun Yao, Rui Min, Yixin Cao, Lei Hou, and Juanzi Li. Rm-bench: Benchmarking reward models of language models with subtlety and style. arXiv preprint arXiv:2410.16184, 2024b. - Liu et al. [2025] Zijun Liu, Peiyi Wang, Runxin Xu, Shirong Ma, Chong Ruan, Peng Li, Yang Liu, and Yu Wu. Inference-time scaling for generalist reward modeling. arXiv preprint arXiv:2504.02495, 2025. - Montibeller and Franco [2010] Gilberto Montibeller and Alberto Franco. Multi-criteria decision analysis for strategic decision making. In Handbook of multicriteria analysis, pages 25–48. Springer, 2010. - Ouyang et al. [2022] Long Ouyang, Jeffrey Wu, Xu Jiang, Diogo Almeida, Carroll Wainwright, Pamela Mishkin, Chong Zhang, Sandhini Agarwal, Katarina Slama, Alex Ray, et al. Training language models to follow instructions with human feedback. Advances in neural information processing systems, 35:27730–27744, 2022. - Reid et al. [2024] Machel Reid, Nikolay Savinov, Denis Teplyashin, Dmitry Lepikhin, Timothy Lillicrap, Jean-baptiste Alayrac, Radu Soricut, Angeliki Lazaridou, Orhan Firat, Julian Schrittwieser, et al. Gemini 1.5: Unlocking multimodal understanding across millions of tokens of context. arXiv preprint arXiv:2403.05530, 2024. - Schulman et al. [2017] John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017. - Setlur et al. [2024] Amrith Setlur, Chirag Nagpal, Adam Fisch, Xinyang Geng, Jacob Eisenstein, Rishabh Agarwal, Alekh Agarwal, Jonathan Berant, and Aviral Kumar. Rewarding progress: Scaling automated process verifiers for llm reasoning. arXiv preprint arXiv:2410.08146, 2024. - Shao et al. [2024] Zhihong Shao, Peiyi Wang, Qihao Zhu, Runxin Xu, Junxiao Song, Xiao Bi, Haowei Zhang, Mingchuan Zhang, YK Li, Y Wu, et al. Deepseekmath: Pushing the limits of mathematical reasoning in open language models. arXiv preprint arXiv:2402.03300, 2024. - Sheng et al. [2024] Guangming Sheng, Chi Zhang, Zilingfeng Ye, Xibin Wu, Wang Zhang, Ru Zhang, Yanghua Peng, Haibin Lin, and Chuan Wu. Hybridflow: A flexible and efficient rlhf framework. arXiv preprint arXiv: 2409.19256, 2024. - Shiwen et al. [2024] Tu Shiwen, Zhao Liang, Chris Yuhao Liu, Liang Zeng, and Yang Liu. Skywork critic model series. https://huggingface.co/Skywork, September 2024. URL https://huggingface.co/Skywork. - Stanton et al. [2021] Samuel Stanton, Pavel Izmailov, Polina Kirichenko, Alexander A Alemi, and Andrew G Wilson. Does knowledge distillation really work? Advances in neural information processing systems, 34:6906–6919, 2021. - Stiennon et al. [2020] Nisan Stiennon, Long Ouyang, Jeffrey Wu, Daniel Ziegler, Ryan Lowe, Chelsea Voss, Alec Radford, Dario Amodei, and Paul F Christiano. Learning to summarize with human feedback. Advances in Neural Information Processing Systems, 33:3008–3021, 2020. - Van Hoeck et al. [2015] Nicole Van Hoeck, Patrick D Watson, and Aron K Barbey. Cognitive neuroscience of human counterfactual reasoning. Frontiers in human neuroscience, 9:420, 2015. - Wang et al. [2024a] Haoxiang Wang, Wei Xiong, Tengyang Xie, Han Zhao, and Tong Zhang. Interpretable preferences via multi-objective reward modeling and mixture-of-experts. In Yaser Al-Onaizan, Mohit Bansal, and Yun-Nung Chen, editors, Findings of the Association for Computational Linguistics: EMNLP 2024, pages 10582–10592, Miami, Florida, USA, November 2024a. Association for Computational Linguistics. URL https://aclanthology.org/2024.findings-emnlp.620. - Wang et al. [2024b] Tianlu Wang, Ilia Kulikov, Olga Golovneva, Ping Yu, Weizhe Yuan, Jane Dwivedi-Yu, Richard Yuanzhe Pang, Maryam Fazel-Zarandi, Jason Weston, and Xian Li. Self-taught evaluators. arXiv preprint arXiv:2408.02666, 2024b. - Wang et al. [2024c] Zhilin Wang, Yi Dong, Jiaqi Zeng, Virginia Adams, Makesh Narsimhan Sreedhar, Daniel Egert, Olivier Delalleau, Jane Scowcroft, Neel Kant, Aidan Swope, and Oleksii Kuchaiev. HelpSteer: Multi-attribute helpfulness dataset for SteerLM. In Kevin Duh, Helena Gomez, and Steven Bethard, editors, Proceedings of the 2024 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies (Volume 1: Long Papers), pages 3371–3384, Mexico City, Mexico, June 2024c. Association for Computational Linguistics. URL https://aclanthology.org/2024.naacl-long.185. - Yang et al. [2024] An Yang, Baosong Yang, Beichen Zhang, Binyuan Hui, Bo Zheng, Bowen Yu, Chengyuan Li, Dayiheng Liu, Fei Huang, Haoran Wei, et al. Qwen2. 5 technical report. arXiv preprint arXiv:2412.15115, 2024. - Yu et al. [2024] Yue Yu, Zhengxing Chen, Aston Zhang, Liang Tan, Chenguang Zhu, Richard Yuanzhe Pang, Yundi Qian, Xuewei Wang, Suchin Gururangan, Chao Zhang, et al. Self-generated critiques boost reward modeling for language models. arXiv preprint arXiv:2411.16646, 2024. - Yuan et al. [2024] Lifan Yuan, Ganqu Cui, Hanbin Wang, Ning Ding, Xingyao Wang, Jia Deng, Boji Shan, Huimin Chen, Ruobing Xie, Yankai Lin, Zhenghao Liu, Bowen Zhou, Hao Peng, Zhiyuan Liu, and Maosong Sun. Advancing llm reasoning generalists with preference trees, 2024. - Zhang et al. [2024] Lunjun Zhang, Arian Hosseini, Hritik Bansal, Mehran Kazemi, Aviral Kumar, and Rishabh Agarwal. Generative verifiers: Reward modeling as next-token prediction. arXiv preprint arXiv:2408.15240, 2024. - Zheng et al. [2023] Lianmin Zheng, Wei-Lin Chiang, Ying Sheng, Siyuan Zhuang, Zhanghao Wu, Yonghao Zhuang, Zi Lin, Zhuohan Li, Dacheng Li, Eric Xing, et al. Judging llm-as-a-judge with mt-bench and chatbot arena. Advances in Neural Information Processing Systems, 36:46595–46623, 2023. - Zhong et al. [2025] Jialun Zhong, Wei Shen, Yanzeng Li, Songyang Gao, Hua Lu, Yicheng Chen, Yang Zhang, Wei Zhou, Jinjie Gu, and Lei Zou. A comprehensive survey of reward models: Taxonomy, applications, challenges, and future. arXiv preprint arXiv:2504.12328, 2025. - Zhou et al. [2024] Enyu Zhou, Guodong Zheng, Binghai Wang, Zhiheng Xi, Shihan Dou, Rong Bao, Wei Shen, Limao Xiong, Jessica Fan, Yurong Mou, et al. Rmb: Comprehensively benchmarking reward models in llm alignment. arXiv preprint arXiv:2410.09893, 2024. - Zhu et al. [2023] Banghua Zhu, Evan Frick, Tianhao Wu, Hanlin Zhu, and Jiantao Jiao. Starling-7b: Improving llm helpfulness & harmlessness with rlaif, November 2023. - Ziegler et al. [2019] Daniel M Ziegler, Nisan Stiennon, Jeffrey Wu, Tom B Brown, Alec Radford, Dario Amodei, Paul Christiano, and Geoffrey Irving. Fine-tuning language models from human preferences. arXiv preprint arXiv:1909.08593, 2019. Contents 1. 1 Introduction 1. 2 RM-R1 1. 2.1 Task Definition 1. 2.2 Reasoning Distillation for Reward Modeling 1. 2.3 RL Training 1. 2.3.1 Chain-of-Rubrics (CoR) Rollout 1. 2.3.2 Reward Design 1. 3 Experiments 1. 3.1 Experimental Setup 1. 3.2 Main Results 1. 4 Analysis 1. 4.1 Training Recipes 1. 4.2 Scaling Effects 1. 4.2.1 Model Sizes 1. 4.2.2 Inference-time Computation 1. 4.3 Effectiveness of Reasoning Training 1. 4.4 Case Study 1. 5 Related Work 1. 6 Conclusion and Future Work 1. A User Prompt for DeepSeek-Distilled Reasoning Models 1. B Details of Reasoning Chain Generation 1. C Group Relative Policy Optimization (GRPO) 1. D Experiment Setups 1. D.1 Benchmarks 1. D.2 Preference Datasets 1. D.3 Baselines 1. E Implementation Details 1. F Full Experiment Result 1. G Supplementary Information for Section 4 1. G.1 Ablation Settings 1. G.2 Training Dynamics Appendix A User Prompt for DeepSeek-Distilled Reasoning Models Large reasoning models such as DeepSeek-R1-distilled models [12] do not have a system prompt, so we show the user prompt for rollouts in Figure 5. Chain-of-Rubrics (CoR) Rollout for Reasoning Models Please act as an impartial judge and evaluate the quality of the responses provided by two AI Chatbots to the Client question displayed below. … [Pairwise Input Content] … Output your final verdict at last by strictly following this format: ’<answer>[[A]]</answer>’ if Chatbot A is better, or ’<answer>[[B]]</answer>’ if Chatbot B is better. Figure 5: The user prompt used for RM-R1 rollout (for reasoning models). Appendix B Details of Reasoning Chain Generation We now expand on the details of generating high-quality reasoning chains. We first use the same prompt to query Claude-3.7-Sonnet, generating initial reasoning traces. However, approximately 25% of these traces are incorrect, primarily on harder chat tasks. To correct these cases, we pass the original prompt, the incorrect trace, and the correct final answer to OpenAI-O3, which then generates a corrected reasoning trace aligned with the right answer. This two-stage process yields a high-quality distillation set. We deliberately choose the order—first Claude, then O3 —based on qualitative observations: Claude excels at solving easier tasks and maintaining attention to safety considerations, whereas O3 performs better on harder tasks but tends to overemphasize helpfulness at the expense of safety. We select approximately 12% of the training data (slightly fewer than 9K examples) for distillation. This is then followed by RL training. Appendix C Group Relative Policy Optimization (GRPO) Group Relative Policy Optimization (GRPO) [28] is a variant of Proximal Policy Optimization (PPO) [26], which obviates the need for additional value function approximation, and uses the average reward of multiple sampled outputs produced in response to the same prompt as the baseline. More specifically, for each prompt $x$ , GRPO samples a group of outputs $\{y_{1},y_{2},·s,y_{G}\}$ from the old policy $\pi_{\theta_{old}}$ and then optimizes the policy model by maximizing the following objective: $$ \begin{split}\mathcal{J}_{\text{GRPO}}(\theta)=\,&\mathbb{E}_{x\sim\mathcal{D}% ,\,\{j_{i}\}_{i=1}^{G}\sim r_{\theta_{\text{old}}}(j\mid x)}\bigg{[}\frac{1}{G% }\sum_{i=1}^{G}\frac{1}{|j_{i}|}\sum_{t=1}^{|j_{i}|}\Big{\{}\min\Big{(}\frac{r% _{\theta}(j_{i,t}\mid x,j_{i,<t})}{r_{\theta_{\text{old}}}(j_{i,t}\mid x,j_{i,% <t})}\hat{A}_{i,t},\\[4.0pt] &\text{clip}\big{(}\frac{r_{\theta}(j_{i,t}\mid x,j_{i,<t})}{r_{\theta_{\text{% old}}}(j_{i,t}\mid x,j_{i,<t})},1-\epsilon,1+\epsilon\big{)}\hat{A}_{i,t}\Big{% )}-\beta\,\mathbb{D}_{\mathrm{KL}}\left[r_{\theta}(\cdot\mid x)\,\|\,\pi_{% \text{ref}}(\cdot\mid x)\right]\Big{\}}\bigg{]},\end{split} \tag{9} $$ where $\beta$ is a hyperparameter balancing the task specific loss and the KL-divergence. Specifically, $\hat{A}_{i}$ is computed using the rewards of a group of responses within each group $\{r_{1},r_{2},...,r_{G}\}$ , and is given by the following equation: $$ \hat{A}_{i}=\frac{r_{i}-{\text{mean}(\{r_{1},r_{2},\cdots,r_{G}\})}}{{\text{% std}(\{r_{1},r_{2},\cdots,r_{G}\})}}. \tag{10} $$ Appendix D Experiment Setups D.1 Benchmarks In this paper, we consider the following three benchmarks: RewardBench [17]: RewardBench is one of the first endeavors towards benchmarking reward models through prompt-chosen-rejected trios, covering four categories: chat, chat-hard, reasoning, and safety, with 358, 456, 740, and 1431 samples, respectively. RM-Bench [21]: Building on RewardBench, RM-Bench evaluates reward models for their sensitivity to subtle content differences and robustness against style biases. It includes four categories: Chat, Safety, Math, and Code, with 129, 441, 529, and 228 samples, respectively. Each sample contains three prompts of varying difficulty. RM-Bench is the most reasoning-intensive benchmark among those we consider. RMB [43]: Compared with RewardBench and RM-Bench, RMB offers a more comprehensive evaluation of helpfulness and harmlessness. It includes over 49 real-world scenarios and supports both pairwise and Best-of-N (BoN) evaluation formats. RMB comprises 25,845 instances in total—37 scenarios under the helpfulness alignment objective and 12 under harmlessness. D.2 Preference Datasets We consider the following datasets for training: Skywork Reward Preference 80K [20] is a high-quality collection of pairwise preference data drawn from a variety of domains, including chat, safety, mathematics, and code. It employs an advanced data filtering technique to ensure preference reliability across tasks. However, we identify a notable issue with this dataset: all samples from the magpie_ultra source exhibit a strong spurious correlation, where rejected responses consistently contain the token “ <im_start>,” while accepted responses do not. Additionally, responses from this source show a systematic bias—accepted responses are typically single-turn, while rejected responses are multi-turn. This problematic subset constitutes approximately 30% of the Skywork dataset and primarily covers mathematics and code domains. To avoid introducing spurious correlations into training, we exclude all magpie_ultra data and retain only the cleaned subset for our experiments. Code-Preference-Pairs is a high-quality coding preference dataset. It is constructed by prompting a model with original code, introducing deliberate bugs, and manipulating examples (e.g., swapping broken and corrected versions, removing error comments) to generate fine-grained preference pairs. We subsample 8K examples from this dataset for use in our experiments. Math-DPO-10K [16] is a high-quality stepwise preference dataset focused on mathematical reasoning. We use the full dataset in our experiments. A global statistics of our training dataset is summarized in Table 5. Table 5: Global Statistics of our Training Dataset. * indicates the source is from Skywork-Reward-Preference-80K-v0.2. | Source | Size | Domain | | --- | --- | --- | | magpile_pro_llama3.1* | 29682 | Reasoning | | offset_bias* | 8504 | Chat (length bias) | | helpsteer2* | 7221 | Chat | | wildguard* | 6709 | Safety | | magpile_pro* | 2030 | Chat | | Code-Preference-Pairs | 8000 | Reasoning | | Math-DPO-10K | 10000 | Reasoning | D.3 Baselines We compare RM-R1 with RMs from three categories: ScalarRMs. ScalarRMs produce a score for model response directly, predicting preference through single numeric scores without explicit reasoning traces. This category includes models such as Eurus-RM [39], Internlm2 [6] SteerLM-RM [36], Nemotron-RM [2], Tulu-v2.5 [15], Starling-RM [44], ArmoRM [34], Skywork-RM [20], etc. While these models often achieve strong results on well-defined benchmarks, they generally lack interpretability and struggle to capture fine-grained reasoning. GenRMs. Generative reward models (GenRMs) offer more expressive feedback by producing free-form textual judgments, typically without further training. This includes the widely used LLM-as-a-Judge setup [41], where pretrained language models are prompted to explain and evaluate responses. We also categorize under GenRMs models that directly generate output answers without intermediate reasoning steps. Representative examples include LLaMA [11], Qwen [37], Claude [3], GPT-4o [1, 14], Gemini 1.5 Pro [25], and Skywork-Critic [30]. By leveraging LLMs’ generative capabilities, these models enhance interpretability through natural language rationales and explanations. ReasRMs. Reasoning-enhanced reward models (ReasRMs) explicitly incorporate reasoning processes before their final judgments, often trained through critiques or chain-of-thought strategies. Notable examples are JudgeLRM [7], Critique-RM [38], DeepSeek-GRM [22], Self-taught Evaluators [35] and our proposed RM-R1 models. These models excel in tasks demanding rigorous reasoning, safety evaluations, and nuanced preference judgments due to their grounding in structured critical thinking. Appendix E Implementation Details Our training framework is based on VERL [29] and OpenRLHF [13]. For Instruct models, we use 8.7k data for distillation and 64k for RLVR. For Deepseek-Distilled models, we use the full data for RLVR. Distillation Stage. We use the SFTTrainer from OpenRLHF with a fixed batch size of 128 and a micro-batch size of 1, training for a single epoch. To optimize GPU memory usage, we enable gradient checkpointing, FlashAttention, and Adam offloading. The learning rates are set based on the model size: $5\mathrm{e}{-6},\ 3\mathrm{e}{-6},$ and $2\mathrm{e}{-6}$ for models of size $7\text{B},\ 14\text{B},$ and $32\text{B}$ , respectively. RLVR Stage. We use the VERL framework for all GRPO training. The training batch size is fixed at 1024, with a mini-batch size of 128. We adopt Fully Sharded Data Parallel (FSDP) to improve memory efficiency. For rollout generation, we use vLLM with tensor parallelism size 4 and GPU memory utilization capped at 0.4. Sampling follows default parameters (temperature = 1.0, top-p = 1.0). KL regularization is applied with a coefficient of $1\mathrm{e}{-3}$ and a clip ratio of 0.2. Each prompt is sampled with 7 candidate responses. The maximum input sequence length is 4,096 tokens, and the maximum response length is 8,192 tokens. Learning rates are set separately for the two model variants: - Instruct models: $1\mathrm{e}{-6},\ 7\mathrm{e}{-7},$ and $5\mathrm{e}{-7}$ for $7\text{B},\ 14\text{B},$ and $32\text{B}$ models, respectively. - Reasoning models: $1\mathrm{e}{-6},\ 1\mathrm{e}{-6},$ and $8\mathrm{e}{-7}$ for $7\text{B},\ 14\text{B},$ and $32\text{B}$ models, respectively. We train the $7\text{B},\ 14\text{B},$ and $32\text{B}$ models on $1,\ 2,$ and $4$ nodes, respectively, each equipped with 8 H100 GPUs. Appendix F Full Experiment Result In this section, we provide the full experiment results and a more comprehensive coverage of existing baselines. The results of RewardBench, RM-Bench, and RMB are provided in Table 6, Table 7, Table 8, respectively. Table 6: Results of our proposed method and baselines on the RewardBench. Bold numbers indicate the best performance, Underlined numbers indicate the second best. ${}^{\text{\char 69}}$ indicates potential data contamination. | Models | Chat | Chat_Hard | Safety | Reasoning | Overall | | --- | --- | --- | --- | --- | --- | | ScalarRMs | | | | | | | Eurus-RM-7b | 98.0 | 65.6 | 81.4 | 86.3 | 82.8 | | Internlm2-7b-reward | 99.2 | 69.5 | 87.2 | 94.5 | 87.6 | | SteerLM-RM 70B | 91.3 | 80.3 | 92.8 | 90.6 | 88.8 | | Cohere-0514 | 96.4 | 71.3 | 92.3 | 97.7 | 89.4 | | Internlm2-20b-reward | 98.9 | 76.5 | 89.5 | 95.8 | 90.2 | | ArmoRM-Llama3-8B-v0.1 | 96.9 | 76.8 | 90.5 | 97.3 | 90.4 | | Nemotron-4-340B-Reward | 95.8 | 87.1 | 91.5 | 93.6 | 92.0 | | Skywork-Reward-Llama-3.1-8B ${}^{\text{\char 69}}$ | 95.8 | 87.3 | 90.8 | 96.2 | 92.5 | | Skywork-Reward-Gemma-2-27B ${}^{\text{\char 69}}$ | 95.8 | 91.4 | 91.9 | 96.1 | 93.8 | | INF-ORM-Llama3.1-70B | 96.6 | 91.0 | 93.6 | 99.1 | 95.1 | | GenRMs | | | | | | | Llama3.1-8B-Instruct | 85.5 | 48.5 | 75.6 | 72.1 | 70.4 | | Prometheus-8*7B-v2 | 93.0 | 47.1 | 80.5 | 77.4 | 74.5 | | Llama3.1-70B-Instruct | 97.2 | 70.2 | 82.8 | 86.0 | 84.0 | | Llama3.1-405B-Instruct | 97.2 | 74.6 | 77.6 | 87.1 | 84.1 | | Claude-3-5-sonnet-20240620 | 96.4 | 74.0 | 81.6 | 84.7 | 84.2 | | GPT-4o-0806 | 96.1 | 76.1 | 86.6 | 88.1 | 86.7 | | Gemini-1.5-pro | 92.3 | 80.6 | 87.9 | 92.0 | 88.2 | | SFR-LLaMa-3.1-70B-Judge-r | 96.9 | 84.8 | 91.6 | 97.6 | 92.7 | | Skywork-Critic-Llama-3.1-70B ${}^{\text{\char 69}}$ | 96.6 | 87.9 | 93.1 | 95.5 | 93.3 | | ReasRMs | | | | | | | JudgeLRM | 92.9 | 56.4 | 78.2 | 73.6 | 75.2 | | SynRM | 38.0 | 82.5 | 74.1 | 87.1 | 70.4 | | RM-R1-DeepSeek-Distilled-Qwen -7B | 88.9 | 66.2 | 78.4 | 87.0 | 80.1 | | CLoud | 97.0 | 58.0 | 84.0 | 92.0 | 82.8 | | DeepSeek-GRM-16B | 90.8 | 74.3 | 84.7 | 81.8 | 82.9 | | DeepSeek-GRM-27B-RFT | 94.7 | 77.2 | 87.0 | 79.2 | 84.5 | | RM-R1-Qwen-Instruct -7B | 94.1 | 74.6 | 85.2 | 86.7 | 85.2 | | DeepSeek-GRM-27B | 94.1 | 78.3 | 88.0 | 83.8 | 86.0 | | DeepSeek-PairRM-27B | 95.5 | 86.8 | 52.3 | 92.0 | 87.1 | | RM-R1-Qwen-Instruct -14B | 93.6 | 80.5 | 86.9 | 92.0 | 88.2 | | RM-R1-DeepSeek-Distilled-Qwen -14B | 91.3 | 79.4 | 89.3 | 95.5 | 88.9 | | Self-taught-evaluator-llama3.1-70B | 96.9 | 85.1 | 89.6 | 88.4 | 90.0 | | RM-R1-DeepSeek-Distilled-Qwen -32B | 95.3 | 80.3 | 91.1 | 96.8 | 90.9 | | RM-R1-Qwen-Instruct -32B | 95.3 | 83.1 | 91.9 | 95.2 | 91.4 | Table 7: The full results of tested reward models on RM-Bench. Chat, Math, Code, Safety show the model’s Average Accuracy on each domain. Easy, Normal, Hard show the model’s Accuracy on each difficulty level across all domains. Bold numbers indicate the best performance, Underlined numbers indicate the second best. | Models | Chat | Math | Code | Safety | Easy | Normal | Hard | Avg | | --- | --- | --- | --- | --- | --- | --- | --- | --- | | ScalarRMs | | | | | | | | | | steerlm-70b | 56.4 | 53.0 | 49.3 | 51.2 | 48.3 | 54.9 | 54.3 | 52.5 | | tulu-v2.5-70b-preference-mix-rm | 58.2 | 51.4 | 55.5 | 87.1 | 72.8 | 65.6 | 50.7 | 63.0 | | Mistral-7B-instruct-Unified-Feedback | 56.5 | 58.0 | 51.7 | 86.8 | 87.1 | 67.3 | 35.3 | 63.2 | | RM-Mistral-7B | 57.4 | 57.0 | 52.7 | 87.2 | 88.6 | 67.1 | 34.9 | 63.5 | | Eurus-RM-7b | 59.9 | 60.2 | 56.9 | 86.5 | 87.2 | 70.2 | 40.2 | 65.9 | | internlm2-7b-reward | 61.7 | 71.4 | 49.7 | 85.5 | 85.4 | 70.7 | 45.1 | 67.1 | | Skywork-Reward-Gemma-2-27B | 69.5 | 54.7 | 53.2 | 91.9 | 78.0 | 69.2 | 54.9 | 67.3 | | ArmoRM-Llama3-8B-v0.1 | 67.8 | 57.5 | 53.1 | 92.4 | 82.2 | 71.0 | 49.8 | 67.7 | | GRM-llama3-8B-sftreg | 62.7 | 62.5 | 57.8 | 90.0 | 83.5 | 72.7 | 48.6 | 68.2 | | internlm2-20b-reward | 63.1 | 66.8 | 56.7 | 86.5 | 82.6 | 71.6 | 50.7 | 68.3 | | Llama-3-OffsetBias-RM-8B | 71.3 | 61.9 | 53.2 | 89.6 | 84.6 | 72.2 | 50.2 | 69.0 | | Nemotron-340B-Reward | 71.2 | 59.8 | 59.4 | 87.5 | 81.0 | 71.4 | 56.1 | 69.5 | | URM-LLaMa-3.1-8B | 71.2 | 61.8 | 54.1 | 93.1 | 84.0 | 73.2 | 53.0 | 70.0 | | Skywork-Reward-Llama-3.1-8B | 69.5 | 60.6 | 54.5 | 95.7 | 89.0 | 74.7 | 46.6 | 70.1 | | INF-ORM-Llama3.1-70B | 66.3 | 65.6 | 56.8 | 94.8 | 91.8 | 76.1 | 44.8 | 70.9 | | GenRMs | | | | | | | | | | tulu-v2.5-dpo-13b-chatbot-arena-2023 | 64.9 | 52.3 | 50.5 | 62.3 | 82.8 | 60.2 | 29.5 | 57.5 | | tulu-v2.5-dpo-13b-nectar-60k | 56.3 | 52.4 | 52.6 | 73.8 | 86.7 | 64.3 | 25.4 | 58.8 | | stablelm-2-12b-chat | 67.2 | 54.9 | 51.6 | 65.2 | 69.1 | 63.5 | 46.6 | 59.7 | | tulu-v2.5-dpo-13b-stackexchange-60k | 66.4 | 49.9 | 54.2 | 69.0 | 79.5 | 63.0 | 37.2 | 59.9 | | Nous-Hermes-2-Mistral-7B-DPO | 58.8 | 55.6 | 51.3 | 73.9 | 69.5 | 61.1 | 49.1 | 59.9 | | Claude-3-5-sonnet-20240620 | 62.5 | 62.6 | 54.4 | 64.4 | 73.8 | 63.4 | 45.9 | 61.0 | | tulu-v2.5-dpo-13b-hh-rlhf-60k | 68.4 | 51.1 | 52.3 | 76.5 | 53.6 | 63.0 | 69.6 | 62.1 | | tulu-2-dpo-13b | 66.4 | 51.4 | 51.8 | 85.4 | 86.9 | 66.7 | 37.7 | 63.8 | | SOLAR-10.7B-Instruct-v1.0 | 78.6 | 52.3 | 49.6 | 78.9 | 57.5 | 67.6 | 69.4 | 64.8 | | Llama3.1-70B-Instruct | 64.3 | 67.3 | 47.5 | 83.0 | 74.7 | 67.8 | 54.1 | 65.5 | | Skywork-Critic-Llama-3.1-70B | 71.4 | 64.6 | 56.8 | 94.8 | 85.6 | 73.7 | 56.5 | 71.9 | | GPT-4o-0806 | 67.2 | 67.5 | 63.6 | 91.7 | 83.4 | 75.6 | 58.7 | 72.5 | | Gemini-1.5-pro | 71.6 | 73.9 | 63.7 | 91.3 | 83.1 | 77.6 | 64.7 | 75.2 | | ReasRMs | | | | | | | | | | JudgeLRM | 59.9 | 59.9 | 51.9 | 87.3 | 73.2 | 766.2 | 54.8 | 64.7 | | RM-R1-Qwen-Instruct -7B | 66.6 | 67.0 | 54.6 | 92.6 | 79.2 | 71.7 | 59.7 | 70.2 | | Self-taught-evaluator-llama3.1-70B | 73.4 | 65.7 | 56.3 | 90.4 | 80.2 | 74.5 | 59.7 | 71.5 | | RM-R1-DeepSeek-Distilled-Qwen -7B | 64.0 | 83.9 | 56.2 | 85.3 | 75.9 | 73.1 | 68.1 | 72.4 | | RM-R1-Qwen-Instruct -14B | 75.6 | 75.4 | 60.6 | 93.6 | 82.6 | 77.5 | 68.8 | 76.1 | | RM-R1-Qwen-Instruct -32B | 75.3 | 80.2 | 66.8 | 93.9 | 86.3 | 80.5 | 70.4 | 79.1 | | RM-R1-DeepSeek-Distilled-Qwen -14B | 71.8 | 90.5 | 69.5 | 94.1 | 86.2 | 83.6 | 74.4 | 81.5 | | RM-R1-DeepSeek-Distilled-Qwen -32B | 74.2 | 91.8 | 74.1 | 95.4 | 89.5 | 85.4 | 76.7 | 83.9 | Table 8: The leaderboard of RMB, ranked by the average score of all subsets. Bold numbers indicate the best performance, Underlined numbers indicate the second best. | | Helpfulness | Harmlessness | | | | | --- | --- | --- | --- | --- | --- | | Models | BoN | Pairwise | BoN | Pairwise | Overall | | ScalarRMs | | | | | | | Tulu-v2.5-13b-preference-mix-rm | 0.355 | 0.562 | 0.351 | 0.545 | 0.453 | | SteerLM-RM 70B | 0.502 | 0.574 | 0.578 | 0.673 | 0.582 | | Skywork-Reward-Gemma-2-27B | 0.472 | 0.653 | 0.561 | 0.721 | 0.602 | | Internlm2-20b-reward | 0.585 | 0.763 | 0.499 | 0.670 | 0.629 | | ArmoRM-Llama3-8B-v0.1 | 0.636 | 0.787 | 0.497 | 0.663 | 0.646 | | Internlm2-7b-reward | 0.626 | 0.782 | 0.563 | 0.712 | 0.671 | | Eurus-RM-7b | 0.679 | 0.818 | 0.543 | 0.693 | 0.683 | | Skywork-Reward-Llama-3.1-8B | 0.627 | 0.781 | 0.603 | 0.759 | 0.693 | | INF-ORM-Llama3.1-70B | 0.650 | 0.798 | 0.607 | 0.767 | 0.705 | | Starling-RM-34B | 0.604 | 0.774 | 0.674 | 0.795 | 0.712 | | GenRMs | | | | | | | Llama2-70b-chat | 0.289 | 0.613 | 0.249 | 0.602 | 0.438 | | Llama3.1-8B-Instruct | 0.365 | 0.675 | 0.267 | 0.653 | 0.490 | | Gemini-1.5-pro | 0.536 | 0.763 | 0.299 | 0.661 | 0.565 | | Mixtral-8x7B-Instruct-v0.1 | 0.480 | 0.706 | 0.491 | 0.671 | 0.587 | | skywork-critic-llama3.1-8B | 0.600 | 0.725 | 0.578 | 0.578 | 0.620 | | skywork-critic-llama3.1-70B | 0.640 | 0.753 | 0.614 | 0.614 | 0.655 | | Llama3.1-70B-Instruct | 0.648 | 0.811 | 0.558 | 0.739 | 0.689 | | Mistral-Large-2407 | 0.678 | 0.817 | 0.583 | 0.725 | 0.701 | | Claude-3-5-sonnet | 0.705 | 0.838 | 0.518 | 0.764 | 0.706 | | Qwen2-72B-Instruct | 0.645 | 0.810 | 0.649 | 0.789 | 0.723 | | GPT-4o-2024-05-13 | 0.639 | 0.815 | 0.682 | 0.814 | 0.738 | | ReasRMs | | | | | | | JudgeLRM | 0.363 | 0.699 | 0.363 | 0.674 | 0.531 | | RM-R1-DeepSeek-Distilled-Qwen -7B | 0.451 | 0.658 | 0.429 | 0.664 | 0.551 | | RM-R1-Qwen-Instruct -7B | 0.543 | 0.740 | 0.608 | 0.765 | 0.664 | | Self-taught-evaluator-llama3.1-70B | 0.616 | 0.786 | 0.546 | 0.733 | 0.670 | | Deepseek-GRM-27B-RFT | 0.592 | 0.801 | 0.548 | 0.765 | 0.670 | | RM-R1-DeepSeek-Distilled-Qwen -14B | 0.593 | 0.765 | 0.613 | 0.769 | 0.685 | | Deepseek-GRM-27B | 0.623 | 0.805 | 0.570 | 0.761 | 0.690 | | RM-R1-Qwen-Instruct -14B | 0.594 | 0.776 | 0.620 | 0.778 | 0.692 | | RM-R1-DeepSeek-Distilled-Qwen -32B | 0.620 | 0.782 | 0.618 | 0.771 | 0.698 | | RM-R1-Qwen-Instruct -32B | 0.636 | 0.791 | 0.682 | 0.809 | 0.730 | Table 9: Complete questions and chatbot responses. Question: symptoms of sickle-cell disease Chatbot A: 1. Painful red or yellow skin lesions 2. Frequent infections 3. Fatigue and weakness 4. Anemia 5. Slower growth and development 6. Jaundice 7. Swelling of hands and feet 8. Vision loss 9. Tiredness and weakness after physical activity 10. Breathlessness 11. Fever, chills, and night sweats. Chatbot B Sickle cell disease is a genetic disorder that affects the shape of red blood cells. It is most common in African Americans, but can also affect people from other ethnic groups. The symptoms of sickle cell disease can vary widely from person to person, but some common symptoms include: 1. Fatigue: People with sickle cell disease often experience fatigue and weakness, even when they have not been physically active. 2. Pain: Sickle cell disease can cause pain in the body, particularly in the arms, legs, back, and abdomen. Pain can be mild or severe and can last for days or weeks. 3. Fever: People with sickle cell disease may be prone to infections and may experience frequent fevers. 4. Anemia: Sickle cell disease can cause anemia, a condition in which the body does not have enough red blood cells to carry oxygen throughout the body. 5. Delayed growth and development: Children with sickle cell disease may be smaller than their peers due to delayed growth and development. 6. Infections: People with sickle cell disease are at increased risk for infections, particularly in the bloodstream and urinary tract. 7. Pigmentation: Sickle cell disease can cause dark areas of pigmentation in the body, particularly on the hands and feet. It’s important to note that not everyone with sickle cell disease will experience all of these symptoms, and some people may not experience any symptoms at all. Therefore, it’s important to consult with a healthcare provider if you suspect you or someone you know may have sickle cell disease. Table 10: Cold-Start RL Judges. The rubrics and evaluation mainly center around superficial shallow features (e.g., number of points listed) without actually taking their accuracy into account. Cold-start RL evaluation <type>Chat</type> <rubric> The evaluation criteria for the responses are as follows: - <item>Relevance to the question</item> (40%): The response should directly address the symptoms of sickle cell disease. - <item>Comprehensiveness</item> (30%): The response should include a wide range of symptoms commonly associated with sickle cell disease. - <item>Clarity and organization</item> (30%): The response should be easy to read and understand, with symptoms listed in a clear and organized manner. <justify> The question specifically asks for the symptoms of sickle cell disease, so the responses should be directly relevant to this topic. Comprehensiveness is important because sickle cell disease can have a variety of symptoms, and a comprehensive list will provide a more complete picture of the condition. Clarity and organization are important because the symptoms can be complex, and a well-organized response will make it easier for the client to understand the information. </justify> </rubric> <eval> <quote_A> 1. Painful red or yellow skin lesions 2. Frequent infections 3. Fatigue and weakness 4. Anemia 5. Slower growth and development 6. Jaundice 7. Swelling of hands and feet 8. Vision loss 9. Tiredness and weakness after physical activity 10. Breathlessness 11. Fever, chills, and night sweats. </quote_A> <summary_A> Chatbot A provided a list of symptoms that are directly relevant to sickle cell disease. The response is comprehensive and includes a wide range of symptoms commonly associated with the condition. The symptoms are listed in a clear and organized manner, making it easy for the client to understand the information. </summary_A> <quote_B> Sickle cell disease is a genetic disorder that affects the shape of red blood cells. It is most common in African Americans, but can also affect people from other ethnic groups. The symptoms of sickle cell disease can vary widely from person to person, but some common symptoms include: 1. Fatigue: People with sickle cell disease often experience fatigue and weakness, even when they have not been physically active. 2. Pain: Sickle cell disease can cause pain in the body, particularly in the arms, legs, back, and abdomen. Pain can be mild or severe and can last for days or weeks. 3. Fever: People with sickle cell disease may be prone to infections and may experience frequent fevers. 4. Anemia: Sickle cell disease can cause anemia, a condition in which the body does not have enough red blood cells to carry oxygen throughout the body. 5. Delayed growth and development: Children with sickle cell disease may be smaller than their peers due to delayed growth and development. 6. Infections: People with sickle cell disease are at increased risk for infections, particularly in the bloodstream and urinary tract. 7. Pigmentation: Sickle cell disease can cause dark areas of pigmentation in the body, particularly on the hands and feet. </quote_B> <summary_B> Chatbot B provided a detailed explanation of sickle cell disease and a list of symptoms. The response is relevant to the question and includes a wide range of symptoms commonly associated with the condition. However, the response is less organized than Chatbot A’s response, and the explanation of sickle cell disease may be unnecessary for the client’s question. </summary_B> </eval> <answer>[[A]]</answer> Table 11: RM-R1 RL Judges. The rubrics and evaluation are well-designed and reasonable, assessing the effectiveness of the model response. Warm-start RL (RM-R1) evaluation <type>Chat</type> <rubric> 1. Accuracy of information (40 %): How correctly does the response describe the symptoms of sickle-cell disease? 2. Comprehensiveness (30 %): How thoroughly does the response cover the range of symptoms associated with sickle-cell disease? 3. Clarity and organization (20 %): How well-structured and easy to understand is the information presented? 4. Helpfulness for the user (10 %): How useful is the information for someone seeking to understand sickle-cell disease symptoms? <justify> These criteria focus on evaluating how well each response addresses the user’s question about sickle-cell disease symptoms. Accuracy is weighted highest because providing correct information about medical conditions is crucial. Comprehensiveness is important, as sickle-cell disease has multiple symptoms that vary in severity and presentation. Clarity and organization affect how easily the user can understand the information. Helpfulness considers how practical and actionable the information is for the user. </justify> </rubric> <eval> Comparing the two responses: Accuracy of information: <quote_A>1. Painful red or yellow skin lesions 2. Frequent infections 3. Fatigue and weakness 4. Anemia 5. Slower growth and development 6. Jaundice 7. Swelling of hands and feet 8. Vision loss 9. Tiredness and weakness after physical activity 10. Breathlessness 11. Fever, chills, and night sweats.</quote_A> <quote_B>1. Fatigue: People with sickle-cell disease often experience fatigue and weakness, even when they have not been physically active. 2. Pain: Sickle-cell disease can cause pain in the body, particularly in the arms, legs, back, and abdomen. Pain can be mild or severe and can last for days or weeks. 3. Fever: People with sickle-cell disease may be prone to infections and may experience frequent fevers. 4. Anemia: Sickle-cell disease can cause anemia, a condition in which the body does not have enough red blood cells to carry oxygen throughout the body. 5. Delayed growth and development: Children with sickle-cell disease may be smaller than their peers due to delayed growth and development. 6. Infections: People with sickle-cell disease are at increased risk for infections, particularly in the bloodstream and urinary tract. 7. Pigmentation: Sickle-cell disease can cause dark areas of pigmentation in the body, particularly on the hands and feet.</quote_B> Chatbot A provides a list of symptoms without explanation, but some listed items (e.g. “painful red or yellow skin lesions,” “vision loss”) are not typical of sickle-cell disease. Chatbot B offers more accurate information, explaining each symptom’s nature and severity. Comprehensiveness: Chatbot A lists 11 symptoms, several of which are inaccurate or uncommon. Chatbot B lists 7 symptoms that are more representative and supplies contextual detail about variability and medical advice. Clarity and organization: Chatbot A’s plain numbered list lacks context, making severity unclear. Chatbot B structures the list with explanations, improving readability and understanding. Helpfulness: Chatbot A is less helpful due to inaccuracies and missing context. Chatbot B is more useful, providing accurate descriptions, context, and guidance. </eval> <answer>[[B]]</answer> Appendix G Supplementary Information for Section 4 G.1 Ablation Settings Cold Start RL. This approach generally involves pure RL, with rule-based rewards centered on answer correctness and format compliance. Such strategies have achieved notable success in advanced mathematical problem solving [28]. In this setting, we replicate this conventional training setup. Specifically, we use a combination of a format reward and an answer reward: $$ \mathcal{R}_{\text{format}}=\begin{cases}1&\text{ if format matches,}\\ 0&\text{ otherwise,}\end{cases}\quad\text{and}\quad\mathcal{R}_{\text{answer}}% =\begin{cases}1&\text{ if answer matches,}\\ 0&\text{ otherwise.}\end{cases} \tag{11} $$ The total reward is the sum $\mathcal{R}=\mathcal{R}_{\text{answer}}+\mathcal{R}_{\text{format}}$ . We use the prompt template shown in Figure 7, a version without any guidance on structured reasoning. Chain -of -Rubrics (CoR) Roll-out for Instruct Models (no categorization of task types) Please act as an impartial judge and evaluate the quality of the responses provided by two AI Chatbots to the Client’s question displayed below. Instructions 1. Begin your evaluation by generating the rubric criteria tailored to the Client’s question and context. Enclose the rubric in <rubric> … </rubric> tags. 2. Assign weights to each rubric item based on their relative importance. 3. Within <rubric>, include a <justify> … </justify> section explaining the rationale behind the chosen criteria and weights. 4. Compare both Chatbot responses using the rubric. 5. Include your evaluation in <eval> … </eval> tags. Support your analysis using: - <quote_A> … </quote_A> for direct quotes from Chatbot A - <summary_A> … </summary_A> for paraphrased summaries of Chatbot A - <quote_B> … </quote_B> for direct quotes from Chatbot B - <summary_B> … </summary_B> for paraphrased summaries of Chatbot B 6. Conclude with your final judgment using: <answer>[[A]]</answer> or <answer>[[B]]</answer> Important Notes: - Be objective and base your evaluation strictly on the content of the responses. - Do not let the response order, length, or Chatbot names bias your judgment. Figure 6: The system prompt of the ablation study on cold start RL without categorization of task types. Chain -of -Rubrics (CoR) Roll-out for Instruct Models (no rubrics) Please act as an impartial judge and evaluate the quality of the responses provided by two AI Chatbots to the Client’s question displayed below. You should choose the chatbot that follows the client’s instructions and answers the client’s question better. Do not allow the length of the responses to influence your evaluation. Do not favor certain names of the chatbots. Be as objective as possible. First, compare the chatbot responses and provide your evaluations. Then, conclude with your verdict using exactly this format: <answer>[[A]]</answer> if Chatbot A is better, <answer>[[B]</answer> if Chatbot B is better. Figure 7: The system prompt of the ablation study on cold start RL without any rubrics. Cold Start RL + Rubrics. To examine the influence of structured reasoning in final model performance, compared with the last setting, we use the prompt template shown in Figure 6. Compared with the last setting, the model is prompted to generate rubrics and evaluate accordingly. However, compared with the final system prompt of RM-R1 Figure 3, all input prompts are treated uniformly—that is, chat and reasoning tasks are not distinguished. Cold Start RL + Rubrics + Query Categorization (QC). This setting largely follows the previous one, with a key modification: prompting the LM to first categorize the task into reasoning or chat, and then apply different strategies for handling those tasks. Intuitively, reinforcement learning alone can effectively explore reasoning tasks, a domain where it has already achieved considerable success. Here, we incorporate the system prompt shown in Figure 3, which explicitly distinguishes between chat and reasoning tasks. For reasoning tasks specifically, we note that answer quality is closely tied to correctness, and that high-level rubrics may be less effective than simply evaluating whether the model can solve the problem and verify its own answer. Thus, this setting emphasizes correctness-based evaluation guided by task classification in the prompt. Distilled + RL + Rubrics + QC (RM-R1). Building on the previous setup, we introduce an additional distillation stage from stronger teacher models as a warm start before RL training. The motivation is that with RL alone, weaker models (especially at smaller scales) often fail to explore high-quality rubrics and convincing reasoning chains for chat tasks throughout the RL training process. Distilling strong reasoning traces on a small subset of data can effectively mitigate this limitation. <details> <summary>x5.png Details</summary>  ### Visual Description ## Line Charts: Response Length vs Step and Train Reward vs Step ### Overview The image contains two line charts side-by-side. The left chart plots "Response Length" against "Step", and the right chart plots "Train Reward" against "Step". Both charts display data points connected by lines, showing how these metrics change over the course of training or some iterative process. ### Components/Axes **Left Chart: Response Length vs Step** * **Title:** Response Length vs Step * **X-axis:** * Label: Step * Scale: 0 to 70, with tick marks at intervals of 10. * **Y-axis:** * Label: Response Length * Scale: 500 to 650, with tick marks at intervals of 50. * **Data Series:** * Color: Blue * Description: The line represents the response length at each step. **Right Chart: Train Reward vs Step** * **Title:** Train Reward vs Step * **X-axis:** * Label: Step * Scale: 0 to 70, with tick marks at intervals of 10. * **Y-axis:** * Label: Train Reward * Scale: 1.50 to 1.90, with tick marks at intervals of 0.05. * **Data Series:** * Color: Red * Description: The line represents the train reward at each step. ### Detailed Analysis **Left Chart: Response Length vs Step** * **Trend:** The blue line generally slopes upward, indicating an increase in response length as the step increases. * **Data Points:** * Step 0: Response Length ≈ 480 * Step 10: Response Length ≈ 520 * Step 20: Response Length ≈ 560 * Step 30: Response Length ≈ 600 * Step 40: Response Length ≈ 620 * Step 50: Response Length ≈ 660 * Step 60: Response Length ≈ 600 * Step 70: Response Length ≈ 680 **Right Chart: Train Reward vs Step** * **Trend:** The red line initially increases rapidly, then plateaus, and finally decreases sharply towards the end. * **Data Points:** * Step 0: Train Reward ≈ 1.52 * Step 10: Train Reward ≈ 1.78 * Step 20: Train Reward ≈ 1.82 * Step 30: Train Reward ≈ 1.85 * Step 40: Train Reward ≈ 1.87 * Step 50: Train Reward ≈ 1.88 * Step 60: Train Reward ≈ 1.86 * Step 70: Train Reward ≈ 1.74 ### Key Observations * The response length generally increases with the step, although there are fluctuations. * The train reward increases rapidly at the beginning, plateaus in the middle, and then drops significantly at the end. ### Interpretation The charts suggest that as the training progresses (indicated by the "Step"), the response length tends to increase. This could mean the model is generating longer outputs over time. The train reward, however, shows a different pattern. It initially improves rapidly, indicating successful learning, but then plateaus, suggesting diminishing returns. The sharp drop at the end could indicate overfitting or some other issue that negatively impacts the model's performance. The relationship between response length and train reward is not directly clear from these charts alone, but it suggests that simply increasing response length does not necessarily correlate with improved reward. </details> (a) Cold Start RL <details> <summary>x6.png Details</summary>  ### Visual Description ## Line Charts: Response Length and Train Reward vs. Step ### Overview The image contains two line charts displayed side-by-side. The left chart plots "Response Length" against "Step," showing a decreasing trend followed by an increasing trend. The right chart plots "Train Reward" against "Step," showing an overall increasing trend. Both charts share the same x-axis ("Step") ranging from 0 to 60. ### Components/Axes **Left Chart:** * **Title:** Response Length vs Step * **Y-axis:** Response Length, ranging from 760 to 840, with increments of 20. * **X-axis:** Step, ranging from 0 to 60, with increments of 10. * **Data Series:** A blue line with circular markers representing the response length at each step. **Right Chart:** * **Title:** Train Reward vs Step * **Y-axis:** Train Reward, ranging from 0.45 to 0.70, with increments of 0.05. * **X-axis:** Step, ranging from 0 to 60, with increments of 10. * **Data Series:** A red line with square markers representing the train reward at each step. ### Detailed Analysis **Left Chart: Response Length vs Step** * **Trend:** The blue line initially fluctuates between steps 0 and 10, then decreases significantly from approximately step 10 to step 35. After step 35, the line increases again, fluctuating until step 60. * **Data Points:** * Step 0: Response Length ≈ 845 * Step 10: Response Length ≈ 835 * Step 20: Response Length ≈ 810 * Step 30: Response Length ≈ 765 * Step 40: Response Length ≈ 750 * Step 50: Response Length ≈ 790 * Step 60: Response Length ≈ 805 **Right Chart: Train Reward vs Step** * **Trend:** The red line generally increases from step 0 to step 60, with some fluctuations. * **Data Points:** * Step 0: Train Reward ≈ 0.47 * Step 10: Train Reward ≈ 0.52 * Step 20: Train Reward ≈ 0.56 * Step 30: Train Reward ≈ 0.60 * Step 40: Train Reward ≈ 0.65 * Step 50: Train Reward ≈ 0.70 * Step 60: Train Reward ≈ 0.69 ### Key Observations * The response length initially decreases and then increases, forming a U-shaped curve. * The train reward consistently increases over the steps, indicating learning or improvement. * Both charts share the same x-axis, allowing for a direct comparison of response length and train reward over time (steps). ### Interpretation The charts suggest a relationship between response length and train reward. Initially, as the training progresses (increasing "Step"), the response length decreases, possibly indicating a more efficient or concise response. However, after a certain point (around step 35), the response length starts to increase again, while the train reward continues to increase. This could indicate that the model is learning to provide more detailed or complex responses, leading to higher rewards. The initial decrease in response length might be due to the model learning to avoid irrelevant information, while the later increase could be due to the model incorporating more relevant details to maximize the reward. </details> (b) Warm Start RL Figure 8: RL training dynamics under different settings: (a) Cold Start RL (Eq. 11) and (b) Warm Start RL (Eq. 8). In Cold Start RL, the response length steadily increases as the model learns to reason, but training becomes unstable near the end. In Warm Start RL, the model exhibits more stable training, with effective refinement of reasoning traces throughout the process. G.2 Training Dynamics We analyze the training dynamics of RM-R1 using the Qwen-2.5-14B-Instruct model by tracking both response length and reward progression throughout RL training. We consider two settings: (a) Cold Start RL, and (b) Warm Start RL following reasoning-chain distillation. We present the finding in Figure 8. In the Cold Start RL setting, we observe that the model gradually learns to reason, as reflected by a steady increase in response length over the course of training. However, training becomes unstable near the end, with a sharp drop in the reward curve, suggesting potential issues such as overfitting. In contrast, under Warm Start RL, the model begins with stronger initial reasoning abilities, exhibiting longer responses from the outset. Interestingly, the model first learns to produce more concise reasoning traces before gradually increasing response length again as training progresses. The reward curve rises smoothly and consistently throughout training, demonstrating more stable and efficient learning compared to the Cold Start setting.