RDR2: Structure-Aware Retrieval

• Retrieve-DocumentRoute-Read (RDR2) is a retrieval system that separates evidence acquisition into a three-stage pipeline using a structured document tree.
• It incorporates an explicit DocumentRoute stage with LLM-based actions such as answer selection, section expansion, and refusal to enhance evidence quality.
• RDR2 optimizes retrieval effectiveness and efficiency by leveraging document structure awareness to guide downstream reading and answer extraction.

Retrieve-DocumentRoute-Read (RDR2) is a retrieval-centered architecture in which evidence acquisition is separated into three stages: initial retrieval, an explicit routing step over documents or document-derived units, and a final reading or generation stage. In the explicit formulation introduced in "Equipping Retrieval-Augmented LLMs with Document Structure Awareness" (Xu et al., 5 Oct 2025), RDR2 treats document structure as a first-class object and uses an LLM-based router to navigate a Document Structure Tree (DST) with actions such as answer selection, section expansion, and refusal. In the broader literature, the same pattern is retrospectively realized by systems that route paragraphs, segments, spans, sentences, repositories, or retrievers before final answer extraction or verification, including unified multi-document question answering, interpretable fact verification, dynamic multi-hop retrieval, and structure-aware agentic search (Hu et al., 2019, Hu et al., 2023).

1. Definition and historical framing

RDR2 arose as a response to a recurring limitation of standard retrieve-and-read pipelines: they usually retrieve top-$k$ passages and feed them to a reader in rank order, treating text as a flat collection of chunks rather than as an organized object with headings, sections, sibling relations, or document identities. The explicit RDR2 formulation states that this flat regime causes loss of navigational priors, disruption of document sequence, and poor query-adaptive selection, especially when relevant evidence is distributed unevenly across structured documents (Xu et al., 5 Oct 2025).

The distinctive element is the middle stage, "DocumentRoute." Unlike ordinary reranking, DocumentRoute is not restricted to sorting already retrieved chunks by a scalar relevance score. It is a decision layer that determines which document path, section, span, sentence subset, repository, or retriever should be exposed to the reader. In the 2025 RDR2 paper, the router operates over a DST whose nodes are structure nodes and content nodes, and it updates a Retrieval SubTree rather than a flat list of chunks (Xu et al., 5 Oct 2025). In earlier work, analogous behavior appears in RE$^3$QA, where routing occurs first by selecting top-$N$ segments and then by reranking routed answer spans, and in ReRead, where sentence-level evidence selection mediates between document retrieval and claim verification (Hu et al., 2019, Hu et al., 2023).

This suggests that RDR2 is best understood as a family of routing-centered retrieval systems rather than a single model class. Its common commitment is that retrieval should not terminate at nearest-neighbor lookup. Evidence must be routed through a policy that reflects structure, utility, redundancy, or faithfulness before reading begins.

2. Canonical pipeline and formal structure

In the explicit structure-aware formulation, the Retrieve stage begins with a conventional retriever over a datastore $D$:

$$\{\langle c_{re}^{(i)}, d_i\rangle\}_{i=1..k} = \mathrm{Retriever}(q, D).$$

The retrieved chunks anchor subsequent routing, but they do not define the final evidence set (Xu et al., 5 Oct 2025).

For each retrieved document $d_i$, RDR2 constructs a Document Structure Tree. Nodes are represented as $\langle id, text, \tau, parent, C\rangle$, where $\tau \in \{\text{structure}, \text{content}\}$, the root is a structure node, and edges encode parent-child relations plus ordered siblings (Xu et al., 5 Oct 2025). The router then acts on a routing state $s_t$, which is a serialized view of the current Retrieval SubTree. At each step it emits discrete actions:

$$\{\langle a_j^{(t)}, p_j^{(t)}\rangle\}_{j=1..n_t} = \mathrm{Router}(q, s_t),$$

with tags including $^3$0, $^3$1, and $^3$2 (Xu et al., 5 Oct 2025).

Answer-bearing content nodes are accumulated across routing steps:

$^3$3

The Read stage then operates on the routed evidence set:

$^3$4

