Agentic Information Retrieval

Learns dense bi-encoder embeddings for questions and passages, beating BM25 on open-domain QA retrieval.

Why it matters Established the dense-retrieval paradigm every later neural retriever and RAG system builds on.

Couples a seq2seq generator with a non-parametric DPR index, retrieving passages to condition generation.

Why it matters Named and defined retrieval-augmented generation — the architecture the whole agentic-IR stack extends.

Has an LLM write a hypothetical answer document, embeds that, and retrieves real neighbors — with zero relevance labels.

Why it matters First clean proof that LLM generation at query time can replace supervised dense retrieval; a precursor to query-expansion-as-reasoning.

Maps the RAG design space across naive, advanced, and modular paradigms with a retrieval/augmentation/generation taxonomy.

Why it matters The reference map for where any retrieval technique sits inside the RAG pipeline.

Plain-language abstract ReAct is a prompting framework for large language models (LLMs) that interleaves verbal reasoning traces with concrete actions in a single generation loop. Instead of reasoning alone (chain-of-thought) or acting alone (action-plan generation), ReAct lets a model think through a step, take an action such as querying a knowledge base, observe the result, and then continue reasoning — all within one prompted sequence. The paper was published as a conference paper at ICLR 2023.

Motivation Prior work on LLMs treated reasoning (chain-of-thought prompting) and acting (action-plan generation for interactive environments) as separate capabilities. Chain-of-thought reasoning is static and grounded only in the model's internal representations, making it prone to hallucination and error propagation. Action-focused approaches lacked high-level verbal reasoning and working memory. No prior work had systematically studied how combining the two in a synergistic, interleaved manner could benefit general task solving.

Methodology ReAct prompts an LLM to generate both reasoning traces and task-specific actions in an interleaved fashion. It was evaluated on four benchmarks: two knowledge-intensive language tasks — multi-hop question answering (HotpotQA) and fact verification (Fever), where the model calls a Wikipedia API for external information — and two interactive decision-making benchmarks (ALFWorld and WebShop). The approach uses few-shot in-context prompting, with only one or two in-context examples provided, and is compared against chain-of-thought (reason-only), act-only, imitation learning, and reinforcement learning baselines.

Results On HotpotQA and Fever, ReAct reduced hallucination and error propagation compared to chain-of-thought baselines by grounding reasoning in retrieved Wikipedia facts, while also producing more human-interpretable task-solving trajectories. On the interactive decision-making benchmarks ALFWorld and WebShop, ReAct outperformed imitation and reinforcement learning methods by an absolute success rate of 34% and 10% respectively, using only one or two in-context examples.

Interleaves retrieval with each chain-of-thought step for multi-hop questions, using partial reasoning to drive the next query.

Why it matters Showed multi-hop retrieval must be reasoning-guided and iterative, not single-shot — the seed of reasoning-intensive retrieval.

Actively decides when to retrieve by watching for low-confidence tokens, then retrieves using the upcoming sentence as the query.

Why it matters Made retrieval timing itself a model decision, closing the gap between 'always retrieve' and 'never retrieve.'

Trains the model to emit reflection tokens that decide when to retrieve and critique whether passages are relevant and supported.

Why it matters Folded retrieval control and self-critique into the model's own decoding — an early test-time-compute-for-retrieval signal.

Uses reinforcement learning to train an LLM to interleave reasoning with live search-engine calls, learning when and what to query.

Why it matters Brings the o1/R1-style reasoning-RL recipe to agentic search, optimizing the retrieve-reason loop directly for the answer.

Runs Monte Carlo Tree Search over interleaved reasoning and retrieval steps, letting a small model scale inference-time compute.

Why it matters Shows search-over-reasoning-paths lets small models rival frontier LLMs on knowledge-intensive tasks — a deliberate test-time-compute lever.

Plain-language abstract Lexical, semantic, and multimodal retrievers have complementary strengths over visually rich documents, but systems usually wire them into fixed pipelines. This paper lets an agent learn the orchestration: a meta-agent studies the task agent's failures, probes the same retrieval tools to diagnose root causes, and rewrites the agent's instructions, so retrieval becomes an adaptive per-step reasoning decision instead of a fixed front-end stage.

Motivation On long multimodal documents no single retrieval paradigm suffices across reasoning steps: BM25 owns exact terms, ColBERT conceptual matching, ColPali visual and layout cues. Static fusion schemes cannot adapt when the useful retriever changes from one reasoning step to the next, or when retrieved evidence must be filtered, compared, and reconciled before it becomes useful.

