REX-RAG: Reasoning Exploration with Policy Correction in Retrieval-Augmented Generation

## Abstract

Abstract Reinforcement learning (RL) is emerging as a powerful paradigm for enabling large language models (LLMs) to perform complex reasoning tasks. Recent advances indicate that integrating RL with retrieval-augmented generation (RAG) allows LLMs to dynamically incorporate external knowledge, leading to more informed and robust decision making. However, we identify a critical challenge
during policy-driven trajectory sampling: LLMs are frequently trapped in unproductive reasoning paths, which we refer to as “dead ends”, committing to overconfident yet incorrect conclusions. This severely hampers exploration and undermines effective policy optimization.
To address this challenge, we propose REX-RAG (Reasoning Exploration with Policy Correction in Retrieval-Augmented Generation), a novel framework that explores alternative reasoning paths while maintaining rigorous policy learning through principled distributional corrections. Our approach introduces two key innovations: (1) Mixed Sampling Strategy, which combines a novel probe sampling method with exploratory prompts to escape dead ends; and (2) Policy Correction Mechanism, which employs importance sampling to correct distribution shifts induced by mixed sampling, thereby mitigating gradient estimation bias. We evaluate it on seven question-answering benchmarks, and the experimental results show that REX-RAG achieves average performance gains of 5.1% on Qwen2.5-3B and 3.6% on Qwen2.5-7B over strong baselines, demonstrating competitive results across multiple datasets. The code is publicly available at https://github.com/MiliLab/REX-RAG .

## 1 Introduction

