Paper deep dive
One Size Does Not Fit All! Dynamic Retriever and Generator Selection for RAG
Neeraj Anand, Payel Santra, Partha Basuchowdhuri, Debasis Ganguly, Sumit Bhatia
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 91%
Last extracted: 9/17/2026, 3:47:27 AM
Summary
The paper introduces DRAG (Dynamic RAG), a query-adaptive framework that dynamically selects retriever and generator configurations based on query complexity to optimize the effectiveness-efficiency trade-off in Retrieval-Augmented Generation systems. It proposes two approaches: DRAG_QPP, a training-free method using Query Performance Prediction and perplexity signals, and DRAG_SFT, a supervised fine-tuning approach. Experiments show DRAG reduces inference latency while maintaining or improving performance compared to static RAG baselines.
Entities (11)
Relation Signals (10)
RAG → employs → Retriever
confidence 95% · A typical RAG pipeline consists of two components: (i) a retriever... and (ii) a generator
RAG → employs → Generator
confidence 95% · A typical RAG pipeline consists of two components: ... (ii) a generator
DRAG → includes → DRAG_SFT
confidence 95% · We further introduce DRAG_SFT... under the common DRAG framework
DRAG → includes → DRAG_QPP
confidence 95% · We first propose DRAG_QPP... We further introduce DRAG_SFT... under the common DRAG framework
DRAG → evaluatedon → HotpotQA
confidence 90% · Performance (F1) and efficiency (time/query) on the HotpotQA dataset
DRAG_QPP → uses → Query Performance Prediction
confidence 90% · DRAG_QPP... uses Query Performance Prediction (QPP) signals to guide retriever selection
DRAG_SFT → uses → Supervised Fine-Tuning
confidence 90% · DRAG_SFT, a supervised routing approach that fine-tunes an LLM
DRAG → evaluatedon → FRAMES
confidence 85% · We study OOD robustness using the FRAMES dataset
BM25 → →
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Retrieval-Augmented Generation (RAG) systems typically employ fixed retriever and generator configurations across queries, despite substantial differences in query complexity and information needs, leading to inefficient allocation of computational resources. While retrieval and generation adaptivity have been studied independently, their joint effect on end-to-end RAG performance remains underexplored. We systematically analyze how retriever and generator complexity interacts across factoid and multi-hop question answering (QA), including bridge and composition reasoning tasks. Our analysis shows that stronger retrieval generally yields larger gains than increased generation effort, but both exhibit diminishing and non-monotonic returns, indicating that higher-complexity configurations are not uniformly better across queries. Motivated by these findings, we introduce DRAG, a query-adaptive framework for selecting retriever-generator configurations. We first propose DRAG$_\text{QPP}$, a training-free routing approach that uses Query Performance Prediction (QPP) signals to guide retriever selection and perplexity-based measures over retrieved context to guide generator selection. We further introduce DRAG$_\text{SFT}$, a supervised routing approach that fine-tunes an LLM to jointly predict retriever-generator configurations. Across three LLM families and four QA benchmarks, \qpprag~achieves performance comparable to strong static RAG baselines while substantially reducing inference latency, whereas DRAG$_\text{SFT}$ consistently improves effectiveness over static and training-free adaptive baselines. Overall, DRAG demonstrates that jointly adapting retrieval and generation achieves a more favorable effectiveness-efficiency trade-off than static RAG pipelines.
Tags
Links
- Source: https://arxiv.org/abs/2609.17709v1
- Canonical: https://arxiv.org/abs/2609.17709v1
Trouble viewing inline? Open PDF directly →
Full Text
79,127 characters extracted from source content.
Expand or collapse full text
One Size Does Not Fit All! Dynamic Retriever and Generator Selection for RAG DOI: X.XXXXXXXCCS: Information systems Query intentCCS: Information systems Information retrieval query processing Neeraj Anand Affiliation: Media and Data Science Research Lab, Adobe Systems, Noida, India email: neeraja@adobe.com , Payel Santra Affiliation: IACS, Kolkata, India email: payel.iacs@gmail.com , Partha Basuchowdhuri Affiliation: IACS, Kolkata, India email: partha.basuchowdhuri@iacs.res.in , Debasis Ganguly Affiliation: University of Glasgow, Glasgow, United Kingdom email: debasis.ganguly@glasgow.ac.uk and Sumit Bhatia Affiliation: Media and Data Science Research Lab, Adobe Systems, Noida, India email: sumit.bhatia@adobe.com Received 5 June 2009 Abstract. Retrieval-Augmented Generation (RAG) systems typically employ fixed retriever and generator configurations across queries, despite substantial differences in query complexity and information needs, leading to inefficient allocation of computational resources. While retrieval and generation adaptivity have been studied independently, their joint effect on end-to-end RAG performance remains underexplored. We systematically analyze how retriever and generator complexity interacts across factoid and multi-hop question answering (QA), including bridge and composition reasoning tasks. Our analysis shows that stronger retrieval generally yields larger gains than increased generation effort, but both exhibit diminishing and non-monotonic returns, indicating that higher-complexity configurations are not uniformly better across queries. Motivated by these findings, we introduce DRAG, a query-adaptive framework for selecting retriever-generator configurations. We first propose DRAGQPP_QPP, a training-free routing approach that uses Query Performance Prediction (QPP) signals to guide retriever selection and perplexity-based measures over retrieved context to guide generator selection. We further introduce DRAGSFT_SFT, a supervised routing approach that fine-tunes an LLM to jointly predict retriever-generator configurations. Across three LLM families and four QA benchmarks, DRAGQPP_QPP achieves performance comparable to strong static RAG baselines while substantially reducing inference latency, whereas DRAGSFT_SFT consistently improves effectiveness over static and training-free adaptive baselines. Overall, DRAG demonstrates that jointly adapting retrieval and generation achieves a more favorable effectiveness-efficiency trade-off than static RAG pipelines. Keywords: Adaptive RAG, Retriever Selection, Generator Selection 1. Introduction Large Language Models (LLMs) have demonstrated strong capabilities in text generation; however, their responses remain constrained by the knowledge encoded in their parameters during pretraining (Lewis et al., 2020). As a result, LLMs often struggle to reliably generate or reason over information that is absent from, outdated in, or only sparsely represented in their training data. Retrieval-Augmented Generation (RAG) addresses this limitation by explicitly incorporating external knowledge sources into the generation process (Lewis et al., 2020; Karpukhin et al., 2020; Ye et al., 2023). A typical RAG pipeline consists of two components: (i) a retriever (such as BM25 (Robertson, 2004), or a dense ranker such as E5 (Wang et al., 2022)) that selects contextually relevant documents from an external corpus, and (i) a generator, which is typically a decoder-based LLM (e.g., LLaMA (Touvron et al., 2023) or GPT (Dale, 2021)), which conditions on both the input query and the retrieved contexts to produce a task-specific response. Most existing RAG systems rely on a fixed retriever–generator configuration that is applied uniformly across all queries (Gao et al., 2023; Wang et al., 2024b; Zhu et al., 2021; Parry et al., 2024), thus leading to computational inefficiency and suboptimal effectiveness. However, prior work in IR has long established that queries differ substantially in the complexity of their underlying information needs, which in turn affects retrieval difficulty and downstream generation quality (Kanoulas et al., 2011; Datta et al., 2022; Ganguly et al., 2011). In a RAG setting, query complexity spans a broad spectrum: from simple factoid queries answerable using a single relevant document (Joshi et al., 2017; Kwiatkowski et al., 2019), to compositional multi-hop queries requiring reasoning across multiple evidence sources (Yang et al., 2018; Trivedi et al., 2022), as well as queries involving temporal reasoning (Jia et al., 2018), numerical aggregation (Dua et al., 2019), or multi-constraint satisfaction (Talmor and Berant, 2018). For simpler queries, standard sparse or dense retrieval models (e.g., sparse such as BM25 or bi-encoders such as E5 (Wang et al., 2022)) are often sufficient without requiring computationally expensive re-ranking strategies (Yani and Krisnadhi, 2021; Gabburo et al., 2024). In contrast, more complex queries require stronger retrieval and generation pipelines, achieved either through enhanced reasoning capabilities in the generator, such as multi-step reasoning (Plaat et al., 2026), query decomposition (Ammann et al., 2025), increasing the thinking capability of the generator, structured generation strategies such as chain-of-thought (Kleinman et al., 2025), or by improving the retrieval pipeline using tools such as retrieve-rerank pipelines employing cross-encoders (Pradeep et al., 2021; Karpukhin et al., 2020; Khattab and Zaharia, 2020) and LLM-based listwise rankers (Tamber et al., 2023; Zhuang et al., 2023; Sinhababu et al., 2024; Zhuang et al., 2025; Zhang et al., 2024). However, these improvements often come at the cost of increased computational overhead and latency (Pradeep et al., 2023). This suggests that a query-adaptive RAG workflow that dynamically allocates retrieval and generation capacity based on the requirements of each query can potentially improve the overall effectiveness–efficiency trade-off. While promising, implementing such an adaptive framework presents two primary challenges: (i) generalizability, since routing decisions must remain robust across diverse query types and adapt to evolving model configurations without relying on relevance judgments or answer quality signals at inference time; and (i) the trade-off between effectiveness and efficiency, since increased retrieval or reasoning effort improves answer quality only selectively while substantially increasing latency. To address these challenges, we first conduct a systematic empirical analysis of retriever-generator configurations of varying complexity (Section 3), examining how their interactions affect downstream RAG effectiveness and efficiency. This analysis provides insights into when additional computational capacity is beneficial and motivates query-adaptive configuration selection. Figure 1. Performance (F1) and efficiency (time/query) on the HotpotQA dataset across 1212 retriever-generator configurations (44 retrievers × 33 generators) of increasing complexity. The DRAGQPP_QPP and DRAGSFT_SFT methods adaptively select query-specific retriever-generator pairs, achieving a favorable effectiveness-efficiency trade-off by attaining strong downstream performance at lower latency than static RAG with high-complexity configurations. To this end, we introduce DRAG (Dynamic RAG), a query-adaptive framework for selecting retriever-generator configurations. We instantiate DRAG through two complementary approaches (Section 4): a training-free dynamic approach, DRAGQPP_QPP, which routes queries through a cascaded sequence of models of increasing complexity, and a supervised approach DRAGSFT_SFT, that learns to jointly predicts retriever-generator configurations from query signals. Together, these approaches explore the effectiveness-efficiency trade-off (EET) of adaptive RAG under different levels of supervision and computational overhead (Meng et al., 2024). We study both DRAGQPP_QPP and DRAGSFT_SFT under the common DRAG framework to analyze their respective strengths and limitations across standard benchmarks as well as evaluate them in out-of-domain (OOD) scenarios. We study OOD robustness using the FRAMES dataset, where routing models are applied without dataset-specific tuning and we show that adaptive retriever-generator selection can generalize beyond the training distribution. The contributions of our work can be summarized as : • We present the first comprehensive empirical study analyzing the joint impact of retriever-generator pair selection on end-to-end RAG performance. • We propose DRAGQPP_QPP, a training-free, query-adaptive framework that leverages unsupervised retrieval performance prediction (QPP-based (Zhou and Croft, 2007)) and generator performance prediction (GPP-based (Shorinwa et al., 2026)) to dynamically balance the EET. • We introduce DRAGSFT_SFT, a supervised framework that treats configuration selection as a predictive task, which improves selection effectiveness over DRAGQPP_QPP, albeit at cost of latency. • We conduct extensive evaluations across three diverse LLM families and four benchmarks – including out-of-domain evaluation on FRAMES – demonstrating the robustness and generalizability of our adaptive paradigms across full test sets. • To facilitate reproducible research, we release our dataset and code at https://anonymous.4open.science/r/DynamicRAG-2A01/. 2. Related Works Retrieval Augmented Generation Retrieval-Augmented Generation (RAG) improves text generation by grounding LLM outputs in external knowledge, thereby mitigating hallucinations and knowledge limitations. Prior work has explored several forms of retrieval augmentation, including query-based retrieval and retrieval-conditioned generation (Guu et al., 2020; Shi et al., 2024), latent and logit-level integration of retrieved evidence into language modeling (Khandelwal et al., 2020; Zhong et al., 2022), retrieval refinement through reranking, active, and iterative retrieval strategies (Glass et al., 2022; Jiang et al., 2023; Zhang et al., 2023), as well as architectures that improve reasoning over retrieved documents and multi-document fusion (Izacard and Grave, 2021; Lan et al., 2023; Santra et al., 2025). Another line of work explores supervised fine-tuning of LLMs, that retrofit any LLM with retrieval capabilities (Lin et al., 2024; Wang et al., 2024a), distill reader signal back into the retriever (Izacard et al., 2023), or fine-tune the generator to reason over retrieved context (Lin et al., 2024; Asai et al., 2024). Adaptive Retrieval Existing studies on adaptive RAG focused on binary decisions, i.e., whether to retrieve or not (Mallen et al., 2023). This method is sufficient for simple queries, but generally fails multi-hop difficult queries. Thus, some studies introduces a method with a variable number of iterative retrieval steps, i.e., it jointly retrieve-and-rerank until sufficient evidence is accumulated for correct prediction(Qi et al., 2021). Furthermore, SELF-RAG (Jeong et al., 2024; Asai et al., 2024) introduces training strategy to retrieve, self-critique and refine the outputs. Unlike our method DRAG, it does not explicitly address the problem of selecting among multiple retriever–generator configurations. In contrast, several works explore adaptivity from reasoning point of view, while assuming a fixed retrieval pipeline. Some existing studies varies the number of reasoning steps (Wang et al., 2023) or samples multiple chain-of-thought reasoning paths to dynamically select the generation path for improving robustness (Yao et al., 2023). Different from previous approaches, this paper jointly analyzes the impact of retriever and generator choices with different capabilities on RAG framework. Query Performance Prediction Query performance predictors can be classified into two major categories: pre-retrieval and post-retrieval. Pre-retrieval prediction technique aims to predict query difficulty by analyzing the prior distribution to querying the given collection of documents (De Loupy and Bellot, 2000; He and Ounis, 2006; Mothe and Tanguy, 2005). The post-retrieval prediction methodology, on the contrary, relies on statistical approaches on retrieval scores (Shtok et al., 2012; Cummins et al., 2011; Zhou and Croft, 2007; Tao and Wu, 2014), learning to rank features inspired predictors (Chifu et al., 2018) and robustness of rank-list perturbation based predictors (Shtok et al., 2010; Roitman et al., 2017). Some recent studies explored supervised and neural approaches for QPP by considering both the content and the score features (Datta et al., 2022; Zamani et al., 2018). In this work, we use these pre-retrieval predictors in our downstream pipeline to guide the selection of an appropriate retriever based on query complexity. 3. RAG Configuration Analysis and Problem Formulation We first formalize the adaptive RAG task and analyze the behavior of static RAG systems, where a fixed retriever and generator are used uniformly across all queries. This analysis serves two purposes: (i) characterizing the EET across retriever-generator configurations, and (i) motivating the need for query-adaptive frameworks. Task Formulation Given a query q, a set of candidate retrievers Θ=θii=1m =\ _i\_i=1^m and a set of candidate generators Φ=ϕii=1n =\ _i\_i=1^n, the objective of adaptive RAG is to select a query-specific retriever-generator configuration (θ,ϕ)∈Θ×Φ(θ,φ)∈ × that balances downstream answer quality and computational cost. Unlike static RAG, adaptive RAG seeks to select the optimal retriever and generator based on the query’s specific information need to maximize effectiveness while minimizing latency. Since the effectiveness of a retriever-generator pair cannot be directly observed at inference time (i.e., the ground-truth answer aqa_q is unavailable), we need an estimator, f:(q,θ,ϕ)↦ℝf:(q,θ,φ) , that predicts the likelihood of generating a correct answer for a given query q. The objective is then to select the most efficient configuration that maximizes downstream effectiveness while minimizing computational overhead. Retriever and Generator Configuration Choice The adaptive setup requires a discrete action space of retrievers Θ and generators Φ , ordered by increasing computational cost and capability. Following the conventional view in IR, we maintain the progression of retriever complexity from lexical retrieval to dense semantic retrieval and further to sophisticated retrieve-and-rerank pipelines employing query decomposition and cross-encoder rerankers. Similarly, generator complexity scales from lightweight decoding with no or minimal reasoning to longer, multi-step reasoning i.e., extending the reasoning effort or thinking modes of LLMs. Importantly, our proposed framework is entirely agnostic to the specific number of retriever or generator choices, allowing it to scale seamlessly across finer- or coarser-grained complexity modes. In our experiments for GPT-OSS base-model, we consider four retrieval levels, i.e., low (L; sparse retriever), medium (M; dense retriever), high (H; retrieve-and-rerank pipeline), and extra-high (XH; query decomposition with retrieve-and-rerank pipeline), reflecting complex retrieval pipelines with increasing latency and three cascaded levels for retriever component, i.e., low (L), medium (M) and high (H) reflecting the mode of thinking, which means total 1212 configurations (4×34× 3). Similarly, for Qwen and Gemma, we consider two generator modes depending on thinking availability (thinking-off/on), resulting in 88 configurations (4×24× 2) per model. Gen / Ret Low (%) Medium (%) High (%) Extra-High (%) Low 11.2 5.6 12.5 6.9 Medium 5.1 3.8 5.7 4.5 High 13.0 7.1 15.6 9.0 Table 1. Distribution (%) of correctly answered HotpotQA queries under an efficiency-aware oracle RAG system across total 12 configurations, with four retriever levels (L, M, H, XH) and three GPT-OSS generator reasoning levels (L, M, H). The results show that a substantial fraction of queries can be answered using low and medium complexity configurations, indicating that considerable latency reductions are achievable through adaptive framework. Efficiency-aware Oracle configuration To understand the query-level EET in static RAG frameworks, we define an efficiency-aware oracle setup that assigns each query to the least computationally expensive configuration of retriever-generator pair to correctly answer the query q. Intuitively, the oracle represents an ideal setup that has access to ground-truth effectiveness and therefore reveals how retrieval and generation effort should ideally be allocated across queries. Formally, given a query q, the oracle selects (1) (θ∗,ϕ∗)=argminθ,ϕ∈Θ×ΦL(θ,ϕ)s.t.P(aq,ϕ(q,θk(q)))≥δ,(θ^*,φ^*)= _θ,φ∈ × L(θ,φ) .t. P (a_q,φ(q, _k(q)) )≥δ, where i) θk(q) _k(q) denotes the top-k documents retrieved by the ranker θ, i) ϕ∈Φ:(q,θq)↦a^φ∈ :(q, _q) a denotes a generator which takes q along with its retrieved documents θq _q as input to yield a predicted answer aq a_q, i) aqa_q is the ground-truth answer for query q, iv) P:aq×aq^↦ℝ P:a_q× a_q denotes downstream effectiveness (measured by metrics such as Exact Match (EM) and F1) between aq a_q and aqa_q, v) L:θ×ϕ↦ℝ L:θ×φ is the total latency and vi) δ represents a effectiveness threshold. When multiple configurations satisfy the threshold, the oracle selects the least expensive one. In practice, if no configuration satisfies the target criterion (e.g., EM=1=1), we map to the least expensive configuration achieving high partial correctness (F1≥0.8≥ 0.8). Following prior works that applied thresholds on answer-level F1 to account for minor lexical variations in partial correct responses (Asai et al., 2024; Jiang et al., 2023), we use 0.80.8 as a threshold . If no configuration satisfies this criterion, the query is assigned to the highest-complexity setting (θXH,ϕH)( _XH, _H) as a safe fallback. Figure 2. Overview of the proposed query-adaptive framework (DRAG) for GPT-OSS. The left panel shows retriever and generator configurations of progressively increasing complexity, ranging from sparse to query decomposition with retrieve-rerank pipelines, and from low to high thinking effort. Given an input query, DRAG dynamically selects a query-specific retriever-generator configuration instead of uniformly invoking a fixed pipeline. The top-right panel illustrates the training-free DRAGQPP_QPP workflow with 2 modules, retrieval performance prediction (RPP) followed by generator performance prediction (GPP). The bottom-right panel shows DRAGSFT_SFT, a supervised framework that learns retriever–generator selection from query–configuration supervision and predicts the optimal configuration during inference. The selected configuration is then executed to produce the downstream answer. While illustrated using GPT-OSS with four retrievers and three generator levels (4×3=124× 3=12 configurations), the framework naturally generalizes to other model families (e.g., Qwen and Gemma with 4×24× 2 configurations). For our proposed adaptive DRAGQPP_QPP approach, we used training-free RPP and GPP-based methods as explained in Section 4. Discussion Table 1 reports the oracle distribution across all retriever-generator configurations on the HotpotQA dataset when GPT-OSS is the base model. Note that a substantial fraction of queries are correctly answered using low- and medium-complexity configurations, indicating that uniformly invoking the most expensive retrieval and reasoning pipeline is often unnecessary. This data underscores a fundamental reality of RAG optimization: query complexity dictates architectural requirements, meaning some queries are adequately resolved by lightweight configurations while others strictly demand advanced retrieval and reasoning pipelines. For example, a simple factoid question from HotpotQA, “Alfie Allen played Theon Greyjoy on which show?” is correctly answered across all retriever-generator configurations; for such simple queries, employing expensive retrieval and reasoning pipelines incurs unnecessary computational cost without yielding any performance gains. Conversely, the oracle distribution (Table 1) also reveals that there are a substantial number of queries that are correctly answered only under an intermediate retrieval setting paired with complex reasoner (e.g., θM _M with ϕH _H), while other modes of retrievers fail irrespective of generator choice. For instance, the query “Belle Gold is a fictional character portrayed by an actress of what nationality?” requires resolving a semantic entity relationship (Belle Gold → portraying actress → nationality), where dense retrieval (θM _M) successfully retrieves semantically relevant evidence, whereas other retrievers either miss relevant context or retrieved noisy evidence. Thus, higher-complexity configurations are not strict supersets of lower ones, and we need adaptive per-query routing framework over the retriever-generator space Θ×Φ × to better balance downstream effectiveness and inference latency. 4. Dynamic RAG Workflow (DRAG) Motivated by the observations in Section 3, which demonstrate that no single configuration is optimal across queries, we introduce DRAG, an adaptive framework that approximates the oracle routing policy of Equation 1 when the ground-truth answer aqa_q is unavailable at inference time. Depending on the availability of supervision, we introduce two complementary approaches under this paradigm: (i) DRAGQPP_QPP, a training-free framework that sequentially selects retrievers and generators using unsupervised performance signals, and (i) DRAGSFT_SFT, a supervised framework that directly learns optimal, query-specific retriever-generator configurations. An overview of the proposed DRAG workflow, including both DRAGQPP_QPP and DRAGSFT_SFT frameworks, is illustrated in Figure 2. 4.1. DRAGQPP_QPP As the initial step towards realizing an optimized adaptive framework, we introduce DRAGQPP_QPP, a training-free routing framework that approximates the oracle routing policy using unsupervised techniques. Rather than directly predicting a joint configuration, DRAGQPP_QPP decomposes the routing process into two sequential prediction stages: (i) Retriever Performance Prediction and (i) Generator Performance Prediction. The selected retriever and generator are then used for downstream answer generation. 4.1.1. Retriever Performance Prediction (RPP) The first module in DRAGQPP_QPP framework aims to select the most suitable retriever for each query by analyzing retrieval difficulty (Tian et al., 2026) without requiring relevance judgments at inference time. Because adaptive routing must decide required retriever complexity before retrieval is executed, we need a retriever-independent signal that relies solely the query text and corpus statistics. Query Performance Prediction (QPP) directly addresses this need by estimating retrieval quality in the absence of relevance judgments (Datta et al., 2024; Ebrahimi et al., 2024). Motivated by this, we leverage a pre-retrieval QPP predictor σ(q):q↦ℝσ(q):q as a signal to guide per-query retriever selection (Datta et al., 2023; Meng et al., 2025); the larger values of σ indicate queries expected to have relevant documents after retrieval. Intuitively, queries that are easier to retrieve can be handled by lightweight retrievers, whereas harder queries are escalated to progressively stronger retrieval pipelines. QPP-aware Retriever Routing Rather than evaluating the effectiveness of all retrievers for each query, which would incur substantial computational overhead and defeat the purpose of adaptive routing, we adopt a lightweight query-specific routing strategy that sequentially selects the retrievers with increasing complexity. Since retriever selection must be performed without actually performing each retrieval , we used pre-retrieval QPP predictors, which are retriever-independent and depend on the query and corpus statistics. Formally, given a query q, we compute a QPP score σ(q)σ(q) and select the least complex retriever satisfying (2) θ∗(q)=θi,where i=minj|σ(q)≥τj,θ^*(q)= _i, i= \j\; |\;σ(q)≥ _j \, where τjj=1m−1\ _j\_j=1^m-1 is a set of m−1m-1 thresholds (where, τj<τj+1,∀j _j< _j+1,∀ j) dividing the score range into m intervals. A query interval with lower value of σ indicate the need of more complex retrievers, while easier queries computer higher σ and are handled by simpler, cheaper retrievers . In our experiments, we employ Average IDF (Avg-IDF) (Kwok, 1996) as our lightweight, pre-retrieval QPP signal to capture query specificity with respect to the underlying corpus. Queries dominated by rare, highly informative content terms typically receive higher Avg-IDF scores and are inherently easier to retrieve. Conversely, queries with ambiguous or common terms yield lower scores, indicating they would benefit from more advanced retrieval pipelines. We select Avg-IDF aligned with recent literature demonstrating its robustness (Arabzadeh et al., 2026), a choice further validated by our initial experiments against alternative pre-retrieval predictors. Threshold Selection We derive the routing thresholds τii=1m−1\ _i\_i=1^m-1 from the Avg-IDF score distribution computed over the training set. Concretely, these thresholds are defined via percentile-based partitioning of the predictor values. We select a base percentile p as a tunable hyperparameter and determine subsequent thresholds using uniform offsets, i.e., p,p+Δ,p+2Δ,…\p,p+ ,p+2 ,…\, where Δ controls the interval spacing between adjacent complexity levels. The score values corresponding to these specific percentiles are then fixed as the routing thresholds τi\ _i\, which are applied to the test data to map incoming queries to their respective retriever complexity levels based on their online QPP scores. 4.1.2. Generator Performance Prediction (GPP) As the second component of our framework, DRAGQPP_QPP selects an appropriate generator for each query, conditioned on the specific retriever θ∗θ^* selected in the previous stage. To capture the generator’s uncertainty regarding the retrieved evidence prior to answer synthesis, we evaluate the perplexity of the retrieved context sequence itself under the base language model (Shorinwa et al., 2026). Perplexity is computed as the exponential of the mean negative log-likelihood of the tokens within the retrieved context documents. Notably, a lower perplexity score indicates that the retrieved evidence is highly consistent with the model’s internal language distribution and parametric expectations. Conversely, a high perplexity score signals that the context is noisy, out-of-distribution, or poorly aligned, which drastically escalates the risk of downstream hallucination (Ji et al., 2023; Xu et al., 2025). Consequently, queries paired with low-perplexity context are routed to lightweight generators, while queries yielding high-perplexity context are escalated to more complex, reasoning-intensive models capable of handling noisy evidence. Formally, for a given query q and retrieved set θk∗(q)θ^*_k(q), we compute the generator-specific perplexity score h(θk∗(q)∣q;ϕj)h(θ^*_k(q) q; _j) and select the generator according to, (3) ϕ∗(q)=ϕi,where i=minj|h(θk∗(q)∣q;ϕj)≤νj.φ^*(q)= _i, i= \j\; |\;h(θ^*_k(q) q; _j)≤ _j \. Threshold on Posterior For each generator ϕi _i, we estimate the distribution of perplexity scores over training queries and define a routing threshold νi _i as the score corresponding to the p-th percentile (p∈10,20,…p∈\10,20,…\), where p is treated as a hyperparameter selected on train data. During inference, we select generators sequentially from low to high complexity. We compute the perplexity of the retrieved context and compare it against the corresponding threshold νi _i. If the perplexity exceeds νi _i – implying that the query can be answered by the current generation tier’s capacity to process the retrieved context’s informational density – the current generator is selected. Otherwise, the query is escalated to the next higher-complexity tier. This process continues until a generator satisfies this threshold criterion or the highest-complexity model is deployed by default. 4.2. DRAGSFT_SFT While DRAGQPP_QPP provides a lightweight and training-free mechanism for adaptive routing using query and corpus derived signals, its effectiveness relies heavily on data-specific threshold selection and the sequential estimation of generation complexity. This limitation motivates a more generalizable supervised approach that directly models retriever and generator selection jointly within a unified framework. To this end, DRAGSFT_SFT casts routing as a supervised mapping P^:q↦(θ,ϕ) P:q (θ,φ) from an input query to its optimal retriever–generator configuration. We instantiate P P by fine-tuning Qwen as the base model on our constructed training dataset Doracle D_oracle (described in Section 3), where each query is paired with its optimal configuration label. The input context consists of the query, the instruction template, and the available configurations, and the model is trained to produce a structured JSON output of the form "retriever": θ, "generator": ϕφ , specifying the selected configuration. At inference time, given a query q, the fine-tuned model predicts the retriever–generator configuration (θ^,ϕ^)( θ, φ) in a single decoding step. The selected retriever θ θ retrieves the top-k contexts, which are subsequently passed to the generator ϕ φ to produce the final answer a^q a_q. By jointly predicting both components directly from the query, DRAGSFT_SFT avoids the sequential routing and threshold calibration required by DRAGQPP_QPP, while introducing negligible upfront inference overhead. 5. Experimental Setup Our empirical evaluation is designed to answer the following core research questions about the behavior of RAG pipelines. • RQ1 (Retriever vs. Generator Capacity): How do retriever and generator complexity individually contribute to end-to-end RAG performance, and does scaling either component in isolation consistently lead to downstream quality gains? • RQ2 (Dynamic vs. Static RAG Trade-offs): Can dynamically selecting the retriever and generator configuration optimize the effectiveness-efficiency trade-off (EET) relative to conventional static, fixed-complexity RAG pipelines? • RQ3 (Framework Generalization): How effectively do our proposed adaptive routing strategies generalize when evaluated across out-of-domain datasets and unseen model configurations? Dataset Task #Train #Test |Q|¯ |Q| Domain TriviaQA Single-hop 78,785 11,313 14.2 Wiki/Web HotpotQA Multi-hop 90,447 7,405 17.8 Wiki MuSiQue 19,938 2,417 26.4 FRAMES - 824 16.0 Table 2. Characteristics of the datasets used in our experiments. We used the entire test set for all evaluations. FRAMES is used as an OOD benchmark while the remaining datasets are in-domain. 5.1. Datasets We evaluate our framework on four question answering (QA) benchmarks selected to represent a spectrum of retrieval and reasoning complexities. TriviaQA (Joshi et al., 2017) consists primarily of open-domain factoid questions that are typically answerable using a single supporting document, serving as a baseline for settings with limited evidence dispersion. To capture increasing retrieval and reasoning difficulty, we consider three multi-hop QA benchmarks: HotpotQA (Yang et al., 2018), which requires bridging information across indirectly connected documents, MuSiQue (Trivedi et al., 2022), which enforces stricter compositional reasoning (2-4 hops) with widely dispersed evidence and, finally we include FRAMES (Krishna et al., 2025) as our multi-hop OOD evaluation benchmark, since, unlike the previous datasets, it involves more diverse reasoning requirements (e.g., numerical, temporal, and multi-constraint reasoning), often requiring aggregation across a larger set of documents. Thus, FRAMES provides a challenging testbed for evaluating the robustness and generalizability of the proposed adaptive routing methodologies . Dataset statistics are reported in Table 2. 5.2. Retrievers Investigated The action space Θ should span retrieval pipelines that differ significantly in cost and capability, so the routing policy has substantial trade-offs to learn. In this study, the granularity of |Θ|| | is itself a design choice that can vary from simple binary routing to more fine-grained adaptive configurations. In this work, motivated by the evolution of retrievers and rankers in IR, we consider Θ as a spectrum of retrieval configurations with progressively increasing complexity: lexical retrieval, dense semantic retrieval, retrieve-rerank pipelines employing cross-encoders, and query decomposition followed by reranking. These configurations have a different spectrum of latency and effectiveness. Although we focus on these dimensions, the framework is general and can accommodate other configuration choices. Particularly, we consider the following: • Low (θL _L) (BM25): We use BM25 (Robertson, 2004), a widely adopted lexical model that relies on exact term matching. It is highly efficient but has no semantic awareness. • Medium (θM _M) (E5): We employ e5-large-v2 (Wang et al., 2022), a dense bi-encoder trained using weakly supervised contrastive learning, which captures semantic relationships under vocabulary mismatch and is more computationally expensive than lexical one. • High (θH _H) (E5%50>>BGEE5\%50>>BGE): As the next level of complexity, we employ a retrieve-and-rank model, where we use E5 to retrieve the top-5050 documents, which are then re-ranked against the query using BGE, a cross-encoder model (Luo et al., 2024). • Extra-High (θXH _XH) (QD>>E5%50>>BGEQD>>E5\%50>>BGE): To address multi-hop information needs, we implement a decompose-and-rerank pipeline. The query is broken into s atomic sub-queries (Ammann et al., 2025). We retrieve the top-5050 documents for each sub-query and the original query using E5, creating a candidate pool of (s+1)×50(s+1)× 50 documents, which are then re-ranked against the original query using BGE (Luo et al., 2024). This incurs the highest computational cost but maximizes relevance for complex tasks. 5.3. Generators Investigated The space of generator configurations should span varying levels of reasoning capability and computational cost, enabling the routing policy to adapt generation effort based on query complexity. We evaluate three open-source LLM families that provide distinct mechanisms for scaling test-time compute (Snell et al., 2024). Each backbone exposes configurable reasoning-effort settings that control the extent of internal chain-of-thought reasoning and inference-time computation. Increasing the reasoning effort generally improves performance on compositional and multi-hop queries, albeit at the cost of higher token usage and increased inference latency. • GPT-OSS (OpenAI, 2025) considers the reasoning effort parameter with three settings, Low (minimal internal thought, lowest latency), Medium (moderate reasoning budget), and High (extensive reasoning paths, highest cost but boost in downstream performance). • Qwen-3 (Team, 2025) considers a binary thinking-mode switch, Low (Thinking-Off) generates a direct response as a standard instruction-tuned LLM, while High (Thinking-On) emits an explicit step-by-step reasoning trace before the final answer, improving multi-hop performance at the cost of a linearly scaled token budget. • Gemma-4 (Team et al., 2026) similar to the previous setup, it also considers binary thinking control with Low (direct response) and High (reasoning-trace-enabled) modes. GPT-OSS (20B) Qwen (8B) Gemma (26B) EM F1 Accuracy EM F1 Accuracy EM F1 Accuracy Ret / Gen L M H L M H L M H L H L H L H L H L H L H TriviaQA L 53.3∗† 55.1∗† 56.7∗† 63.5∗† 64.7∗† 64.8∗† 65.4∗† 66.4∗† 67.4∗† 57.4∗† 57.1∗† 65.5∗† 64.9∗† 66.0∗† 64.8∗† 49.6∗† 52.1∗† 59.1∗† 61.4∗† 61.6∗† 63.4∗† M 59.6∗† 62.3∗† 64.4∗† 71.4∗† 73.4∗† 73.7† 74.4∗† 76.0∗† 77.1† 64.0∗† 64.4† 73.5∗† 73.4∗† 74.3∗† 74.1∗† 56.3∗† 58.8† 66.8∗† 69.0† 70.8∗† 72.4∗† H 61.5∗† 64.2∗† 66.1† 73.3∗† 75.4∗† 75.7∗† 76.3∗† 77.9∗† 78.4∗ 66.1∗† 66.8∗ 75.7∗† 75.9∗† 76.5∗ 76.5∗ 58.6† 60.1∗† 69.3∗† 71.1∗ 73.9∗† 76.2∗ XH 60.8∗† 63.2∗† 65.2† 72.6∗† 74.3† 74.8∗† 75.6∗† 77.1∗† 77.9∗† 64.9† 65.6∗† 74.3† 74.1∗† 75.4† 74.7∗† 57.6∗† 59.7∗† 68.3† 70.5∗† 72.6∗† 74.1† DRAGQPP_QPP 65.4 73.9 76.7 64.9 74.3 75.1 58.5 68.4 74.3 DRAGSFT_SFT 68.1 77.1 79.6 67.1 76.2 76.9 61.2 71.9 76.8 HotpotQA L 25.5∗† 28.8∗† 30.2∗† 35.6∗† 38.1∗† 38.9∗† 35.8∗† 36.4∗† 37.4∗† 26.7∗† 27.8∗† 35.5∗† 35.4∗† 33.4∗† 33.5∗† 25.2∗† 26.8∗† 33.1∗† 34.4∗† 33.1∗† 33.9∗† M 38.5∗† 43.9∗† 45.5∗† 53.4∗† 57.4∗† 57.9∗† 53.0∗† 54.2∗† 54.7∗† 41.49∗† 45.4∗† 53.3∗† 57.0 ∗† 49.5∗† 52.3∗† 41.6∗† 44.3∗† 53.5∗† 56.1∗† 52.3∗† 54.0∗† H 44.0∗† 49.9† 51.6∗† 60.1∗† 64.5∗† 65.2† 59.5∗† 60.9† 61.5† 46.4∗† 50.9∗ 59.6∗† 63.9∗ 55.2† 58.7∗ 46.9∗† 50.5∗† 60.4∗† 63.8∗† 59.2† 61.8∗ XH 41.2∗† 47.4∗† 48.8∗† 57.3∗† 61.6∗† 62.3∗† 57.0∗† 57.7∗† 58.6∗† 43.9∗† 48.1† 56.5∗† 60.3∗† 52.5∗† 53.3∗† 44.6∗† 50.5∗† 57.5∗† 62.7† 56.6∗† 60.1∗† DRAGQPP_QPP 49.2 63.1 60.8 48.2 61.3 55.9 48.4 61.2 59.4 DRAGSFT_SFT 53.2 67.6 63.8 50.5 63.9 58.2 51.1 64.1 62.2 MuSiQue L 7.1∗† 7.2∗† 7.6∗† 11.4∗† 11.4∗† 11.7∗† 10.1∗† 10.6∗† 12.0∗† 3.9∗† 5.5∗† 7.9∗† 9.2∗† 6.5∗† 8.2∗† 4.4∗† 4.5∗† 7.6∗† 7.3∗† 7.5 ∗† 7.1∗† M 14.3∗† 17.8∗† 18.5∗† 22.1∗† 25.0∗† 25.3∗† 20.3∗† 23.3∗† 25.8∗† 9.6∗† 15.8∗† 15.7∗† 22.1∗† 13.4∗† 19.8† 11.8∗† 14.8∗† 17.3∗† 20.0∗† 16.7∗† 20.0∗† H 19.5† 21.1∗† 22.8∗† 27.7∗† 29.7∗† 30.1∗† 26.0∗† 28.4† 31.1∗ 11.3∗† 18.9∗† 18.1∗† 25.4∗† 15.9∗† 23.7∗† 15.4† 17.3∗ 20.9∗† 22.9† 21.0∗† 23.9† XH 18.6∗† 21.6∗† 22.1∗† 26.8∗† 29.8† 29.3∗† 25.1∗† 28.1∗† 30.5∗† 11.0∗† 17.9∗† 17.6∗† 24.0∗† 15.3∗† 22.2∗† 14.3∗† 17.7∗† 19.8∗† 23.2∗ 19.5∗† 25.0∗ DRAGQPP_QPP 19.5 28.4 28.4 17.1 23.3 20.8 15.9 22.8 23.0 DRAGSFT_SFT 24.5 31.9 32.3 19.3 26.2 24.4 19.2 24.6 25.4 FRAMES L 14.2∗† 13.2∗† 12.1∗† 22.9∗† 20.6∗† 18.5∗† 18.2∗† 17.5∗† 17.7∗† 8.1∗† 12.6∗† 13.9∗† 19.5∗† 9.8∗† 13.8∗† 6.3∗† 9.5∗† 11.2∗† 15.0∗† 8.1∗† 11.3∗† M 18.3∗† 18.1∗† 18.2∗† 28.4∗† 27.2∗† 27.1∗† 21.5∗† 22.2∗† 25.1∗† 12.6∗† 18.0∗† 20.2∗ 26.5∗† 14.4∗† 18.9† 10.6∗† 15.3† 17.9∗† 23.3∗† 12.6∗† 17.6† H 19.4† 19.5† 17.6∗† 28.6† 28.8† 26.3∗† 22.9∗† 23.3∗† 23.5∗† 10.7∗† 17.0† 19.1∗ 24.9† 12.1∗† 18.0† 11.7∗† 16.8† 18.4∗† 24.0∗† 13.8∗† 19.0∗ XH 21.8∗† 21.1∗ 20.4∗† 32.1∗ 30.6∗† 29.6† 26.5∗ 25.2∗† 26.0∗ 11.3∗† 18.6∗† 19.6∗† 27.6∗ 13.1∗† 20.3∗ 12.0∗† 17.8∗† 19.0∗† 24.3∗† 13.8∗† 18.3∗† DRAGQPP_QPP 19.3 29.5 23.9 15.8 24.8 18.4 15.3 22.9 16.3 DRAGSFT_SFT 23.3 33.9 27.2 19.5 28.1 21.3 18.6 25.8 18.9 Table 3. End-to-end RAG performance of three LLMs across four QA benchmarks under all retriever-generator configurations. Rows correspond to retriever complexity levels (θ∈L,M,H,XHθ∈\L,M,H,XH\), while columns correspond to generator complexity levels (ϕ∈L,M,Hφ∈\L,M,H\ for GPT-OSS and ϕ∈L,Hφ∈\L,H\ for Qwen and Gemma). We report Exact Match (EM), F1, Accuracy, and average per-query inference time. Among static configurations, bold numbers denote the best result within each retriever block (best generator for a fixed retriever), while underlined numbers denote the best result within each generator block (best retriever for a fixed generator). We additionally bold the best of the two proposed adaptive methods. Asterisks (∗) and Dagger († ) indicate statistically significant differences compared to DRAGQPP_QPP and DRAGSFT_SFT respectively (p<0.05p<0.05). All reported results use 5 contextual examples. TriviaQA HotpotQA MuSiQue FRAMES (OOD) Model EM F1 Acc t(s) EM F1 Acc t(s) EM F1 Acc t(s) EM F1 Acc t(s) GPT-OSS RAGOrac_Orac 77.5 86.1 85.5 2.56 63.9 76.9 71.9 1.83 37.1 44.5 43.3 5.36 38.9 52.4 44.3 4.89 RAGmax_max 66.1 75.7 78.4 10.73 51.6 65.2 61.5 4.36 22.8 30.1 31.1 10.2 21.8 32.1 26.5 5.14 0-shot 42.5 52.3 53.0 1.02 20.7 27.9 34.8 0.83 5.4 10.4 21.6 1.73 10.9 17.6 23.8 1.72 DRAGAP_AP 67.3 76.2 78.9 5.74 52.3 67.9 64.2 2.67 24.6 32.2 32.5 6.43 22.8 33.7 27.8 3.20 DRAGPPT_PPT 52.7 65.8 65.2 5.12 43.7 57.9 55.3 2.87 16.8 26.7 26.9 6.45 16.4 27.3 21.1 3.22 DRAGQPP_QPP 65.4 73.9 76.7 5.14 49.2 63.1 60.8 2.18 19.5 28.4 28.4 6.36 19.3 29.5 23.9 3.15 DRAGSFT_SFT 68.1 77.1 79.6 5.37 53.2 67.6 63.8 3.11 24.5 31.9 32.3 6.85 23.3 33.9 27.2 3.28 Qwen RAGOrac_Orac 76.0 84.3 83.3 2.34 61.8 75.3 68.9 1.13 29.6 39.8 35.3 1.65 31.8 45.1 33.7 0.78 RAGmax_max 66.8 75.9 76.5 8.76 50.9 63.9 58.7 3.16 18.9 25.4 23.7 8.64 18.6 27.5 20.3 4.39 0-shot 50.6 58.3 56.5 0.82 21.3 29.8 24.1 0.86 4.9 11.6 7.5 1.07 10.4 17.9 11.5 1.41 DRAGAP_AP 67.2 75.6 76.3 4.37 50.8 63.9 58.9 1.28 19.9 26.5 24.9 4.87 18.8 27.8 21.1 2.30 DRAGPPT_PPT 54.7 67.8 66.5 4.35 46.3 58.4 54.4 1.18 15.3 21.6 19.2 4.76 12.7 20.5 16.8 1.93 DRAGQPP_QPP 64.9 74.3 75.1 4.10 48.2 61.3 55.9 1.21 17.1 23.3 20.8 4.23 15.8 24.8 18.4 1.84 DRAGSFT_SFT 67.1 76.2 76.9 4.46 50.5 63.9 58.2 1.37 19.3 26.2 24.4 5.10 19.5 28.1 21.3 2.14 Gemma RAGOrac_Orac 76.5 85.4 84.2 2.86 63.3 76.7 72.2 1.32 27.7 36.1 36.1 6.87 27.3 38.2 29.8 4.36 RAGmax_max 60.1 71.1 76.2 10.86 50.4 63.8 61.8 4.87 17.7 23.2 24.9 11.13 17.7 24.3 18.3 5.68 0-shot 55.8 64.3 66.9 1.32 27.1 36.8 30.3 1.09 9.4 18.8 11.9 1.04 16.3 26.1 18.0 1.55 DRAGAP_AP 61.4 71.7 75.8 5.7 50.8 63.4 60.5 2.7 17.4 24.4 25.1 7.7 18.2 25.5 18.6 3.4 DRAGPPT_PPT 51.8 61.6 64.5 3.77 45.8 59.3 57.3 2.1 15.2 22.3 22.8 7.3 15.1 21.2 16.5 3.1 DRAGQPP_QPP 58.5 68.4 74.3 5.34 48.4 61.2 59.4 2.2 15.9 22.8 23.0 7.16 15.3 22.9 16.3 3.35 DRAGSFT_SFT 61.2 71.9 76.8 5.67 51.1 64.1 62.2 2.30 19.2 24.6 25.4 7.34 18.6 25.8 18.9 3.51 Table 4. We compare static, oracle, and adaptive RAG configurations across TriviaQA, HotpotQA, MuSiQue, and FRAMES. Our adaptive methods, DRAGQPP_QPP (training-free) and DRAGSFT_SFT (supervised), select retriever–generator from available configurations. We report EM, F1-score, Accuracy, and average inference latency (time/second, represented in table as t(s)). The number of contexts used for few-shot experiments is 55. All evaluations are conducted on the full test sets to ensure statistical robustness. Bold denotes the best result among static and adaptive methods, while underline indicates the best over our proposed methods (i.e., grey portion). 5.4. Baselines We compare our adaptive methodology against the following baselines to evaluate the benefits of dynamic RAG configurations: • 0-shot: In this baseline, we directly predict the answer to a particular query without any supporting document, serves as lower bound. It shows the impact of generator’s parametric knowledge. • RAGmax_max: This represents a standard static RAG setup, where a fixed configuration is uniformly applied to all queries, and performance is reported for the best-performing configuration over the dataset. • RAGOrac_Orac: This represents the theoretical upper bound of an ideal adaptive RAG system as mentioned in Equation 1 of Section 3 (Efficiency-aware Oracle Configuration). • DRAGAP_AP: Our routing policy of RPP in DRAGQPP_QPP (in Equation 2) is dependent on pre-retrieval QPP, thus we define an upper-bound by replacing QPP with the ground-truth retrieval effectiveness (AP@50) of each retriever. This yields a retrieval-aware, sequential routing strategy that estimates the maximum achievable gain under perfect effectiveness signals. • DRAGPPT_PPT: In this case, given a query, the generator is provided with a natural language description of the available retriever-generator configurations and is asked to select the most suitable one, relying solely on parametric knowledge rather than retrieved evidence. The chosen configuration is then used to generate the final answer. This shows whether an LM can infer appropriate configurations from the query’s information need. This is a basic baseline from DRAG’s perspective. 5.5. Experimental Details Evaluation Metrics We assess the effectiveness of the downstream task using three standard metrics: Exact Match (EM), F1, and Accuracy (Acc), which capture exact correctness, partial lexical overlap, and answer containment, respectively. We report statistical significance at the query level using McNemar’s test for EM and Accuracy (due to comparison between binary outcomes), and a paired t-test for F1, which captures the comparison between systems. The retrieval quality is evaluated using AP@10 to assess the relevance of the retrieved contexts provided to the generator. Hyperparameter Details For Extra-High mode of retriever we use same the target LLM to decompose each query into atomic sub-queries (temperature =0.1=0.1). In this paper, for RPP module in DRAGQPP_QPP we employ Avg-IDF as we pre-retrieved QPP which is computed over query terms with respect to the corpus. It uses thresholds set of 75th75^th, 50th50^th, and 25th25^th percentiles for distinguishing all four retriever levels. For GPP, we use threshold set of perplexity scores at the 20th20^th percentile of the training distribution (where lower is better). Additionally, for DRAGSFT_SFT we used Qwen3-4B-Instruct. We train for 5 epochs with a learning rate of 2e-5, a cosine decay schedule with warmup ratio 0.15, weight decay 0.05, and an effective batch size of 256. The maximum sequence length is set to 1,280 tokens. The best checkpoint is selected based on combined (retrieval + generator) macro-F1. For generation, we use GPT-OSS (20B11 1 https://huggingface.co/openai/gpt-oss-20b), Qwen3 (8B22 2 https://huggingface.co/Qwen/Qwen3-8B) and Gemma (26B33 3 google/gemma-4-26B-A4B-it) both deployed using the vLLM inference engine. To accommodate the necessary reasoning tokens required by these strategies, we set the maximum generation budget (max_new_tokens) to 512512, 20482048, and 40964096 for the Low, Medium, and High modes, respectively. All experiments are conducted on NVIDIA A100 GPUs with a batch size of 1212. 6. Results and Discussion We present our experimental results to answer the proposed research questions in Section 5. 6.1. Effect of Retriever and Generator Complexity Table 3 reports the performance of each retriever-generator pair in terms of EM, F1-score, and Accuracy across all four QA benchmarks using three different families of LLMs. To address RQ1, we examine how varying the complexity individually influences end-to-end RAG performance, and whether scaling either component separately consistently yields gains. Overall, we observe that increasing component complexity leads to performance improvement, but the gains are not monotonic. When we fix the choice of generators and increase the retriever complexity, performance generally improves from lexical retrieval (θL _L) to dense (θM _M) and reranking-based pipelines (θH _H), with gains in all datasets, particularly higher gains for multi-hop benchmarks such as HotpotQA, MuSiQue, and FRAMES, where evidence is dispersed across multiple documents and stronger retrieval is needed. However, it saturates at higher retrieval levels (e.g., θH→θXH _H→ _XH) for all datasets except FRAMES, i.e., diminishing returns from retrieval scaling despite substantially higher computational cost . A likely reason of the effect is less evident in FRAMES is that its queries impose multiple constraints (numerical, temporal, multi-entity) and require evidence assembled from genuinely distinct sub-aspects, so atomic sub-query retrieval supplies a signal that single-pass retrievers miss. In contrast, increasing generator reasoning effort under a fixed retriever (particularly, for weak retrieval) shows comparatively smaller and inconsistent gains for all datasets. For example, for multi-hop dataset, MuSiQue, increasing reasoning effort under weak retrieval (θL _L) yields only a 7% improvement in terms of EM, but improves performance by 16.9% in terms of EM for θH _H. It shows that reasoning cannot compensate for poor retrieval quality and generator effectiveness is fundamentally constrained by retrieval quality, with stronger retrieval typically yielding larger gains than increased reasoning effort alone. Effectiveness–Efficiency Trade-off Table 3 reports downstream effectiveness, while Table 5 shows per-query latency for static RAG configurations. We observe a clear trade-off between effectiveness and computational cost, i.e., increasing retriever or generator complexity incurs substantially higher latency while providing only marginal downstream gains. For example, on HotpotQA (GPT-OSS), increasing generator complexity from ϕM _M to ϕH _H under θH _H improves EM only marginally (49.9→ 51.6), while increasing latency (2.34s→ 4.36s, per query). Similarly, under θXH _XH, the same increase very marginally (47.4→ 48.8) despite a high latency increase (4.10s→ 5.87s, per query). Moreover, stronger configurations are not always strictly better (e.g., θH _H outperforming θXH _XH), so uniformly allocating maximum retrieval and reasoning effort is inefficient. These findings motivate an adaptive routing strategy that dynamically allocates retrieval and generation complexity based on query requirements. (a) Static RAG Latency ϕ\θφ θ L M H XH L 0.11 0.33 1.04 3.51 M 0.38 0.67 2.34 4.10 H 1.02 1.70 4.36 5.87 (b) DRAG Latency Breakdown Time DRAGQPP_QPP DRAGSFT_SFT Decision 0.28 0.36 RAG 1.90 2.75 Total 2.18 3.11 Table 5. Per-query latency (seconds) on HotpotQA using GPT-OSS. (a) Static retriever-generator configurations across retrieval (θ) and generator (ϕφ) complexity levels. (b) Latency breakdown of adaptive methods, where decision time denotes routing overhead (IDF computation and perplexity estimation) and RAG time corresponds to downstream retrieval and generation. Retrieval indexing is excluded, as it is a one-time offline preprocessing cost. GreenGreen and redred cells indicate, respectively, lower and higher total latency w.r.t DRAGSFT_SFT. 6.2. Dynamic vs. Static RAG Performance To address RQ2, Table 4 compares our adaptive methods against oracle setup, RAGOrac_Orac and other baselines across downstream QA metrics for three LLM families. Being an oracle setup, RAGOrac_Orac consistently outperforms all adaptive methods and baselines. This performance gap highlights the difficulty of routing under realistic settings, where configuration decisions must be made with or without supervision. Among the baselines, DRAGPPT_PPT consistently outperforms 0-shot across nearly all datasets (except TriviaQA with Gemma), suggesting that directly prompting an LLM to predict the answer is insufficient, whereas explicitly predicting the retriever-generator configuration provides a more appropriate downstream prediction. Furthermore, DRAGAP_AP consistently improves over DRAGQPP_QPP across datasets, indicating that retrieval quality estimation remains a key bottleneck for unsupervised adaptive routing. Notably, both DRAGSFT_SFT and DRAGAP_AP outperform the static configuration, RAGmax_max, thus query-adaptive selection is more effective than uniformly assigning a fixed high-complexity pipeline to all queries. Finally, DRAGSFT_SFT consistently improves over DRAGQPP_QPP, suggesting that jointly learning query-specific retriever-generator interactions is more effective than sequential threshold-based routing, albeit at the cost of supervision. Figure 3. Effect of change in retrieved document count (k) on the performance of HotpotQA dataset. We analyze F1 scores under varying Retriever (θ) and Generator (ϕφ) complexities. The results demonstrate how increasing the number of documents impacts performance across different system configurations. Each line corresponds to a retrieval complexity. The shared legend applies to all subplots. Figure 4. Impact of retriever effectiveness on downstream QA performance using GPT-OSS on HotpotQA and MuSiQue. MAP@10 measures retrieval effectiveness, while F1 measures end-to-end QA performance under static RAG configurations. The bars correspond to retriever modes. RAGOrac_Orac DRAGSFT_SFT Query and Gold Answer Config Output Config Output Failure Type What is Mohamed Atta’s car, manufactured by the company that includes Datsun, an instance of? Ans: Nissan Altima XH / L a 2001 Nissan Altima XH / H a blue rental car Overestimation What is the oldest college in the state that contains Borough House Plantation? Ans: College of Charles Towne H / H College of Charles Towne L / M Columbia University Underestimation What is the tallest building in the state where KZAR is located? Ans: JPMorgan Chase Tower H / H JPMorgan Chase Tower L / M Transamerica Tower Overestimation What is the position of the first governor general of India? Ans: Governor-General of India L / H Governor-General of British India L / L Warren Hastings Wrong Entity What team does the person who hit the first home run at the new South Bronx stadium play for? Ans: New York Yankees M / L New York Yankees H / H Indians Wrong Entity Table 6. Qualitative failure cases on MuSiQue dataset. Each row shows a query where DRAGSFT_SFT selects the failure/suboptimal cases relative to the oracle RAGOrac_Orac, along with the resulting output error. Config columns represent the mode of retriever/ generator. never use vspace; the publishers won’t allow this anyway Performance vs Latency Figure 1 and Tables 4 illustrate the effectiveness and latency (sec/query) values of adaptive and static RAG systems. Overall, increasing retriever and generator complexity improves downstream performance but at substantially higher inference cost, with marginal gains at stronger configurations. We also observe a clear trade-off emerges between our two proposed DRAG methods, DRAGSFT_SFT consistently achieves better downstream effectiveness than DRAGQPP_QPP, typically improving performance by approximately 2-12%\% across datasets, but incurs a modest increase in latency (approximately 5-40%\%). While DRAGQPP_QPP remains training-free and lightweight, DRAGSFT_SFT leverages supervision to model query-specific interactions, resulting in better downstream performance with higher inference cost. Significance Testing Table 3 further highlights the statistical behavior of the DRAG framework. Across in-domain datasets, DRAGSFT_SFT consistently yields statistically significant gains over static configurations, whereas DRAGQPP_QPP often remains statistically comparable to static RAG with medium/high-complexity generators. Under the OOD setting (FRAMES), although DRAGSFT_SFT generally maintains stronger performance, improvements are not always statistically significant, suggesting that transferring routing decisions across datasets with different query types remains challenging. Latency Table 5 reports the per-query latency breakdown of adaptive RAG systems. We observe that the routing cost, i.e., model configuration prediction cost, is relatively less. Instead, most of the latency difference arises from retrieval and downstream generation (1.901.90s vs. 2.752.75s RAG time), here DRAGSFT_SFT picks higher-complexity configurations, trading latency for effectiveness, while DRAGQPP_QPP favors cheaper settings at the cost of a modest accuracy drop. 6.3. Model Generalization To address RQ3, we evaluate the robustness of our adaptive methods under an OOD setting using FRAMES, where models don’t rely on dataset-specific training (i.e., use training data of MuSiQue and are evaluated directly on FRAMES). From Tables 4 and 3, we observe that both DRAGQPP_QPP and DRAGSFT_SFT provide better results w.r.t all the baselines, including DRAGAP_AP across all three LLM families. Interestingly, Table 3 shows that for GPT-OSS on FRAMES dataset, the best static RAG performance is achieved under low or medium-reasoning generator settings with a fixed retriever choice, thus uniformly increasing reasoning effort is not always beneficial under distribution shift. In contrast, our adaptive methods not only achieve better downstream effectiveness than RAGmax_max and other baselines, but also incur a lower inference cost. Thus, our proposed framework, DRAG is robust and generalizable across OOD datasets. 6.4. Ablation Studies Impact of Increasing Context Size Figure 3 analyzes the sensitivity of RAG performance to the number of retrieved documents k across retrieval complexity levels and generator reasoning modes. While low-complexity retrieval (θL _L) shows steady improvement with increasing k, reflecting its lower per-document precision and reliance on broader context coverage, higher-complexity retrievers (θM _M, θH _H, θXH _XH) plateau early, as their stronger relevance signals are largely captured within a compact candidate set. This saturation behavior is consistent across all three generator reasoning levels, suggesting it is driven by retrieval quality rather than generation capacity, and collectively justifies our choice of k=5k=5 as a balance between evidence coverage and computational efficiency. Correlation between retrieval and downstream performance Figure 4 examines the relationship between retrieval effectiveness (MAP@10) and downstream QA performance (F1) across retrieval complexity levels on HotpotQA and MuSiQue. A clear positive correlation is observed: as retrieval complexity increases from lexical (θL _L) to dense (θM _M) and reranking-based pipelines (θH _H, θXH _XH), both MAP@10 and F1 improve consistently and proportionally across both benchmarks, confirming that stronger retrieval directly translates to better answer generation, particularly for multi-hop queries where evidence is dispersed across multiple documents. 6.5. Per-Query Analysis Table 6 presents qualitative failure cases of our best performing adaptive method DRAGSFT_SFT (as shown in Table 3) on MuSiQue, revealing three primary error patterns. Overestimation occurs when DRAGSFT_SFT routes simple queries to unnecessarily expensive configurations (e.g., θH _H/ϕXH _XH instead of θL _L/ϕXH _XH), introducing noisy evidence that degrades answer quality. Underestimation occurs when DRAGSFT_SFT assigns insufficient capacity to genuinely complex queries (e.g., θM _M/ϕL _L instead of θH _H/ϕH _H), leading to factually incorrect answers. Finally, wrong entity errors occur when suboptimal configuration selection (e.g., θH _H/ϕH _H instead of θL _L/ϕM _M) causes the model to retrieve incorrect evidence, leading to entity confusion during multi-hop reasoning. Together, these cases highlight that routing errors are systematically tied to query complexity estimation, and that better query representations could further improve adaptive configuration selection. 7. Conclusions and Future Work We presented a systematic study of how retrieval complexity and generation effort jointly affect end-to-end RAG performance. Our results show that increasing complexity does not consistently improve accuracy, and that high-complexity configurations are not strict supersets of simpler ones. This highlights the non-monotonic, query-dependent nature of RAG and the limitations of fixed retriever–generator settings. To address this, we introduced a training-free approach (DRAGQPP_QPP) and a supervised approach (DRAGSFT_SFT) under a common framework DRAG for per-query retriever-generator selection. Across multiple QA benchmarks, DRAGQPP_QPP matches strong static baselines while reducing latency, and DRAGSFT_SFT further improves the effectiveness–efficiency trade-off, achieving performance close to oracle routing. Future work will focus on developing more expressive routing policies that better capture the non-separable interactions between retrieval and generation, including richer supervision and reinforcement learning for optimizing cost–quality trade-offs. GenAI Usage Disclosure Generative AI tools were not used for core idea generation or experimental design. Its use was limited to minor writing and formatting. References Ammann et al. (2025) P. J. L. Ammann, J. Golde, and A. Akbik Question decomposition for retrieval-augmented generation. In ACL (4), p. 497–507. Cited by: §1, 4th item. Arabzadeh et al. (2026) N. Arabzadeh, A. Drozdov, M. Bendersky, and M. Zaharia Can QPP choose the right query variant? evaluating query variant selection for RAG pipelines. CoRR abs/2604.22661. Cited by: §4.1.1. Asai et al. (2024) A. Asai, Z. Wu, Y. Wang, A. Sil, and H. Hajishirzi Self-rag: learning to retrieve, generate, and critique through self-reflection. In ICLR, Cited by: §2, §2, §3. Chifu et al. (2018) A. Chifu, L. Laporte, J. Mothe, and Md. Z. Ullah Query performance prediction focused on summarized letor features. In SIGIR, p. 1177–1180. Cited by: §2. Cummins et al. (2011) R. Cummins, J. M. Jose, and C. O’Riordan Improved query performance prediction using standard deviation. In SIGIR, p. 1089–1090. Cited by: §2. Dale (2021) R. Dale GPT-3: what’s it good for?. Nat. Lang. Eng. 27 (1), p. 113–118. Cited by: §1. Datta et al. (2022) S. Datta, D. Ganguly, D. Greene, and M. Mitra Deep-qpp: A pairwise interaction-based deep learning model for supervised query performance prediction. In WSDM, p. 201–209. Cited by: §1, §2. Datta et al. (2024) S. Datta, D. Ganguly, S. MacAvaney, and D. Greene A deep learning approach for selective relevance feedback. In ECIR (2), Lecture Notes in Computer Science, p. 189–204. Cited by: §4.1.1. Datta et al. (2023) S. Datta, D. Ganguly, M. Mitra, and D. Greene A relative information gain-based query performance prediction framework with generated query variants. ACM Trans. Inf. Syst. 41 (2), p. 38:1–38:31. Cited by: §4.1.1. De Loupy and Bellot (2000) C. De Loupy and P. Bellot Evaluation of document retrieval systems and query difficulty. In LREC Workshop, Athens, p. 32–39. Cited by: §2. Dua et al. (2019) D. Dua, Y. Wang, P. Dasigi, G. Stanovsky, S. Singh, and M. Gardner DROP: a reading comprehension benchmark requiring discrete reasoning over paragraphs. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), J. Burstein, C. Doran, and T. Solorio (Eds.), Minneapolis, Minnesota, p. 2368–2378. External Links: Link, Document Cited by: §1. Ebrahimi et al. (2024) S. Ebrahimi, M. Khodabakhsh, N. Arabzadeh, and E. Bagheri Estimating query performance through rich contextualized query representations. In ECIR (4), Lecture Notes in Computer Science, p. 49–58. Cited by: §4.1.1. Gabburo et al. (2024) M. Gabburo, N. P. Jedema, S. Garg, L. F. R. Ribeiro, and A. Moschitti Measuring retrieval complexity in question answering systems. In ACL (Findings), Findings of ACL, p. 14636–14650. Cited by: §1. Ganguly et al. (2011) D. Ganguly, J. Leveling, W. Magdy, and G. J. F. Jones Patent query reduction using pseudo relevance feedback. In CIKM, p. 1953–1956. Cited by: §1. Gao et al. (2023) Y. Gao, Y. Xiong, X. Gao, K. Jia, J. Pan, Y. Bi, Y. Dai, J. Sun, Q. Guo, M. Wang, and H. Wang Retrieval-augmented generation for large language models: A survey. CoRR abs/2312.10997. Cited by: §1. Glass et al. (2022) M. R. Glass, G. Rossiello, Md. F. M. Chowdhury, A. Naik, P. Cai, and A. Gliozzo Re2G: retrieve, rerank, generate. In NAACL-HLT, p. 2701–2715. Cited by: §2. Guu et al. (2020) K. Guu, K. Lee, Z. Tung, P. Pasupat, and M. Chang Retrieval augmented language model pre-training. In ICML, Proceedings of Machine Learning Research, p. 3929–3938. Cited by: §2. He and Ounis (2006) B. He and I. Ounis Query performance prediction. Inf. Syst. 31 (7), p. 585–594. Cited by: §2. Izacard and Grave (2021) G. Izacard and E. Grave Leveraging passage retrieval with generative models for open domain question answering. In EACL, p. 874–880. Cited by: §2. Izacard et al. (2023) G. Izacard, P. Lewis, M. Lomeli, L. Hosseini, F. Petroni, T. Schick, J. Dwivedi-Yu, A. Joulin, S. Riedel, and E. Grave Atlas: few-shot learning with retrieval augmented language models. J. Mach. Learn. Res. 24, p. 251:1–251:43. Cited by: §2. Jeong et al. (2024) S. Jeong, J. Baek, S. Cho, S. J. Hwang, and J. Park Adaptive-rag: learning to adapt retrieval-augmented large language models through question complexity. In NAACL-HLT, p. 7036–7050. Cited by: §2. Ji et al. (2023) Z. Ji, N. Lee, R. Frieske, T. Yu, D. Su, Y. Xu, E. Ishii, Y. Bang, A. Madotto, and P. Fung Survey of hallucination in natural language generation. ACM Comput. Surv. 55 (12), p. 248:1–248:38. Cited by: §4.1.2. Jia et al. (2018) Z. Jia, A. Abujabal, R. Saha Roy, J. Strötgen, and G. Weikum TempQuestions: a benchmark for temporal question answering. In Companion Proceedings of the The Web Conference 2018, W ’18, Republic and Canton of Geneva, CHE, p. 1057–1062. External Links: ISBN 9781450356404, Link, Document Cited by: §1. Jiang et al. (2023) Z. Jiang, F. F. Xu, L. Gao, Z. Sun, Q. Liu, J. Dwivedi-Yu, Y. Yang, J. Callan, and G. Neubig Active retrieval augmented generation. In EMNLP, p. 7969–7992. Cited by: §2, §3. Joshi et al. (2017) M. Joshi, E. Choi, D. S. Weld, and L. Zettlemoyer TriviaQA: A large scale distantly supervised challenge dataset for reading comprehension. In ACL (1), p. 1601–1611. Cited by: §1, §5.1. Kanoulas et al. (2011) E. Kanoulas, B. Carterette, P. D. Clough, and M. Sanderson Evaluating multi-query sessions. In SIGIR, p. 1053–1062. Cited by: §1. Karpukhin et al. (2020) V. Karpukhin, B. Oguz, S. Min, P. Lewis, L. Wu, S. Edunov, D. Chen, and W. Yih Dense passage retrieval for open-domain question answering. In EMNLP (1), p. 6769–6781. Cited by: §1, §1. Khandelwal et al. (2020) U. Khandelwal, O. Levy, D. Jurafsky, L. Zettlemoyer, and M. Lewis Generalization through memorization: nearest neighbor language models. In ICLR, Cited by: §2. Khattab and Zaharia (2020) O. Khattab and M. Zaharia ColBERT: efficient and effective passage search via contextualized late interaction over BERT. In Proceedings of the 43rd International ACM SIGIR conference on research and development in Information Retrieval, SIGIR 2020, Virtual Event, China, July 25-30, 2020, J. Huang, Y. Chang, X. Cheng, J. Kamps, V. Murdock, J. Wen, and Y. Liu (Eds.), p. 39–48. External Links: Document, Link Cited by: §1. Kleinman et al. (2025) M. Kleinman, M. Trager, A. Achille, W. Xia, and S. Soatto E1: learning adaptive control of reasoning effort. CoRR abs/2510.27042. Cited by: §1. Krishna et al. (2025) S. Krishna, K. Krishna, A. Mohananey, S. Schwarcz, A. Stambler, S. Upadhyay, and M. Faruqui Fact, fetch, and reason: A unified evaluation of retrieval-augmented generation. In NAACL (Long Papers), p. 4745–4759. Cited by: §5.1. Kwiatkowski et al. (2019) T. Kwiatkowski, J. Palomaki, O. Redfield, M. Collins, A. Parikh, C. Alberti, D. Epstein, I. Polosukhin, J. Devlin, K. Lee, et al. Natural questions: a benchmark for question answering research. Transactions of the Association for Computational Linguistics 7, p. 453–466. Cited by: §1. Kwok (1996) K. L. Kwok A new method of weighting query terms for ad-hoc retrieval. In SIGIR, p. 187–195. Cited by: §4.1.1. Lan et al. (2023) T. Lan, D. Cai, Y. Wang, H. Huang, and X. Mao Copy is all you need. In ICLR, Cited by: §2. Lewis et al. (2020) P. Lewis, E. Perez, A. Piktus, F. Petroni, V. Karpukhin, N. Goyal, H. Küttler, M. Lewis, W. Yih, T. Rocktäschel, S. Riedel, and D. Kiela Retrieval-augmented generation for knowledge-intensive NLP tasks. In NeurIPS, Cited by: §1. Lin et al. (2024) X. V. Lin, X. Chen, M. Chen, W. Shi, M. Lomeli, R. James, P. Rodriguez, J. Kahn, G. Szilvasy, M. Lewis, L. Zettlemoyer, and W. Yih RA-DIT: retrieval-augmented dual instruction tuning. In ICLR, Cited by: §2. Luo et al. (2024) K. Luo, Z. Liu, S. Xiao, and K. Liu BGE landmark embedding: A chunking-free embedding method for retrieval augmented long-context large language models. CoRR abs/2402.11573. Cited by: 3rd item, 4th item. Mallen et al. (2023) A. Mallen, A. Asai, V. Zhong, R. Das, D. Khashabi, and H. Hajishirzi When not to trust language models: investigating effectiveness of parametric and non-parametric memories. In ACL (1), p. 9802–9822. Cited by: §2. Meng et al. (2024) C. Meng, N. Arabzadeh, A. Askari, M. Aliannejadi, and M. de Rijke Ranked list truncation for large language model-based re-ranking. In SIGIR, p. 141–151. Cited by: §1. Meng et al. (2025) C. Meng, N. Arabzadeh, A. Askari, M. Aliannejadi, and M. de Rijke Query performance prediction using relevance judgments generated by large language models. ACM Trans. Inf. Syst. 43 (4), p. 106:1–106:35. Cited by: §4.1.1. Mothe and Tanguy (2005) J. Mothe and L. Tanguy Linguistic features to predict query difficulty. In SIGIR, Predicting query difficulty-methods and applications workshop, p. 7–10. Cited by: §2. OpenAI (2025) OpenAI Gpt-oss-120b & gpt-oss-20b model card. CoRR abs/2508.10925. Cited by: 1st item. Parry et al. (2024) A. Parry, D. Ganguly, and M. Chandra "In-context learning" or: how I learned to stop worrying and love "applied information retrieval". In SIGIR, p. 14–25. Cited by: §1. Plaat et al. (2026) A. Plaat, A. Wong, S. Verberne, J. Broekens, N. van Stein, and T. Bäck Multi-step reasoning with large language models, a survey. ACM Comput. Surv. 58 (6), p. 160:1–160:35. Cited by: §1. Pradeep et al. (2021) R. Pradeep, R. Nogueira, and J. Lin The expando-mono-duo design pattern for text ranking with pretrained sequence-to-sequence models. CoRR abs/2101.05667. Cited by: §1. Pradeep et al. (2023) R. Pradeep, S. Sharifymoghaddam, and J. Lin RankZephyr: effective and robust zero-shot listwise reranking is a breeze!. CoRR abs/2312.02724. Cited by: §1. Qi et al. (2021) P. Qi, H. Lee, T. Sido, and C. D. Manning Answering open-domain questions of varying reasoning steps from text. In EMNLP (1), p. 3599–3614. Cited by: §2. Robertson (2004) S. Robertson Understanding inverse document frequency: on theoretical arguments for IDF. J. Documentation 60 (5), p. 503–520. Cited by: §1, 1st item. Roitman et al. (2017) H. Roitman, S. Erera, and B. Weiner Robust standard deviation estimation for query performance prediction. In ICTIR, p. 245–248. Cited by: §2. Santra et al. (2025) P. Santra, M. Ghosh, D. Ganguly, P. Basuchowdhuri, and S. K. Naskar HF-RAG: hierarchical fusion-based RAG with multiple sources and rankers. In CIKM, p. 5202–5207. Cited by: §2. Shi et al. (2024) W. Shi, S. Min, M. Yasunaga, M. Seo, R. James, M. Lewis, L. Zettlemoyer, and W. Yih REPLUG: retrieval-augmented black-box language models. In NAACL-HLT, p. 8371–8384. Cited by: §2. Shorinwa et al. (2026) O. Shorinwa, Z. Mei, J. Lidard, A. Z. Ren, and A. Majumdar A survey on uncertainty quantification of large language models: taxonomy, open research challenges, and future directions. ACM Comput. Surv. 58 (3), p. 63:1–63:38. Cited by: 2nd item, §4.1.2. Shtok et al. (2012) A. Shtok, O. Kurland, D. Carmel, F. Raiber, and G. Markovits Predicting query performance by query-drift estimation. ACM Trans. Inf. Syst. 30 (2), p. 11:1–11:35. Cited by: §2. Shtok et al. (2010) A. Shtok, O. Kurland, and D. Carmel Using statistical decision theory and relevance models for query-performance prediction. In SIGIR, p. 259–266. Cited by: §2. Sinhababu et al. (2024) N. Sinhababu, A. Parry, D. Ganguly, D. Samanta, and P. Mitra Few-shot prompting for pairwise ranking: an effective non-parametric retrieval model. In EMNLP (Findings), Findings of ACL, p. 12363–12377. Cited by: §1. Snell et al. (2024) C. Snell, J. Lee, K. Xu, and A. Kumar Scaling LLM test-time compute optimally can be more effective than scaling model parameters. CoRR abs/2408.03314. Cited by: §5.3. Talmor and Berant (2018) A. Talmor and J. Berant The web as a knowledge-base for answering complex questions. In Proceedings of the 2018 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long Papers), M. Walker, H. Ji, and A. Stent (Eds.), New Orleans, Louisiana, p. 641–651. External Links: Link, Document Cited by: §1. Tamber et al. (2023) M. S. Tamber, R. Pradeep, and J. Lin Scaling down, litting up: efficient zero-shot listwise reranking with seq2seq encoder-decoder models. CoRR abs/2312.16098. Cited by: §1. Tao and Wu (2014) Y. Tao and S. Wu Query performance prediction by considering score magnitude and variance together. In CIKM, p. 1891–1894. Cited by: §2. Team et al. (2026) G. Team, S. E. Abd, V. Aggarwal, R. Algayres, A. Andreev, O. Bachem, I. Ballantyne, C. Brick, V. Cărbune, M. Casbon, et al. Gemma 4 technical report. arXiv preprint arXiv:2607.02770. Cited by: 3rd item. Team (2025) Q. Team Qwen3 technical report. CoRR abs/2505.09388. Cited by: 2nd item. Tian et al. (2026) F. Tian, D. Ganguly, and C. Macdonald Predicting retrieval utility and answer quality in retrieval-augmented generation. In ECIR (1), Lecture Notes in Computer Science, p. 368–385. Cited by: §4.1.1. Touvron et al. (2023) H. Touvron, T. Lavril, G. Izacard, X. Martinet, M. Lachaux, T. Lacroix, B. Rozière, N. Goyal, E. Hambro, F. Azhar, et al. Llama: open and efficient foundation language models. ArXiv preprint abs/2302.13971. External Links: Link Cited by: §1. Trivedi et al. (2022) H. Trivedi, N. Balasubramanian, T. Khot, and A. Sabharwal ♪ MuSiQue: multihop questions via single-hop question composition. Trans. Assoc. Comput. Linguistics 10, p. 539–554. Cited by: §1, §5.1. Wang et al. (2024a) B. Wang, W. Ping, L. McAfee, P. Xu, B. Li, M. Shoeybi, and B. Catanzaro InstructRetro: instruction tuning post retrieval-augmented pretraining. In ICML, Proceedings of Machine Learning Research, p. 51255–51272. Cited by: §2. Wang et al. (2022) L. Wang, N. Yang, X. Huang, B. Jiao, L. Yang, D. Jiang, R. Majumder, and F. Wei Text embeddings by weakly-supervised contrastive pre-training. CoRR abs/2212.03533. Cited by: §1, §1, 2nd item. Wang et al. (2024b) L. Wang, N. Yang, X. Huang, L. Yang, R. Majumder, and F. Wei Improving text embeddings with large language models. In ACL (1), p. 11897–11916. Cited by: §1. Wang et al. (2023) X. Wang, J. Wei, D. Schuurmans, Q. V. Le, E. H. Chi, S. Narang, A. Chowdhery, and D. Zhou Self-consistency improves chain of thought reasoning in language models. In ICLR, Cited by: §2. Xu et al. (2025) S. Xu, L. Pang, H. Shen, and X. Cheng A theory for token-level harmonization in retrieval-augmented generation. In ICLR, Cited by: §4.1.2. Yang et al. (2018) Z. Yang, P. Qi, S. Zhang, Y. Bengio, W. W. Cohen, R. Salakhutdinov, and C. D. Manning HotpotQA: A dataset for diverse, explainable multi-hop question answering. In EMNLP, p. 2369–2380. Cited by: §1, §5.1. Yani and Krisnadhi (2021) M. Yani and A. A. Krisnadhi Challenges, techniques, and trends of simple knowledge graph question answering: A survey. Inf. 12 (7), p. 271. Cited by: §1. Yao et al. (2023) S. Yao, J. Zhao, D. Yu, N. Du, I. Shafran, K. R. Narasimhan, and Y. Cao ReAct: synergizing reasoning and acting in language models. In The Eleventh International Conference on Learning Representations, ICLR 2023, Kigali, Rwanda, May 1-5, 2023, External Links: Link Cited by: §2. Ye et al. (2023) Q. Ye, I. Beltagy, M. E. Peters, X. Ren, and H. Hajishirzi FiD-icl: A fusion-in-decoder approach for efficient in-context learning. In ACL’23 (1), p. 8158–8185. Cited by: §1. Zamani et al. (2018) H. Zamani, W. B. Croft, and J. S. Culpepper Neural query performance prediction using weak supervision from multiple signals. In SIGIR’18, p. 105–114. Cited by: §2. Zhang et al. (2023) F. Zhang, B. Chen, Y. Zhang, J. Keung, J. Liu, D. Zan, Y. Mao, J. Lou, and W. Chen RepoCoder: repository-level code completion through iterative retrieval and generation. In EMNLP’23, p. 2471–2484. Cited by: §2. Zhang et al. (2024) L. Zhang, Y. Zhang, D. Long, P. Xie, M. Zhang, and M. Zhang A two-stage adaptation of large language models for text ranking. In ACL’24 (Findings), p. 11880–11891. Cited by: §1. Zhong et al. (2022) Z. Zhong, T. Lei, and D. Chen Training language models with memory augmentation. In EMNLP, p. 5657–5673. Cited by: §2. Zhou and Croft (2007) Y. Zhou and W. B. Croft Query performance prediction in web search environments. In SIGIR, p. 543–550. Cited by: 2nd item, §2. Zhu et al. (2021) F. Zhu, W. Lei, C. Wang, J. Zheng, S. Poria, and T. Chua Retrieving and reading: A comprehensive survey on open-domain question answering. CoRR abs/2101.00774. Cited by: §1. Zhuang et al. (2023) H. Zhuang, Z. Qin, R. Jagerman, K. Hui, J. Ma, J. Lu, J. Ni, X. Wang, and M. Bendersky RankT5: fine-tuning T5 for text ranking with ranking losses. In SIGIR, p. 2308–2313. Cited by: §1. Zhuang et al. (2025) S. Zhuang, X. Ma, B. Koopman, J. Lin, and G. Zuccon Rank-r1: enhancing reasoning in llm-based document rerankers via reinforcement learning. CoRR abs/2503.06034. Cited by: §1.