Methodology A tool-using task agent iterates over a toolset (BM25, ColBERT, ColPali, VLM-based page retrieval, a calculator), maintaining a scratchpad and deciding at each step which evidence to gather and how to compose it. A failure-driven meta-agent operates offline: given a failed trajectory and the gold answer, it generates and executes analysis code against the same retrievers to diagnose the root cause, then proposes targeted updates to the task agent's system prompt and tool-parser instructions. Only the evolved task agent is deployed at inference.

Results With Gemini 3.1 Flash the evolved agent improves from 42.4% to 62.0% on MMLongBench-Doc and from 73.4% to 85.1% on DocBench; with GPT-5-mini from 40.7% to 55.4% and 68.6% to 79.3%, up to +19.6 points over the unevolved baseline and ahead of MACT, MDocAgent, and SimpleDoc. Retrieval analyses attribute the gains to adaptive routing and evidence composition rather than any single dominant retrieval mode, and evolution traces show a progressive shift from narrow lexical behavior to rich multi-tool coordination.

Plain-language abstract WebSwarm is a multi-agent web-search framework that builds its task decomposition and agent collaboration during inference instead of fixing them upfront. A root agent instantiates search nodes as evidence accumulates; each node couples a local objective with a search mode and can either search on its own or recursively spawn and coordinate child nodes, returning evidence upward so parents can expand, revise, or aggregate. It is evaluated on four deep, wide, and interleaved web-search benchmarks.

Motivation A single ReAct-style agent has one long trajectory and limited context, so it handles either depth or coverage but not both at once. Existing multi-agent search systems usually decompose only at the root, apply one fixed collaboration pattern, and split tasks by surface query semantics, leaving them short on recursive depth, adaptability, and evidence-grounded expansion, because in deep-and-wide tasks the solving structure only emerges as intermediate evidence reveals new entities and constraints.

Methodology WebSwarm organizes search as progressive recursive delegation. Each node's search mode picks a local collaboration structure, parallel divide-and-conquer, sequential search-and-verification, or multi-path sampling and aggregation, and the node either solves directly or delegates children. Two signals keep recursion from going blind: a lightweight web-probing step determines whether relevant evidence is concentrated in a few aggregated pages or dispersed along a dimension, guiding how nodes expand, and trajectory experience distilled from earlier homogeneous sibling nodes guides later ones. It is tested on BrowseComp-Plus, WideSearch, DeepWideSearch, and GISA across several backbones.

Results WebSwarm consistently outperforms single-agent ReAct and multi-agent baselines across all four benchmarks, improving over ReAct by 17.50 accuracy points on BrowseComp-Plus and by 10.91 Row F1 and 9.76 Item F1 on WideSearch-EN. Ablations show both mechanisms matter: removing recursive delegation lowers BrowseComp-Plus accuracy from 68.00 to 63.50, and removing web-probing inflates average web-tool calls (for example from 137.03 to 239.90), indicating it mainly reduces redundant, misaligned search.

Plain-language abstract Retrieval is trained and scored on static utility: give a reader the document and a question and see whether the answer improves. This paper shows that assumption breaks once a language model acts as a multi-step search agent that issues several queries and reasons across turns. Replaying 1000 HotpotQA trajectories from a ReAct agent and deleting each document the agent read one at a time, the authors define Counterfactual Trajectory Utility (CTU) from three deltas (final-answer quality, next-query retrieval quality, and turn count) and cross it against Static RAG Utility (SRU). The two are nearly statistically independent; roughly a third of read documents are 'bridge documents' that are causally load-bearing yet look useless to a static reader.

Motivation Standard IR metrics such as nDCG, MAP, and MRR, the training objective of most learned rankers, and the usual way retrieval-augmented generation is evaluated all reduce to the same static question and assume a reader sees the question and document together with no history and no plans. That assumption stops holding once a ReAct-style agent reads a question, decides what it does not know, searches, reads the result, and searches again, because the link between a document and the final answer runs through several turns. A document can be the reason the agent succeeds without containing anything resembling the answer, and one that contains the answer outright can change nothing because the agent already knew it. The authors set out to measure that gap rather than argue it.

Methodology They build Counterfactual Trajectory Exploration over a ReAct agent on a stratified 1000-question HotpotQA sample: for every document read at every step, delete that single document from the ranked list, hand the agent the remaining evidence, and replay the rest of the trajectory with everything else held fixed, so the original and counterfactual runs differ in exactly one thing. CTU combines the answer, next-query, and effort deltas and is thresholded at the point of zero causal effect. Crossing CTU against SRU over 23,322 document observations yields a contingency table, and a robustness check replaces the reader-based SRU axis with a BM25 and cross-encoder proxy. A second experiment uses the Observable Entity Relevance (OER) measure over 227,139 observations to test the proposed mechanism.