Recent advances have shown that reinforcement learning (RL) offers a promising avenue for training large language models (LLMs) to perform complex reasoning tasks (Ouyang et al. 2022; Yu et al. [2025](https://arxiv.org/html/2508.08149v2#biba.bib21); Chen et al. 2025b). By integrating multi-step reasoning with retrieval-augmented generation (RAG), RL-trained LLMs can dynamically leverage external knowledge sources—essentially allowing them to “think while searching” (Chen et al. 2025a; Jin et al. [2025b](https://arxiv.org/html/2508.08149v2#biba.bib3)). This paradigm holds particular promise for multi-hop question answering, where models must iteratively gather and synthesize evidence across multiple queries to arrive at well-founded conclusions (Jin et al. 2025a).

Figure: Figure 1: Framework comparison between existing approaches and REX-RAG. (a) Self-Reflection: when encountering incorrect answers, the model attempts to “rethink”, but often produces similar trajectories that lead to dead ends with no effective updates. (b) REX-RAG: our method employs mixed sampling with exploration trajectories guided by diverse reasoning prompts, followed by policy correction to ensure low-bias policy updates.
Refer to caption: x1.png

Despite this potential, we observe a critical challenge that substantially hinders policy optimization in such settings. During RL training, LLMs frequently become trapped in what we term “dead ends”: situations where the model consistently fails to arrive at the correct final answer after multiple rollouts. This phenomenon often stems from premature or overconfident conclusions drawn despite insufficient supporting information, effectively terminating exploration along potentially fruitful reasoning  (Yue et al. 2025; Wen et al. 2025; Liu et al. 2025).

Addressing this challenge requires mechanisms that can proactively explore alternative reasoning paths when initial trajectories prove unproductive. A straightforward solution is self-reflection (Guo et al. [2025](https://arxiv.org/html/2508.08149v2#biba.bib1); Jin et al. [2025b](https://arxiv.org/html/2508.08149v2#biba.bib3)), which attempts to revise failed reasoning chains to generate alternative ones. However, we observe that these revised trajectories are often merely slight perturbations of the original paths, offering limited novelty and insufficient deviation to meaningfully explore alternative solutions. Consequently, it struggles to escapee from dead-end reasoning paths, as illustrated in Fig. [1](https://arxiv.org/html/2508.08149v2#S1.F1)(a). In our experiments with the Qwen2.5-3B model, self-reflection consistently results in a high incidence of “dead ends”, where LLMs generate wrong answers across all rollouts. This phenomenon surpasses 85% in the early phases of RL training and significantly impedes effective policy learning, as shown in Fig. [2](https://arxiv.org/html/2508.08149v2#S1.F2).

On the other hand, more aggressively enforcing exploration, such as introducing additional agents (Xiong et al. 2025; Nguyen, Chin, and Tai 2025), makes end-to-end optimization challenging due to the complexity of jointly training multiple components. This challenge underscores the need for principled strategies that can foster sufficiently diverse and informative exploration while ensuring stable and unbiased policy optimization without compromising the end-to-end learning paradigm (Feng et al. 2025).

To address this challenge, we propose REX-RAG (Reasoning EXploration with Policy Correction in Retrieval-Augmented Generation), a novel framework that explores alternative reasoning paths while maintaining rigorous policy learning through principled distributional corrections. Our framework incorporates an exploratory probe policy that collaborates with the standard policy to escape from the “dead ends”, as shown in Fig. [1](https://arxiv.org/html/2508.08149v2#S1.F1) (b).

Figure: Figure 2: Training dynamics comparison between self-reflection and REX-RAG. Top: Success rate over training steps, showing REX-RAG (red) achieving higher and more stable performance compared to self-reflection (blue). Bottom: Dead end rate over training steps, demonstrating that REX-RAG effectively reduces dead ends throughout while self-reflection shows persistent high “dead end” rates.
Refer to caption: x2.png

The key innovation of REX-RAG lies in its Mixed Sampling Strategy that combines exploration and exploitation in a principled manner. Our framework employs a curated collection of chain-of-thought prompts to inject diverse reasoning directions when trajectories fail. Specifically, when the policy encounters a dead end—indicated by incorrect answers—we strategically insert concise reasoning hints from the prompt pool and resume generation from that point, effectively steering the model toward unexplored solution paths. This approach generates substantially different reasoning trajectories that can escape local optima while maintaining computational efficiency.

Crucially, to prevent the distributional shifts inherent in such interventions from destabilizing training, REX-RAG incorporates a Policy Correction Mechanism based on importance sampling theory. This mechanism accurately estimates the likelihood of probe-induced trajectories and applies appropriate corrections to minimize the bias in the policy gradient, under mixed sampling from both the original policy and the probe policy (Yan et al. 2025; Tan, Yan, and Yang 2025).

Extensive experiments on multi-hop question answering benchmarks demonstrate that REX-RAG significantly outperforms existing methods, achieving substantial improvements in both answer accuracy and reasoning quality. On average, it outperforms strong baselines by 5.1% on Qwen2.5-3B and 3.6% on Qwen2.5-7B. Furthermore, as shown in Fig. [2](https://arxiv.org/html/2508.08149v2#S1.F2), our analysis reveals that the framework successfully escapes dead ends while maintaining stable policy learning, with consistently higher success rates and lower dead end rates compared to self-reflection approaches, validating the effectiveness of our principled exploration strategy.

The main contribution can be concluded that:

- •
We identify and formalize the dead end problem in RL-based RAG training, demonstrating its significant impact on policy optimization and showing that it affects over 85% of training instances in early phases.
- •
We propose REX-RAG, a novel framework combining Mixed Sampling Strategies with Policy Correction Mechanism for effective exploration and stable training.
- •
We achieve substantial improvements over strong baselines (5.1% on Qwen2.5-3B and 3.6% on Qwen2.5-7B) on multi-hop question answering benchmarks.

## 2 Related Work

##### Retrieval-Augmented Generation.

RAG (Lewis et al. [2020](https://arxiv.org/html/2508.08149v2#biba.bib8)) has fundamentally transformed how language models access and utilize external knowledge. The RAG framework combines search engines with generative models, enabling LLMs to ground their responses in retrieved documents (Arslan et al. 2024). This paradigm has proven particularly effective for knowledge-intensive tasks where parametric knowledge alone is insufficient (Mallen et al. 2023).
For multi-hop reasoning tasks, several specialized approaches have emerged (Asai et al. 2024; Gao et al. 2025), for example, IRCoT (Trivedi et al. [2023](https://arxiv.org/html/2508.08149v2#biba.bib17)) interleaves retrieval with chain-of-thought reasoning, allowing models to iteratively gather evidence across multiple reasoning steps.
However, these methods rely on supervised fine-tuning or simple prompting, limiting their capacity to learn optimal retrieval and reasoning through interaction.

##### Reinforcement Learning with Verifiable Rewards (RLVR).

RLVR has emerged as a popular approach for improving LLM reasoning.
The integration of RL and RAG has opened new avenues for training LLMs to perform complex reasoning tasks (Zheng et al. 2025; Mei et al. 2025; Qian and Liu 2025). Recent advances include reasoning-oriented models that employ RL to improve step-by-step reasoning capabilities (Sun et al. 2025; Wu et al. 2025; Li et al. 2025b). In the context of RAG, Search-R1 (Jin et al. [2025b](https://arxiv.org/html/2508.08149v2#biba.bib3)) represents a pioneering and excellent effort to apply RL for training LLMs to dynamically interact with search engines. However, as noted in empirical studies (Jin et al. 2025a), existing RL approaches (Song et al. 2025) for reasoning-search interleaved agents face challenges in exploration efficiency and training stability.

Figure: Figure 3: Overview of REX-RAG. (a) Overall framework architecture; (b) Mixed Sampling Strategy in Rollout Phase that combines policy and probe sampling; (c) Policy Correction Mechanism in Update Phase that corrects distribution shift.
Refer to caption: x3.png

## 3 Method

### 3.1 Preliminary

##### RAG Task Formulation

RAG addresses this limitation of LLMs when answering complex questions that require external knowledge beyond their training data. Formally, given a question $q$ and a golden answer $a$ from a dataset $\mathcal{D}=\{(q_{i},a_{i})\}_{i=1}^{n}$, the LLM alternates between generation and retrieval. At each step, it generates reasoning text or a search query, which is used to retrieve documents $d=\{d_{1},d_{2},\dots,d_{k}\}$ from an external knowledge source $\mathcal{R}$ (e.g., a search engine or database), and produces a final answer.

##### RLVR Enhanced RAG

RLVR extends the RAG framework by integrating retrieval and reasoning into a reinforcement learning loop (Li et al. 2025c). The learning process is guided by a verifiable reward signal based on an objective correctness criterion, such as exact match.
Formally, for each question-answer pair $(q,y)$, the reward signal $r(q,y)$ provides feedback indicating whether the generated answer satisfies predefined verification criteria.

##### GRPO Algorithm

GRPO (Shao et al. [2024](https://arxiv.org/html/2508.08149v2#biba.bib13)) is an emerging RL algorithm for training LLM policies. Formally, GRPO trains a target policy LLM $\pi_{\theta}$ using trajectories collected from a previous policy $\pi_{\theta_{\text{old}}}$. The goal is to maximize the expected reward while keeping the learned policy close to a fixed reference policy $\pi_{\mathrm{ref}}$ (e.g., the pre-trained LLM prior to RL fine-tuning), ensuring training stability. For a given query $q$, GRPO generates multiple trajectories through rollouts and computes a normalized reward as the advantage. Moreover, for readability, the descriptions related to GRPO in the main text do not distinguish between $\pi_{\theta_{old}}$ and $\pi_{\theta}$.

### 3.2 REX-RAG Framework

In this work, we propose REX-RAG, a novel framework that addresses the exploration challenge in RLVR-based RAG through two key innovations. As illustrated in Fig.[3](https://arxiv.org/html/2508.08149v2#S2.F3), during the Rollout Phase (Fig. [3](https://arxiv.org/html/2508.08149v2#S2.F3) (b)), a Mixed Sampling Strategy generates diverse trajectories by combining actions from both the target policy $\pi_{\theta}$ and the probe policy $\pi_{\varepsilon}$ to escape “dead ends”. In the subsequent Update Phase (Fig. [3](https://arxiv.org/html/2508.08149v2#S2.F3) (c)), a Policy Correction Mechanism applies importance sampling to correct distribution shifts introduced by mixed sampling, ensuring stable policy learning while incorporating insights from exploratory rollouts.

##### RLVR Algorithm

REX-RAG is implemented using GRPO as the underlying reinforcement learning algorithm. As described in Sec. [3.1](https://arxiv.org/html/2508.08149v2#S3.SS1.SSS0.Px3), GRPO generates multiple trajectories in Rollout Phase and computes normalized rewards as advantages to update policy parameters in Update Phase.

##### Structured Interaction Protocol

To facilitate structured interaction between the model and search engine, we adopt the Search-R1 protocol (Jin et al. [2025b](https://arxiv.org/html/2508.08149v2#biba.bib3)), which uses specialized tokens to define different actions during the reasoning process. Specifically, this method use prompt engineering to enables the model to autonomously interact with the search engine through special tokens that trigger different actions. The specific actions are detailed in the Appendix [E](https://arxiv.org/html/2508.08149v2#A5).

##### Reward Function

The reward function is a rule-based reward using exact match. Specifically, the exact match strictly assigns a reward of 1 if the model’s answer exactly matches the golden answer, and 0 otherwise.

$$ $\displaystyle r=\mathrm{EM}(\text{ans}_{\mathrm{pred}},\text{ans}_{\mathrm{gold}})\text{.}$ (1) $$

### 3.3 Mixed Sampling Strategy

The Mixed Sampling Strategy enhances exploration by employing a mixed behavior policy that combines trajectories from both the current policy $\pi_{\theta}$ and the probe policy $\pi_{\varepsilon}$, thus, the mixed behavior policy can be formulated as:

$$ $\displaystyle\mu=\{\pi_{\theta},\pi_{\varepsilon}\}\text{.}$ (2) $$

Specifically, the strategy adaptively samples from both policies to maintain exploration diversity. It operates through a two-stages process: first sampling trajectories from the LLM policy, then adaptively performing probe sampling based on the proportion of incorrect paths.

##### Adaptive Probe Re-sampling

To effectively balance exploration and exploitation, REX-RAG introduces an adaptive probe re-sampling mechanism that dynamically adjusts the degree of exploration based on the observed performance of the current policy.

The exploration process begins by sampling $n$ trajectories for each question. After collecting the corresponding rewards $\{r_{1},r_{2},\dots,r_{n}\}$, where each $r_{i}\in[0,1]$, additional exploratory trajectories are sampled in an adaptive manner. Specifically, each trajectory is resampled with probability $p(1-r_{i})$, where $p\in[0,1]$ is a hyperparameter that controls sampling ratio. This adaptive mechanism encourages more exploration when the policy underperforms and less when it performs well. Consequently, for each question, the expected number of resampled trajectories is given by:

$$ $\displaystyle m=p\sum_{i=1}^{n}(1-r_{i})\text{.}$ (3) $$

##### Construction of Probe Policy

To enable effective exploration, the probe policy $\pi_{\varepsilon}$ is constructed using a simple prompt-guided augmentation strategy, which generates exploratory trajectories by injecting exploratory guidance into the original reasoning process.

Each exploratory trajectory $o^{\prime}$ is composed by concatenating three components:

$$ $\displaystyle o^{\prime}=o^{\prime}_{\text{origin}}\oplus o^{\prime}_{\text{prompt}}\oplus o^{\prime}_{\text{probe}}\text{,}$ (4) $$

where $\oplus$ denotes sequence concatenation. Specifically:

- •
$o^{\prime}_{\text{origin}}$: the original model rollout up to the point where it produces an incorrect or premature answer, preserving the initial reasoning context.
- •
$o^{\prime}_{\text{prompt}}$: an exploration prompt sampled from a curated prompt pool $\mathcal{P}$, designed to inject alternative reasoning directions.
- •
$o^{\prime}_{\text{probe}}$: a new continuation generated by the target model $\pi_{\theta}$, conditioned on the modified context.

The prompt pool $\mathcal{P}$ is built by rephrasing a comprehensive reflection prompt into $k$ diverse chain-of-thought fragments using GPT-4.5  (OpenAI [2025](https://arxiv.org/html/2508.08149v2#biba.bib10)). These fragments represent various reasoning strategies or question reformulations designed to stimulate exploration. The full list of base prompts and their derived fragments are provided in the Appendix [F](https://arxiv.org/html/2508.08149v2#A6). For more empirical results on different prompts, please refer to Appendix[A.2](https://arxiv.org/html/2508.08149v2#A1.SS2).

### 3.4 Policy Correction Mechanism

##### Distribution Shift Chanllenge

If the mismatch between the behavior policy $\mu=\{\pi_{\theta},\pi_{\varepsilon}\}$ and the target policy $\pi_{\theta}$ introduced by the mixed sampling strategy is not addressed, model-generated samples are systematically underweighted, whereas tokens from exploration prompts are overweighted. As a result, tokens in inserted spans with negative advantages may be excessively penalized, potentially falling outside $\pi_{\theta}$’s support, whereas regions with positive advantages risk entropy collapse due to overly concentrated probabilities. Although GRPO’s clipping trick partially addresses these issues, it does not apply during the first update in each training step, leaving the problem unresolved. Fundamentally, using an on-policy estimator in an off-policy setting introduces estimation bias and instability. For detailed mathematical analysis, refer to Appendix [B.2](https://arxiv.org/html/2508.08149v2#A2.SS2). To mitigate this, we propose a *Policy Correction Mechanism* (Fig. [3](https://arxiv.org/html/2508.08149v2#S2.F3) (c)), which reduces distribution shift and gradient bias via two steps: (i) Trajectory Filtering, and (ii) Distribution Realignment.

##### Trajectory Filtering

A trajectory filtering mechanism is first introduced to preferentially select rollouts from the probe policy that closely approximate the target policy, thereby mitigating instability and bias. Specifically, trajectories $o^{\prime}$ are filtered according to their log-likelihood under the current policy $\pi_{\theta}$, retaining those consistent enough with it. The retention ratio is controlled by a hyperparameter $\alpha$. After filtering, for each question $t$, the retained trajectories are combined with those generated from the target policy:

$$ $\displaystyle\mathcal{O}_{t}$ $\displaystyle=\bigl{\{}\,o_{i}\mid o_{i}\sim\pi_{\theta}\,\bigr{\}}_{i=1}^{G}\;\cup\;\bigl{\{}\,o^{\prime}_{j}\mid o^{\prime}_{j}\sim\pi_{\varepsilon}\,\bigr{\}}_{j=1}^{\alpha G}\text{.}$ (5) $$

##### Distribution Realignment

Despite the trajectory filtering, a significant distributional mismatch still exists between the mixed behavior policy $\mu$ and the target policy $\pi_{\theta}$. Specifically, we first define the distribution of the Probe Policy through a principled realignment mechanism. Then, leveraging the theory of multiple importance sampling, we derive a custom GRPO optimization objective to perform parameter updates.

**Table 1: Main experimental results on seven QA benchmarks. Best performance is highlighted in bold; the second best is underlined. $\heartsuit$ denotes in-domain datasets (trained on), $\diamondsuit$ denotes out-of-domain datasets. All results are exact match accuracy. Additional statistical analysis and significance testing are detailed in the Appendix [A.3](https://arxiv.org/html/2508.08149v2#A1.SS3).**
| Methods | General QA | Multi-Hop QA | Avg. |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| NQ^♡ | TriviaQA^♢ | PopQA^♢ | HotpotQA^♡ | 2wiki^♢ | Musique^♢ | Bamboogle^♢ |  |  |
| Qwen2.5-3B-Base/Instruct |  |  |  |  |  |  |  |  |
| RAG | 34.8 | 54.4 | 38.7 | 25.5 | 22.6 | 4.7 | 0.8 | 27.0 |
| IRCoT | 11.1 | 31.2 | 20.0 | 16.4 | 17.1 | 6.7 | 24.0 | 18.1 |
| Search-o1 | 23.8 | 47.2 | 26.2 | 22.1 | 21.8 | 5.4 | 32.0 | 25.5 |
| R1-base | 22.6 | 45.5 | 17.3 | 20.1 | 26.8 | 5.5 | 22.4 | 22.9 |
| R1-instruct | 21.0 | 44.9 | 17.1 | 20.8 | 27.5 | 6.0 | 19.2 | 22.4 |
| Search-R1-base | 42.1 | 58.3 | 41.3 | 29.7 | 27.4 | 6.6 | 12.8 | 31.2 |
| Search-R1-instruct | 39.7 | 56.6 | 39.1 | 33.1 | 31.0 | 12.4 | 23.2 | 33.6 |
| REX-RAG (Ours) | 43.9 | 60.4 | 44.2 | 37.4 | 39.7 | 14.5 | 31.2 | 38.7 |
| Qwen2.5-7B-Base/Instruct |  |  |  |  |  |  |  |  |
| RAG | 34.9 | 58.5 | 39.2 | 29.9 | 23.5 | 5.8 | 20.8 | 30.4 |
| IRCoT | 22.4 | 47.8 | 30.1 | 13.3 | 14.9 | 7.2 | 22.4 | 23.9 |
| Search-o1 | 15.1 | 44.3 | 13.1 | 18.7 | 17.6 | 5.8 | 29.6 | 20.6 |
| R1-base | 29.7 | 53.9 | 20.2 | 24.2 | 27.3 | 8.3 | 29.6 | 27.6 |
| R1-instruct | 27.0 | 53.7 | 19.9 | 23.7 | 29.2 | 7.2 | 29.3 | 27.1 |
| Search-R1-base | 39.5 | 56.0 | 38.8 | 32.6 | 27.0 | 12.5 | 36.0 | 35.0 |
| Search-R1-instruct | 42.9 | 62.3 | 42.7 | 38.6 | 34.6 | 16.2 | 40.0 | 39.6 |
| REX-RAG (Ours) | 45.5 | 62.6 | 44.3 | 42.2 | 43.7 | 19.7 | 44.8 | 43.2 |

Probe Policy Definition is nontrivial because the probe policy constructs trajectories by augmenting original rollouts with injected prompts and subsequent continuations. To model $\pi_{\varepsilon}$ accurately, trajectories are decomposed into segments, each modeled individually under $\pi_{\varepsilon}$ as follows:

$$ $\displaystyle\pi_{\varepsilon}$ $\displaystyle(o^{\prime}_{i,t}\mid q_{i},o^{\prime}_{i<t})=\begin{cases}\dfrac{\pi_{\theta}(o^{\prime}_{i,t}\mid q_{i},o^{\prime}_{i<t})}{z^{1/|o^{\prime}_{\mathrm{origin}}|}},&\text{if }o^{\prime}_{i,t}\in o^{\prime}_{\mathrm{origin}}\[11.99998pt] \mathrm{PMF}(o^{\prime}_{i<t},o^{\prime}_{i,t}),&\text{if }o^{\prime}_{i,t}\in o^{\prime}_{\mathrm{prompt}}\[11.99998pt] \pi_{\theta}(o^{\prime}_{i,t}\mid q_{i},o^{\prime}_{i<t}),&\text{if }o^{\prime}_{i,t}\in o^{\prime}_{\mathrm{probe}}\end{cases}\text{.}$ (6) $$

- •
The prefix segment is treated as sampled from a truncated version of $\pi_{\theta}$, conditioned on failure, with $z$ representing the empirical failure rate.
- •
The prompt segment is deterministically selected, modeled by an empirical probability mass function (PMF) over the prompt pool.
- •
The continuation segment is sampled directly from $\pi_{\theta}$, thus requires no correction.

The specific design details and the construction method of the probability mass function based on frequency distribution are provided in the Appendix [B.3](https://arxiv.org/html/2508.08149v2#A2.SS3).

Multiple Importance Sampling is then further employed to correct the distributional mismatch between the mixed behavior policy $\mu$, from which data is collected, and the target policy $\pi_{\theta}$, under which the model is optimized.

The importance ratio for action $o_{i,t}$ at time step $t$ within trajectory $i$ is computed according to the balance heuristic  (Veach and Guibas [1995](https://arxiv.org/html/2508.08149v2#biba.bib18)) as:

$$ $\displaystyle\omega_{i,t}=\frac{(1+\alpha)\,\pi_{\theta}\!\left(o_{i,t}\mid q_{i},o_{i,<t}\right)}{\pi_{\theta}\!\left(o_{i,t}\mid q_{i},o_{i,<t}\right)+\alpha\,\pi_{\varepsilon}\!\left(o_{i,t}\mid q_{i},o_{i,<t}\right)}\text{.}$ (7) $$

The policy is then optimized with the GRPO objective:

$$ $\displaystyle J_{\text{GRPO}}(\theta)=\mathbb{E}_{\,q\sim\mathcal{D},\;\{o_{i}\}_{i=1}^{\mid\mathcal{O}\mid}\sim\mu(\cdot\mid q)}\Bigg{[}\frac{1}{\mid\mathcal{O}\mid}\sum_{i=1}^{\mid\mathcal{O}\mid}\frac{1}{|o_{i}|}\sum_{t=1}^{|o_{i}|}$ $\displaystyle\quad\min\!\Bigg{(}\omega_{i,t}\,\hat{A}_{i,t},\;\mathrm{clip}\!\left(\omega_{i,t},\,1-\varepsilon,\,1+\varepsilon\right)\hat{A}_{i,t}\Bigg{)}$ $\displaystyle\quad-\beta\,D_{\mathrm{KL}}\!\left(\pi_{\theta}\,\|\,\pi_{\mathrm{ref}}\right)\Bigg{]}\text{,}$ (8) $$

where the behavior policy was updated to a mixture $\mu$, the coefficient multiplying the advantage was updated to the importance ratio in Eq. ([7](https://arxiv.org/html/2508.08149v2#S3.E7)) rather than simple ratio between the new and old $\pi_{\theta}$, and the group size was updated to $\mid\mathcal{O}\mid$.

## 4 Experiment

We conduct extensive evaluations of REX-RAG on seven QA benchmarks, generalizability analysis. Additionals experimental anaylsis on prompts and hyper–parameters are included in the Appendix [A](https://arxiv.org/html/2508.08149v2#A1).

### 4.1 Experimental Setup

**Table 2: Ablation study over key components in REX-RAG (Qwen2.5-3B,GRPO).**
| Methods | General QA | Multi-Hop QA | Avg. |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| NQ | TriviaQA | PopQA | HotpotQA | 2wiki | Musique | Bamboogle |  |  |
| REX-RAG | 43.9 | 60.4 | 44.2 | 37.4 | 39.7 | 14.5 | 31.2 | 38.7 |
| Coarse PPD | 45.4 | 60.9 | 44.1 | 35.4 | 35.1 | 10.7 | 23.2 | 36.4 |
| w/o IS | 45.4 | 61.8 | 43.9 | 32.5 | 28.8 | 8.1 | 13.6 | 33.4 |
| w/o TF | 39.7 | 54.2 | 36.6 | 26.0 | 26.4 | 5.5 | 9.6 | 28.2 |
| w/o IS&TF | 39.5 | 56.1 | 41.5 | 26.6 | 26.0 | 5.3 | 8.8 | 29.1 |

##### Datasets

We evaluate REX-RAG on seven QA benchmarks: three general QA datasets NQ (Kwiatkowski et al. [2019](https://arxiv.org/html/2508.08149v2#biba.bib7)), TrivialQA (Joshi et al. [2017](https://arxiv.org/html/2508.08149v2#biba.bib5)), and PopQA (Mallen et al. 2023), together with four Multi-Hop QA datasets HotpotQA (Yang et al. [2018](https://arxiv.org/html/2508.08149v2#biba.bib20)), 2WikiMultiHopQA (Ho et al. [2020](https://arxiv.org/html/2508.08149v2#biba.bib2)), Musique (Trivedi et al. [2022](https://arxiv.org/html/2508.08149v2#biba.bib16)), and Bamboogle (Press et al. [2023](https://arxiv.org/html/2508.08149v2#biba.bib11)). In line with earlier studies (Jin et al. [2025b](https://arxiv.org/html/2508.08149v2#biba.bib3), a), we merge the NQ and HotpotQA training sets for REX‑RAG training. The test splits of NQ and HotpotQA are treated as in‑domain evaluations, and the remaining five datasets are used for out‑of‑domain evaluation. For detailed information, please refer to Appendix [C.2](https://arxiv.org/html/2508.08149v2#A3.SS2).

##### Baselines

To evaluate the effectiveness of REX-RAG, we compare it with several baselines, categorized into two groups: (1) non-fine-tuned methods, including Naive RAG (Lewis et al. [2020](https://arxiv.org/html/2508.08149v2#biba.bib8)), IRCOT (Trivedi et al. [2023](https://arxiv.org/html/2508.08149v2#biba.bib17)), and Search-o1 (Li et al. [2025a](https://arxiv.org/html/2508.08149v2#biba.bib9)); and (2) fine-tuned methods, including R1-like (Guo et al. [2025](https://arxiv.org/html/2508.08149v2#biba.bib1)) training using PPO (Schulman et al. [2017](https://arxiv.org/html/2508.08149v2#biba.bib12)) without retrieval and those with retrieval (Jin et al. [2025b](https://arxiv.org/html/2508.08149v2#biba.bib3)) using GRPO (Shao et al. [2024](https://arxiv.org/html/2508.08149v2#biba.bib13)).

**Table 3: Algorithm generalizability analysis comparing GRPO and DAPO frameworks on Qwen2.5-3B. Scores represent exact match accuracy (%) averaged across General QA and Multi-Hop QA categories.**
| Methods | General QA | Multi-Hop QA | Avg. |
| --- | --- | --- | --- |
| GRPO |  |  |  |
| Search-R1 | 47.2 | 19.1 | 31.2 |
| REX-RAG | 49.5 | 30.7 | 38.7 |
| DAPO |  |  |  |
| Search-R1 | 50.9 | 22.7 | 34.8 |
| REX-RAG | 48.4 | 30.9 | 38.4 |

##### Implementation Details

For external search engines, we utilize the December 2018 Wikipedia dump  (Karpukhin et al. [2020](https://arxiv.org/html/2508.08149v2#biba.bib6)) as our primary data source and employ the E5-base-v2 model  (Wang et al. [2022](https://arxiv.org/html/2508.08149v2#biba.bib19)) as the retriever. During each retrieval step, the top-3 documents returned by the retriever are provided as additional context.

For REX-RAG, we adopt Qwen2.5-3B and Qwen2.5-7B as base models  (Team [2024](https://arxiv.org/html/2508.08149v2#biba.bib15)), using GRPO as the default RL algorithm. The hyperparameters $\alpha$ and $p$ are set to default values of 0.12 and 0.2. For further details on experimental settings, please refer to the Appendix [C](https://arxiv.org/html/2508.08149v2#A3).

For evaluation, we mainly rely on the exact match. Additionally, most of the baseline results in Table [1](https://arxiv.org/html/2508.08149v2#S3.T1) are taken from Search-R1 (Jin et al. [2025b](https://arxiv.org/html/2508.08149v2#biba.bib3), a).

Figure: Figure 4: Uncertainty quantification visualization comparing Qwen2.5-7B-Base (left) and REX-RAG (right). Color intensity represents uncertainty levels; Blue bars represent Aleatoric Uncertainty (AU) and orange bars represent Epistemic Uncertainty (EU). REX-RAG demonstrates coherent reasoning with reduced epistemic uncertainty and higher reliability scores.
Refer to caption: x4.png

### 4.2 Overall Performance

Table [1](https://arxiv.org/html/2508.08149v2#S3.T1) presents the main experimental results across seven diverse QA benchmarks. REX-RAG demonstrates consistent and substantial improvements over all baseline methods across both model sizes and dataset types.

##### Performance Gains

REX-RAG achieves significant performance improvements over the strongest baseline (Search-R1-instruct): +5.1% average improvement on Qwen2.5-3B (38.7% vs 33.6%) and +3.6% on Qwen2.5-7B (43.2% vs 39.6%). These gains are particularly pronounced on multi-hop reasoning tasks, where REX-RAG shows +8.7% improvement on 2Wiki and +4.3% on HotpotQA for the 3B model, demonstrating the effectiveness of our method.

##### Out-of-Domain Generalization

REX-RAG also exhibits strong generalization capabilities across out-of-domain datasets. On TriviaQA, PopQA, 2Wiki, MuSiQue, and Bamboogle—none of which were seen during training—REX-RAG consistently outperforms baselines by substantial margins. This suggests that the mixed sampling strategy successfully learns generalizable reasoning patterns rather than overfitting to specific dataset characteristics.

##### Comparison with Non-Finetuned Methods

REX-RAG significantly outperforms non-finetuned approaches, achieving 13.2% higher average performance than the best non-finetuned RAG method on 3B models. This demonstrates the value of reinforcement learning for RAG reasoning, while our method further amplifies these benefits.

### 4.3 Ablation Studies

#### Ablation on Key Components

Table [2](https://arxiv.org/html/2508.08149v2#S4.T2) presents ablation studies examining the contribution of each component in REX-RAG. We systematically remove or modify key components to understand their individual impact.

##### Component Analysis

(1) Full REX-RAG: Our complete method achieving 38.7% average performance. (2) Coarse PPD: Uses a simplified probe policy definition where the first token of inserted prompts receives probability $1/k$, while remaining prompt tokens are assigned probability 1. This coarse approximation leads to a 2.3% performance drop, demonstrating the importance of accurate probability modeling. (3) w/o IS: Removes importance sampling, treating all trajectories equally during training. This results in a 5.3% performance degradation. (4) w/o TF: Eliminates trajectory filtering, including all probe-generated trajectories regardless of quality. Performance drops by 10.5%, showing that quality control is essential for effective exploration. (5) w/o IS&TF: Removes the entire Policy Correction Mechanism, including IS and TS, essentially reducing to naive trajectory augmentation. This causes a 9.6% performance drop, confirming that principled distribution correction is crucial for stable learning.

##### Key Insights

The ablation results reveal several important insights: First, the Policy Correction Mechanism is a critical component, with its removal causing a large performance degradation. Second, trajectory filtering is essential for maintaining training stability—without it, noisy exploratory trajectories significantly harm performance. Third, even coarse probability estimation provides substantial benefits over no correction, though precise modeling yields optimal results. These findings validate the effectiveness of our framework and design choices.

#### Algorithm Generalizability

Table [3](https://arxiv.org/html/2508.08149v2#S4.T3) demonstrates that REX-RAG’s benefits generalize across different reinforcement learning algorithms. When trained with DAPO  (Yu et al. [2025](https://arxiv.org/html/2508.08149v2#biba.bib21)) instead of GRPO, REX-RAG maintains substantial improvements over Search-R1 (38.4% vs 34.8% average performance), though gains are slightly smaller than with GRPO. This suggests that REX-RAG is algorithm-agnostic and can be integrated with various RL frameworks.
Interestingly, DAPO shows stronger performance on general QA tasks for Search-R1, while GRPO excels on multi-hop reasoning. REX-RAG benefits from both algorithms but shows more consistent improvements with GRPO, likely due to GRPO’s group-based advantage estimation being more compatible with our mixed sampling strategy.

### 4.4 Case Studies and Visualization

Fig. [4](https://arxiv.org/html/2508.08149v2#S4.F4) presents a comprehensive visualization analysis comparing reasoning trajectories of Qwen2.5-7B-Base and REX-RAG using uncertainty quantification methodology from LogTokU (Ma et al. 2025). Following the framework, we analyze Aleatoric Uncertainty (AU) representing inherent data randomness and Epistemic Uncertainty (EU) capturing model knowledge gaps through token-level confidence scoring. The visualization demonstrates that REX-RAG achieves universally higher reliability scores for reasoning tokens, with values frequently falling in the 0.6–0.8 range, whereas the baseline exhibits lower reliability (typically in the 0.2–0.4 range). This indicates REX-RAG exhibits superior confidence calibration and more reliable decision-making throughout the reasoning process.

The uncertainty analysis reveals that REX-RAG exhibits high AU combined with low EU, providing evidence that REX-RAG is more exploratory precisely when it possesses relevant knowledge. This behavior demonstrates that REX-RAG’s probe policy effectively identifies situations where multiple valid reasoning paths exist (high AU) while maintaining confidence in its knowledge base (low EU), leading to more thorough exploration of the solution space. In contrast, the baseline model shows the opposite pattern with low AU and high EU, indicating overconfidence in limited reasoning paths while lacking awareness of knowledge gaps.

Beyond uncertainty patterns, REX-RAG produces significantly more standardized and coherent output formats compared to the baseline’s fragmented and irregular response structures. The visualization clearly shows that REX-RAG maintains logical flow, consistent structure, and systematic reasoning throughout, whereas the base LLM exhibits abrupt transitions, disjointed reasoning, and produces overconfident yet incorrect answer.
This highlights that REX-RAG offers more reliable confidence estimation, coherent reasoning, and overall robustness in RAG reasoning.

## 5 Limitation

We discuss main limitations of our current approach; further details are provided in the Appendix [D](https://arxiv.org/html/2508.08149v2#A4).

##### Limited Exploration Strategy

Our method relies on fixed-pool prompt insertion, which, though effective, can be improved. Future work could include model-generated prompts, backtracking-based search, or full-path restructuring for more comprehensive exploration.

##### Computational Overhead

The mixed sampling strategy introduces additional trajectories due to difficulty assessment followed by resampling. Though more efficient than uniform oversampling, difficulty-predictive sampling could reduce this overhead but remains challenging.

## 6 Conclusion

This work addresses the dead end problem in reinforcement learning-based retrieval-augmented generation, where models become trapped in unproductive reasoning paths during policy optimization. Our REX-RAG framework introduces the Mixed Sampling Strategy and the Policy Correction Mechanism to enable systematic exploration while maintaining training stability. Comprehensive experiments demonstrate consistent improvements over strong baselines, with particularly notable gains on multi-hop reasoning tasks.
Our key contribution lies in providing a principled approach to exploration in LLM reasoning systems through importance sampling-based distributional correction.
This insight may offers a practical solution for improving retrieval-augmented generation systems and provides a new exploration perspective for LLM reinforcement learning.

## References

- Arslan et al. (2024)
Arslan, M.; Ghanem, H.; Munawar, S.; and Cruz, C. 2024.
A Survey on RAG with LLMs.
*Procedia computer science*, 246: 3781–3790.
- Asai et al. (2024)
Asai, A.; Wu, Z.; Wang, Y.; Sil, A.; and Hajishirzi, H. 2024.
Self-RAG: Learning to Retrieve, Generate, and Critique through Self-Reflection.
In *The Twelfth International Conference on Learning Representations*.
- Chen et al. (2025a)
Chen, M.; Li, T.; Sun, H.; Zhou, Y.; Zhu, C.; Wang, H.; Pan, J. Z.; Zhang, W.; Chen, H.; Yang, F.; et al. 2025a.
Learning to reason with search for llms via reinforcement learning.
*arXiv preprint arXiv:2503.19470*.
- Chen et al. (2025b)
Chen, Q.; Qin, L.; Liu, J.; Peng, D.; Guan, J.; Wang, P.; Hu, M.; Zhou, Y.; Gao, T.; and Che, W. 2025b.
Towards reasoning era: A survey of long chain-of-thought for reasoning large language models.
*arXiv preprint arXiv:2503.09567*.
- Feng et al. (2025)
Feng, L.; Xue, Z.; Liu, T.; and An, B. 2025.
Group-in-group policy optimization for llm agent training.
*arXiv preprint arXiv:2505.10978*.
- Gao et al. (2025)
Gao, Y.; Xiong, Y.; Zhong, Y.; Bi, Y.; Xue, M.; and Wang, H. 2025.
Synergizing rag and reasoning: A systematic review.
*arXiv preprint arXiv:2504.15909*.
- Guo et al. (2025)
Guo, D.; Yang, D.; Zhang, H.; Song, J.; Zhang, R.; Xu, R.; Zhu, Q.; Ma, S.; Wang, P.; Bi, X.; et al. 2025.
Deepseek-r1: Incentivizing reasoning capability in llms via reinforcement learning.
*arXiv preprint arXiv:2501.12948*.
- Ho et al. (2020)
Ho, X.; Duong Nguyen, A.-K.; Sugawara, S.; and Aizawa, A. 2020.
Constructing A Multi-hop QA Dataset for Comprehensive Evaluation of Reasoning Steps.
In *Proceedings of the 28th International Conference on Computational Linguistics*, 6609–6625. International Committee on Computational Linguistics.
- Jin et al. (2025a)
Jin, B.; Yoon, J.; Kargupta, P.; Arik, S. O.; and Han, J. 2025a.
An Empirical Study on Reinforcement Learning for Reasoning-Search Interleaved LLM Agents.
*arXiv preprint arXiv:2505.15117*.
- Jin et al. (2025b)
Jin, B.; Zeng, H.; Yue, Z.; Yoon, J.; Arik, S.; Wang, D.; Zamani, H.; and Han, J. 2025b.
Search-r1: Training llms to reason and leverage search engines with reinforcement learning.
*arXiv preprint arXiv:2503.09516*.
- Johnson, Douze, and Jégou (2019)
Johnson, J.; Douze, M.; and Jégou, H. 2019.
Billion-scale similarity search with GPUs.
*IEEE Transactions on Big Data*, 7(3): 535–547.
- Joshi et al. (2017)
Joshi, M.; Choi, E.; Weld, D. S.; and Zettlemoyer, L. 2017.
TriviaQA: A Large Scale Distantly Supervised Challenge Dataset for Reading Comprehension.
In *Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics*, 1601–1611.
- Karpukhin et al. (2020)
Karpukhin, V.; Oguz, B.; Min, S.; Lewis, P.; Wu, L.; Edunov, S.; Chen, D.; and Yih, W.-t. 2020.
Dense Passage Retrieval for Open-Domain Question Answering.
In Webber, B.; Cohn, T.; He, Y.; and Liu, Y., eds., *Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing*, 6769–6781. Association for Computational Linguistics.
- Kwiatkowski et al. (2019)
Kwiatkowski, T.; Palomaki, J.; Redfield, O.; Collins, M.; Parikh, A.; Alberti, C.; Epstein, D.; Polosukhin, I.; Devlin, J.; Lee, K.; et al. 2019.
Natural questions: a benchmark for question answering research.
*Transactions of the Association for Computational Linguistics*, 7: 453–466.
- Lewis et al. (2020)
Lewis, P.; Perez, E.; Piktus, A.; Petroni, F.; Karpukhin, V.; Goyal, N.; Küttler, H.; Lewis, M.; Yih, W.-t.; Rocktäschel, T.; Riedel, S.; and Kiela, D. 2020.
Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks.
In Larochelle, H.; Ranzato, M.; Hadsell, R.; Balcan, M.; and Lin, H., eds., *Advances in Neural Information Processing Systems*, volume 33, 9459–9474. Curran Associates, Inc.
- Li et al. (2025a)
Li, X.; Dong, G.; Jin, J.; Zhang, Y.; Zhou, Y.; Zhu, Y.; Zhang, P.; and Dou, Z. 2025a.
Search-o1: Agentic search-enhanced large reasoning models.
*arXiv preprint arXiv:2501.05366*.
- Li et al. (2025b)
Li, Y.; Luo, Q.; Li, X.; Li, B.; Cheng, Q.; Wang, B.; Zheng, Y.; Wang, Y.; Yin, Z.; and Qiu, X. 2025b.
R3-RAG: Learning Step-by-Step Reasoning and Retrieval for LLMs via Reinforcement Learning.
*arXiv preprint arXiv:2505.23794*.
- Li et al. (2025c)
Li, Y.; Zhang, W.; Yang, Y.; Huang, W.-C.; Wu, Y.; Luo, J.; Bei, Y.; Zou, H. P.; Luo, X.; Zhao, Y.; et al. 2025c.
Towards Agentic RAG with Deep Reasoning: A Survey of RAG-Reasoning Systems in LLMs.
*arXiv preprint arXiv:2507.09477*.
- Liu et al. (2025)
Liu, Z.; Chen, C.; Li, W.; Qi, P.; Pang, T.; Du, C.; Lee, W. S.; and Lin, M. 2025.
Understanding r1-zero-like training: A critical perspective.
*arXiv preprint arXiv:2503.20783*.
- Ma et al. (2025)
Ma, H.; Chen, J.; Zhou, J. T.; Wang, G.; and Zhang, C. 2025.
Estimating LLM Uncertainty with Evidence.
*arXiv preprint arXiv:2502.00290*.
- Mallen et al. (2023)
Mallen, A.; Asai, A.; Zhong, V.; Das, R.; Khashabi, D.; and Hajishirzi, H. 2023.
When Not to Trust Language Models: Investigating Effectiveness of Parametric and Non-Parametric Memories.
In *Proceedings of the 61st Annual Meeting of the Association for Computational Linguistics*, 9802–9822.
- Mei et al. (2025)
Mei, J.; Hu, T.; Fu, D.; Wen, L.; Yang, X.; Wu, R.; Cai, P.; Cai, X.; Gao, X.; Yang, Y.; et al. 2025.
$O^{2}$-Searcher: A Searching-based Agent Model for Open-Domain Open-Ended Question Answering.
*arXiv preprint arXiv:2505.16582*.
- Nguyen, Chin, and Tai (2025)
Nguyen, T.; Chin, P.; and Tai, Y.-W. 2025.
MA-RAG: Multi-Agent Retrieval-Augmented Generation via Collaborative Chain-of-Thought Reasoning.
*arXiv preprint arXiv:2505.20096*.
- OpenAI (2025)
OpenAI. 2025.
Introducing GPT-4.5.
https://openai.com/index/introducing-gpt-4-5/.
- Ouyang et al. (2022)
Ouyang, L.; Wu, J.; Jiang, X.; Almeida, D.; Wainwright, C.; Mishkin, P.; Zhang, C.; Agarwal, S.; Slama, K.; Ray, A.; et al. 2022.
Training language models to follow instructions with human feedback.
*Advances in neural information processing systems*, 35: 27730–27744.
- Press et al. (2023)
Press, O.; Zhang, M.; Min, S.; Schmidt, L.; Smith, N. A.; and Lewis, M. 2023.
Measuring and Narrowing the Compositionality Gap in Language Models.
In *Findings of the Association for Computational Linguistics: EMNLP 2023*, 5687–5711.
- Qian and Liu (2025)
Qian, H.; and Liu, Z. 2025.
Scent of Knowledge: Optimizing Search-Enhanced Reasoning with Information Foraging.
*arXiv preprint arXiv:2505.09316*.
- Schulman et al. (2017)
Schulman, J.; Wolski, F.; Dhariwal, P.; Radford, A.; and Klimov, O. 2017.
Proximal policy optimization algorithms.
*arXiv preprint arXiv:1707.06347*.
- Shao et al. (2024)
Shao, Z.; Wang, P.; Zhu, Q.; Xu, R.; Song, J.; Bi, X.; Zhang, H.; Zhang, M.; Li, Y.; Wu, Y.; et al. 2024.
Deepseekmath: Pushing the limits of mathematical reasoning in open language models.
*arXiv preprint arXiv:2402.03300*.
- Sheng et al. (2024)
Sheng, G.; Zhang, C.; Ye, Z.; Wu, X.; Zhang, W.; Zhang, R.; Peng, Y.; Lin, H.; and Wu, C. 2024.
HybridFlow: A Flexible and Efficient RLHF Framework.
*arXiv preprint arXiv: 2409.19256*.
- Song et al. (2025)
Song, H.; Jiang, J.; Min, Y.; Chen, J.; Chen, Z.; Zhao, W. X.; Fang, L.; and Wen, J.-R. 2025.
R1-searcher: Incentivizing the search capability in llms via reinforcement learning.
*arXiv preprint arXiv:2503.05592*.
- Sun et al. (2025)
Sun, H.; Qiao, Z.; Guo, J.; Fan, X.; Hou, Y.; Jiang, Y.; Xie, P.; Zhang, Y.; Huang, F.; and Zhou, J. 2025.
Zerosearch: Incentivize the search capability of llms without searching.
*arXiv preprint arXiv:2505.04588*.
- Tan, Yan, and Yang (2025)
Tan, H.; Yan, H.; and Yang, Y. 2025.
LLM-Guided Reinforcement Learning: Addressing Training Bottlenecks through Policy Modulation.
*arXiv preprint arXiv:2505.20671*.
- Team (2024)
Team, Q. 2024.
Qwen2.5: A Party of Foundation Models.
- Trivedi et al. (2022)
Trivedi, H.; Balasubramanian, N.; Khot, T.; and Sabharwal, A. 2022.
MuSiQue: Multihop Questions via Single-hop Question Composition.
*Transactions of the Association for Computational Linguistics*, 10: 539–554.
- Trivedi et al. (2023)
Trivedi, H.; Balasubramanian, N.; Khot, T.; and Sabharwal, A. 2023.
Interleaving Retrieval with Chain-of-Thought Reasoning for Knowledge-Intensive Multi-Step Questions.
In *Proceedings of the 61st Annual Meeting of the Association for Computational Linguistics*, 10014–10037.
- Veach and Guibas (1995)
Veach, E.; and Guibas, L. J. 1995.
Optimally combining sampling techniques for Monte Carlo rendering.
In *Proceedings of the 22nd annual conference on Computer graphics and interactive techniques*, 419–428.
- Wang et al. (2022)
Wang, L.; Yang, N.; Huang, X.; Jiao, B.; Yang, L.; Jiang, D.; Majumder, R.; and Wei, F. 2022.
Text embeddings by weakly-supervised contrastive pre-training.
*arXiv preprint arXiv:2212.03533*.
- Wen et al. (2025)
Wen, X.; Liu, Z.; Zheng, S.; Xu, Z.; Ye, S.; Wu, Z.; Liang, X.; Wang, Y.; Li, J.; Miao, Z.; et al. 2025.
Reinforcement Learning with Verifiable Rewards Implicitly Incentivizes Correct Reasoning in Base LLMs.
*arXiv preprint arXiv:2506.14245*.
- Wu et al. (2025)
Wu, J.; Deng, Z.; Li, W.; Liu, Y.; You, B.; Li, B.; Ma, Z.; and Liu, Z. 2025.
MMSearch-R1: Incentivizing LMMs to Search.
*arXiv preprint arXiv:2506.20670*.
- Xiong et al. (2025)
Xiong, G.; Jin, Q.; Wang, X.; Fang, Y.; Liu, H.; Yang, Y.; Chen, F.; Song, Z.; Wang, D.; Zhang, M.; et al. 2025.
Rag-gym: Optimizing reasoning and search agents with process supervision.
*arXiv preprint arXiv:2502.13957*.
- Yan et al. (2025)
Yan, J.; Li, Y.; Hu, Z.; Wang, Z.; Cui, G.; Qu, X.; Cheng, Y.; and Zhang, Y. 2025.
Learning to reason under off-policy guidance.
*arXiv preprint arXiv:2504.14945*.
- Yang et al. (2018)
Yang, Z.; Qi, P.; Zhang, S.; Bengio, Y.; Cohen, W.; Salakhutdinov, R.; and Manning, C. D. 2018.
HotpotQA: A Dataset for Diverse, Explainable Multi-hop Question Answering.
In *Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing*, 2369–2380.
- Yu et al. (2025)
Yu, Q.; Zhang, Z.; Zhu, R.; Yuan, Y.; Zuo, X.; Yue, Y.; Dai, W.; Fan, T.; Liu, G.; Liu, L.; et al. 2025.
Dapo: An open-source llm reinforcement learning system at scale.
*arXiv preprint arXiv:2503.14476*.
- Yue et al. (2025)
Yue, Y.; Chen, Z.; Lu, R.; Zhao, A.; Wang, Z.; Song, S.; and Huang, G. 2025.
Does reinforcement learning really incentivize reasoning capacity in llms beyond the base model?
*arXiv preprint arXiv:2504.13837*.
- Zheng et al. (2025)
Zheng, Y.; Fu, D.; Hu, X.; Cai, X.; Ye, L.; Lu, P.; and Liu, P. 2025.
Deepresearcher: Scaling deep research via reinforcement learning in real-world environments.
*arXiv preprint arXiv:2504.03160*.

## Contents

Additional Experimental Analysis ……………………… [A](https://arxiv.org/html/2508.08149v2#A1)

Analysis of Hyper-parameters ……………………….. [A.1](https://arxiv.org/html/2508.08149v2#A1.SS1)

Analysis of Exploration Prompt …………………….. [A.2](https://arxiv.org/html/2508.08149v2#A1.SS2)

Statistical Analysis and Significance Test ……….. [A.3](https://arxiv.org/html/2508.08149v2#A1.SS3)

Mathematical Formulations and Derivations ………..[B](https://arxiv.org/html/2508.08149v2#A2)

GRPO Algorithm …………………………………………. [B.1](https://arxiv.org/html/2508.08149v2#A2.SS1)

Distribution Shift …………………………………………. [B.2](https://arxiv.org/html/2508.08149v2#A2.SS2)

Probe Policy Definition ………………………………… [B.3](https://arxiv.org/html/2508.08149v2#A2.SS3)

Coefficient for Importance Sampling ……………… [B.4](https://arxiv.org/html/2508.08149v2#A2.SS4)

Experimental Implementation Details ………………… [C](https://arxiv.org/html/2508.08149v2#A3)

Baseline Methods ………………………………………… [C.1](https://arxiv.org/html/2508.08149v2#A3.SS1)

Dataset Descriptions …………………………………….. [C.2](https://arxiv.org/html/2508.08149v2#A3.SS2)

Computational Environment and Infrastructure .. [C.3](https://arxiv.org/html/2508.08149v2#A3.SS3)

Hyper-parameter Configuration and Tuning ……. [C.4](https://arxiv.org/html/2508.08149v2#A3.SS4)

Limitations, Discussion, and Future Work…………… [D](https://arxiv.org/html/2508.08149v2#A4)

Structured Search Interaction Protocol…………………[E](https://arxiv.org/html/2508.08149v2#A5)

Special Tokens ……………………………………………..
[E.1](https://arxiv.org/html/2508.08149v2#A5.SS1)

System Prompt ……………………………………………. [E.2](https://arxiv.org/html/2508.08149v2#A5.SS2)

Prompt Templates and Examples………………………….[F](https://arxiv.org/html/2508.08149v2#A6)

## Appendix A Additional Experimental Analysis

### A.1 Analysis of Hyper-parameters

REX-RAG introduces a hyperparameter $p$ that controls the number of additionally sampled trajectories. As shown in the Table [4](https://arxiv.org/html/2508.08149v2#A1.T4), sampling only an extra 12% of trajectories yields a substantial performance improvement over Search-R1. By contrast, Search-R1 attains only a negligible gain even when using 20% more trajectories, highlighting the superior sample efficiency of REX-RAG. Moreover, we observe a positive correlation between model performance and the resampling parameter $p$; with 20% additional sampling, the improvement becomes even more pronounced. This property allows practitioners to flexibly trade off performance gains against computational cost according to their specific needs and resource constraints.

**Table 4: Impact of trajectory sampling strategies on performance. Expected rollout counts shown for REX-RAG under maximum resampling scenarios (all initial outputs incorrect).**
| Sampling Strategy | General | Multi-Hop | Avg. |
| --- | --- | --- | --- |
| Search-R1 |  |  |  |
| 5 rollouts (+0%) | 47.2 | 19.1 | 31.2 |
| 6 rollouts (+20%) | 47.6 | 19.1 | 31.3 |
| REX-RAG |  |  |  |
| 5.6 (+12% $\leftarrow$ 12%) | 48.7 | 23.4 | 34.2 |
| 5.6 (+12% $\leftarrow$ 20%) | 49.5 | 30.7 | 38.7 |

### A.2 Analysis of Exploration Prompt

As shown in the Table [5](https://arxiv.org/html/2508.08149v2#A1.T5), we examined how varying exploration prompts affects model performance. With five prompts, we observe modest improvements on General QA and Multi-Hop QA. However, when expanding from five to thirty prompts, REX-RAG achieves a substantial performance gain relative to Serach-R1. These results indicate that the REX-RAG framework exhibits strong scalability, rather than merely benefiting from a small set of specially selected prompts.

**Table 5: Impact of Number of Exploration Prompt**
| Sampling Strategy | General | Multi-Hop | Avg. |
| --- | --- | --- | --- |
| Search-R1 | 47.2 | 19.1 | 31.2 |
| REX-RAG(5 Prompts) | 48.3 | 20.0 | 32.1 |
| REX-RAG(30 Prompts) | 49.5 | 30.7 | 38.7 |

### A.3 Statistical Analysis and Significance Test

Given that Exact Match is a binary evaluation metric, we adopt the McNemar test to determine whether the performance differences observed in the ablation study constitute statistically significant improvements or degradations. As shown in Table [2](https://arxiv.org/html/2508.08149v2#S4.T2), we evaluate a total of five models. In this subsection, we first rank the models by their Average scores in descending order and then perform pairwise comparisons between successive models.

Each numerical value in the Table [6](https://arxiv.org/html/2508.08149v2#A1.T6) represents the p-value corresponding to the statistical test of the alternative hypothesis, evaluating the difference between the two models across various benchmark.

As shown in Table [6](https://arxiv.org/html/2508.08149v2#A1.T6), the majority of the test results are significant (p-value $<$ 0.05). While the results on a few individual benchmarks are not statistically significant, this does not affect the overall conclusions presented in the main text.

**Table 6: Significance Test over key components in REX-RAG (Qwen2.5-3B,GRPO). Overall represents the results of the tests conducted on seven benchmarks. The rest are the test results obtained on each benchmark.**
| Alternative Hypothesis | General QA | Multi-Hop QA | Overall |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| NQ | TriviaQA | PopQA | HotpotQA | 2wiki | Musique | Bamboogle |  |  |
| REX-RAG $\neq$ Coarse PPD | $1e{-9}$ | $5e{-15}$ | $4e{-9}$ | $1e{-50}$ | $1e{-74}$ | $1e{-10}$ | $2e{-2}$ | $5e{-144}$ |
| Coarse PPD $\neq$ w/o IS | $9e{-1}$ | $1e{-3}$ | $4e{-1}$ | $2e{-10}$ | $8e{-55}$ | $1e{-5}$ | $2e{-2}$ | $3e{-33}$ |
| w/o IS $\neq$w/o IS&IF | $4e{-20}$ | $4e{-103}$ | $6e{-125}$ | $3e{-52}$ | $2e{-9}$ | $1e{-8}$ | $2e{-1}$ | $7e{-250}$ |
| w/o IS&IF $\neq$ w/o TF | $7e{-1}$ | $3e{-7}$ | $1e{-53}$ | $1e{-1}$ | $2e{-1}$ | $7e{-1}$ | 1 | $1e{-24}$ |

## Appendix B Mathematical Formulations and Derivations

### B.1 GRPO Algorithm

GRPO (Shao et al. [2024](https://arxiv.org/html/2508.08149v2#biba.bib13)) is a reinforcement-learning algorithm for aligning large language models that removes the value/critic network by computing *group-relative* advantages across multiple sampled outputs for the same prompt. The baseline is the group’s average reward, and policy updates are additionally regularized by a KL term to a frozen reference model.

For each prompt $q$, sample a group of $G$ outputs $\{o_{i}\}_{i=1}^{G}$ from the old policy $\pi_{\theta_{\mathrm{old}}}$.
Define the likelihood ratio
$\rho_{i,t}=\frac{\pi_{\theta}(o_{i,t}\mid q,o_{i,<t})}{\pi_{\theta_{\mathrm{old}}}(o_{i,t}\mid q,o_{i,<t})}$.
GRPO maximizes:

$$ $\displaystyle J_{\text{GRPO}}(\theta)$ $\displaystyle=$ $\displaystyle\mathbb{E}_{q\{o_{i}\}\sim\pi_{\theta_{\mathrm{old}}}}$ $\displaystyle\left[\frac{1}{G}\sum_{i=1}^{G}\frac{1}{|o_{i}|}\sum_{t=1}^{|o_{i}|}\big{(}\min\!\big{(}\rho_{i,t}\,\widehat{A}_{i,t},\,\operatorname{clip}(\rho_{i,t},\varepsilon)\,\widehat{A}_{i,t}\big{)}\big{)}\right]$ $\displaystyle-\beta\,\widehat{D}_{\mathrm{KL}}\!\left(\pi_{\theta}\,\|\,\pi_{\mathrm{ref}}\right),$ (9) $$

where $\varepsilon$ is the PPO clipping parameter and $\beta$ controls KL regularization to the reference policy $\pi_{\mathrm{ref}}$.

##### Unbiased per-token KL estimator

GRPO uses a per-token estimator of the forward KL:

$$ $\displaystyle\widehat{D}_{\mathrm{KL}}\!\left(\pi_{\theta}\|\pi_{\mathrm{ref}}\right)=$ $\displaystyle\mathbb{E}_{(q,o_{i,<t})\sim\pi_{\theta}}\left[\frac{\pi_{\mathrm{ref}}(o_{i,t}\mid q,o_{i,<t})}{\pi_{\theta}(o_{i,t}\mid q,o_{i,<t})}-\right.$ $\displaystyle\left.\log\frac{\pi_{\mathrm{ref}}(o_{i,t}\mid q,o_{i,<t})}{\pi_{\theta}(o_{i,t}\mid q,o_{i,<t})}-1\right].$ (10) $$

##### Outcome supervision

Let $r_{\phi}$ denote a reward scoring each output. For a fixed $q$, obtain rewards $r=\{r_{i}\}_{i=1}^{G}$, one per output $o_{i}$.
Compute the group mean and standard deviation

$$ $\mu_{r}=\frac{1}{G}\sum_{i=1}^{G}r_{i},\qquad\sigma_{r}=\operatorname{std}(r_{1},\dots,r_{G}).$ $$

Normalize each reward
$\tilde{r}_{i}=\frac{r_{i}-\mu_{r}}{\sigma_{r}}$,
and assign a constant advantage to all tokens in $o_{i}$:

$$ $\displaystyle\widehat{A}_{i,t}=\tilde{r}_{i},\qquad\forall\,t\in\{1,\dots,|o_{i}|\}.$ (11) $$

### B.2 Distribution Shift

For the sake of analytical simplicity, we disregard the clipping technique and the KL-divergence regularization term in GRPO. If we intend to employ data drawn from the mixture policy $\mu$ to optimize the target policy $\theta$, the unbiased gradient is given by:

$$ $\displaystyle\nabla_{\theta}J(\theta)=\mathbb{E}_{q,\{o_{i}\}\sim\mu}\!\!\left[\frac{1}{G}\sum_{i=1}^{G}\frac{1}{\lvert o_{i}\rvert}\sum_{t=1}^{\lvert o_{i}\rvert}\hat{A}_{i,t}\,\nabla_{\theta}\frac{\pi_{\theta}(o_{i,t}\mid q,o_{i,<t})}{\mu(o_{i,t}\mid q,o_{i,<t})}\right].$ (12) $$

If, instead, we apply no corrective procedure and directly use the data collected under the mixture policy $\mu$ to optimize $\theta$, the gradient we actually compute becomes:

$$ $\displaystyle\tilde{g}(\theta)=\mathbb{E}_{q,\{o_{i}\}\sim\mu}\!\!\left[\frac{1}{G}\sum_{i=1}^{G}\frac{1}{\lvert o_{i}\rvert}\sum_{t=1}^{\lvert o_{i}\rvert}\hat{A}_{i,t}\,\nabla_{\theta}\frac{\pi_{\theta}(o_{i,t}\mid q,o_{i,<t})}{\pi_{\theta_{\mathrm{old}}}(o_{i,t}\mid q,o_{i,<t})}\right].$ (13) $$

Subtracting the two importance ratios yields the bias:

$$ $\displaystyle\Delta_{i,t}$ $\displaystyle=\tilde{\rho}_{i,t}-\rho_{i,t}$ $\displaystyle=\frac{\pi_{\theta,i,t}}{\pi_{\theta_{\mathrm{old}},i,t}}-\frac{\pi_{\theta,i,t}}{\mu_{i,t}}$ $\displaystyle=\frac{\pi_{\theta,i,t}}{\mu_{i,t}}\cdot\left(\frac{\mu_{i,t}-\pi_{\theta_{\mathrm{old}},i,t}}{\mu_{i,t}}\right)$ $\displaystyle=\tilde{\rho}_{i,t}\left(1-\frac{\pi_{\theta_{\mathrm{old}},i,t}}{\mu_{i,t}}\right).$ (14) $$

In this expression, the first factor, $\tilde{\rho}_{i,t}$, is strictly positive and can therefore be ignored. Focusing on the sign of the second factor, we observe that for tokens generated freely by the model, $\mu$ comprises both $\pi_{\theta}$ and $\pi_{\epsilon}$, where $\pi_{\epsilon}$ is defined only along erroneous trajectories. Consequently, $\mu$ is smaller than $\pi_{\theta}$, rendering the second factor negative. Thus, for tokens sampled freely by the model, the importance ratio is biased downward, leading to systematic underestimation.

Conversely, for the segments inserted by the probe policy, the second factor is positive, conferring a systematic up-weighting. This persistent high weighting can drive the probabilities of tokens with negative advantages to decline rapidly, potentially pushing them outside the support of the policy model. Tokens with positive advantages, on the other hand, may experience rapid probability increases, thereby squeezing the probabilities of alternative tokens and inducing severe entropy collapse.

### B.3 Probe Policy Definition

For the Probe Policy, we partition the procedure into three components according to their ordering relative to the inserted prompt: (1) the segment of the model rollout up to the point of failure; (2) the inserted prompt; and (3) the subsequent trajectory obtained by conditioning on the erroneous reasoning path and the prompt as context.

$$ $\displaystyle\pi_{\varepsilon}$ $\displaystyle(o^{\prime}_{i,t}\mid q_{i},o^{\prime}_{i<t})=\begin{cases}\dfrac{\pi_{\theta}(o^{\prime}_{i,t}\mid q_{i},o^{\prime}_{i<t})}{z^{1/|o^{\prime}_{\mathrm{origin}}|}},&\text{if }o^{\prime}_{i,t}\in o^{\prime}_{\mathrm{origin}}\[11.99998pt] \mathrm{PMF}(o^{\prime}_{i<t},o^{\prime}_{i,t}),&\text{if }o^{\prime}_{i,t}\in o^{\prime}_{\mathrm{prompt}}\[11.99998pt] \pi_{\theta}(o^{\prime}_{i,t}\mid q_{i},o^{\prime}_{i<t}),&\text{if }o^{\prime}_{i,t}\in o^{\prime}_{\mathrm{probe}}\end{cases}\text{.}$ (15) $$

First, for the segment of the model rollout up to the point where an error occurs, our aim is to model the region of the original policy distribution that gives rise to failures. Within the set of all trajectories that can be sampled from the original distribution, we approximate this subset using $z$, defined as the fraction of erroneous trajectories among those sampled at the current step. This yields a distribution that is truncated relative to the original policy. To make this subset of trajectories a valid probability distribution—that is, to let “the probability mass of these trajectories fill the entire space”—we renormalize it. Accordingly, we divide the probability of each token by $z^{1/\lvert o^{\prime}_{\mathrm{origin}}\rvert}$ as a simple sequence-level normalization.

For the inserted prompt part, we define it based on the frequency distribution. The method induces a discrete vocabulary via a tokenizer and builds a nonparametric next-token model by aggregating, for each observed prefix $p$, the multiset of successor tokens from the corpus. Each prefix is mapped to a count vector over the vocabulary; the probability mass function is the normalized frequency. Conceptually, this is an unsmoothed, memory-based (variable-length $n$-gram) estimator that returns the empirical conditional distribution of the next token given $p$, assigning zero mass to unseen events. Specifically, the construction algorithm is as shown in Algorithm [1](https://arxiv.org/html/2508.08149v2#alg1).

For the last part, since we do not impose any restrictions on the sampling of these parts, we directly use the probability of the original policy model as the probability of the probe policy.

Figure: Algorithm 1 PMF Construction via Frequency Distribution

### B.4 Coefficient for Importance Sampling

Let the goal be to estimate the policy gradient using a mixed policy $\mu=\{\pi_{\theta},\pi_{\epsilon}\}$. During sampling, a fraction of $\frac{1}{1+\alpha}$ of the trajectories come from $\pi_{\theta}$, while a fraction of $\frac{\alpha}{1+\alpha}$ of the trajectories come from $\pi_{\epsilon}$:

$$ $\displaystyle c_{\theta}=\frac{1}{1+\alpha},\qquad c_{\epsilon}=\frac{\alpha}{1+\alpha}.$ (16) $$

Under the *balance heuristic* (Veach and Guibas [1995](https://arxiv.org/html/2508.08149v2#biba.bib18)), the weight is

$$ $\displaystyle\hat{\omega}_{i}(x)=\frac{c_{i}\,p_{i}(x)}{\sum_{j}c_{j}p_{j}(x)}.$ (17) $$

Substitute the variables into it respectively, and we can obtain the Importance ratio for estimating the policy gradient of Multiple Importance Sampling:

$$ $\displaystyle\omega=\frac{(1+\alpha)\,\pi_{\theta}}{\pi_{\theta}+\alpha\,\pi_{\varepsilon}}\text{.}$ (18) $$

## Appendix C Experimental Implementation Details

### C.1 Baseline Methods

We evaluate REX-RAG against two categories of baselines: (1) non-fine-tuned methods, including Naive RAG (Lewis et al. [2020](https://arxiv.org/html/2508.08149v2#biba.bib8)), IRCOT (Trivedi et al. [2023](https://arxiv.org/html/2508.08149v2#biba.bib17)), and Search-o1 (Li et al. [2025a](https://arxiv.org/html/2508.08149v2#biba.bib9)); and (2) fine-tuned methods, including R1-like (Guo et al. [2025](https://arxiv.org/html/2508.08149v2#biba.bib1)) trained with PPO (Jin et al. [2025b](https://arxiv.org/html/2508.08149v2#biba.bib3)) (with and without retrieval) using GRPO (Shao et al. [2024](https://arxiv.org/html/2508.08149v2#biba.bib13)).

Naive RAG (Lewis et al. [2020](https://arxiv.org/html/2508.08149v2#biba.bib8)) is the standard retrieval-augmented generation approach that retrieves documents using dense passage retrieval and generates answers conditioned on both the query and the retrieved context. It employs a bi-encoder architecture and marginalizes over retrieved documents during generation, enabling dynamic access to external knowledge and reducing hallucination in knowledge-intensive tasks.

IRCOT (Trivedi et al. [2023](https://arxiv.org/html/2508.08149v2#biba.bib17)) interleaves reasoning and retrieval steps, alternating between generating intermediate reasoning steps and retrieving new information. This few-shot prompting approach enables step-wise information gathering and supports multi-hop reasoning by refining retrieval based on the evolving reasoning chain.

Search-o1 (Li et al. [2025a](https://arxiv.org/html/2508.08149v2#biba.bib9)) enhances LLM reasoning by integrating web search. It uses multi-step reasoning to analyze queries, formulate searches, and synthesize results. Iterative search-query reformulation and result ranking improve retrieval quality. The approach relies on chain-of-thought reasoning to generate comprehensive answers using diverse sources.

R1-like Training (Guo et al. [2025](https://arxiv.org/html/2508.08149v2#biba.bib1)) employs RLHF via PPO to fine-tune LLMs for reasoning tasks without retrieval. Following DeepSeek-R1, it includes supervised reasoning trace training, reward modeling, and PPO optimization. This pipeline enhances reasoning quality using curated datasets and human feedback, serving as a strong non-retrieval baseline.

Search-R1 (Jin et al. [2025b](https://arxiv.org/html/2508.08149v2#biba.bib3)) extends R1-style training by integrating retrieval actions into the policy optimization process using GRPO. It jointly optimizes reasoning and retrieval quality, with rewards based on final answer accuracy and coherence. Retrieval is treated as part of the trajectory, allowing the model to learn effective information-seeking strategies. This serves as a strong prior baseline for evaluating the improvements brought by our proposed policy realignment mechanisms.

### C.2 Dataset Descriptions

We evaluate REX-RAG on seven QA benchmarks: three general QA datasets NQ (Kwiatkowski et al. [2019](https://arxiv.org/html/2508.08149v2#biba.bib7)), TrivialQA (Joshi et al. [2017](https://arxiv.org/html/2508.08149v2#biba.bib5)), and PopQA (Mallen et al. 2023), together with four Multi-Hop QA datasets HotpotQA (Yang et al. [2018](https://arxiv.org/html/2508.08149v2#biba.bib20)), 2WikiMultiHopQA (Ho et al. [2020](https://arxiv.org/html/2508.08149v2#biba.bib2)), Musique (Trivedi et al. [2022](https://arxiv.org/html/2508.08149v2#biba.bib16)), and Bamboogle (Press et al. [2023](https://arxiv.org/html/2508.08149v2#biba.bib11)). In line with earlier studies (Jin et al. [2025b](https://arxiv.org/html/2508.08149v2#biba.bib3), a), we merge the NQ and HotpotQA training sets for REX‑RAG training. The test splits of NQ and HotpotQA are treated as in‑domain evaluations, and the remaining five datasets are used for out‑of‑domain evaluation.

Natural Questions (NQ) (Kwiatkowski et al. [2019](https://arxiv.org/html/2508.08149v2#biba.bib7)) is a large-scale dataset featuring real Google Search queries paired with Wikipedia passages containing the answers. It includes over 300K naturally occurring questions, each annotated with both a long answer (usually a paragraph) and a short answer (typically a phrase). NQ reflects realistic information-seeking behavior across diverse topics such as history, science, and current events, with varying complexity. We use it as an in-domain benchmark, as it contributes to REX-RAG’s training.

TriviaQA (Joshi et al. [2017](https://arxiv.org/html/2508.08149v2#biba.bib5)) is a reading comprehension dataset containing over 95K question-answer pairs sourced from trivia websites and paired with evidence documents from Wikipedia and the web. Not all documents are guaranteed to contain the answer, requiring models to perform effective retrieval. The questions emphasize factual knowledge, making the dataset ideal for evaluating retrieval-augmented systems.

PopQA (Mallen et al. 2023) targets popular factual questions about widely known topics such as celebrities, movies, and sports events. It evaluates models’ ability to answer questions about current and trending topics that may not appear in training corpora, highlighting the importance of real-time retrieval for up-to-date knowledge.

HotpotQA (Yang et al. [2018](https://arxiv.org/html/2508.08149v2#biba.bib20)) is a multi-hop QA dataset with over 113K Wikipedia-based examples, where each question requires reasoning across at least two paragraphs. It includes bridge and comparison questions and provides supporting facts. As an in-domain benchmark, it plays a key role in evaluating REX-RAG’s multi-hop reasoning performance.

2WikiMultiHopQA (Ho et al. [2020](https://arxiv.org/html/2508.08149v2#biba.bib2)) extends multi-hop QA by requiring reasoning over two Wikipedia articles using varied operations like numerical, logical, and compositional reasoning. Each question involves exactly two hops and is annotated with reasoning paths and supporting evidence, facilitating fine-grained evaluation of multi-step reasoning.

MuSiQue (Trivedi et al. [2022](https://arxiv.org/html/2508.08149v2#biba.bib16)) focuses on compositional multi-hop reasoning across multiple documents. Questions often involve temporal or relational reasoning and require synthesizing scattered information. It includes both answerable and unanswerable questions, testing models’ ability to detect insufficient context.

Bamboogle (Press et al. [2023](https://arxiv.org/html/2508.08149v2#biba.bib11)) is a challenging multi-hop QA benchmark designed to stress-test reasoning capabilities. Questions involve complex inference steps, including temporal and causal reasoning, often under ambiguous or incomplete information. It highlights the limitations of current QA systems and the need for more advanced reasoning strategies.

### C.3 Computational Environment and Infrastructure

All experiments in this study were conducted on a cluster of 8 NVIDIA A800 80GB GPUs, providing the computational resources necessary for large-scale reinforcement learning training and evaluation of retrieval-augmented generation systems.

Reinforcement Learning Framework. We implemented our REX-RAG training pipeline using VERL (Sheng et al. [2024](https://arxiv.org/html/2508.08149v2#biba.bib14)), an open-source distributed reinforcement learning framework developed by ByteDance for efficient large language model training. VERL is specifically designed to handle the computational challenges of RLHF at scale, providing optimized implementations of policy optimization algorithms such as PPO and GRPO.

Retrieval Infrastructure. Our retrieval system is built upon FAISS (Facebook AI Similarity Search) (Johnson, Douze, and Jégou [2019](https://arxiv.org/html/2508.08149v2#biba.bib4)) for efficient similarity search and indexing. We employ the E5 embedding model (Wang et al. [2022](https://arxiv.org/html/2508.08149v2#biba.bib19)) to encode both queries and documents into dense vector representations, enabling semantic similarity matching for retrieval operations. The knowledge base consists of Wikipedia passages from the DPR corpus (Karpukhin et al. [2020](https://arxiv.org/html/2508.08149v2#biba.bib6)), specifically the Wiki-18 dataset. The entire retrieval system is deployed using FastAPI.

Data Processing and Evaluation Pipeline. For data preprocessing, evaluation metrics computation, and baseline comparisons, we adopted the experimental framework from Search-R1 (Jin et al. [2025b](https://arxiv.org/html/2508.08149v2#biba.bib3)). This includes standardized data loading procedures, question-answer pair formatting, retrieval corpus preparation, and evaluation protocols that ensure fair comparison across different methods. The Search-R1 framework provides implementations for computing exact match accuracy for multi-hop reasoning evaluation.

Prompt Generation and Template Management. We utilized GPT-4.5 for generating high-quality prompts and reasoning templates used throughout our experiments. This mainly includes the generation of exploration prompts for policy training, as shown in Appendix [F](https://arxiv.org/html/2508.08149v2#A6).

### C.4 Hyper-parameter Configuration and Tuning

Our hyperparameter configuration strategy primarily focused on tuning algorithm-agnostic parameters that optimize GPU computational performance, particularly those related to macro batch size and GPU utilization settings. This approach ensures efficient resource utilization while maintaining training stability. For all other hyperparameters not directly related to computational performance, we maintained consistency with the Search R1 baseline configuration to ensure fair comparison and reproducibility.
Table [7](https://arxiv.org/html/2508.08149v2#A3.T7) presents the key hyperparameters used in our REX-RAG implementation.

**Table 7: Primary hyperparameters used by REX-RAG. Performance-related parameters were tuned for optimal GPU utilization, while other parameters follow Search R1 baseline configuration.**
| Category | Hyperparameter | Value |
| --- | --- | --- |
| Performance | Training Batch Size | 512 |
| Mini Batch Size | 256 |  |
| Max Token Length | 24,000 |  |
| GPU Memory Utilization | 0.8 |  |
| Max Batched Tokens | 8,192 |  |
| Max Sequences per Batch | 1,024 |  |
| Training | Actor Learning Rate | $1\times 10^{-6}$ |
| Warmup Steps Ratio | 0.285 |  |
| Weight Decay | 0.01 |  |
| PPO Epochs | 1 |  |
| Policy | Clip Ratio | 0.2 |
| KL Coefficient | 0.001 |  |
| Use Dynamic Batch Size | True |  |
| Generation | Max Search Turns | 5 |
| Response Length | 500 |  |
| Temperature | 1.0 |  |
| Top-p Value | 1.0 |  |

Figure: Figure 5: Complete prompt template and example interaction for the structured search protocol

The performance-oriented hyperparameters in the first category were specifically tuned to optimize computational efficiency on our hardware configuration. The training batch size of 512 and PPO mini batch size of 256 were selected to maximize throughput while maintaining gradient stability. The GPU memory utilization of 0.8 ensures efficient memory usage without risking out-of-memory errors during training. The token length and sequence limits were configured to balance between accommodating longer reasoning chains and maintaining computational feasibility.

To support deeper reasoning and allow recovery from failed attempts, we increased the Max Search Turns from 2 (as used in Search-R1) to 5. This extension enables the model to conduct further retrieval after initial errors, which is essential for our exploration-driven method. Notably, we kept the overall maximum token budget unchanged, ensuring that this change does not introduce significant additional computational overhead.

All remaining hyperparameters, including learning rates, regularization coefficients, and generation parameters, were kept consistent with the Search-R1 baseline to ensure that performance improvements can be attributed to our proposed REX-RAG methodology rather than hyperparameter optimization advantages.

**Table 8: Complete collection of revision prompts used in REX-RAG for triggering self-reflection during reasoning**
| ID | Revision Prompt Text | ID | Revision Prompt Text |
| --- | --- | --- | --- |
| 0 | <think> Perhaps I’ve overlooked critical points or slipped up in my logic. | 15 | <think> Concerned I might have overlooked key aspects or made subtle errors. |
| 1 | <think> I wonder if vital information escaped my notice or if I made an error. | 16 | <think> I might have unintentionally ignored essential details or misunderstood something. |
| 2 | <think> There might be key gaps in my understanding or errors in reasoning. | 17 | <think> Revisiting carefully, perhaps errors or oversights went unnoticed earlier. |
| 3 | <think> It’s possible I’ve missed something important or misunderstood crucial details. | 18 | <think> Maybe important points slipped my attention, or I made a miscalculation. |
| 4 | <think> I suspect errors crept in, or essential points went unnoticed. | 19 | <think> It’s likely I’ve overlooked something crucial or stumbled in logic. |
| 5 | <think> Maybe I’ve misjudged something important or neglected key facts. | 20 | <think> Reflecting, I could’ve missed critical clues or made errors in judgment. |
| 6 | <think> Reflecting now, I might have overlooked critical data or erred somewhere. | 21 | <think> Possibly, I misunderstood something fundamental or missed key evidence. |
| 7 | <think> Possibly, I’ve missed significant insights or made a mistake. | 22 | <think> Concerned about potential unnoticed mistakes or overlooked essential details. |
| 8 | <think> I’m sensing a gap or error might be present in my recent reasoning. | 23 | <think> Perhaps my earlier step wasn’t entirely accurate or lacked vital points. |
| 9 | <think> I could have misinterpreted important facts or overlooked necessary details. | 24 | <think> It’s conceivable that I’ve neglected critical information or erred. |
| 10 | <think> Aware that my reasoning might be flawed or lacking crucial points. | 25 | <think> Wondering if I’ve mistakenly dismissed something important or misunderstood it. |
| 11 | <think> I need to reconsider—I might’ve skipped vital information or erred. | 26 | <think> Maybe my previous reasoning has blind spots or unnoticed errors. |
| 12 | <think> There’s a chance my previous thinking has unnoticed mistakes or omissions. | 27 | <think> I’m doubting if crucial points were missed or mistakes made earlier. |
| 13 | <think> I feel there might be something critical I overlooked or misunderstood. | 28 | <think> Feeling uncertain—perhaps critical details slipped past or were misunderstood. |
| 14 | <think> Perhaps my earlier reasoning has hidden mistakes or missing information. | 29 | <think> Recognizing possible gaps or missteps I didn’t previously notice. |

## Appendix D Limitations, Discussion, and Future Work

##### Limited Exploration Strategy

Our current exploration mechanism relies on a relatively simple strategy—injecting prompts from a pre-constructed prompt pool to guide the model toward alternative reasoning paths. While effective, this approach may fall short of the full potential of more sophisticated exploration techniques. From the prompt perspective, online generation of exploration prompts conditioned on the model’s current reasoning state may offer greater adaptivity and contextual relevance than our static prompt set. From the policy perspective, incorporating more structured search procedures, such as backtracking trees or trajectory-level search algorithms, could enable more systematic exploration across the reasoning space. Moreover, our method emphasizes local trajectory perturbation via prompt insertion, rather than global restructuring of the reasoning path. Despite these limitations, our results demonstrate that end-to-end optimization under an exploratory policy is both feasible and beneficial, laying the groundwork for future work on more principled and expressive exploration strategies.

##### Computational Overhead and Adaptive Sampling Limitations

The mixed sampling strategy inherently introduces computational overhead compared to standard policy optimization approaches. Our resampling mechanism requires a two-stage process: first performing normal sampling to assess question difficulty through initial trajectory evaluation, then conducting exploratory sampling based on the observed failure rates. This sequential approach increases computational complexity as it necessitates generating $(1-\alpha)G$ additional exploratory trajectories from the probe policy $\pi_{\varepsilon}$, resulting in approximately 12% more trajectory sampling in our experiments. While this overhead is substantially more efficient than uniform oversampling approaches (which require 20% additional trajectories for minimal gains), the computational cost scales linearly with the resampling parameter $p$ and the exploration ratio $\alpha$. A more efficient approach would involve predicting question difficulty a priori and automatically adjusting sampling quantities accordingly, eliminating the need for the initial sampling phase. However, developing reliable difficulty prediction mechanisms remains an open challenge. Furthermore, the policy realignment mechanism requires computing importance sampling ratios for each token, adding non-negligible computational complexity during training.

##### Lack of Validation in Broader Agentic Tasks

While REX-RAG demonstrates consistent improvements across seven open-domain question answering datasets, its effectiveness has only been validated within the RAG (retrieval-augmented generation) framework. Our method specifically targets reasoning-intensive QA tasks where external information retrieval and multi-turn reasoning are tightly coupled. As such, it remains unclear whether the proposed exploration and policy realignment strategies generalize to broader agentic scenarios—such as tool use, web navigation, or embodied planning—where action spaces, environmental feedback, and task dynamics differ substantially. Extending our framework to these settings would require adapting both the structured interaction protocol and the rollout mechanism to accommodate more complex state-action transitions. Future work may explore the applicability of REX-RAG’s core ideas beyond QA, investigating how exploration with distribution correction can benefit general-purpose decision-making agents.

## Appendix E Structured Search Interaction Protocol

The structured search interaction protocol employed in REX-RAG follows the framework established by Search-R1 (Jin et al. [2025b](https://arxiv.org/html/2508.08149v2#biba.bib3)), which defines a systematic approach for integrating reasoning and retrieval operations through specialized tokens and prompt templates. The structured interaction protocol relies on four primary special tokens that delineate different phases of the reasoning and retrieval process:

### E.1 Special Tokens

<think> and </think> encapsulate the model’s internal reasoning process, allowing it to engage in chain-of-thought reasoning without external interference. Within these tags, the model can perform logical deduction, analyze given information, identify knowledge gaps, and plan subsequent actions. This internal reasoning phase is crucial for determining when external retrieval is necessary and formulating appropriate search queries.

<search> and </search> trigger external information retrieval operations. When the model generates these tokens, the content within them is interpreted as a search query that is executed against the external knowledge base. This mechanism allows for dynamic knowledge acquisition during the reasoning process.

<information> and </information> contain the retrieved external knowledge that is returned by the search engine in response to search queries. This mechanism allows for dynamic knowledge acquisition during the reasoning process.

<information> and </information> contain the retrieved external knowledge that is returned by the search engine in response to search queries. The content within these tags represents the top search results that are automatically inserted into the model’s context after a search operation. This information serves as additional context that the model can analyze and incorporate into itse content within these tags represents the top search results that are automatically inserted into the model’s context after a search operation. This information serves as additional context that the model can analyze and incorporate into its reasoning process.

These special tokens serve multiple purposes: they provide clear demarcation between different operational phases, enable selective training on specific components of the reasoning process, and facilitate systematic evaluation of reasoning quality versus retrieval effectiveness.

<answer> and </answer> mark the final response generation phase, where the model synthesizes information from both its internal reasoning and retrieved external knowledge to produce a comprehensive answer. The content within these tags represents the model’s final output, incorporating insights gained througning and retrieval process.

These special tokens serve multiple purposes: they provide clear demarcation between different operational phases, enable selective training on specific components of the reasoning process, and facilitate systematic evaluation of reasoning quality versus retrieval effectiveness.

### E.2 System Prompt

The system prompt template structure orchestrates the interaction between reasoning and retrieval components through a carefully designed format that guides the model’s behavior throughout the question-answering process. The template follows a think-search-answer paradigm that promotes systematic problem-solving. The entire prompt template is demonstrated in Fig. [5](https://arxiv.org/html/2508.08149v2#A3.F5).

## Appendix F Prompt Templates and Examples

The revision prompts are formulated to express uncertainty and encourage critical self-evaluation without being overly prescriptive. Each prompt is designed to maintain the model’s natural reasoning flow while introducing a reflective pause that can lead to error correction and improved reasoning quality.

The Table [8](https://arxiv.org/html/2508.08149v2#A3.T8) presents all 30 revision prompts used in our implementation. These prompts are randomly selected during training to provide diverse expressions of self-doubt and reflection.

## References

- Guo et al. (2025)
Guo, D.; Yang, D.; Zhang, H.; Song, J.; Zhang, R.; Xu, R.; Zhu, Q.; Ma, S.; Wang, P.; Bi, X.; et al. 2025.
Deepseek-r1: Incentivizing reasoning capability in llms via reinforcement learning.
*arXiv preprint arXiv:2501.12948*.
- Ho et al. (2020)
Ho, X.; Duong Nguyen, A.-K.; Sugawara, S.; and Aizawa, A. 2020.
Constructing A Multi-hop QA Dataset for Comprehensive Evaluation of Reasoning Steps.
In *Proceedings of the 28th International Conference on Computational Linguistics*, 6609–6625. International Committee on Computational Linguistics.
- Jin et al. (2025b)
Jin, B.; Zeng, H.; Yue, Z.; Yoon, J.; Arik, S.; Wang, D.; Zamani, H.; and Han, J. 2025b.
Search-r1: Training llms to reason and leverage search engines with reinforcement learning.
*arXiv preprint arXiv:2503.09516*.
- Johnson, Douze, and Jégou (2019)
Johnson, J.; Douze, M.; and Jégou, H. 2019.
Billion-scale similarity search with GPUs.
*IEEE Transactions on Big Data*, 7(3): 535–547.
- Joshi et al. (2017)
Joshi, M.; Choi, E.; Weld, D. S.; and Zettlemoyer, L. 2017.
TriviaQA: A Large Scale Distantly Supervised Challenge Dataset for Reading Comprehension.
In *Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics*, 1601–1611.
- Karpukhin et al. (2020)
Karpukhin, V.; Oguz, B.; Min, S.; Lewis, P.; Wu, L.; Edunov, S.; Chen, D.; and Yih, W.-t. 2020.
Dense Passage Retrieval for Open-Domain Question Answering.
In Webber, B.; Cohn, T.; He, Y.; and Liu, Y., eds., *Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing*, 6769–6781. Association for Computational Linguistics.
- Kwiatkowski et al. (2019)
Kwiatkowski, T.; Palomaki, J.; Redfield, O.; Collins, M.; Parikh, A.; Alberti, C.; Epstein, D.; Polosukhin, I.; Devlin, J.; Lee, K.; et al. 2019.
Natural questions: a benchmark for question answering research.
*Transactions of the Association for Computational Linguistics*, 7: 453–466.
- Lewis et al. (2020)
Lewis, P.; Perez, E.; Piktus, A.; Petroni, F.; Karpukhin, V.; Goyal, N.; Küttler, H.; Lewis, M.; Yih, W.-t.; Rocktäschel, T.; Riedel, S.; and Kiela, D. 2020.
Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks.
In Larochelle, H.; Ranzato, M.; Hadsell, R.; Balcan, M.; and Lin, H., eds., *Advances in Neural Information Processing Systems*, volume 33, 9459–9474. Curran Associates, Inc.
- Li et al. (2025a)
Li, X.; Dong, G.; Jin, J.; Zhang, Y.; Zhou, Y.; Zhu, Y.; Zhang, P.; and Dou, Z. 2025a.
Search-o1: Agentic search-enhanced large reasoning models.
*arXiv preprint arXiv:2501.05366*.
- OpenAI (2025)
OpenAI. 2025.
Introducing GPT-4.5.
https://openai.com/index/introducing-gpt-4-5/.
- Press et al. (2023)
Press, O.; Zhang, M.; Min, S.; Schmidt, L.; Smith, N. A.; and Lewis, M. 2023.
Measuring and Narrowing the Compositionality Gap in Language Models.
In *Findings of the Association for Computational Linguistics: EMNLP 2023*, 5687–5711.
- Schulman et al. (2017)
Schulman, J.; Wolski, F.; Dhariwal, P.; Radford, A.; and Klimov, O. 2017.
Proximal policy optimization algorithms.
*arXiv preprint arXiv:1707.06347*.
- Shao et al. (2024)
Shao, Z.; Wang, P.; Zhu, Q.; Xu, R.; Song, J.; Bi, X.; Zhang, H.; Zhang, M.; Li, Y.; Wu, Y.; et al. 2024.
Deepseekmath: Pushing the limits of mathematical reasoning in open language models.
*arXiv preprint arXiv:2402.03300*.
- Sheng et al. (2024)
Sheng, G.; Zhang, C.; Ye, Z.; Wu, X.; Zhang, W.; Zhang, R.; Peng, Y.; Lin, H.; and Wu, C. 2024.
HybridFlow: A Flexible and Efficient RLHF Framework.
*arXiv preprint arXiv: 2409.19256*.
- Team (2024)
Team, Q. 2024.
Qwen2.5: A Party of Foundation Models.
- Trivedi et al. (2022)
Trivedi, H.; Balasubramanian, N.; Khot, T.; and Sabharwal, A. 2022.
MuSiQue: Multihop Questions via Single-hop Question Composition.
*Transactions of the Association for Computational Linguistics*, 10: 539–554.
- Trivedi et al. (2023)
Trivedi, H.; Balasubramanian, N.; Khot, T.; and Sabharwal, A. 2023.
Interleaving Retrieval with Chain-of-Thought Reasoning for Knowledge-Intensive Multi-Step Questions.
In *Proceedings of the 61st Annual Meeting of the Association for Computational Linguistics*, 10014–10037.
- Veach and Guibas (1995)
Veach, E.; and Guibas, L. J. 1995.
Optimally combining sampling techniques for Monte Carlo rendering.
In *Proceedings of the 22nd annual conference on Computer graphics and interactive techniques*, 419–428.
- Wang et al. (2022)
Wang, L.; Yang, N.; Huang, X.; Jiao, B.; Yang, L.; Jiang, D.; Majumder, R.; and Wei, F. 2022.
Text embeddings by weakly-supervised contrastive pre-training.
*arXiv preprint arXiv:2212.03533*.
- Yang et al. (2018)
Yang, Z.; Qi, P.; Zhang, S.; Bengio, Y.; Cohen, W.; Salakhutdinov, R.; and Manning, C. D. 2018.
HotpotQA: A Dataset for Diverse, Explainable Multi-hop Question Answering.
In *Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing*, 2369–2380.
- Yu et al. (2025)
Yu, Q.; Zhang, Z.; Zhu, R.; Yuan, Y.; Zuo, X.; Yue, Y.; Dai, W.; Fan, T.; Liu, G.; Liu, L.; et al. 2025.
Dapo: An open-source llm reinforcement learning system at scale.
*arXiv preprint arXiv:2503.14476*.

## Peer Reviews

confidence: 4
contribution: 2
initial_rating: 2
presentation: 2
questions: 1. For the exploration prompt sampled from a curated prompt pool, are these tokens masked out in policy update or are they also included in training as in Eq. 5-7?

2. Can you provide more dataset-specific results with DAPO on Search-R1 and REX-RAG?
soundness: 3
strengths: 1. The authors study an important problem of dead end in RL-based RAG settings, where the policy is often unable to generate correct reasoning paths for complex input queries.

2. The authors introduces effective techniques to improve the training dynamics on the rollouts and additional correction continuations by the probe policy.

3. REX-RAG shows strong performance on open-domain QA datasets, suggesting the model learns improved reasoning patterns for multi-turn search LLMs.
summary: This paper introduces REX-RAG, a retrieval augmented generation framework to address the dead end problem in RL-based RAG training. That is, when RL rollouts results in incorrect reasoning paths but the policy is unable to self-correct. The proposed REX-RAG consists of (1) a sixed sampling strategy that uses a so-called "probe sampling" to help the model increase rollout sample size to avoid dead ends; and (2) policy correction learning that introduces techniques such as trajectory filtering and multiple importance sampling to stabilize RL training with the introduced rollouts & additional corrections introduced by REX-RAG. The authors evaluate the proposed method on several QA benchmarks, where REX-RAG achieved consistent improvements over RL-based RAG baselines.
weaknesses: 1. The entire exploration and correction mechanism is training-only, as it relies on ground truth labels (rather than learning a verifier) to identify dead ends and trigger exploration. Therefore in inference, these mechanisms are deactivated and the model cannot really correct itself if it heads down to incorrect reasoning paths.

2. The exploration & additional sampling introduces extra computation overhead during the training phase, which may be potentially unfair to baselines like Search-R1 which adopts fixed group size in training. Although the authors provide additional results with over-sampling using DAPO, these results are inconsistent (Search-R1 outperforms REX-RAG) and does have dataset-specific results.

3. Some technical details are missing in writing. For example, although I can image how these are computed, the authors should provide a formula to show how PMF is computed in Eq. 5.

---

confidence: 4
contribution: 3
initial_rating: 4
presentation: 2
questions: What happens if you assign the same exploration budget (n) to the policy model of search-r1? Would it still downperform your model? Or in other words, I would like to see how your model performs if it can only sample (including exploratory sampling) the same as search-r1? Would that affect your findings?
soundness: 2
strengths: The proposed method seems sound and effective based on the reported results, which makes it convincing that this approach is useful for training policies that better interact with search engines (or tools). Additionally, the experiment setup is very comprehensive and is accompanied by a good set of ablations that clarify the effectiveness of each component in the system.
summary: This paper investigates the dead-end problem in RAG systems trained with RL, where the model often gets stuck in incorrect reasoning paths and fails to explore new directions. To overcome this, the authors propose REX-RAG, a framework that introduces a Mixed Sampling Strategy to inject exploratory prompts and guide the model toward more diverse reasoning trajectories. However, such exploration may cause distributional shifts that make RL training unstable, so a Policy Correction Mechanism is further designed to re-weight the exploratory data using trajectory filtering and multiple importance sampling, keeping the optimization process stable and unbiased. Experiments on several question-answering benchmarks show that this approach brings consistent performance gains, and ablation results confirm the importance of the correction mechanism for effective exploration.
weaknesses: The proposed method is significantly more expensive than the baselines, specifically the most similar baseline, search-r1. It is not clear for me the improvements observed here are from the increased number of sampling during training or because of the sampling strategy. We know that number of rollouts in the training can significantly increase the compute budget of training and improving performance. I am curios to  see if this method still performs better than search-r1 if it uses the same number of rollouts (including initial and exploratory rollouts).

---

confidence: 5
contribution: 4
initial_rating: 4
presentation: 3
questions: ### Questions for the Authors

- Regarding the definition of *dead ends*: besides trajectories that end with `<answer> ... </answer>`, are there other types of dead-end trajectories considered?  

- There is confusion between the *current policy* and the *probe policy*. Does the probe policy $\pi_\epsilon$ share the same parameters as $\pi_\theta$ (only using different prompts), or are they two separate models with distinct parameters?  

- For the probe policy, after identifying a dead end, are the subsequent rollouts — including reasoning, search, and answer generation — produced by $\pi_\epsilon$?  

- What is the exact training procedure? Are $\pi_\theta$ and $\pi_\epsilon$ trained jointly, or is $\pi_\theta$ first warmed up and then used to train the probe policy?  

- Equation (5) defining the probe policy is difficult to interpret. Could the authors provide more explanation for this formulation, particularly why the denominator involves $z^{\frac{1}{|o'_{\text{origin}}|}}$ when $o'_{i,t} \in o'_{\text{origin}}$? What is the intuition behind this design?  

- In the ablation study, what exactly is *coarse-PPD*? A one-sentence description is insufficient to understand the difference — please clarify what it looks like in detail.  

- It would be helpful to include more **case studies** comparing the behaviors of Search-R1 and the proposed model, to better illustrate their differences.  

- During the reflection process, how many new search actions are typically performed?
soundness: 4
strengths: - The paper presents an interesting and well-written idea.

- It addresses a compelling question in agentic reinforcement learning: how can we enable LLMs to learn to reflect, or more generally, when introducing an external policy (e.g., for reflection), how can we ensure the policy we want to learn remains on-policy? The paper provides reasonable and well-motivated solutions, including (1) filtering and (2) distribution realignment.

- The experimental evaluation is comprehensive and thoughtfully designed, effectively exploring several important questions related to the framework’s design choices.
summary: Overall, the paper is interesting and presents a novel idea. It proposes an agentic RL framework that teaches an LLM how to reflect and improve upon its own reasoning. The method leverages a probe policy that, given a trajectory leading to a dead end, generates a new trajectory with reflective reasoning to potentially correct the original mistake. The idea is original, and the overall modeling and writing are clear and well-structured.

However, the main issue is that the authors appear to have omitted the appendix from the submission, which is a serious oversight. This omission makes it difficult to fully understand the paper, particularly regarding several important implementation details.

In summary, I find the paper promising and would be inclined to raise my score to acceptance if the authors can provide the missing appendix and clarify the implementation details during the rebuttal period.
weaknesses: - The appendix pages are missing, which makes it difficult to fully understand several key parts of the work.

- The training process is somewhat complicated and not clearly explained, leading to confusion. For example, it is unclear what the complete training pipeline looks like — whether the two policies are trained jointly or sequentially, and whether they share parameters. 

- The ambiguity in describing the training procedure, along with the complexity of the overall training pipeline, makes it difficult to reproduce or fully evaluate the proposed method.

---

confidence: 3
contribution: 2
initial_rating: 6
presentation: 3
questions: 1. Why does this work focus solely on the RAG problem? The overall pipeline appears to be general and potentially applicable to a broader range of tasks.

2. Please provide the clear distinction with existing self-reflection works (especially those using self-reflection in training).

3. Please provide the ablation study results of the full pipeline.
soundness: 3
strengths: 1. The paper is well-motivated, clearly identifying a key limitation of existing self-reflection methods and proposing a principled approach to address it.

2. The paper is clearly written and easy to follow, with well-structured explanations of both intuition and methodology.
summary: During reinforcement learning (RL) training, “dead ends” — consistently failing trajectories — often occur. Simple self-reflection does not effectively address this issue, as it tends to only slightly perturb the original path without resolving the underlying problem. To mitigate this, the proposed method introduces several design considerations. First, it employs a mixed sampling strategy, which samples from both the current policy and a probe policy. Second, it includes a policy correction mechanism to account for the distribution shift introduced by exploration.
weaknesses: 1. It is unclear whether the prompts used in “Construction of the Probe Policy” were also used as the prompts for the self-reflection baseline shown in Figure 1. Additionally, does the self-reflection baseline involve training with self-reflected responses, or is it only evaluated with self-reflected responses without training? This distinction is important because the main difference between the proposed mixed sampling strategy and prior self-reflection approaches is not entirely clear. Some previous works also correct answers using self-reflection and incorporate these corrected responses during training. Alternatively, is this work applying self-reflection in parallel to the sampled generations within GRPO? This needs to be clarified in the paper.

2. The experimental section lacks a comparison with existing self-reflection baselines, which are necessary to contextualize the improvements.

3. The ablation study only investigates components within the policy correction mechanism. It should also include an ablation study evaluating the contribution of the mixed sampling strategy.


Decision: Reject