This decomposition makes routing a trainable intermediate task rather than an unexamined side effect of retrieval (Xu et al., 5 Oct 2025).

A structurally different but operationally similar realization appears in DeepRead. There, documents are converted to structured Markdown, indexed at the paragraph level, and every paragraph receives coordinate-style metadata $^3$5. The Retrieve tool returns coordinate-anchored paragraphs with a lightweight scanning context, while ReadSection reads contiguous, order-preserving paragraphs within a specified section and range. The resulting behavior resembles a human "locate then read" pattern rather than a single flat retrieval pass (Li et al., 4 Feb 2026).

3. The DocumentRoute stage as the defining mechanism

The most direct form of DocumentRoute is tree navigation. In the explicit RDR2 framework, the router jointly evaluates content relevance and hierarchical relationships, selecting visible content nodes with $^3$6, expanding collapsed headings with $^3$7, and terminating exploration with $^3$8 when marginal returns are low (Xu et al., 5 Oct 2025). Routing therefore serves simultaneously as evidence selection, expansion control, and redundancy suppression.

In unified extractive QA, the same role is played by segment routing and span routing. RE$^3$9QA begins with paragraph pruning, splits the pruned document into overlapping segments, ranks segments using shallow shared representations $N$0, and routes only the top-$N$1 segments forward to the reader. After reading, it performs span-level non-maximum suppression and reranks the remaining candidates across segments. The final answer is selected by a weighted combination of retrieving, reading, and reranking scores, with default inference weights $N$2 (Hu et al., 2019). Here DocumentRoute is not a tree policy but a two-stage gating process over segment and span spaces.

In interpretable fact verification, DocumentRoute becomes evidence selection under faithfulness constraints. ReRead defines a sentence-importance predictor $N$3 over a source document $N$4, assigns per-sentence probabilities, and selects the Top-$N$5 sentences as evidence $N$6, with $N$7 in experiments. The verifier first reads the full document and then revisits only $N$8, so routing is the step that converts a full document into a faithful and plausible rationale set (Hu et al., 2023).

In multi-hop RAG, DocumentRoute can be realized by query augmentation and classifier-based filtering. DR-RAG first retrieves static-relevant documents, then concatenates the query with each retrieved document to form augmented queries $N$9, re-retrieves dynamic-relevant documents, and applies either Classifier Forward Selection or Classifier Inverse Selection to determine which documents contribute to answering the query. Only the final routed context is sent to the LLM, and the LLM is called exactly once (Hei et al., 2024).

The same logic extends beyond document internals. In federated search, RAGRoute treats repositories as the routed objects: a shallow multi-label classifier decides which repositories to query, reducing the number of repository queries up to $D$0 and communication volume up to $D$1 (Guerraoui et al., 26 Feb 2025). In retriever routing, R$D$2AG routes among candidate retrievers, including a null retriever $D$3, by modeling both retrieval quality and generation utility, then sends only the selected retriever’s top-$D$4 documents to the generator (Zhao et al., 22 Apr 2026). The routing unit therefore varies, but the middle-stage function remains the same: constrain the evidence path before reading.

4. Learning paradigms and supervision signals

A central property of RDR2-style systems is that routing is usually trained rather than hard-coded. In the explicit RDR2 framework, the router is supervised with automatically curated single-turn action triples $D$5 and optimized with standard next-token prediction:

$D$6

The curation pipeline produces $D$7 training samples with $D$8 $D$9, $$\{\langle c_{re}^{(i)}, d_i\rangle\}_{i=1..k} = \mathrm{Retriever}(q, D).$$0 $$\{\langle c_{re}^{(i)}, d_i\rangle\}_{i=1..k} = \mathrm{Retriever}(q, D).$$1, and $$\{\langle c_{re}^{(i)}, d_i\rangle\}_{i=1..k} = \mathrm{Retriever}(q, D).$$2 $$\{\langle c_{re}^{(i)}, d_i\rangle\}_{i=1..k} = \mathrm{Retriever}(q, D).$$3 labels, which gives the router both positive and negative supervision without ground-truth routing trajectories (Xu et al., 5 Oct 2025).