Results SRU and CTU are close to statistically independent (Spearman rho = -0.026), and 35.7% of read documents land in the bridge cell (causally useful, statically useless); the pattern survives the BM25 and cross-encoder proxy with a 27.2% bridge cell on an evenly spread axis. Mechanistically, entities with high Observable Entity Relevance propagate into the agent's next query 4.02 times more often than non-discriminative entities (6.1% versus 1.5%), so a bridge document earns its keep by supplying a discriminative entity that redirects the search. The authors flag a skew in the static-utility axis that limits how much the headline quadrant number carries on its own.

A benchmark where relevance requires reasoning rather than keyword or semantic overlap; standard retrievers score poorly.

Why it matters Defined the yardstick for reasoning-intensive retrieval and exposed how far embeddings alone fall short.

First retriever trained specifically for reasoning tasks, via a synthetic pipeline of hard queries and hard negatives; SOTA on BRIGHT.

Why it matters Proves retrievers themselves — not just rerankers — can be trained to reason, and that they exploit test-time compute via richer rewritten queries.

Instruction-tunes a single LLM to both rank contexts and generate the answer, unifying reranking and generation.

Why it matters Collapsed reranker and generator into one model — a step toward retrieval as a reasoning capability rather than a separate component.

Systematizes reasoning-intensive retrieval: benchmarks organized by domain, and a taxonomy of where and how reasoning enters the pipeline.

Why it matters The first roadmap of the exact subfield SID-1 sits in, organizing a fragmented, fast-moving area.

Plain-language abstract ProjAgent is a repository-level code generation system that adds procedural similarity as an explicit retrieval signal. It decomposes a target function into reasoning steps and uses an agentic workflow to retrieve repository functions that implement similar procedures at each step, represented through LLM hidden-state projections, then combines that procedural context with conventional lexical and semantic retrieval and repairs the generated code with a static-analysis feedback loop.

Motivation Repository-level code generation depends on retrieving context across cross-file dependencies and project conventions, but lexical and semantic retrieval surface only textually or semantically similar code. Useful context often comes from functions that implement the same procedure, such as input validation, unit conversion, or state transformation, while sharing little naming, type, or domain overlap, so surface-similarity retrieval overlooks them; the paper's example pair of guard-clause validators scores just 0.38 BM25 and 0.59 embedding similarity.

Methodology ProjAgent represents procedural similarity with projections of LLM hidden states, which encode implementation behavior beyond surface text. An agentic retrieval workflow decomposes the target function into steps, identifies and validates a small set of procedurally related functions, then expands the set via projection-similarity retrieval and merges it with lexical and semantic retrieval to capture project APIs, symbols, and structure. A conservative static-analysis feedback loop iteratively repairs the generated code using compiler and static-analysis feedback. It is evaluated on REPOCOD, with an ablation on the 85 Astropy problems.

Results On REPOCOD, ProjAgent reaches 41.14% Pass@1, improving Pass@1 by 12.31% over sparse, dense, and same-file retrieval baselines and outperforming SpecAgent. Ablations show procedural and semantic retrieval are complementary and both load-bearing: removing procedural context drops Pass@1 from 41.14% to 25.76%, a larger fall than removing semantic context, while the static-analysis feedback loop adds a modest but measurable improvement.

The first reranker trained to spend test-time compute: distills R1/o1 reasoning traces so a small model reasons before scoring relevance.

Why it matters The direct academic statement of SID-1's thesis — explainable, test-time-compute reranking that generalizes out of distribution.

Distills then RL-refines reasoning into a 3B reranker that generates relevance explanations at inference; third on BRIGHT, beating 20x-larger models.

Why it matters Shows the test-time-compute reranking win survives heavy distillation — small, cheap, explainable rerankers that reason.

A verbal reranker that reasons in natural language to bridge retrieval and the generator, instead of injecting raw passages.

Why it matters Positions reasoning-at-rerank as the missing connective tissue of RAG.

Critic-free policy optimization that turns retrieval interactions into localized credit signals for latent reasoning steps.

Why it matters Tackles the credit-assignment problem blocking the training of reasoning-based retrieval agents — the next training frontier.

Unifies reasoning-driven generation, retrieval, and compression in one LLM, sharing training across embedding and generative tasks.

Why it matters Points toward a single model that retrieves, reasons, and writes — erasing the retriever/generator boundary.