In RE$$\{\langle c_{re}^{(i)}, d_i\rangle\}_{i=1..k} = \mathrm{Retriever}(q, D).$$4QA, routing is embedded in a shared-encoder, end-to-end, multi-task objective. The retriever, reader, and reranker share contextualized text representations, and the unweighted joint loss is

$$\{\langle c_{re}^{(i)}, d_i\rangle\}_{i=1..k} = \mathrm{Retriever}(q, D).$$5

The training schedule recomputes retrieval scores before each epoch, rebuilds the routed training set $$\{\langle c_{re}^{(i)}, d_i\rangle\}_{i=1..k} = \mathrm{Retriever}(q, D).$$6 from top-$$\{\langle c_{re}^{(i)}, d_i\rangle\}_{i=1..k} = \mathrm{Retriever}(q, D).$$7 segments, and injects a gold segment when all routed segments are negative. This is intended to mitigate the context inconsistency problem that plagues detached pipelines (Hu et al., 2019).

ReRead makes routing supervision explicitly interpretable. Its retriever objective is

$$\{\langle c_{re}^{(i)}, d_i\rangle\}_{i=1..k} = \mathrm{Retriever}(q, D).$$8

with $$\{\langle c_{re}^{(i)}, d_i\rangle\}_{i=1..k} = \mathrm{Retriever}(q, D).$$9 in experiments. Fullness penalizes evidence whose removal does not hurt verification; sufficiency penalizes evidence-only subsets that fail to preserve the original decision; plausibility aligns selected evidence with gold rationales using binary cross-entropy (Hu et al., 2023).

Retriever routing introduces yet another supervision pattern. R$d_i$0AG learns separate embeddings for retrieval quality and generation utility, uses Top-$d_i$1 retrievers under each signal as positives for contrastive training, and then fuses the two capability dimensions with multi-head attention before final route selection. This training target is not simple relevance; it is downstream answer support (Zhao et al., 22 Apr 2026).

5. Empirical behavior across tasks and domains

Empirically, routing usually improves either answer quality, efficiency, or both, although the dominant effect depends on the task. In multi-document extractive QA, RE$d_i$2QA achieves state-of-the-art results on TriviaQA-Wikipedia, TriviaQA-unfiltered, SQuAD-document, and SQuAD-open, including $d_i$3 EM / $d_i$4 F1 on TriviaQA-Wikipedia, $d_i$5 EM / $d_i$6 F1 on the verified subset, and $d_i$7 EM / $d_i$8 F1 on SQuAD-open. On TriviaQA-Wikipedia and SQuAD-document dev sets, the unified model outperforms the pipeline by $d_i$9 F1 and is $\langle id, text, \tau, parent, C\rangle$0 faster (Hu et al., 2019).

In evidence-based fact verification, ReRead reports BERT-based test performance of approximately $\langle id, text, \tau, parent, C\rangle$1 Micro/Macro F1 and RoBERTa-based test performance of approximately $\langle id, text, \tau, parent, C\rangle$2, with an average improvement over the previous SOTA of $\langle id, text, \tau, parent, C\rangle$3 Micro F1 and $\langle id, text, \tau, parent, C\rangle$4 Macro F1 across dev/test. Its evidence quality is also higher, with BLEU versus gold evidence approximately $\langle id, text, \tau, parent, C\rangle$5–$\langle id, text, \tau, parent, C\rangle$6 compared with approximately $\langle id, text, \tau, parent, C\rangle$7–$\langle id, text, \tau, parent, C\rangle$8, and human-labeled verification Micro F1 from retrieved evidence approximately $\langle id, text, \tau, parent, C\rangle$9–$\tau \in \{\text{structure}, \text{content}\}$0 versus approximately $\tau \in \{\text{structure}, \text{content}\}$1–$\tau \in \{\text{structure}, \text{content}\}$2 (Hu et al., 2023).

In multi-hop RAG, DR-RAG combines dynamic relevance mining with classifier-based routing and uses exactly one LLM call per query. On Llama3-8B, it reports $\tau \in \{\text{structure}, \text{content}\}$3 EM / $\tau \in \{\text{structure}, \text{content}\}$4 F1 / $\tau \in \{\text{structure}, \text{content}\}$5 Acc on MuSiQue, $\tau \in \{\text{structure}, \text{content}\}$6 EM / $\tau \in \{\text{structure}, \text{content}\}$7 F1 / $\tau \in \{\text{structure}, \text{content}\}$8 Acc on HotpotQA, and $\tau \in \{\text{structure}, \text{content}\}$9 EM / $s_t$0 F1 / $s_t$1 Acc on 2Wiki, while reducing time overhead by approximately $s_t$2 versus Adaptive-RAG (Hei et al., 2024).

In long-document agentic search, DeepRead uses paragraph coordinates, a TOC-like hierarchical skeleton, and paired Retrieve and ReadSection tools. It reaches $s_t$3 average accuracy versus $s_t$4 for Search-o1, with benchmark-level gains of $s_t$5 on ContextBench and $s_t$6 on SyllabusQA. Its behavioral analysis shows very high probability of first retrieving and then reading, including $s_t$7 on ContextBench and $s_t$8 on QASPER (Li et al., 4 Feb 2026).

In homogeneous financial corpora, the same routing principle appears as Hybrid Document-Routed Retrieval. On FinDER, HDRR reaches an average score of $s_t$9, a failure rate of $$\{\langle a_j^{(t)}, p_j^{(t)}\rangle\}_{j=1..n_t} = \mathrm{Router}(q, s_t),$$0, a correctness rate of $$\{\langle a_j^{(t)}, p_j^{(t)}\rangle\}_{j=1..n_t} = \mathrm{Router}(q, s_t),$$1, and a perfect-answer rate of $$\{\langle a_j^{(t)}, p_j^{(t)}\rangle\}_{j=1..n_t} = \mathrm{Router}(q, s_t),$$2, outperforming both chunk-based retrieval and Semantic File Routing across all reported metrics (Cheng et al., 26 Mar 2026).

6. Trade-offs, misconceptions, and unresolved issues

A common misconception is that RDR2 is merely reranking with a new name. The literature shows a broader picture. In some systems DocumentRoute is a tree-navigation policy over headings and sections; in others it is segment gating, span routing, sentence selection, repository pre-selection, retriever selection, or contiguous section reading. What unifies these variants is not a single scoring function or model family, but the insertion of an explicit routing decision between retrieval and reading (Xu et al., 5 Oct 2025, Zhao et al., 22 Apr 2026).

Another misconception is that structure-aware routing is uniformly beneficial. It is not. In SF-Re2G, structure-aware retrieval and reranking improve on structurally rich data, especially on Doc2Bot, but in MultiDoc2Dial the variant without subgraph context achieves higher F1, SacreBLEU, and ROUGE than the full structure-conditioned generator. The reported interpretation is that subgraph context can introduce noise when structural signals are weak (Zhang et al., 2 Jun 2026). Similarly, in FinDER, routing to whole files reduces catastrophic cross-document confusion, but reading an entire filing dilutes precision; HDRR resolves this by routing first and then performing scoped chunk retrieval (Cheng et al., 26 Mar 2026).

Error modes also recur across implementations. Poor initial routing deprives downstream modules of useful evidence. RE$$\{\langle a_j^{(t)}, p_j^{(t)}\rangle\}_{j=1..n_t} = \mathrm{Router}(q, s_t),$$3QA notes that if the retriever routes poor segments, reader and reranker see low-quality context; ReRead identifies plausible-but-unfaithful evidence and overfitting to surface forms; DeepRead warns that OCR parsing errors can make headings inaccessible; DR-RAG notes false negatives in classifier-based filtering and dependence on at least one high-quality static document (Hu et al., 2019, Hu et al., 2023, Li et al., 4 Feb 2026, Hei et al., 2024).

The literature therefore points to a stable design lesson: retrieval quality alone is insufficient. Systems improve when they treat routing as a separate optimization target, whether the objective is end-to-end consistency, interpretability, efficiency, robustness to homogeneous corpora, or structure-aware reading. The explicit RDR2 formulation makes that principle programmatic by turning document navigation into a supervised task over document trees, but the broader body of work shows that the same principle generalizes to spans, sentences, sections, repositories, and retrievers (Xu et al., 5 Oct 2025).