Deep Research: A Systematic Survey

ArXiv: 2512.02038

🎯 Pitch

Think you know LLM search? This survey reveals that today’s “deep research” agents are autonomously orchestrating multi-step workflows with persistent memory—far beyond single-shot retrieval—and yet the field still lacks a common technical vocabulary to even compare them. The authors disentangle the hype by delivering a crisp, three-phase capability roadmap and a component-by-component blueprint, showing exactly where simple RAG ends and a true AI research agent begins.

1. Executive Summary

This survey presents a systematic taxonomy and roadmap for Deep Research (DR) — a paradigm in which large language models function as autonomous research agents that iteratively decompose complex problems, acquire evidence through tool use, and synthesize verified insights into coherent long-form outputs. The paper formalizes a three-phase capability trajectory — Agentic Search, Integrated Research, and Full-stack AI Scientist — and decomposes DR systems into four core components: query planning (decomposing questions into sub-queries via parallel, sequential, or tree-based strategies), information acquisition (determining when and how to retrieve), memory management (consolidating, indexing, updating, and forgetting context across long horizons), and answer generation (integrating evidence into structured, attributable reports). The survey consolidates optimization techniques across three paradigms — workflow prompting (multi-agent orchestration exemplified by Anthropic’s system), supervised fine-tuning (strong-to-weak distillation and iterative self-evolution), and end-to-end agentic reinforcement learning (PPO and GRPO applied to both individual modules and entire pipelines) — while cataloging evaluation benchmarks spanning agentic information seeking, comprehensive report generation, and AI-for-research tasks, establishing that DR fundamentally extends beyond conventional RAG through flexible tool interaction, long-horizon autonomous workflows, and verifiable language interfaces.

2. Context and Motivation

The Core Problem: Deep Research Systems Lack a Coherent Technical Identity

The fundamental gap this paper addresses is that the field has no shared vocabulary, taxonomy, or architectural blueprint for what constitutes a Deep Research system. While individual labs and companies have built increasingly capable research agents — OpenAI's Deep Research, Google's Gemini Deep Research, Anthropic's multi-agent research system, Grok's DeepSearch, and numerous open-source efforts — each operates under different design assumptions, optimization strategies, and evaluation protocols. The term "deep research" has become a marketing label as much as a technical descriptor, creating confusion about what capabilities these systems actually possess and how to compare them meaningfully.

This gap matters because deep research represents a qualitative shift in how LLMs are deployed. Unlike older paradigms where models produced answers from static parametric knowledge or retrieved a few passages before generating a response, DR systems orchestrate multi-step workflows: they plan sub-questions, search the live web, navigate through documents, filter evidence, maintain memory across tens or hundreds of interactions, and synthesize findings into structured reports with verifiable citations. The complexity of this orchestration means that design choices in one component (e.g., whether to retrieve before or after a reasoning step) cascade through the entire pipeline, yet without a systematic framework, practitioners have no principled basis for making these choices. The paper states this explicitly in Section 1:

"despite rapid progress, there remains no comprehensive survey that systematically analyzes the key components, technical details, and open challenges of DR"

The practical consequence is that researchers building DR systems reinvent the same infrastructure repeatedly, organizations evaluating DR capabilities lack standardized benchmarks, and the broader AI community cannot track whether progress represents genuine capability improvements or merely more sophisticated engineering on static benchmarks.

Why This Problem Is Important: Beyond Simple QA to Autonomous Research

The significance of formalizing DR extends beyond academic taxonomy. The paper identifies three shifts that make DR systems qualitatively different from prior paradigms and essential for real-world deployment (Section 2.3):

Flexible interaction with the digital world. Conventional RAG systems operate against static, pre-indexed corpora — typically a fixed collection of documents embedded into a vector database and retrieved via similarity search. Real-world tasks, however, demand interaction with dynamic environments: search engines whose results change hourly, web APIs with authentication layers, structured databases requiring SQL queries, code executors for computational verification. DR systems extend the action space of LLMs to include these tools, enabling agents to access up-to-date information, execute operations in real environments, and verify hypotheses through computation rather than relying solely on memorized facts. This capability is not a marginal improvement — it transforms LLMs from passive knowledge retrievers into active investigators that can probe the world.

Long-horizon planning with autonomous workflows. Complex research-like problems — conducting a market analysis across five competitors, synthesizing scientific literature on a novel drug target, planning an itinerary under multiple constraints — require agents to coordinate dozens of subtasks with logical dependencies. A market analysis might require: (1) identifying the top competitors, (2) retrieving their product offerings, (3) extracting pricing information, (4) comparing feature matrices, (5) analyzing recent news for strategic moves, (6) synthesizing financial data where available, and (7) writing a structured report. Each step may generate information that changes the plan for subsequent steps — discovering a new competitor mid-analysis requires revisiting earlier assumptions. Conventional RAG has no mechanism for this kind of closed-loop control and multi-turn reasoning. DR systems, by contrast, architect workflows where the model can autonomously plan, revise, and optimize its approach toward long-horizon objectives.

Reliable language interfaces for open-ended tasks. LLMs hallucinate — they generate plausible-sounding but factually incorrect statements. This is problematic in any setting, but catastrophic in research contexts where outputs inform decisions. The paper identifies that DR systems introduce verifiable mechanisms that align natural language outputs with grounded evidence, establishing a more reliable interface between human users and autonomous research agents. Rather than trusting the model's parametric knowledge, DR systems require explicit citations to retrieved sources, cross-source validation, and structured reasoning that exposes intermediate steps for audit. This is not just about accuracy — it is about building trustworthy autonomous systems that humans can rely on for consequential analysis.

Prior Approaches and Where They Fall Short

The paper identifies three existing paradigms that partially address the capabilities DR systems aim to integrate, but each falls short in fundamental ways (Section 2.3, Table 1):

Standard Retrieval-Augmented Generation (RAG) represents the most widely deployed approach for grounding LLM outputs in external knowledge. In RAG, a user query triggers retrieval from a vector database (e.g., dense embeddings of Wikipedia), the top-k passages are appended to the LLM's context, and the model generates an answer conditioned on this retrieved evidence. The approach is well-understood, computationally efficient, and effective for single-hop factual queries. However, the paper identifies that RAG's limitations are structural, not incidental:

Static retrieval loop: RAG operates against pre-indexed corpora — what you indexed is what you can retrieve. Real-world questions often demand information not present in any corpus the system builder can anticipate, necessitating live search or API access.
No autonomous workflow: RAG typically performs a single retrieval-generation cycle. There is no mechanism for decomposing a complex question into sub-questions, iteratively refining retrieval based on intermediate findings, or synthesizing evidence across multiple retrieval rounds.
Narrow action space: RAG's only tool is retrieval from a fixed corpus. It cannot execute code to verify a computation, navigate web pages to extract data, or query structured databases for precise factual lookups.
Output limitations: RAG produces short-span answers (a sentence, a paragraph) rather than structured reports with citation chains, multiple sections, and explicit reasoning.

The paper cites extensive prior survey work on RAG ([89, 72] in the paper's references) but positions these as necessary context rather than sufficient solutions — RAG is a component within DR systems, not a substitute for them.

Web-based agents and tool-augmented LLMs represent a step toward broader action spaces. Systems like WebGPT ([221]), Toolformer ([274]), and ReAct ([428]) demonstrated that LLMs can learn to issue search queries, click on links, invoke calculators, and call APIs as part of their reasoning process. These works established the feasibility of tool use but operated under constraints that prevent them from being full DR systems:

Narrow task framing: WebGPT was evaluated on answering specific factual questions from ELI5, not on synthesizing multi-page research reports. The task horizon was short — a few search-and-read cycles rather than sustained investigation.
No memory management: These systems treat each interaction as essentially stateless beyond what fits in the context window. They lack mechanisms for consolidating information across long horizons, selectively forgetting irrelevant details, or maintaining structured memory representations that support multi-hop reasoning across dozens of steps.
Heuristic retrieval timing: Most web agents from this era retrieved on every step or used simple heuristics (retrieve when confidence is low), rather than learning adaptive retrieval policies that balance information gain against computational cost.

LLM-based reasoning and iterative refinement — including Chain-of-Thought ([376]), Tree-of-Thoughts ([427]), and Reflexion ([290]) — demonstrated that models can improve their outputs through structured reasoning and self-critique. These works showed that allocating more inference-time compute (via deeper reasoning trees, more iterative refinement cycles) improves performance on reasoning benchmarks. However, their capabilities were demonstrated primarily in closed-world settings:

Parametric knowledge only: These systems reason over what the model already knows, without mechanisms to acquire new evidence from the external world. A model can think step-by-step about a math problem, but if it doesn't know the GDP of Lithuania, no amount of reasoning trees will conjure that fact.
No verifiable grounding: The reasoning chains in these works are self-consistent but not necessarily factually grounded. The model can produce a plausible-sounding but incorrect deduction, and there is no external verification mechanism to catch the error.
Short-horizon tasks: Most reasoning benchmarks involve problems solvable in a handful of reasoning steps, not the sustained, multi-hour investigation characteristic of real research.

The crucial gap across all these paradigms is the absence of integration. RAG provides retrieval but no reasoning workflow. Tool-augmented agents provide action spaces but no memory management across long horizons. Chain-of-thought provides reasoning structure but no evidence acquisition. DR, as the paper frames it, is not a single new capability but rather the orchestration of planning, retrieval, memory, and synthesis into a coherent autonomous workflow — and no prior work had systematically analyzed what this orchestration requires or how to evaluate it.

How This Paper Positions Itself

The paper's positioning is explicitly integrative rather than competitive. It does not propose a new DR architecture, a novel training algorithm, or a state-of-the-art benchmark result. Instead, it provides the conceptual infrastructure that the field currently lacks — a shared vocabulary, a component-level decomposition, a taxonomy of optimization approaches, and a consolidated evaluation framework — so that future work can build on common ground rather than each system defining its own terminology and assumptions.

This positioning manifests in several concrete ways:

The three-phase roadmap as a capability trajectory, not a value hierarchy (Section 2.2). The paper is careful to state that the phases — Agentic Search (Phase I), Integrated Research (Phase II), and Full-stack AI Scientist (Phase III) — represent a progressive expansion of what systems can reliably do, not a ranking where higher phases are "better." Phase I systems focusing on faithful evidence retrieval with minimal synthesis fill an important niche for applications where accuracy-per-token is paramount. Phase II systems trading additional compute for structured reports serve different use cases. Phase III systems aiming at hypothesis generation and experimental validation represent a scientific ambition, not a commercially mature capability. By framing these as a trajectory, the paper avoids the trap of claiming that all systems should aspire to the most ambitious phase, while still providing a vocabulary for discussing what different approaches currently achieve.

The four-component decomposition as a unifying framework (Section 3). Rather than describing each DR system as a monolith with its own idiosyncratic design, the paper decomposes all DR systems into four interacting components: query planning, information acquisition, memory management, and answer generation. This decomposition is not arbitrary — it reflects an analysis of what cognitive functions any autonomous research agent must perform, drawing analogy to how human researchers work (formulate sub-questions, gather evidence, maintain organized notes, synthesize findings). By showing that ostensibly different systems (Anthropic's multi-agent pipeline, Search-R1's RL-trained agent, OpenAI's DeepResearch) can all be understood as instantiations of these four components with different design choices, the paper provides a lens for comparing approaches that previously seemed incommensurate.

The three optimization paradigms as a practical toolkit (Section 4). The paper recognizes that different deployment contexts demand different optimization strategies. Workflow prompting (Section 4.1) — constructing a multi-agent pipeline where an orchestrator delegates to specialized workers — is described as "simple yet effective," appropriate when rapid prototyping or interpretability is prioritized and training infrastructure is unavailable. Supervised fine-tuning (Section 4.2) — distilling behaviors from more capable systems or iteratively self-improving — provides a middle ground between hand-engineering and full RL. End-to-end agentic RL (Section 4.3) — training the complete pipeline via PPO or GRPO — offers the greatest potential for holistic optimization but faces stability challenges in multi-turn settings. By surveying all three rather than advocating for one, the paper serves as a practical guide for practitioners making engineering decisions based on their specific constraints.

The evaluation consolidation (Section 5) as a call for standardization. The paper catalogs an extensive range of benchmarks across four application domains — agentic information seeking, comprehensive report generation, AI for research, and software engineering — not to declare any single benchmark authoritative, but to reveal the fragmentation that currently hampers progress. Different papers evaluate on different benchmarks with different metrics, making it impossible to track whether the field is genuinely advancing. By organizing these benchmarks into a coherent taxonomy and identifying their strengths and limitations (Section 6.4), the paper implicitly argues that the next phase of DR research requires community agreement on evaluation standards.

The explicit delineation from RAG (Section 2.3, Table 1). One of the paper's clearest positioning moves is the systematic comparison between RAG and the three DR phases across nine dimensions: search engine access, use of various tools, code execution, reflection for action correction, task-solving memory management, innovation and hypothesis proposal, long-form answer generation, action space, reasoning horizon, and workflow organization. The table makes visually explicit what would otherwise require paragraphs of prose: RAG has a narrow action space, single-step reasoning horizon, and fixed workflow organization, while DR phases progressively expand all of these dimensions. This comparison serves dual purposes — it educates readers unfamiliar with the distinction and it stakes an intellectual claim that DR is not merely "RAG with more steps" but a qualitatively different paradigm with distinct technical requirements.

The acknowledgment of open challenges (Section 6). Rather than presenting DR as a solved paradigm, the paper devotes substantial space to unresolved problems: retrieval timing (when to stop searching), memory evolution (how to make memory proactive rather than reactive), training instability in multi-turn RL (entropy collapse, echo traps), and evaluation difficulties (logical coherence in long outputs, distinguishing novelty from hallucination, bias in LLM-as-judge evaluation). This self-critical stance positions the paper as an honest broker rather than an advocate — it is mapping the terrain, including the dangerous regions, not selling a particular approach. This is particularly important for a survey paper in a rapidly evolving field, where overclaiming would quickly become dated; by identifying challenges explicitly, the paper remains relevant even as specific systems become obsolete.

3. Technical Approach

This is a survey paper — it does not propose a novel system but rather constructs a unifying taxonomy that organizes the rapidly growing landscape of deep research agents into a coherent conceptual framework. Its core contribution is the four-component decomposition described in Section 3, which asserts that all DR systems, regardless of their implementation details, can be understood as orchestrating query planning, information acquisition, memory management, and answer generation in an iterative loop.

3.1 Reader Orientation

The paper synthesizes dozens of existing DR systems into a common architectural blueprint: a closed-loop workflow in which an LLM agent continuously cycles through decomposing a complex question into sub-queries, acquiring evidence from external tools, managing the accumulated context across potentially hundreds of interactions, and ultimately synthesizing a structured, verifiable report. The taxonomy solves a fragmentation problem — before this survey, each DR system was described in its own idiosyncratic terms, making cross-system comparison impossible. By showing that Search-R1, Anthropic's multi-agent system, OpenAI's DeepResearch, and dozens of others are all instantiations of the same four components with different design choices, the paper provides the shared vocabulary the field has been missing.

3.2 Big-Picture Architecture

A DR system operates as a closed-loop pipeline with four interacting modules:

Query Planning — receives the user's original complex question and decomposes it into a structured sequence of executable sub-queries or tool calls. Output is a plan (parallel, sequential, or tree-structured) that guides subsequent retrieval and reasoning.
Information Acquisition — executes the planned sub-queries by invoking external tools (search engines, web browsers, APIs, code interpreters). Determines when retrieval is needed (adaptive retrieval timing) and how to filter retrieved documents for relevance and reliability.
Memory Management — maintains the agent's working context across long interaction horizons. Consolidates raw tool outputs into structured representations (summaries, knowledge graphs, hierarchical trees), indexes these representations for efficient retrieval, updates them as new information arrives, and selectively forgets outdated or irrelevant content.
Answer Generation — synthesizes all accumulated evidence into a coherent, attributable output. Integrates information from upstream components, resolves conflicting evidence, maintains logical coherence across potentially thousands of words, and may produce multimodal outputs (reports with charts, tables, and citations).

Information flows cyclically: the query planner produces sub-queries → information acquisition retrieves evidence → memory management stores and organizes findings → these findings may trigger the query planner to generate new sub-queries (closing the loop) → eventually, answer generation consumes the final memory state to produce the research output. The cycle repeats an arbitrary number of times, with the system dynamically deciding when sufficient evidence has been gathered to terminate the loop and generate the final answer.

3.3 Roadmap for the Deep Dive

First, query planning (Section 3.1) — because it determines the structure and dependencies of all downstream retrieval. Understanding the three planning strategies (parallel, sequential, tree-based) is prerequisite to understanding why certain retrieval and memory designs are chosen.
Second, information acquisition (Section 3.2) — because this is where the plan meets the external world. We examine retrieval tools (what kinds of information can be accessed), retrieval timing (when should the agent search versus reason from what it has), and information filtering (how to separate signal from noise in retrieved documents).
Third, memory management (Section 3.3) — because it bridges acquisition and generation. Memory is what allows DR systems to maintain coherent context across dozens or hundreds of interactions. The four sub-operations (consolidation, indexing, updating, forgetting) form a lifecycle that determines what information persists and how it can be accessed.
Fourth, answer generation (Section 3.4) — because it consumes the output of all upstream components and produces the user-visible research product. We examine how systems integrate evidence, synthesize conflicting sources, maintain narrative coherence, and extend to multimodal outputs.
Finally, optimization techniques (Section 4) — because these are the engineering methods that make the components work well together. The three paradigms (workflow prompting, supervised fine-tuning, reinforcement learning) represent different points on a spectrum from hand-engineering to learned optimization.

3.4 Detailed, Sentence-Based Technical Breakdown

The paper's intellectual architecture is built on two interlocking contributions: a component-level decomposition of DR systems into four interacting modules (Section 3), and a three-paradigm optimization taxonomy for coordinating these modules (Section 4). The component decomposition provides the static structure — what pieces any DR system must have. The optimization taxonomy provides the dynamic coordination — how those pieces can be made to work together effectively. Together, they constitute a complete design space for DR systems.

3.4.1 Query Planning: Decomposing Complex Questions into Executable Sub-Queries

Definition and Core Function

Query planning is the first stage in the DR loop. It transforms a user's original question — which may be deeply complex, multi-faceted, and require synthesizing information from diverse sources — into a structured sequence of simpler, self-contained sub-queries, each of which can be addressed independently by downstream retrieval and reasoning modules. The paper's formal definition (Section 3.1):

"Query Planning refers to the process of transforming a complex and logically intricate question into a structured sequence of executable sub-queries (aka., sub-tasks), each of which can be addressed incrementally."

This is not merely syntactic — the planner must understand the logical dependencies between sub-questions. If answering sub-question B requires knowing the answer to sub-question A, the planner must encode this dependency so that A is resolved before B is attempted. The planner must also decide on the granularity of decomposition: too fine-grained and the agent wastes resources on trivial lookups; too coarse and the sub-questions remain too complex for direct retrieval.

The paper identifies three fundamental strategies: parallel planning, sequential planning, and tree-based planning. These are not different algorithms so much as different topological structures for organizing sub-queries, each appropriate for different classes of research questions.

Parallel Planning (Section 3.1.1)

What it does: Parallel planning decomposes the original query into multiple independent sub-questions in a single pass, with no iterative interaction with downstream components. All sub-questions are generated simultaneously, before any retrieval occurs. The sub-questions are assumed to be conditionally independent — the answer to one does not depend on the answer to any other.

How it works mechanically: Given a user query $Q$ , the planner produces a set of sub-queries $\{q_1, q_2, ..., q_k\}$ where each $q_i$ is a self-contained question that can be answered independently. The planner then dispatches all $k$ sub-queries to the retrieval module in parallel (or near-parallel, depending on infrastructure), collects the $k$ sets of retrieved documents, and passes them to the answer generation module for synthesis.

Representative systems:

Least-to-Most Prompting ([484]) guides GPT-3 to decompose a complex task into an ordered sequence of simpler sub-queries using few-shot examples. The key insight is that the decomposition itself does not require retrieval — the LLM's parametric knowledge is sufficient to identify the constituent parts of a complex question, even if it cannot answer those parts from memory.
CoVE (Chain-of-Verification, [59]) prompts LLMs to first generate multiple independent sub-questions, then grounds each one with evidence retrieved in parallel. The verification aspect comes from cross-checking across the retrieved evidence for each sub-question, rather than from iterative refinement.
Rewrite-Retrieve-Read ([203]) represents a significant advance by training the query planner via Proximal Policy Optimization (PPO). The planner's objective is not to produce linguistically plausible sub-queries but to maximize final answer accuracy. It receives a positive reinforcement signal only when the documents retrieved by its sub-queries enable the downstream LLM to generate the correct answer. The paper notes that this replaces "reliance on heuristic decomposition rules" with a learned policy that discovers what kinds of sub-queries are actually useful.
DeepRetrieval ([133]) and CardRewriter ([96]) extend this RL approach to incorporate additional reward signals beyond final answer correctness, including evidence recall (the fraction of necessary documents retrieved) and retrieval NDCG@k (a ranking quality metric). This multi-objective reward design allows the planner to balance answer quality with retrieval efficiency.
MMOA-RAG ([36]) explores joint optimization, using multi-agent RL to train the query planner simultaneously with other components in the retrieval pipeline, rather than optimizing the planner in isolation with frozen downstream modules.

When it works: Parallel planning is most effective for questions that are "broad but shallow" — requiring coverage across many independent dimensions but with no logical dependencies between them. For example, "compare the GDP, population, and political system of France, Germany, and Italy" can be decomposed into nine independent sub-queries (three countries × three attributes), all of which can be executed simultaneously.

Key limitation: The paper identifies a structural weakness that limits parallel planning's applicability:

"Parallel execution assumes conditional independence, yet many real-world queries involve sequential reasoning in which later subtasks depend on the resolution of earlier ones. This can result in ill-posed or unanswerable sub-queries due to missing contextual information."

Consider "Which pharmaceutical company had the highest revenue in 2023, and what was its CEO's compensation?" This cannot be answered via parallel sub-queries because you need to know which company before you can look up the CEO's compensation. A parallel planner would generate two independent sub-queries — "which pharmaceutical company had the highest revenue in 2023" and "what was [UNKNOWN COMPANY]'s CEO compensation" — where the second query is under-specified and unanswerable.

Sequential Planning (Section 3.1.2)

What it does: Sequential planning decomposes the original query through multiple iterative steps, where each round of decomposition builds upon the outputs of previous rounds. Unlike parallel planning's one-shot generation, sequential planning is a feedback-driven process: the planner generates a sub-query, executes it, examines the retrieved evidence, and then decides what sub-query to generate next based on what it has learned.

How it works mechanically: Given a user query $Q$ , the planner:

Generates an initial sub-query $q_1$ based on $Q$ .
Dispatches $q_1$ to the retrieval module and receives evidence $E_1$ .
Assesses whether $E_1$ fully answers $Q$ . If not, it identifies the information gap — what specific knowledge is still missing.
Generates a new sub-query $q_2$ conditioned on both $Q$ and the evidence $E_1$ accumulated so far.
Repeats steps 2-4 until the accumulated evidence is sufficient to answer the original question.

The key algorithmic question is step 3: how does the planner determine whether it has enough information, and if not, what specific gap to target next?

Representative systems and their mechanisms for assessing information sufficiency:

LLatrieval ([181]) uses LLM-based verification. After each retrieval round, the system prompts an LLM to check whether the currently accumulated documents fully support a verifiable answer. If not, the LLM identifies the specific missing knowledge and generates a new query — either a natural language question or a "pseudo-passage" (a synthetic passage containing the desired information, used as a query for dense retrieval).
DRAGIN ([308]) takes a more mechanistic approach, leveraging the LLM's internal attention scores. Rather than prompting the model to explicitly identify information gaps, DRAGIN extracts the tokens in the generation history that received the highest self-attention weights from the most recent generated tokens. These high-attention tokens are presumed to represent the concepts the model is "thinking about" and needing more information on. The planner reformulates these tokens into a concise, focused retrieval query. The paper notes this "dynamic, attention-driven approach produces more accurate queries compared to the static last sentence or last n tokens strategies in previous methods."
ReSP (Retrieve, Summarize, Plan, [139]) introduces a more structured gap-identification mechanism. The planner maintains two memory states — global memory (all evidence accumulated so far) and local memory (the most recent retrieval results). When assessing whether retrieval is sufficient, it explicitly identifies information gaps and formulates novel sub-questions targeting those gaps. To prevent redundant retrieval, it disallows previously issued sub-questions. The paper notes: "This design ensures that each newly generated query substantially contributes to advancing the multi-hop reasoning trajectory toward the final answer."
S3 ([134]) and AI-SearchPlanner ([213]) frame the sequential decision as an explicit control problem: at each turn, the planner evaluates the evolving evidence state and makes a binary decision — retrieve additional context or stop. This is formulated as a Markov Decision Process where the state is the accumulated evidence and the action space is {continue, stop}.
Search-R1 ([145]), R1-Searcher ([300, 301]) represent the current frontier, integrating sequential planning into end-to-end RL-trained agents. Rather than hand-designing the planning logic, these systems train the LLM to learn, through reinforcement, when to search, what to search for, and how to use retrieved information — all optimized against final answer correctness as the reward signal.

When it works: Sequential planning is essential for multi-hop reasoning tasks where the answer requires synthesizing information across multiple sources with logical dependencies. HotpotQA-style questions ("Which team does the player who scored the most goals in the 2014 World Cup play for?") are the canonical use case — you must first identify the top scorer, then look up their team affiliation.

Key limitation: The paper identifies a fundamental tension:

"excessive reasoning turns or overly long reasoning chains can incur substantial computational costs and latency. In addition, an increased number of turns may introduce cumulative noise and error propagation, potentially causing instability during reinforcement learning training."

Every retrieval round adds latency (the agent must wait for search results) and introduces the risk of retrieving misleading documents that derail the reasoning trajectory. The sequential planner must balance information gain against these costs, a problem that becomes particularly acute in RL training where early mistakes cascade through subsequent turns.

Tree-Based Planning (Section 3.1.3)

What it does: Tree-based planning integrates features of both parallel and sequential planning by organizing sub-queries as nodes in a tree or directed acyclic graph (DAG). Each node represents a sub-question; edges represent logical dependencies. The planner can explore multiple reasoning paths simultaneously (like parallel planning) while maintaining logical dependencies between steps (like sequential planning). When one path proves unfruitful, the agent can backtrack and explore alternative branches — a capability neither pure parallel nor pure sequential planning provides.

How it works mechanically: The planner maintains a tree $T$ where:

The root node is the original user query $Q$ .
Each non-root node is a sub-question $q_i$ paired with a tentative answer $a_i$ .
Children of a node represent sub-questions whose answers depend on the parent's answer.
The tree grows iteratively through an explore-expand-evaluate-backpropagate cycle.

At each iteration, the planner selects a node to expand (typically using a selection criterion like the Upper Confidence Bound for Trees, UCT), generates one or more child sub-questions from that node, retrieves evidence and generates tentative answers for each child, evaluates the quality of those answers (typically using a retrieval-based reward model), and backpropagates the reward up the tree to update the estimated value of ancestor nodes. This process continues until a satisfactory answer for the root question is obtained or a computational budget is exhausted.

Representative systems:

RAG-Star ([132]) is the canonical example, using Monte Carlo Tree Search (MCTS) with UCT as the node selection criterion. At each iteration, the UCT formula selects the most promising node by balancing exploitation (nodes with high estimated value) against exploration (nodes with few visits). The selected node is expanded by generating a sub-query and corresponding answer via an LLM, the expansion is evaluated by a retrieval-based reward model, and the score is backpropagated. The paper emphasizes that the MCTS formulation allows the planner to "grow a reasoning tree of sub-queries until a satisfactory final answer is obtained" — the search is guided by a principled exploration-exploitation tradeoff rather than greedy or heuristic expansion.
DTA (Divide-Then-Aggregate, [494]) and DeepSieve ([106]) use tree-based planning to restructure sequential reasoning traces into DAGs. This restructuring is not merely representational — by aggregating intermediate answers along multiple branches, the system can capture non-linear dependencies that would be invisible to a linear chain of reasoning. For example, if answering a question requires evidence from three independent sources and then a synthesis step that depends on all three, the DAG structure makes explicit that the three evidence-gathering steps can proceed in parallel, converging only at the synthesis node.
DeepRAG ([103]) introduces a specific tree structure — binary-tree exploration — where each node represents a sub-question that the planner must classify as either answerable from parametric knowledge or requiring retrieval. This classification determines whether the planner spends retrieval budget on that node or relies on the LLM's internal knowledge. The paper reports "large accuracy gains with fewer retrievals," suggesting that the tree structure enables the planner to allocate retrieval resources only where they are most impactful.
MAO-ARAG ([37]) extends the tree concept to orchestration over diverse query reformulation modules: rather than a single planner generating all sub-queries, the system trains a meta-planner that can dynamically select among multiple specialized reformulation agents and arrange them in a DAG structure. This "adaptive workflow enables comprehensive query decomposition to enhance performance" by matching the right reformulation strategy to each sub-question's characteristics.

When it works: Tree-based planning is most appropriate for research questions that are both complex (requiring multiple reasoning steps) and uncertain (the optimal decomposition strategy is not known in advance). The MCTS formulation allows the planner to explore alternative decompositions, commit resources to promising paths, and abandon unpromising ones — capabilities essential when the structure of the answer is part of what must be discovered.

Key limitation: The paper identifies three interlocking challenges that make tree-based planning difficult to implement:

"training a robust Tree-based Planning module is challenging, requiring precise dependency modeling, careful trade-offs between speed and quality, addressing data scarcity, and tackling credit assignment issues in reinforcement learning."

Dependency modeling : determining the correct parent-child relationships between sub-questions is a reasoning task in itself. A poorly constructed tree where a node is placed under the wrong parent will propagate errors through the entire branch.
Speed-quality tradeoff : tree search is inherently more computationally expensive than linear decomposition. Each expansion requires LLM calls for sub-query generation and answer generation, plus retrieval calls for evidence acquisition. The planner must decide how deeply to explore before committing to an answer.
Credit assignment in RL : when training the planner via reinforcement learning, the final reward (answer correctness) must be attributed to specific planning decisions made many steps earlier. If the planner generated a poor sub-question at step 3 that led to a wrong answer at step 10, the RL algorithm must identify step 3 as the source of the error despite the intervening steps — a challenging temporal credit assignment problem.

3.4.2 Information Acquisition: When and How to Interact with the External World

Information acquisition encompasses the complete pipeline by which a DR system accesses and processes external knowledge — from the tools used for retrieval through the timing of when retrieval occurs to the filtering that separates useful evidence from noise. The paper organizes this along three sub-dimensions: retrieval tools (Section 3.2.1), retrieval timing (Section 3.2.2), and information filtering (Section 3.2.3).

Retrieval Tools (Section 3.2.1): The Interface to External Knowledge

Definition and scope: Retrieval tools are the mechanisms by which DR systems identify relevant information from large-scale information sources in response to a query. The paper categorizes these along a modality axis — text retrieval versus multimodal retrieval — and then further decomposes text retrieval into lexical, semantic, and commercial web search approaches.

Text retrieval: three families of methods.

Lexical retrieval matches documents based on exact term overlap and statistical term weighting. The canonical algorithm is BM25 ([269]), which assigns each document a score based on term frequency (how often the query terms appear in the document), inverse document frequency (how rare those terms are across the corpus), and document length normalization (longer documents are not inherently more relevant). The paper also mentions "neural sparse models that learn to expand queries and documents with relevant terms while maintaining interpretable inverted-index structures," citing SPLADE ([80]) and SPLADE-v2 ([79]). These models learn to add weighted terms to both queries and documents to improve recall — for example, expanding "car" to include "automobile," "vehicle," and "sedan" — while still using the efficient inverted-index data structures that make lexical retrieval fast at scale.

Semantic retrieval — also called dense retrieval — encodes queries and documents into continuous vector spaces using neural encoders. Relevance is measured as the cosine similarity (or inner product) between the query embedding and each document embedding. The foundational work cited is DPR (Dense Passage Retrieval, [156]), which uses a dual-encoder architecture: one BERT-based encoder for queries, another for documents, trained with contrastive learning (relevant query-document pairs are pulled together in embedding space, irrelevant pairs are pushed apart). The paper notes that dense retrieval "captures semantic similarity beyond exact term matching" — it can retrieve documents about "climate change" even when the query uses "global warming," because the two phrases are semantically similar despite having zero lexical overlap. The paper also cites ColBERT ([157]) and ColBERT-v2 ([273]) as "late interaction" methods, which encode queries and documents independently but then compute token-level similarities at scoring time, providing finer-grained matching than single-vector approaches while remaining more efficient than full cross-attention.

Commercial web search (Google, Bing, and their APIs) diverges from both lexical and semantic retrieval in several ways the paper highlights: it provides "access to real-time information" (the index is continuously updated, unlike static corpora), "leveraging massive-scale web crawling and indexing" (orders of magnitude more documents than any locally indexed corpus), "incorporating sophisticated ranking algorithms that consider authority and freshness signals" (PageRank, click-through rates, domain authority), and "offering built-in fact verification through cross-source validation" (multiple independent sources reporting the same fact increases confidence). The paper cites WebGPT ([221]) and SearchGPT ([412]) as pioneering systems that demonstrated commercial search APIs enable research agents to "access current events and dynamic content that would be missing from static corpora." Recent systems like Search-o1 ([182]) and WebThinker ([183]) are described as demonstrating "deep web exploration capabilities, allowing them to interactively navigate beyond static search results to gather information."

Multimodal retrieval: beyond text.

The paper identifies that DR questions often require evidence embedded in visual or structured formats that text-only retrieval cannot access. The organization is by information modality:

Text-aware retrieval with layout indexes not just the textual content of documents but also their layout information — titles, captions, callouts, and surrounding prose. The paper cites document understanding models like LayoutLM ([415]), Donut ([159]), and DocVQA ([210]) that can parse PDF or document structures to extract semantically meaningful regions (e.g., distinguishing a figure caption from body text).
Visual retrieval via text–image similarity encodes figures, charts, and images using vision-language models like CLIP ([261]), SigLIP ([446]), or BLIP ([171]), which map images into the same embedding space as text. This enables queries like "retrieve a chart showing GDP growth in Europe" to match against images based on their visual content, not just their captions.
Structure-aware retrieval over parsed tables and charts indexes the internal structure of data-bearing elements — axes, legends, data marks, and table schemas — enabling grounded lookup of specific numeric facts. The paper cites ChartReader ([42]) and Chartformer ([477]) as systems that parse chart images into structured data representations that can be queried for specific values.

The practical deployment of multimodal retrieval typically involves "queries searched across all indices simultaneously, with results fused using reciprocal-rank fusion or cross-modal reranking to preserve grounded pointers for citations" — that is, the system hits text, image, and structured indices in parallel, merges the results, and re-ranks the merged list so that the final evidence set is diverse across modalities while being internally coherent.

Comparing text and multimodal retrieval: The paper identifies three advantages of multimodal over text-only: (1) it captures visually encoded information and numeric trends that text-based methods overlook; (2) it enables cross-modal verification through hybrid fusion (a fact reported in text can be corroborated by a chart showing the same data); (3) it enables grounded citations by linking retrieved evidence back to specific data points (e.g., "this number comes from cell B3 of Table 2 in the retrieved PDF"). The primary costs are "increased computational costs for visual processing, sensitivity to OCR errors and variations in chart formats, and the complexity of aligning information across different modalities."

Retrieval Timing (Section 3.2.2): When to Search Rather Than Reason

The core problem: Retrieval is not free — it adds latency, consumes computational budget, and can introduce noise that degrades rather than improves reasoning. The paper articulates this tradeoff explicitly:

"blindly performing retrieval at every step is often sub-optimal... Retrieval introduces additional computational overhead, and low-quality or irrelevant documents may even mislead the model or degrade its reasoning performance"

This means DR systems need adaptive retrieval — mechanisms to decide, at each step, whether the potential information gain from additional retrieval justifies its costs. The paper frames this as fundamentally a problem of knowledge boundary perception: the model must recognize "what it knows and what it does not."

Confidence estimation as a proxy for boundary perception.

The paper surveys four approaches to measuring a model's confidence in its knowledge, each of which can serve as a signal for whether retrieval is needed:

Probabilistic confidence uses token-level generation probabilities as a confidence measure. If the model assigns high probability to its generated answer tokens, this is interpreted as high confidence; low probability suggests uncertainty and triggers retrieval. The paper notes that pre-LLM work found neural networks "tend to be poorly calibrated, often producing overconfident predictions even when incorrect" ([104, 58, 137]). For LLMs specifically, some work finds they "can be well calibrated on structured tasks such as multi-choice question answering" ([153, 295]), but for open-ended generation, "predicted probabilities still diverge from actual correctness" ([69, 164]). This unreliability of raw token probabilities has motivated alternative confidence measures.
Consistency-based confidence estimates confidence from the degree to which multiple independent generations from the same model agree with each other. The intuition is that if the model consistently produces the same answer across multiple sampling runs, it is likely confident and correct; if answers diverge, the model is uncertain. The paper traces the evolution: Fomicheva et al. ([78]) first measured consistency through lexical similarity; later work used natural language inference (NLI) models to assess semantic consistency ([207]); Kuhn et al. ([164]) introduced "semantic uncertainty," which clusters generated answers by meaning and uses cluster entropy as an uncertainty measure. Zhang et al. ([451]) extended consistency to cross-model settings, measuring agreement across different models since "incorrect answers tend to vary between models, whereas correct ones align."
Confidence based on internal states leverages the model's hidden representations rather than its outputs. The paper reports that Azaria and Mitchell ([10]) "first discovered that internal states can signal models' judgment of textual factuality" — the activation patterns in the model's layers encode information about whether a generated statement is factual, even when the model does not explicitly express uncertainty. Subsequent work ([309, 28]) found that "internal states after response generation reflect the factuality of self-produced answers," and more recently, "factuality-related signals already exist in the pre-generation states, enabling the prediction of whether the output will be correct before any tokens are generated" ([364, 230]).
Verbalized confidence involves prompting or training the model to express its confidence in natural language. The paper reports mixed results: Yin et al. ([431]) and Ni et al. ([228]) "examined whether LLMs can identify unanswerable questions, finding partial ability but persistent overconfidence." Other work investigated "fine-grained confidence expression" ([340, 409]), with Xiong et al. ([409]) providing "the first comprehensive study for black-box models." Beyond prompting, some methods "explicitly train models to verbalize confidence" ([185, 424, 450]) using correctness-based supervision — the model is trained to output "I am 90% confident" only when it is actually correct 90% of the time.

Representative adaptive retrieval approaches.

The paper organizes systems by which confidence paradigm they use to trigger retrieval:

Probabilistic strategy: FLARE ([138]) and DRAGIN ([308]) trigger retrieval when the model generates tokens with low probability, indicating uncertainty about the current reasoning step.
Consistency-based strategy: Rowen ([60]) evaluates consistency across responses generated by multiple models and multiple languages, triggering retrieval when cross-model or cross-lingual agreement is low — a more robust signal than single-model self-consistency.
Internal states probing: CtrlA ([126]), UAR ([40]), and SEAKR ([429]) use the model's internal states as a confidence signal, arguing that internal activations provide "a more faithful reflection of its confidence" than generated text, which can be stylistically confident while factually wrong.
Verbalized strategy: The paper traces an evolution from ReAct ([428]), which "directly prompts the model to generate corresponding action text when retrieval is needed" (e.g., the model outputs "Search: GDP of France" as part of its response), to Self-RAG ([9]), which "trains the model to explicitly express uncertainty through the special token <retrieve>," to recent reasoning-augmented approaches where "search-o1 [182] introduces a Reason-in-Documents module, which prompts the model to selectively invoke search during reasoning" and "Search-R1 [145] frames retrieval as part of the environment and employs reinforcement learning to jointly optimize both when and what to retrieve."

Information Filtering (Section 3.2.3): Separating Signal from Noise

The core problem: Retrieval tools are imperfect — they return documents that are irrelevant, outdated, contradictory, or factually incorrect. The paper notes that "LLMs are highly sensitive to such noise; without additional filtering or optimization, they can be easily misled into generating incorrect or hallucinated responses" ([433, 143]). Filtering is the set of techniques that process raw retrieval results before they enter the model's context, removing harmful noise while preserving useful signal.

Document Selection: ranking to identify the most useful documents.

The paper identifies three strategies for selecting which documents to keep from a candidate set:

Point-wise selection scores each document independently, then selects the top-k. The most common approach uses a dual encoder (e.g., BGE [406]) to embed the query and each document separately, computing relevance as the inner product between embeddings ([410, 128]). Cross-encoders take the concatenated query-document pair as input and directly predict a binary relevance score — more accurate but computationally more expensive per document ([65, 371]). More recently, LLM-based methods "train LLMs to output special tokens, such as <ISREL> [9] or the identifier True [439], to indicate whether an input document is relevant to the query."
Pair-wise selection compares two documents at a time, predicting which is more relevant to the query. The representative system is PRP (Pairwise Ranking Prompting, [255]), which feeds the LLM a query and two candidate documents, asks it to decide which is more relevant, and constructs the final ranking using a heapsort algorithm — repeatedly comparing pairs and bubbling the more relevant documents upward. To mitigate positional bias (LLMs often prefer the first option in a pair), "PRP performs the comparison twice, swapping the document order each time, and aggregates the results to yield a more stable judgment."
List-wise selection processes the entire candidate set at once, producing a global ranking. RankGPT ([317]) "feeds the entire candidate sequence into an LLM and leverages prompt engineering to produce a global ranking" — the LLM is prompted to output the document IDs in order of relevance. TourRank ([35]) uses a tournament-inspired approach: documents compete in rounds, with winners advancing, producing a robust ranking that is less sensitive to ordering effects. ListT5 ([432]) takes a different architectural approach, using a Fusion-in-Decoder (FiD [127]) architecture that independently encodes multiple documents in parallel, then uses a decoder to order them by relevance. For scalability, "it builds m-ary tournament trees to group, rank, and merge results in parallel."

The paper notes a recent trend toward reasoning-augmented selection: "InstructRAG [381] trains an LLM to generate detailed rationales via instruction tuning, directly judging the usefulness of each document in the raw retrieved document list. Rank-R1 [505] employs the reinforcement learning algorithm GRPO to train the LLM, enabling it to learn how to select the documents most relevant to a query from a list of candidates."

Content Compression: reducing document length while preserving information.

Content compression addresses the problem of long-context dilution — when models must attend to very long contexts, their performance on information extraction degrades. Compression aims to increase the density of useful information per token.

Lexical-based methods condense text into concise natural language summaries. RECOMP ([410]) fine-tunes a smaller open-source LLM to summarize retrieved documents, using GPT-4-generated summaries as training targets. Chain-of-Note ([438]) introduces a "reading-notes mechanism that compels the model to assess the relevance of retrieved documents to the query and extract the most critical information before generating an answer." BIDER ([146]) "eliminates reliance on external model distillation by synthesizing Key Supporting Evidence (KSE) for each document" — the model learns to extract the minimal set of sentences that answer the query, trained via SFT and then further optimized with PPO based on downstream answer correctness. RankCoT ([395]) adds an implicit reranking step: the model generates summary candidates for each document, and the compression model is trained via DPO to prefer summaries that lead to correct final answers, inducing the model to implicitly assign higher quality to more relevant documents.
Embedding-based methods compress context into sequences of dense embedding vectors rather than natural language text. ICAE (In-Context Autoencoder, [92]) uses an encoder to compress long contexts into fixed-length embedding sequences, trained with autoencoding tasks that force the embeddings to preserve the information needed to reconstruct the original text. COCOM ([263]) jointly fine-tunes the encoder and the downstream answer generation model, so the embeddings are optimized not for reconstruction but for their utility in answering questions. xRAG ([41]) achieves extreme compression by projecting document embeddings into a single token in the answer generation model's representation space — this is initialized with a simple MLP and trained through "paraphrase pretraining and context-aware instruction tuning." ACC-RAG ([107]) introduces adaptive compression rates: different documents receive different compression levels based on their estimated relevance to the query, with more relevant documents compressed less (preserving more detail). QGC ([24]) similarly adjusts compression rates per document based on query characteristics.

Rule-based Cleaning: handling structured external sources.

For data with known structure — web pages (HTML), tables, code — rule-based methods remove semantically empty elements while preserving information-bearing content. HtmlRAG ([323]) "applies rule-based compression to remove structurally present but semantically empty elements, such as CSS styling and JavaScript code, from retrieved web pages." This is combined with a "two-stage block-tree pruning strategy that first uses embeddings for coarse pruning, followed by a generative model for fine-grained pruning" — the HTML DOM tree is progressively pruned, keeping only blocks likely to contain relevant content. TableRAG ([32]) addresses the specific challenge of large tables (which can exceed context windows) by performing "schema retrieval, which identifies key column names and data types, and cell retrieval, which locates high-frequency cell value pairs," effectively selecting only the most relevant rows and columns rather than processing the entire table.

The inherent tension in filtering: The paper identifies that filtering creates a fundamental tradeoff:

"However, incorporating an additional filtering module typically incurs additional computational costs and increased latency. Moreover, overly filtering may remove useful or even correct information, thereby degrading model performance."

The optimal filtering strategy is therefore query-dependent and context-dependent — aggressive filtering that removes 90% of documents may be appropriate when the retrieval pool is large and noisy, but harmful when the pool is small and most documents contain at least some relevant information. The paper does not prescribe a one-size-fits-all solution but rather provides the taxonomy for thinking about when each approach is appropriate.

3.4.3 Memory Management: Maintaining Coherent Context Across Long Horizons

Definition and Motivation

Memory management is the component that distinguishes DR systems from single-turn QA or even multi-turn but stateless RAG. The paper's formal definition:

"Memory management is a foundational component of advanced DR architectures, which governs the dynamic lifecycle of context used by DR agents in complex, long-horizon tasks... aiming to maintain coherent and relevant task-solving context."

The key insight is that DR agents operate over horizons that far exceed what can fit in a single LLM context window (even with modern long-context models, the quality of reasoning degrades as context length grows). The agent must therefore actively manage what information to retain, how to organize it for efficient retrieval, when to update it as new evidence arrives, and when to discard it as irrelevant or outdated. The paper draws an explicit analogy to human memory systems, organizing these functions into four operations: consolidation, indexing, updating, and forgetting.

Memory Consolidation (Section 3.3.1): From Raw Experience to Durable Representations

Definition: "Memory consolidation is the process of transforming transient, short-term information, such as user dialogues or tool execution outputs, into stable, long-term representations." This is the initial transformation that converts raw, unstructured interaction data into a form that can be efficiently stored and later retrieved. The paper distinguishes consolidation from indexing: "Distinct from memory indexing, which creates navigable access pathways over existing memories, consolidation is fundamentally concerned with the initial transformation and structural organization of raw experience."

Unstructured memory consolidation distills long interaction histories into concise natural language summaries or key event logs. The paper provides several examples:

MemoryBank ([482]) "processes and distills conversations into a high-level summary of daily events, which helps in constructing a long-term user profile." The raw transcripts of a day's interactions are compressed into a structured summary capturing key topics, decisions, and user preferences.
MemoChat ([197]) "summarizes conversation segments by abstracting the main topics discussed." Rather than storing the full conversation, it stores topic-level summaries that are more compact and less noisy.
ChatGPT-RSum ([358]) "adopts a recursive summarization strategy to manage extended conversations." For conversations too long to summarize in a single pass, the system summarizes segments, then summarizes the summaries, recursively building a hierarchical compression.
Generative Agents ([245]) "utilize a reflection mechanism triggered by sufficient event accumulation to generate more abstract thoughts as new, consolidated memories." When enough raw experiences have accumulated on a topic, the agent synthesizes higher-level insights ("I've been spending a lot of time on project X, and I'm making progress on subtask Y") that are more useful for future planning than the raw event logs.

Structured memory consolidation transforms unstructured information into organized formats like databases, knowledge graphs, or hierarchical trees:

TiM (Think-in-Memory, [187]) "extracts entity relationships from raw information and stores them as tuples in a structured database." Each tuple represents a fact: (entity1, relation, entity2), enabling structured queries that would be impossible over unstructured text.
ChatDB ([119]) "leverages a database as a form of symbolic memory, transforming raw inputs into a queryable, relational format" — the agent can issue SQL queries over its own memory.
AriGraph ([6]) "implements a memory graph where knowledge is represented as vertices and their interconnections as edges." The graph structure captures not just individual facts but the relationships between them, enabling multi-hop reasoning over stored knowledge.
HippoRAG ([142]) "constructs knowledge graphs over entities, phrases, and summaries to form an interconnected web of fragmented knowledge units." The graph serves as the consolidated memory representation, with retrieval framed as graph traversal.
MemTree ([268]) "builds and updates a tree structure by traversing from the root and deciding whether to deepen the tree with new information or create new leaf nodes based on semantic similarity." This hierarchical organization supports both broad-brush recall (high-level nodes) and detailed recall (deep leaf nodes).

The paper positions structured consolidation as enabling more sophisticated downstream operations — structured querying, multi-hop reasoning, and relationship-aware retrieval — at the cost of more complex consolidation logic that must correctly parse entity relationships and resolve co-references.

Memory Indexing (Section 3.3.2): Building Navigable Access Pathways

Definition: "Memory indexing involves constructing a navigational map over a DR agent's consolidated memories, analogous to a library's catalog or a book's index for efficient information retrieval." While consolidation transforms raw data into durable representations, indexing builds auxiliary access structures that make those representations retrievable. The paper emphasizes that "effective indexing goes beyond simple keyword matching by encoding temporal and relational dependencies among memories."

Signal-enhanced indexing augments memory entries with auxiliary metadata — emotional context, topics, keywords, temporal signals — that serve as granular pivots for context-aware retrieval:

LongMemEval ([390]) "enhances memory keys by integrating temporal and semantic signals to improve retrieval precision." Each memory entry is tagged with when it was created and what semantic cluster it belongs to, enabling queries like "what did the user say about project deadlines last month?"
The Multiple Memory System (MMS, [448]) "decomposes experiences into discrete components, such as cognitive perspectives and semantic facts, thereby facilitating multifaceted retrieval strategies." A single experience might be indexed under multiple facets — what happened (event), what was learned (knowledge), how the user felt (sentiment) — enabling retrieval from different angles depending on the query.
The paper also cites Locality-Sensitive Hashing (LSH, [54]), Hierarchical Navigable Small World (HNSW) graphs ([205]), and FAISS ([150]) as the underlying infrastructure that makes these enriched indices searchable at scale.

Graph-based indexing uses graph structures where memories are nodes and relationships are edges as the indexing mechanism:

HippoRAG ([142]) "uses lightweight knowledge graphs to explicitly model inter-memory relations, enabling structured, interpretable access." Retrieval is cast as a graph traversal problem — the agent starts from query-relevant nodes and follows edges to related memories.
A-Mem ([414]) "adopts a dynamic strategy where the agent autonomously links related memory notes, progressively growing a flexible access network." Unlike a static graph built once, the access network evolves as the agent discovers new relationships between previously unconnected memories.
The paper notes that graph-based indexing is particularly powerful for complex multi-hop reasoning because the agent can "traverse chains of connections to locate information that is not explicitly linked to the initial query."

Timeline-based indexing organizes memory along chronological or causal sequences:

Theanine ([235]) "arranges memories along evolving timelines to facilitate retrieval based on both relevance and temporal dynamics." A query about "recent developments in topic X" can be answered by retrieving memories within a specific time window.
Zep ([262]) "introduces a bi-temporal model for its knowledge graph, indexing each fact with $t_{valid}$ and $t_{invalid}$ timestamps, which allows the agent to navigate the memory based on temporal validity." This captures the fact that knowledge has a validity period — "the CEO of Company X was Alice" might be true from 2020-01 to 2023-06, after which it was Bob. The bi-temporal index supports queries like "who was the CEO in 2022?" by checking whether the query time falls within the valid interval.
The paper notes that timeline-based indexing is essential for understanding progression, maintaining conversational coherence, and supporting lifelong learning — capabilities that require knowing not just what is true but when it became true and potentially when it ceased to be true.

Memory Updating (Section 3.3.3): Keeping Knowledge Current and Consistent

Definition: "Memory updating is a core capability of DR agents, involving the reactivation and modification of existing knowledge in response to new information or environmental feedback." The paper distinguishes updating from forgetting: "Although related to memory forgetting, which focuses on removing outdated or incorrect content, memory updating centers on modifying and refining existing knowledge to increase its fidelity."

The paper organizes updating strategies by memory type — non-parametric (external storage) versus parametric (model weights).

Non-parametric memory updating operates on external storage through explicit, discrete operations:

Integration and conflict updating focuses on incorporating new information while maintaining logical consistency. Mem0 ([46]) "employs an LLM to manage its knowledge base through explicit operations, such as adding new facts (ADD) or modifying existing entries with new details (UPDATE) to resolve inconsistencies." Zep ([262]) handles temporal conflicts by "modifying an existing fact's effective time range, setting an invalidation timestamp ( $t_{invalid}$ ) to reflect that a newer fact has superseded it" — a non-destructive update that preserves the history of what was previously believed. TiM ([187]) uses "MERGE operations to combine related facts into a more coherent representation."
Self-reflection updating enables agents to iteratively refine their knowledge by reflecting on past experiences. Reflexion ([290]) and Voyager ([349]) "implement this through verbal self-correction and updates to a skill library" — the agent tries something, observes the outcome, and updates its stored knowledge accordingly. A-Mem ([414]) goes further, triggering "a Memory Evolution process that re-evaluates and autonomously refines previously linked memories based on new contextual information."

Parametric memory updating modifies the model's weights directly — more powerful but more complex and riskier:

Global updating continues model training on new data to integrate knowledge. The paper acknowledges this is "computationally expensive and prone to catastrophic forgetting" — new knowledge can overwrite old knowledge if not carefully managed. Memory-R1 ([417]) addresses this by training a "dedicated Memory Manager agent to learn an optimal policy for modification operations such as ADD and UPDATE, moving beyond heuristic rules." The paper also cites work that "employs methods such as Direct Preference Optimization to fine-tune the model's memory utilization strategy" ([463]).
Localized updating modifies specific facts without full retraining, using "a locate-and-edit strategy or using meta-learning to predict weight adjustments while preserving unrelated knowledge" ([55, 218, 321]). These methods identify the specific neurons or attention heads that encode a particular fact and modify only those, leaving the rest of the model unchanged.
Modular updating avoids modifying the base model entirely: "Frameworks such as MLP Memory ([380]) and Memory Decoder ([22]) train a lightweight external module to imitate the output distribution of a non-parametric kNN retriever. This process effectively compiles a large corpus of external knowledge into the compact weights of the module." The trained module can be attached to any compatible LLM to provide specialized knowledge without modifying the base model, "thereby avoiding catastrophic forgetting and reducing the latency of real-time retrieval."

Memory Forgetting (Section 3.3.4): Selectively Removing Information

Definition: "Forgetting constitutes a fundamental mechanism in advanced agent architectures, enabling the selective removal or suppression of outdated, irrelevant, or potentially erroneous memory content. Rather than a system defect, forgetting is a functional process critical for filtering noise, reclaiming finite storage resources, and mitigating interference between conflicting information."

Passive forgetting simulates natural memory decay through automated, time-based rules:

MemGPT ([243]) "employs a First-In-First-Out (FIFO) queue for recent interactions, automatically moving the oldest messages from the main context into long-term storage." This keeps the active working memory bounded while preserving information in a less accessible but persistent form.
MemoryBank ([482]) "draws inspiration from the Ebbinghaus forgetting curve, in which memory traces decay over time unless reinforced, allowing the agent to naturally prioritize recent content." Memories that are not accessed or reinforced gradually lose salience, while frequently accessed memories are strengthened.
MEM1 ([491]) uses an aggressive "use-and-discard policy: after each interaction, the agent synthesizes essential information into a compact state and immediately discards all prior contextual data to maintain constant memory consumption."

Active forgetting involves deliberate, targeted removal of specific content:

For non-parametric memory, this involves direct data manipulation:

Mem0 ([46]) "implements an explicit DELETE command to remove outdated or contradictory facts."
TiM ([187]) "introduces a dedicated FORGET operation to actively purge irrelevant or incorrect thoughts."
Memory-R1 ([417]) uses RL to "train a specialized Memory Manager agent to autonomously decide when to execute a DELETE command."
Zep ([262]) takes a non-destructive approach: "edge invalidation to assign an invalid timestamp to an outdated entry, effectively retiring it without permanent deletion" — the history is preserved but the fact is no longer considered current.
AriGraph ([6]) "maintains a structured memory graph by removing outdated vertices and edges."

For parametric memory, forgetting is achieved through machine unlearning:

MEOW ([101]) "facilitates efficient forgetting by fine-tuning an LLM on generated contradictory facts, effectively overwriting undesirable memories stored in its weights." By training the model on facts that contradict what should be forgotten, the target knowledge is suppressed without requiring identification of specific neurons.

3.4.4 Answer Generation: Synthesizing Evidence into Coherent, Attributable Outputs

Answer generation is the culminating stage of the DR pipeline, consuming the outputs of query planning, information acquisition, and memory management to produce the user-visible research output. The paper organizes this along four progressive dimensions: integrating upstream information, synthesizing evidence with coherence, structuring reasoning and narrative, and extending to multimodal presentation.

Integrating Upstream Information (Section 3.4.1)

The core principle: "The main principle of trustworthy answer generation is to ensure that every statement is grounded in verifiable external evidence." The generator must integrate diverse inputs — the sub-queries from planning, the ranked (and potentially conflicting) evidence from retrieval, and the evolving contextual state from memory — into a coherent response.

The paper distinguishes between simple and sophisticated integration:

Simple integration is exemplified by Self-RAG ([9]), which "adaptively retrieves passages on demand... then generates reflection tokens to assess the relevance of the retrieved information and its own generation, effectively integrating an internal self-correction mechanism to steer the synthesis." The model interleaves retrieval and generation tokens in a single output stream: it can generate a partial answer, reflect on whether more information is needed, retrieve additional passages, and continue.

Stateful query planning integration tightly couples the generation process with the dynamic memory state:

Plan-on-Graph (PoG, [30]) "explicitly integrates the plan with a dynamic memory (storing sub-goal status, explored paths, and retrieved entities). This memory is then actively used during a reflection step to guide and self-correct subsequent planning, tightly coupling the reasoning state with the generation process." The system does not just generate a plan and then execute it — it continuously monitors the execution state and adjusts the plan based on what has been discovered so far.
MCTS-OPS ([435]) "formalizes this by treating the MCTS tree itself as the state of the evolving query plan. Here, the system integrates its experiential memory (node values from past rollouts) to guide the SELECTION and EXPANSION of the next planning step, ensuring the final answer synthesizes the full context of the problem-solving process." The tree is both the plan and the memory — its structure captures what has been explored, and its node values capture how promising each branch appears.

Synthesizing Evidence and Maintaining Coherence (Section 3.4.2)

The two key challenges: Research queries frequently surface (1) contradictory sources that must be resolved, and (2) the need to maintain coherent, information-dense narration across extended outputs.

Resolving conflicting evidence draws on three strategies:

Credibility-aware attention weights evidence based on source reliability. CRAM (Credibility-aware Attention Modification, [56]) "assigns a higher score to information coming from more credible sources (e.g., a top-tier scientific journal) compared to less reliable ones (e.g., an unverified blog). This allows the model to prioritize trustworthy information while still considering relevant insights from a wider range of sources." The attention mechanism is modified so that tokens from high-credibility sources receive higher attention weights, effectively giving them more influence over the generated output.
Multi-agent deliberation simulates expert consensus-building. MADAM-RAG ([350]) "employ[s] multiple independent AI agents, each tasked with analyzing the retrieved documents from a different perspective. Each agent forms its own assessment and conclusion. Afterwards, a final meta-reasoning step synthesizes these diverse viewpoints to forge a more robust and nuanced final answer." Conflict is not suppressed but explicitly surfaced and debated before synthesis.
Reinforcement learning for factuality trains the generator to inherently prefer grounded outputs. RioRAG ([372]) gives "an LLM a positive reward when it generates statements that are strongly and consistently supported by the provided evidence... penalized for making unsubstantiated claims or statements that contradict the source material, shaping the model to inherently prefer generating factually grounded and reliable answers."

Long-form coherence and information density addresses the problem that models tend to degrade in quality over very long outputs — they repeat themselves, lose logical thread, or generate plausible but vacuous text:

LongWriter ([12]) "empirically demonstrates that the maximum coherent length of a model's output often scales with the average length of its fine-tuning samples." If a model is fine-tuned on 500-word examples, it will struggle to produce coherent 5,000-word outputs. The solution is to train on long-form examples, extending the model's coherent generation horizon. The paper formalizes this as $L_{model} \propto L_{SFT}$ , where $L_{model}$ is the maximum coherent output length and $L_{SFT}$ is the average length of fine-tuning examples.
RioRAG ([372]) also "introduces a length-adaptive reward function to promote information density, which penalizes verbosity that fails to add informational value, preventing reward hacking through verbosity" — a model cannot simply write more words to get higher scores if those words do not convey new information.

Structuring Reasoning and Narrative (Section 3.4.3)

The paper identifies a shift from generating monolithic answers to generating structured reasoning that users can inspect, verify, and trust:

Prompt-based Chain-of-Thought is the foundational approach, eliciting intermediate reasoning steps before the final answer. The paper formalizes this as $R = \text{LLM}(\text{CoT-Prompt} + Q + \text{Evidence})$ — the model receives the question, retrieved evidence, and a prompt that encourages step-by-step reasoning. Chain-of-Thought ([376]) demonstrated that this improves both accuracy and interpretability; zero-shot CoT ([162]) and Least-to-Most prompting ([484]) extended its applicability.

Explicit structural planning moves beyond linear chains to formalized answer structures:

RAPID ([99]) formalizes answer generation into three stages: "(i) outline generation; (ii) outline refinement through evidence discovery; and (iii) plan-guided writing, where the outline forms a directed acyclic graph to support complex, non-linear argumentation." The outline is not a simple bullet list but a graph encoding the logical dependencies between sections — Section C might depend on conclusions from both Sections A and B, and this dependency is explicitly represented.
SuperWriter ([399]) "extends this idea by decoupling the reasoning and text-production phases and optimizing the entire process via hierarchical Direct Preference Optimization." The model first produces a detailed reasoning trace, then generates the final text conditioned on that trace, and the entire pipeline is optimized end-to-end.

Tool-augmented reasoning enhances reasoning by dynamically invoking external resources during generation — calling calculators for numerical verification, querying databases for specific facts, executing code for computational checks. The paper cites Toolformer ([274]) and subsequent work as enabling models to interleave reasoning with tool calls, ensuring analytic rigor and factual grounding.

Presentation Generation (Section 3.4.4)

The frontier of answer generation extends beyond text to multimodal outputs — reports that include charts, tables, images, audio narration, and even video elements:

Early breakthroughs like BLIP-2 ([172]), InstructBLIP ([53]), and MiniGPT-4 ([493]) enabled multimodal instruction-following by aligning vision and language representations.
Systems like LIDA ([346]), ChartGPT ([441]), and Urania ([430]) synthesize data analyses into dynamic, interactive visualizations.
PresentAgent ([149]) and Qwen2.5-Omni ([147]) generate synchronized audio narrations alongside text.
PPTAgent ([479]) and Paper2Video ([504]) extend to editable presentation generation, transforming analytical reports into slide decks with coordinated text, figures, and layout.

The paper includes Table 2, which compares the output capabilities of contemporary DR systems: Gemini DeepResearch, Grok DeepSearch, OpenAI DeepResearch, AutoGLM, H2O.ai DeepResearch, and others. The comparison spans text generation, structured output formats (presentations, tables, JSON, code, charts, GUI, citations), and advanced modalities (image, audio, video). The table reveals that "while most DR systems still focus on textual synthesis with citations, only a handful, such as OpenAI DeepResearch and H2O.ai DeepResearch, currently support comprehensive multimodal output." The paper positions this as an emerging trend: "rich, multi-format answer generation will soon become a standard expectation, bridging the gap between knowledge synthesis and human-centered presentation."

4. Key Insights and Innovations

Innovation 1: A Taxonomic Unification That Transforms Fragmentation into a Design Space

This paper's most significant intellectual contribution is not a new algorithm or a benchmark, but a conceptual infrastructure — a shared vocabulary and architectural decomposition that transforms the fragmented landscape of deep research from a collection of incommensurate one-off systems into a coherent design space where tradeoffs can be systematically analyzed. Before this survey, terms like "deep research," "agentic search," and "web agent" were used loosely and often interchangeably. Each system — Anthropic's multi-agent pipeline, Search-R1's RL-trained searcher, OpenAI's DeepResearch — was described in its own idiosyncratic language, making cross-system comparison nearly impossible. The field lacked an answer to the basic question: what are the pieces any deep research system must have, and how do design choices in one piece constrain options in others?

The paper's four-component decomposition — query planning, information acquisition, memory management, and answer generation — provides this answer. It is an analytical framework, not an architectural prescription. The paper does not claim that all systems should implement these four components separately; rather, it argues that all systems can be understood through this lens, regardless of how tightly coupled their implementations are. This is the difference between saying "a car engine must have a carburetor" (prescriptive, and sometimes wrong) versus saying "a car engine's functionality can be analyzed in terms of fuel delivery, air intake, compression, and ignition" (analytical, and always applicable).

What makes this contribution fundamental rather than incremental is that it changes what questions researchers can ask. Without a shared decomposition, the only meaningful comparison between systems is end-to-end benchmark performance — did System A score higher than System B on GAIA? With the decomposition, researchers can ask more precise and productive questions: Does the performance gap come from better query planning or better memory management? Does System A's tree-based planning actually produce more diverse sub-queries than System B's sequential planning, or is the difference elsewhere? The paper does not answer these questions — it provides the intellectual scaffolding that makes it possible to ask them in a principled way.

The three-phase roadmap (Agentic Search → Integrated Research → Full-stack AI Scientist) reinforces this by providing a developmental, non-hierarchical capability trajectory. The paper is explicit that these are not value judgments — Phase I systems prioritizing accuracy-per-token fill an important niche, and Phase III systems aiming at hypothesis generation represent scientific ambition, not commercial maturity. By framing these as phases on a trajectory rather than levels on a ladder, the paper avoids the trap of implying that all systems should aspire to the most ambitious phase, while still providing vocabulary for describing what different approaches currently achieve. This is a subtle but important conceptual move: it acknowledges that different use cases require different capability profiles, and that progress in the field should be measured by how well each phase's goals are met, not by how quickly all systems converge toward Phase III.

The systematic comparison between RAG and DR phases (Table 1) serves as the bridge between old and new paradigms. By mapping RAG onto the same analytical dimensions as the DR phases — action space, reasoning horizon, workflow organization, output form — the paper makes visible what was previously implicit: DR is not "RAG with more steps" but a qualitatively different paradigm with distinct technical requirements, including flexible tool interaction, long-horizon autonomous workflows, and verifiable language interfaces. This comparison is what allows the field to stop arguing about whether DR is "just" advanced RAG and start investigating the specific capabilities that distinguish them.

The significance of this unification extends beyond academic taxonomy. For practitioners building DR systems, the decomposition provides a systematic debugging and improvement framework. If a system's reports lack coherent narrative structure, the decomposition suggests examining the answer generation component's evidence synthesis and narrative structuring, rather than randomly tuning hyperparameters. If a system retrieves redundant information across iterations, the memory management component's updating and forgetting mechanisms are the natural locus of investigation. Without this decomposition, debugging is guesswork; with it, debugging becomes systematic diagnosis.

Innovation 2: Retrieval Timing as a Meta-Cognitive Capability — When to Search, Not Just How

The paper's treatment of retrieval timing (Section 3.2.2) represents a diagnostic reframing of a previously under-theorized problem. Prior work on retrieval-augmented systems focused overwhelmingly on how to retrieve — developing better dense retrievers, multi-stage ranking pipelines, and fusion techniques. The question of when retrieval should occur was either ignored (retrieve once at the beginning), answered heuristically (retrieve on every step), or treated as a simple confidence threshold. The paper elevates retrieval timing from an implementation detail to a first-class design dimension and connects it to the deeper cognitive problem of knowledge boundary perception — the model's ability to recognize what it knows and what it does not.

This framing is intellectually distinctive because it reframes retrieval from a mechanical operation (execute search, get results) to a meta-cognitive decision (do I need more information to answer this question, or is my existing knowledge sufficient?). The paper's organization of confidence estimation approaches — probabilistic, consistency-based, internal-state-based, and verbalized — provides a taxonomy not just of technical methods but of different answers to the fundamental question: how can a model know when it doesn't know? Each approach represents a different theory of what constitutes reliable self-assessment:

Probabilistic confidence assumes that token-level generation probabilities reflect factual certainty — a theory that the paper acknowledges has been empirically challenged, since models can be confidently wrong.
Consistency-based confidence assumes that uncertainty manifests as output divergence across multiple samples — a theory grounded in Bayesian principles (posterior uncertainty produces diverse samples) but computationally expensive.
Internal-state probing assumes that factual uncertainty is encoded in hidden representations even when it is not expressed in output — a theory supported by evidence the paper cites ([10, 309, 28, 364, 230]) but still poorly understood mechanistically.
Verbalized confidence assumes that models can learn to express uncertainty in natural language through appropriate training — a theory that makes uncertainty explicit and auditable but is vulnerable to the same calibration failures as any learned behavior.

The significance of this reframing is that it connects retrieval timing to the broader literature on model calibration, uncertainty quantification, and honest AI. The finding that models "tend to be poorly calibrated, often producing overconfident predictions even when incorrect" ([104, 58, 137]) is not merely an engineering obstacle for building better DR systems — it is a fundamental limitation of current architectures that has implications for safety, reliability, and trust. A DR system that cannot reliably assess its own uncertainty will either over-retrieve (wasting compute on questions it could answer from memory) or under-retrieve (generating plausible but incorrect answers without seeking evidence). The paper's taxonomy makes visible that the field's ability to build efficient DR systems is bounded by its ability to solve the deeper problem of model self-awareness.

This intellectual move is fundamental rather than incremental because it redefines what it means to optimize a retrieval system. Before this framing, retrieval optimization meant improving ranking metrics (NDCG, recall). After this framing, retrieval optimization also means improving the model's ability to decide whether to retrieve at all. This doubles the optimization surface: you must optimize both the retriever's quality and the model's meta-cognitive accuracy. The paper's survey of adaptive retrieval approaches — from fixed per-step retrieval (IR-CoT) through dynamically triggered retrieval (ReAct, Self-RAG) to RL-trained retrieval policies (Search-R1) — traces an evolution from systems that treat retrieval uniformly to systems that treat retrieval as a learned behavior optimized against downstream task performance. This evolution mirrors the broader trajectory in AI from hard-coded control to learned policies, applied specifically to the problem of knowledge acquisition.

Innovation 3: Forgetting as a Functional Capability, Not a System Defect

The paper's treatment of memory forgetting (Section 3.3.4) makes a counterintuitive conceptual move that challenges a deeply ingrained assumption in AI system design. The default stance in most information systems — databases, knowledge bases, vector stores — is that forgetting is a bug. Information should be preserved indefinitely; storage is cheap; more data is always better. The paper explicitly rejects this stance, asserting that forgetting is "rather than a system defect... a functional process critical for filtering noise, reclaiming finite storage resources, and mitigating interference between conflicting information."

This is not merely a terminological reframe. It draws an explicit analogy to human memory, where forgetting is well-established as essential for cognitive function — without the ability to discard outdated or irrelevant information, retrieval becomes slower, interference increases, and generalization suffers. The paper imports this insight into AI agent design, arguing that DR systems operating over long horizons must have principled mechanisms for selective forgetting, because unbounded memory accumulation degrades rather than improves performance.

The paper's taxonomy of forgetting mechanisms — passive (time-based decay, FIFO eviction) versus active (targeted deletion, edge invalidation, machine unlearning for parametric memory) — provides a vocabulary for a capability that most systems implement implicitly and poorly. Prior work typically handled memory overflow through crude heuristics (keep the most recent N items, drop the oldest). The paper shows that a richer set of forgetting strategies exists, each appropriate for different scenarios: passive forgetting (Ebbinghaus-style decay in MemoryBank [482]) for prioritizing recent information, active non-parametric forgetting (DELETE commands in Mem0 [46], FORGET operations in TiM [187]) for correcting errors, temporal invalidation (Zep's bi-temporal model [262]) for preserving historical context while marking facts as superseded, and parametric unlearning (MEOW [101]) for removing knowledge from model weights.

What makes this intellectually distinctive is the shift from forgetting-as-constraint to forgetting-as-capability. In most system designs, memory constraints are an inconvenient reality to be managed (context windows are finite, so we must truncate). The paper reframes the constraint as an opportunity: because context windows are finite, the agent must learn what is worth keeping and what can be safely discarded. This transforms memory management from a storage problem (how to fit everything) into a relevance judgment problem (what is important enough to persist). The connection to reinforcement learning — Memory-R1 [417] training a dedicated Memory Manager agent to learn an optimal policy for ADD, UPDATE, and DELETE operations — makes this transformation explicit: forgetting is not something that happens to the agent when it runs out of space, but something the agent decides to do as part of its task-solving strategy.

The significance of this reframing extends beyond DR systems to the broader AI agent literature. As agents are deployed over increasingly long horizons — days, weeks, or indefinitely in persistent environments — the ability to selectively forget becomes not just useful but essential. An agent that never forgets is an agent that accumulates noise without bound, eventually drowning in its own history. The paper's taxonomy provides the conceptual foundation for developing forgetting mechanisms that are as sophisticated as the memory mechanisms they complement, rather than being an afterthought addressed by the simplest possible eviction policy.

Innovation 4: Multimodal Retrieval and Generation as Inseparable from Robust DR

The paper's treatment of multimodality — spanning retrieval tools (Section 3.2.1), answer generation presentation (Section 3.4.4), and the output capabilities comparison (Table 2) — makes a structural argument that the field has not yet internalized: robust deep research requires multimodal capabilities, not as an optional enhancement but as a fundamental necessity for evidence-grounded reasoning. This is a more specific and forceful claim than the generic observation that "multimodal AI is the future."

The argument's logic, implicit in the paper's organization but sharp when extracted, proceeds as follows: (1) much of the world's information exists in non-textual formats — charts, tables, images, structured databases, code outputs; (2) DR questions routinely require evidence from these formats (a market analysis needs to interpret revenue charts, a scientific literature review needs to extract data from tables, a competitive analysis needs to compare product images); (3) text-only DR systems, by definition, cannot access this evidence; (4) therefore, text-only DR systems have a hard ceiling on their reliability — they will either miss evidence entirely or hallucinate information that would have been available from non-textual sources. The corollary is that citation-grounded, verifiable DR cannot be achieved without multimodal retrieval and generation, because the evidence that would ground the most critical claims often lives outside text.

The paper does not merely assert this; it provides the technical taxonomy to make the argument concrete. Multimodal retrieval is organized by information modality — text-aware retrieval with layout, visual retrieval via text–image similarity, and structure-aware retrieval over parsed tables and charts — each addressing a different class of non-textual evidence and each requiring fundamentally different indexing and search infrastructure. The practical note that "queries are searched across all indices simultaneously, with results fused using reciprocal-rank fusion or cross-modal reranking" reveals that multimodal retrieval is not a simple extension of text retrieval but a fusion problem — the system must reconcile results from indices with incompatible relevance scoring functions and different failure modes.

The presentation generation discussion (Section 3.4.4) and Table 2 complete the argument by showing that output multimodality is as important as input multimodality. A research report that includes generated charts, structured tables, and formatted citations is not just aesthetically superior to a plain-text report — it is epistemically superior because it makes the evidence visible and auditable. A claim about a trend is more trustworthy when accompanied by the chart that shows the trend. A factual assertion is more verifiable when linked to a specific table cell in a retrieved document. The paper's observation that "while most DR systems still focus on textual synthesis with citations, only a handful... currently support comprehensive multimodal output" is not merely a feature comparison — it identifies a capability gap that directly limits trustworthiness.

What makes this contribution fundamental rather than incremental is that it redefines the scope of DR evaluation. If multimodality is necessary for robust DR, then benchmarks that evaluate only text-based Q&A are measuring an incomplete system. The field must develop evaluation frameworks that assess whether systems can find, interpret, and synthesize evidence regardless of the format in which it appears — and whether they can present that evidence in formats that support verification. This connects to the paper's broader argument about evaluation challenges (Section 6.4) and implies that progress toward robust DR cannot be measured by text-only benchmarks alone, no matter how challenging those benchmarks become.

5. Experimental Analysis

Important methodological note: This is a survey paper. Unlike the reference example (which described novel experiments on PaLM 2-S* with a specific test-time compute scaling framework), this paper does not conduct original experiments. It synthesizes results reported across dozens of prior publications, each with its own experimental setup, model family, dataset, and evaluation protocol. The "Experimental Analysis" section must therefore be structurally different: rather than describing a unified experimental campaign, it must characterize the diversity of evaluation practices across the field, assess whether this diversity supports or undermines the paper's central claims, and evaluate the frameworks the paper itself proposes for organizing evaluation.

The paper's contribution to experimental methodology is not new data but a taxonomy of evaluation benchmarks (Section 5) with an implicit argument that the field needs standardized evaluation protocols. The critical question for this section is: does the taxonomy reveal systematic gaps or biases in how DR systems are currently evaluated, and does the paper's proposed organization provide actionable guidance for future benchmarking?

Evaluation Methodology

Dataset. The paper does not introduce a new dataset. Section 5 catalogs multiple existing benchmarks across four application domains:
- Agentic Information Seeking (Section 5.1): Benchmarks range from single-hop QA (Natural Questions [165], TriviaQA [151], SimpleQA [377]) through multi-hop QA (HotpotQA [425], 2WikiMultihopQA [115], MuSiQue [344], FRAMES [163]) to complex, graduate-level reasoning (GPQA [265], GAIA [215], HLE [249]) and dynamic web interaction environments (BrowseComp [378], WebArena [488], Mind2Web [57, 98]). These span data sizes from 448 questions (GPQA) to over 300K (NQ), with formats ranging from short-answer exact match to multi-step interactive web trajectories. Table 4 summarizes key benchmarks for QA-focused DR evaluation, including data sizes and primary metrics.
- Comprehensive Report Generation (Section 5.2): Benchmarks cover survey generation (AutoSurvey [366] with 530,000 articles, ReportBench [175] with 600 papers, SurveyGen [14] with 4,200 human-written surveys), long-form report generation (DeepResearch Bench [66] with 100 PhD-level tasks, ResearcherBench [413] with 65 research questions, LiveDRBench [130] with 100 queries), poster generation (Paper2Poster [244] with 100 paper-poster pairs, PosterGen [464] with 10 papers), and slides generation (SLIDESBENCH [91] with 7,000 training + 585 test examples, Zenodo10K [478] with 10,448 artifacts). Table 5 summarizes these benchmarks with data sizes and evaluation metrics.
- AI for Research (Section 5.3): Benchmarks assess idea generation (AI Idea Bench 2025 [258] with 3,495 papers), experimental execution (PaperBench [304] with 20 ICML 2024 papers, Scientist-Bench [326] with 52 top-cited papers), academic writing (same benchmarks overlapping with execution), and peer review (ASAP-Review [442] with 8,877 papers, DeepReview-Bench [498] with ~1.2K submissions). Software engineering (SWE-Bench [141] with 500 instances, CORE-Bench [297], DSBench [148]) is treated as a related but distinct application domain.
Critical observation: These benchmarks were NOT designed to evaluate DR systems. Most predate the DR paradigm and were developed for evaluating specific capabilities (reading comprehension, multi-hop reasoning, web navigation) in isolation. The paper's contribution is organizing them into a DR evaluation framework, but this means the entire experimental landscape is a post-hoc mapping of existing benchmarks onto the DR taxonomy, not a purpose-built evaluation suite. Whether these benchmarks collectively measure what the paper claims — autonomous research capability — is an open question, not an established fact.
Base model(s). The paper does not prescribe or evaluate specific models. Section 5 cites performance across dozens of model families and system architectures, including: GPT-4-based systems (WebGPT [221], various agentic search systems), Gemini DeepResearch [193], Grok DeepSearch [400], OpenAI DeepResearch [238], AutoGLM [190], Kimi-K2 [338], DeepSeek-based RL-trained agents (Search-R1 [145], R1-Searcher [300, 301]), and numerous open-source frameworks. The models range from small fine-tuned LMs to frontier proprietary systems. This diversity makes cross-system comparison impossible from the paper alone, since each benchmark result is reported for a different system with different training data, architecture, and scale. The paper does not attempt to normalize for these differences — it catalogs what exists rather than evaluating what is best.

The practical consequence is that Section 5 functions as a resource directory, not a leaderboard. Readers can identify which benchmarks are relevant to their use case and which systems have been evaluated on them, but cannot draw conclusions about relative system quality because no two systems are evaluated on the same set of benchmarks under the same conditions. This is not a flaw in the paper (surveys do not perform original experiments) but it is a limitation the reader must understand: the paper's taxonomy is descriptive of a fragmented field, not prescriptive of a unified evaluation methodology.
Metrics. The paper surveys a wide range of metrics, each appropriate to different evaluation scenarios:
- Short-form QA metrics: Exact Match (EM), F1 score, and Accuracy — standard for benchmarks like NQ, HotpotQA, and SimpleQA where answers are short spans or entities. These are well-defined and automatable but the paper notes (Section 6.4.1) they are "primarily suited for tasks with well-defined, short-span ground truths" and "struggle to evaluate multi-answer or open-ended questions effectively."
- Long-form evaluation metrics: The paper identifies a shift from surface-form matching to content-based assessment as outputs grow longer. Benchmarks like DeepResearch Bench [66] and ResearcherBench [413] use LLM-as-Judge evaluation where an external LLM (typically GPT-4) assigns scores along dimensions such as factual accuracy, citation quality, structural coherence, and completeness. Some benchmarks (ReportBench [175]) use reference-based assessment where generated reports are compared against gold-standard survey papers. FActScore [216] is cited for fine-grained atomic factuality evaluation — decomposing generated text into atomic claims and verifying each against a knowledge source.
- Interactive environment metrics: Benchmarks like WebArena [488] and Mind2Web [57] use task success rate (did the agent complete the specified task?), sometimes combined with efficiency metrics (number of actions taken). BrowseComp [378] uses exact match on the final answer. GAIA [215] uses exact match despite questions requiring multi-step reasoning, because all answers are designed to be unambiguous strings.
- Scientific evaluation metrics: PaperBench [304] uses LLM-based rubric assessment where a detailed scoring rubric is manually constructed for each paper. AI Idea Bench 2025 [258] evaluates whether generated ideas are consistent with ground-truth papers. For peer review (DeepReview-Bench [498]), metrics include MAE, MSE, accuracy, F1, and Spearman correlation against human review scores.
Critical observation: The paper consistently flags LLM-as-Judge as the dominant evaluation paradigm for long-form outputs (Sections 5.2, 5.3, 6.4.3) but also identifies its limitations: bias toward longer responses, sensitivity to answer ordering, preference for particular writing styles, and self-preference (models rate their own outputs higher). Section 6.4.3 is dedicated to these concerns, noting that "such biases may reduce the robustness and fairness of existing evaluation protocols." This means that for the most ambitious DR outputs — long-form research reports — the evaluation methodology itself is unreliable in ways that are not fully characterized, a genuinely important limitation the paper surfaces rather than hides.
Baselines. The paper does not establish baselines; it catalogs them from the literature. Across the surveyed works, common baselines include:
- Standard RAG: single-step retrieval from a static corpus followed by generation, representing the pre-DR paradigm.
- No-retrieval LLM: the base model answering from parametric knowledge alone, measuring the value added by external evidence.
- Majority voting: sampling N answers and selecting the most common, as a simple test-time compute baseline.
- ReAct-style agents: interleaved reasoning and action without the full DR pipeline (memory management, structured planning).
- Single-agent vs. multi-agent: comparing a monolithic agent against a multi-agent orchestration for the same task.
However, these baselines are not consistently applied across studies. Each paper typically compares against a different set of prior systems, making the baseline landscape as fragmented as the system landscape. The paper's taxonomy of evaluation benchmarks (Tables 4 and 5) does not include baseline information — it is purely a catalog of tasks and metrics.
Generation budget / compute accounting. The paper does not establish a unified compute accounting framework. Across the surveyed literature, compute is measured in incompatible units: number of LLM calls (ReAct-style agents), number of search queries (web agents), total tokens generated (long-form report generation), wall-clock time (interactive web tasks), or simply "API cost" (proprietary system comparisons). The paper reports these metrics as they appear in the original works without attempting normalization.

This is a significant gap because DR systems vary enormously in their computational footprint. A multi-agent system with 10 worker agents each making 20 LLM calls consumes vastly more compute than a single-agent system with a retrieval-augmented generation loop, even if both produce reports of similar length. Without a standardized compute accounting methodology, it is impossible to know whether reported performance improvements come from better algorithms or simply from spending more compute. The paper identifies training instability (Section 6.3) as a challenge but does not address the equally important problem of inference compute accounting in evaluation.

Section 4.3.1 provides mathematical definitions for PPO and GRPO objective functions, including advantage estimation formulas and reward normalization, but these are training-time compute formulations, not evaluation-time accounting.
Cross-validation / statistical protocol. The paper does not describe statistical protocols for the experiments it surveys. Individual papers cited may use cross-validation, holdout sets, or multiple random seeds, but the paper does not systematically report these methodological details. For RL-trained systems (Section 4.3), stability is a known concern — the paper devotes Section 6.3 to training instability, discussing entropy collapse, gradient explosion, and the "Echo Trap" phenomenon — but does not report whether the evaluation results it cites are from single training runs (potentially cherry-picked) or averaged across multiple seeds with confidence intervals.

For LLM-as-Judge evaluation, Section 6.4.3 notes that "large-scale pairwise evaluation is resource- intensive" and that positional bias, verbosity bias, and self-preference can affect results, but does not propose or survey statistical corrections for these biases beyond general suggestions (human calibration, debiasing signals in judge fine-tuning).

Main Quantitative Results

Structural caveat: Unlike the reference example, which presented original experimental data in figures showing accuracy-vs-compute scaling curves, this paper does not contain original quantitative results. Section 5 is a taxonomy, not an experimental section. The "results" it reports are qualitative characterizations of benchmark properties — what each benchmark measures, what format its outputs take, what metrics it uses — organized into comparative tables (Tables 4 and 5).

The following subsections therefore characterize what the paper's taxonomy reveals about the state of DR evaluation, which is its primary empirical contribution to the field.

The Benchmark Landscape Is Heavily Skewed Toward Short-Form QA, Despite DR's Focus on Long-Form Outputs

The paper catalogs benchmarks across four application domains, but the distribution is revealing. Section 5.1 (Agentic Information Seeking) lists 17 distinct benchmarks (Table 4), the majority of which evaluate short-form question answering: NQ, TriviaQA, SimpleQA, HotpotQA, 2WikiMultihopQA, Bamboogle, MultiHop-RAG, MuSiQue, GPQA, and GAIA all measure whether an agent can produce a correct short answer (an entity, a phrase, a number) or select the correct multiple-choice option. Even benchmarks described as "complex" — GAIA requires multi-step reasoning and tool use, HLE spans dozens of academic disciplines — reduce evaluation to a single correct answer string.

The paper does not present error bars because the original works typically do not report them in a standardized format, and the paper's role as a survey is to catalog what exists rather than to re-analyze raw data.

By contrast, Section 5.2 (Comprehensive Report Generation) lists 12 benchmarks (Table 5), but most are recent (2024-2025), small-scale (DeepResearch Bench: 100 tasks; ResearcherBench: 65 questions; Paper2Poster: 100 pairs), and use LLM-as-Judge evaluation whose reliability the paper itself questions (Section 6.4.3). The imbalance is striking: the DR paradigm's defining characteristic is producing structured, long-form, evidence-grounded reports, yet the evaluation ecosystem is dominated by benchmarks designed for a fundamentally different output format.

This skew has a consequential implication that the paper implies but does not state explicitly: DR systems are being evaluated primarily on tasks they were not designed for. An agent optimized for GAIA (short-answer exact match) may or may not produce coherent research reports. Conversely, a system that excels at report generation may underperform on short-answer benchmarks because it allocates compute to synthesis and citation that those benchmarks do not reward. The evaluation ecosystem, as cataloged, does not distinguish between these capability profiles — it treats all benchmarks as equally informative about "deep research" capability, when in fact they measure fundamentally different things.

LLM-as-Judge Dominates Long-Form Evaluation, Despite Known Biases the Paper Itself Documents

For benchmarks that evaluate long-form outputs — ResearchBench, DeepResearch Bench, LiveDRBench, ReportBench, and the various generation benchmarks in Section 5.2 — LLM-as-Judge is the primary evaluation methodology. The paper reports this fact without endorsement, and Section 6.4.3 explicitly catalogs the limitations:

Verbosity bias: "LLM judges may prefer longer responses" — a well-documented phenomenon where longer outputs receive higher scores regardless of quality, creating an incentive for systems to generate verbose but information-sparse text.
Position bias: "be affected by answer ordering" — when comparing two outputs, the order in which they are presented can change which one the judge prefers.
Style bias: "reward particular writing styles" — judges may prefer outputs that match their own training distribution's stylistic patterns.
Self-preference bias: "favor systems that resemble themselves" — models trained by the same organization or sharing architectural similarities may receive inflated scores.

Section 6.4.1 adds that current LLM-based evaluation struggles specifically with logical coherence in long-form outputs: "while LLMs demonstrate strong capabilities for recognizing logical patterns, such as in summarization tasks or the detection of inconsistencies in short passages, their ability to create rigorous logical chains during DR remains uncertain." The paper also notes that "generated reasoning may contain gaps, abrupt leaps, or even circular justifications" that surface-level evaluation metrics fail to detect.

The implication is significant: for the very capabilities that distinguish DR from simpler paradigms — sustained logical argumentation, cross-source synthesis, novelty without hallucination — the evaluation methodology is least reliable. The field is in the uncomfortable position of using tools whose limitations are well-documented to evaluate systems whose capabilities exceed what those tools can reliably measure. The paper's contribution is making this tension visible rather than resolving it.

Interactive Environment Benchmarks Grow in Realism but Shrink in Scale

Section 5.1.2 catalogs a progression toward increasingly realistic web-based evaluation environments: from WebArena (812 tasks across four domains, 2024) through Mind2Web (2,350 tasks from real websites, 2023) to BrowseComp (1,266 challenging questions requiring persistent web navigation, 2025) and DeepResearchGym (96,000 tasks with reproducible search API, 2025).

The paper reports data sizes as published in the original works (e.g., WebArena: 812; BrowseComp: 1,266; DeepResearchGym: 96,000) but does not attempt to reconcile these numbers with the observation that task complexity and task count tend to be inversely correlated. BrowseComp's 1,266 questions are each substantially harder than DeepResearchGym's 96,000 questions (the latter are algorithmically generated with more constrained answer formats). The paper treats size and difficulty as orthogonal dimensions worthy of separate consideration rather than implying a tradeoff.

The trend the paper identifies is toward environments that require agents to "interact with, navigate, and creatively explore web pages to obtain complex or hard-to-find information" — a capability profile far beyond static QA. However, evaluation in these environments becomes more expensive and less reproducible: live web content changes, API rate limits constrain throughput, and network latency introduces variance not present in static benchmarks. The paper notes these challenges in Section 5.1.2 ("task degradation and network randomness") but does not quantify their impact on result reliability.

AI-for-Research Evaluation Is in Its Infancy, with Benchmarks That Test Narrow Slices of Scientific Capability

Section 5.3 catalogs benchmarks for idea generation, experimental execution, academic writing, and peer review — the components of the Phase III "Full-stack AI Scientist" vision. The landscape here is characterized by:

Extremely small scale: PaperBench [304] contains 20 papers. Scientist-Bench [326] contains 52 papers. AI Idea Bench 2025 [258] is larger (3,495 papers) but evaluates only a narrow slice of the idea-generation pipeline (consistency with known results, not genuine novelty).
Heavy reliance on human judgment: The paper cites Si et al. [296] who recruited "over 100 NLP researchers to evaluate the novelty of ideas" — a methodology that is not scalable and introduces its own reliability concerns (inter-annotator agreement is not reported).
Lack of standardized metrics for novelty and insight: Section 6.4.2 discusses the "boundary between novelty and hallucination" as an unresolved challenge. The paper frames this as a fundamental tension: "outputs that appear original may embed unverifiable claims, fabricated connections between sources, or spurious inferences lacking epistemic grounding." No existing benchmark, as cataloged, reliably distinguishes between genuine synthesis and plausible-sounding confabulation.

The implication is that Phase III DR evaluation is premature. The benchmarks exist, but they capture only fragments of scientific capability (can the system replicate a known paper? can it produce text that humans rate as interesting?) rather than the full autonomous research loop the phase envisions. The paper's decision to include these benchmarks despite their limitations is appropriate for a survey — cataloging what exists — but readers should not interpret their inclusion as validation that Phase III capabilities are measurable with current tools.

Table 2 Reveals a Capability Gap Between Proprietary and Open-Source DR Systems

The paper's Table 2 compares output capabilities of 12 contemporary DR systems across 10 dimensions (text, image, audio, video, presentations, tables, JSON, code, charts/GUI, citations). While this is not a quantitative result in the traditional sense (no accuracy numbers are reported), it is the paper's most direct empirical contribution to system comparison. Key patterns visible in the table:

Proprietary systems support broader output modalities: OpenAI DeepResearch and Gemini DeepResearch support the widest range of output formats (7-8 of 10 dimensions). Open-source systems (AutoGLM, OpenManus, OWL) support narrower ranges (4-6 dimensions).
Citation support is nearly universal among DR-labeled systems: All systems listed support citations, confirming that verifiable attribution is a defining characteristic of the DR paradigm, not an optional feature.
Advanced modalities remain rare: Only one system (Gemini DeepResearch) supports audio output. Only one system supports video. The gap between what the paper describes as the frontier (Section 3.4.4: "multimodal generation, where text, visuals, tables, and audio coalesce") and what deployed systems actually provide is substantial.

The paper does not attempt to explain this gap — it reports the capability matrix without analyzing whether the differences reflect technical difficulty, different use case prioritization, or simply different stages of development.

Ablation Studies and Robustness Checks

As a survey, this paper does not conduct original ablations. However, it reports and synthesizes ablations from the cited literature. The following characterizes the types of robustness evidence the paper surveys, organized by the component taxonomy.

Query planning strategy comparison (from cited works, Section 3.1): The paper reports that parallel planning is most effective when sub-queries are independent (Least-to-Most Prompting [484], CoVE [59]), sequential planning outperforms parallel when logical dependencies exist between sub-questions (LLatrieval [181], DRAGIN [308]), and tree-based planning (RAG-Star [132]) can outperform both when the optimal decomposition is not known in advance. However, the paper does not provide a single controlled experiment comparing all three strategies on the same task — it synthesizes findings from different papers using different models and benchmarks, which limits the strength of comparative claims.

PRM aggregation strategy (from cited works, Appendix E, Figure 13 of another paper): The paper references findings that "last" step aggregation outperforms "min" and "prod" for process reward model scoring, contrary to prior findings by Lightman et al. (2023). This is cited in the context of search-based DR but is not original to this paper.

Revision model sequential vs. parallel ratio (from cited works, Section 6 of another paper): The paper references findings that the optimal sequential-to-parallel sampling ratio is difficulty-dependent: fully sequential for easy questions, balanced for hard questions. Again, this is cited rather than original.

Cold-start SFT for RL training (Section 4.2): The paper reports that "SFT is commonly employed as the cold start, e.g., a warm-up process, before online reinforcement learning" and that systems like Search-R1 [145], WebDancer [391], and R1-Searcher [300] use this pipeline. The implication — that SFT warm-start improves RL training stability — is plausible but not demonstrated through controlled ablation within this paper.

GRPO vs. PPO for multi-turn RL (Section 4.3.1): The paper provides mathematical definitions for both algorithms and describes their differences: "In PPO, each sampled output is optimized using an advantage signal derived from a value model... In contrast, GRPO optimizes by contrasting each response against others within the same group." Section 6.3.2 notes that while PPO's critic module "naturally smooths reward signals," GRPO "relies on group-wise normalization, which makes it more sensitive to reward variance and extreme values." However, the paper does not provide head-to-head empirical comparison of the two algorithms on the same DR task — this is a theoretical characterization rather than an experimental finding.

Filtering ablation (from cited works, Section 3.2.3): The paper reports that within individual cited systems, ablations show filtering improves answer accuracy, with contributions attributed to specific components (e.g., dual-stage pruning in HtmlRAG [323], schema retrieval in TableRAG [32]). However, there is no cross-system comparison showing which filtering strategy dominates under which conditions.

The absence of original ablations is not a weakness of the paper (surveys synthesize, they do not experiment), but it means the robustness evidence for individual design choices must be sought in the original papers, not in this survey. The paper's contribution is organizing these design choices into a taxonomy where future researchers can systematically ablate, not providing the ablation results themselves.

Critical Assessment

How to read this section: The paper's central claims are taxonomic ("DR systems can be decomposed into four components"), definitional ("DR is distinct from RAG along nine dimensions"), and organizational ("the field can be understood through three optimization paradigms and four evaluation domains"). These are not empirical claims in the traditional sense — there is no experiment that "proves" a taxonomy is correct. Rather, these are framework claims: assertions that a particular way of organizing knowledge is useful and illuminates genuine structure in the phenomena being organized.

The appropriate evaluation is therefore not "do the experiments support the claims" but rather: does the taxonomy reveal patterns that were invisible before, does it enable questions that could not previously be asked, and does it faithfully reflect the diversity of actual systems without distorting or oversimplifying?

The Four-Component Decomposition: Useful but Potentially Over-Constraining

The paper's central organizational claim is that all DR systems can be understood as orchestrating query planning, information acquisition, memory management, and answer generation in an iterative loop (Section 3, Figure 1). This decomposition has genuine analytical value — it replaces ad-hoc system descriptions with a shared vocabulary, it highlights cross-system commonalities (e.g., retrieval timing is a problem in both Search-R1 and Anthropic's multi-agent system, even though they implement it differently), and it provides a systematic debugging framework for practitioners.

However, the decomposition also has structural limitations that the paper does not fully address:

The implied linearity is an idealization. Figure 1 shows a clean cycle: query planning → information acquisition → memory management → answer generation → back to planning. Real DR systems, as the paper acknowledges in describing specific implementations, are messier. Memory operations may occur during retrieval (filtering retrieved documents updates working memory). Answer generation may trigger new retrieval (Self-RAG's interleaved generation and retrieval). Planning may be revised mid-execution based on retrieved evidence (ReSP's iterative gap identification). By imposing a four-component cycle, the taxonomy may obscure the tight coupling between components that makes systems effective. A more faithful representation might show components as overlapping processes rather than sequential stages.

Memory management is treated as a separate component, but in many systems it is distributed across all other components. Query planning stores intermediate plans in memory. Information acquisition stores retrieved documents in memory. Answer generation reads from and writes to memory. The paper's decision to treat memory as a distinct stage with its own sub-taxonomy (consolidation, indexing, updating, forgetting) is useful for highlighting the importance of state management, but may mislead readers into thinking memory is a module that can be independently optimized, when in practice its quality depends on the coherence of the entire pipeline's memory interactions.

Some systems resist clean decomposition. The paper's own examples illustrate this. Search-R1 [145] is described in Section 3.1.2 (sequential planning) but also in Section 4.3.3 (end-to-end optimization), and its core contribution — RL-trained retrieval timing — blurs the boundary between planning and information acquisition. The paper's framework can accommodate this (the system is described from multiple angles in different sections), but the fact that key systems appear in multiple component discussions suggests the decomposition may fragment rather than illuminate some of the most interesting architectural innovations.

The Three-Phase Roadmap: Descriptive but Not Yet Predictive

The Phase I (Agentic Search) → Phase II (Integrated Research) → Phase III (Full-stack AI Scientist) progression (Section 2.2) provides useful vocabulary for characterizing system capabilities, but the paper does not establish that this progression is predictive — that is, that capability at Phase I predicts capability at Phase II, or that the phases represent genuine developmental stages rather than simply different application domains.

Several observations complicate the phase narrative:

Phase I benchmarks (short-form QA) are weakly correlated with Phase II capabilities (long-form report generation). The paper catalogs extensive short-form QA benchmarks (Section 5.1) and long-form report benchmarks (Section 5.2) but provides no evidence that performance on one predicts performance on the other. A system optimized for HotpotQA accuracy may generate incoherent reports; a system that produces excellent research reports may underperform on multi-hop QA if it allocates compute to synthesis rather than precise answer extraction. The phases may represent orthogonal capability dimensions rather than developmental stages.

Phase III evaluation is too immature to validate the phase distinction. The benchmarks for AI-for-research (Section 5.3) are small (20-52 papers), rely heavily on human judgment, and do not have established validity (does PaperBench performance predict real scientific contribution?). Claiming Phase III as a distinct capability level requires demonstrating that systems exist which reliably perform the Phase III tasks at a level beyond Phase II systems — but with current evaluation tools, such a demonstration is not possible.

The RAG comparison (Table 1) oversimplifies the boundary. Table 1 maps RAG and the three DR phases onto nine capability dimensions, drawing clean boundaries: RAG has no code execution, no reflection, no memory management, narrow action space, single-turn reasoning. But the boundaries are blurrier than the table implies. Advanced RAG systems (Self-RAG [9]) incorporate reflection. Some RAG pipelines maintain conversation history (a form of memory). WebGPT [221] performs multi-turn search within a RAG-like framework. The table's binary checkmarks obscure continuous variation along each dimension, potentially creating a false sense of categorical difference where gradations exist.

The Optimization Taxonomy: Missing the Interaction Effects Between Paradigms

Section 4 organizes optimization approaches into three paradigms: workflow prompting, supervised fine-tuning, and end-to-end agentic RL. This is a clean taxonomy, but the paper presents them largely as alternatives — different points on a spectrum from hand-engineering to learned optimization — without systematically analyzing their interaction effects.

In practice, many of the strongest DR systems combine paradigms. Search-R1 [145] uses SFT warm-start before RL training. WebDancer [391] distills from a strong teacher (SFT) then applies RL. Anthropic's system (Section 4.1.1) uses purely prompting-based orchestration but could potentially be improved by fine-tuning individual worker agents. The paper acknowledges these combinations in individual system descriptions but does not provide a framework for thinking about when combination is beneficial and when it introduces conflicting optimization signals.

A particularly important question the taxonomy does not address: does end-to-end RL training eliminate the need for careful component design, or does it amplify the importance of getting the component architecture right? If RL can discover effective retrieval timing policies regardless of the initial retrieval architecture, then component design matters less. If RL only works when built on a well-designed component architecture, then the component taxonomy (Section 3) and the optimization taxonomy (Section 4) are deeply interdependent, not independent dimensions of variation. The paper does not take a position on this question, and the cited literature (being too young for systematic cross-paradigm comparisons) does not resolve it.

Evaluation Coverage: Systematic Gaps That Limit the Taxonomy's Utility

The paper's evaluation benchmark catalog (Section 5, Tables 4 and 5) is extensive but has structural gaps that limit its utility for practitioners:

No cost or latency benchmarks. DR systems vary enormously in computational cost — a multi-agent system with 10 workers each calling GPT-4 costs orders of magnitude more than a single-agent system using a small open-source model. Yet no benchmark in the catalog measures cost-effectiveness (accuracy per dollar) or latency (time to produce a report). A practitioner choosing between DR systems based on this survey's taxonomy would have no way to assess whether a system with 5% higher accuracy but 10× higher cost is a better choice. This is a significant gap because cost and latency are often the binding constraints in deployment, not maximum capability on an academic benchmark.

No robustness or reliability benchmarks. The paper catalogs benchmarks that measure best-case performance (accuracy on a fixed test set) but none that measure robustness to distribution shift, adversarial inputs, or edge cases. A DR system that achieves 90% accuracy on GPQA but catastrophically fails when the question format changes slightly is less useful than one with 80% accuracy but consistent behavior. The absence of robustness evaluation is not unique to this survey — it reflects the broader field's focus on static benchmark performance — but the paper does not identify this as a gap, focusing instead on the more tractable problems of evaluation bias and logical coherence.

Temporal validity is unaddressed. DR systems that access the live web face a unique evaluation challenge: the correct answer to a question may change over time (stock prices, political leadership, scientific consensus). A system evaluated in January 2025 on questions about "the current CEO of Company X" may receive a different ground-truth answer than the same system evaluated in June 2025, even if both answers were correct at the time of evaluation. The paper's benchmark catalog (with the exception of LiveDRBench [130], which explicitly incorporates temporally evolving queries) does not address how to evaluate systems when the "ground truth" is itself dynamic.

The Survey's Most Important Implicit Finding: The Field Cannot Measure What It Claims to Build

Reading across the paper's evaluation sections (5.1-5.4) and its challenges section (6.4) reveals a tension that the paper documents without fully confronting: the DR field's ambitions (autonomous research, verifiable reports, novel scientific contributions) far exceed its measurement capabilities (short-answer QA benchmarks, LLM-as-Judge with known biases, tiny expert-annotated test sets).

This is not a flaw in the paper — it is a flaw in the field that the paper usefully exposes. By organizing the evaluation landscape into a coherent taxonomy, the paper makes visible that:

Phase I (Agentic Search) has the most mature evaluation, but Phase I is the least ambitious phase.
Phase II (Integrated Research) has growing but methodologically fragile evaluation, dependent on LLM judges whose biases are documented but not corrected for.
Phase III (Full-stack AI Scientist) has evaluation that is too small-scale, too subjective, and too narrow to support claims about scientific capability.

The paper's contribution is making this imbalance explicit. The implicit argument is that evaluation methodology, not system architecture, is the binding constraint on DR progress. Until the field can reliably measure whether a generated research report is factually accurate, logically coherent, properly cited, and genuinely novel — and can do so at scale without prohibitive human annotation costs — claims about system capability will remain unverifiable regardless of how sophisticated the underlying architecture becomes.

This is a more sober assessment than the paper's optimistic framing would suggest, but it is the logical conclusion of its own evidence. The taxonomy is valuable precisely because it reveals this gap, not because it fills it.

6. Limitations and Trade-offs

The Taxonomy Is Descriptive, Not Empirically Validated

The assumption or constraint. The paper's central contribution — the four-component decomposition of DR systems into query planning, information acquisition, memory management, and answer generation — is presented as a universal framework through which all DR systems can be understood. The paper states this explicitly in Section 3:

"A DR system can be viewed as a closed-loop workflow that takes a complex research question as input and produces a structured answer, typically in the form of long-form text with citations or synthesized reports."

However, the paper provides no empirical evidence that this decomposition captures the essential structure of DR systems rather than being one of many possible taxonomies. The framework is asserted, not tested. The paper does not demonstrate, for example, that systems decompose cleanly into these four components (with minimal cross-component coupling), that system performance can be predicted from component-level design choices, or that the taxonomy enables interventions (improving a specific component yields predictable improvements in overall system behavior) that would not be possible with alternative decompositions.

The consequence. A taxonomy that is not empirically grounded risks being plausible but misleading. If real DR systems exhibit tight coupling between components — where, for instance, memory management quality depends on how query planning structures sub-questions, not just on the memory module's design — then treating components as independent design dimensions will produce incorrect predictions about system behavior. A practitioner who follows the taxonomy might optimize memory management in isolation, only to discover that the real bottleneck was the interaction between planning and retrieval. More subtly, the taxonomy could blind researchers to alternative decompositions that cut across the paper's component boundaries. For example, "uncertainty management" (deciding when the agent has sufficient evidence, when to seek more, when to revise earlier conclusions) cuts across planning, retrieval timing, and answer generation, but the paper's decomposition distributes it across three components, potentially obscuring it as a coherent design problem.

What evidence exists in the paper. The paper provides no empirical validation of the taxonomy. The evidence offered is demonstrative, not evaluative: the paper shows that various DR systems can be described using the four-component vocabulary (Sections 3.1-3.4), not that the vocabulary improves analysis, prediction, or design. Table 2 compares output capabilities of twelve DR systems, but this comparison is organized by output modality, not by the four components, and does not test whether component-level differences explain capability differences. The survey of optimization techniques (Section 4) organizes approaches by training paradigm (prompting, SFT, RL) rather than by which component they optimize, further decoupling the optimization taxonomy from the component taxonomy.

Mitigation status. Not addressed. The paper does not acknowledge this as a limitation, does not propose methods for validating the taxonomy, and does not discuss alternative decomposition frameworks. The taxonomy is presented as a finding rather than a hypothesis. For a survey paper, some level of asserted taxonomy is necessary — the alternative is an unstructured list of systems — but the absence of validation criteria means readers must treat the decomposition as a useful conceptual tool rather than an established structural truth about DR systems.

The Paper Provides No Cost or Latency Accounting, Despite DR's Extreme Computational Heterogeneity

The assumption or constraint. The paper implicitly treats all DR systems as comparable units of analysis, cataloging their capabilities and optimization approaches without reference to their computational cost. Section 4 surveys workflow prompting (Anthropic's multi-agent system with "up to 10 or more" worker agents), supervised fine-tuning (which requires generating and filtering training trajectories from teacher systems), and end-to-end RL (which the paper acknowledges faces "sparse rewards, excessively long responses, and unstable training," Section 4.3.3). The paper reports the mathematical formulations of PPO and GRPO (Equations 1-7) and discusses training instability (Section 6.3), but never quantifies the computational resources required for any approach — no FLOP counts, no GPU-hours, no API cost estimates, no latency measurements.

The paper acknowledges cost indirectly when describing Anthropic's system (Section 4.1.1), noting that it operates "under an explicit research budget controlling agent count, tool usage, and reasoning depth," but this budget is described qualitatively (effort scales "from 1-2 agents for factual lookups to up to 10 or more for multi-perspective analyses") rather than quantitatively.

The consequence. Without cost accounting, the paper's optimization taxonomy cannot guide practical decision-making. A practitioner choosing between workflow prompting, SFT, and end-to-end RL needs to know not just which approach yields higher benchmark scores, but at what cost. The three paradigms span orders of magnitude in computational requirements:

Workflow prompting requires no training but incurs high per-query inference cost (10+ agents each making multiple LLM calls).
SFT requires one-time training data generation and fine-tuning but yields a single model with lower per-query cost.
End-to-end RL requires the most expensive training (iterative environment interaction, policy updates over thousands of trajectories) but potentially the most efficient inference.

Without quantifying these costs, the paper cannot address the most basic engineering question: under what resource constraints should a practitioner choose which paradigm? The omission is particularly consequential because DR systems are, by design, computationally intensive — they make many more LLM calls and retrieval operations than simpler RAG systems. A DR system that achieves 5% higher accuracy on a benchmark but costs 50× more to run may be the wrong choice for most deployments, yet the paper provides no framework for making this tradeoff visible.

What evidence exists in the paper. None. The paper contains no cost analysis, no latency measurements, and no compute-normalized comparisons. The evaluation benchmarks (Section 5) report accuracy, F1, and LLM-judge scores, never cost-adjusted metrics. Table 2 compares capability presence (does the system support charts? citations?) but not capability cost. The paper's discussion of GRPO in Section 4.3.1 mentions that it "reduces resource requirements" compared to PPO by eliminating the value model, but this is a qualitative claim with no supporting numbers.

Mitigation status. Not addressed. The paper does not identify cost accounting as a gap, does not propose cost as an evaluation dimension, and does not suggest that future benchmarks should report compute-normalized metrics. This is a significant omission in a survey that aims to guide practitioners in building and deploying DR systems.

The Survey Cannot Assess Whether DR Progress Is Genuine or an Artifact of Benchmark-Conditional Overfitting

The assumption or constraint. The paper catalogs an extensive set of evaluation benchmarks (Section 5, Tables 4 and 5) and organizes them by application domain, but it does not — and structurally cannot — assess whether performance improvements on these benchmarks reflect genuine capability advances or overfitting to benchmark-specific patterns. This is not a flaw in the paper's execution but a limitation inherent to the survey format and the state of the field: the paper can only report what the original works report, and the original works overwhelmingly report single-benchmark results with no cross-benchmark generalization analysis.

The paper does not present, for example, a matrix showing whether systems that perform well on GAIA also perform well on BrowseComp, or whether improvements on HotpotQA transfer to DeepResearch Bench. Without such cross-benchmark correlations, it is impossible to distinguish between a system that has learned general research skills and one that has been optimized (through architecture design, prompt engineering, or training data selection) for a specific benchmark's idiosyncrasies.

The paper acknowledges a related concern in Section 6.4.3, discussing bias in LLM-as-Judge evaluation, noting that "LLM judges may prefer longer responses, be affected by answer ordering, reward particular writing styles, or favor systems that resemble themselves." However, this acknowledges evaluation measurement bias, not benchmark overfitting — the possibility that systems achieve high scores by exploiting benchmark-specific shortcuts rather than developing general capabilities.

The consequence. The paper's evaluation taxonomy, while extensive, may create a false sense of measurable progress. A reader who sees that System A achieves 85% on GPQA, System B achieves 72% on GAIA, and a recent RL-trained system achieves 90% on HotpotQA might conclude that the field is advancing rapidly. But if these systems were each optimized for their specific benchmark and would perform poorly on each other's benchmarks, the apparent progress is illusory — it reflects specialization, not generalization. The paper's implicit argument that these benchmarks collectively measure "deep research capability" is only valid if performance transfers across benchmarks within the same phase, an assumption the paper does not test and the cited literature does not support.

This is particularly concerning for Phase III (AI-for-Research) benchmarks, which are extremely small (PaperBench: 20 papers; Scientist-Bench: 52 papers) and potentially memorizable. A system trained on a corpus that includes these papers or their close derivatives could achieve high scores through memorization rather than genuine scientific reasoning. The paper does not discuss contamination or memorization risks for any benchmark in its catalog.

What evidence exists in the paper. None that addresses cross-benchmark generalization. The paper reports benchmark results as they appear in the original works, organized by task domain, but provides no analysis of whether performance on one benchmark predicts performance on another. The evaluation sections (5.1-5.4) treat each benchmark as an independent data point rather than as part of a broader construct validity argument for "deep research capability."

Mitigation status. Not addressed. The paper does not identify benchmark overfitting or cross-benchmark generalization as concerns, does not propose meta-analysis across benchmarks, and does not call for the field to establish benchmark suites with demonstrated cross-benchmark correlation. The paper's call for standardization (implicit in Section 5 and explicit in Section 6.4) focuses on having more benchmarks and better metrics, not on establishing that existing benchmarks measure a common underlying capability.

The Paper Does Not Address the Temporal Validity Problem for DR Systems That Access the Live Web

The assumption or constraint. A defining characteristic of DR systems, as the paper establishes in Section 2.3, is their ability to access "up-to-date information" through live web search, APIs, and tool use. DR systems are explicitly contrasted with traditional RAG, which "operate[s] in a static retrieval loop, relying solely on pre-indexed corpora" (Section 2.3). This capability is presented as a key advantage: DR systems can answer questions about current events, recent developments, and dynamically changing information.

However, the paper's evaluation framework implicitly assumes static ground truth. All benchmarks cataloged in Section 5 — from NQ (2019) to BrowseComp (2025) — have fixed answer sets. When a benchmark is created, the correct answers are determined once and assumed to remain correct indefinitely. For DR systems that access the live web, this creates a temporal validity problem: the ground-truth answer at evaluation time may differ from the ground-truth answer at benchmark creation time, and the system may be penalized for retrieving the currently correct answer rather than the historically correct one.

Consider a benchmark question like "Who is the CEO of Company X?" If the benchmark was created in 2023 when Alice was CEO, the ground-truth answer is "Alice." A DR system evaluated in 2025 that searches the live web will find that Bob is now CEO and answer "Bob." The system will be marked incorrect, despite having performed exactly the research task it was designed for — retrieving current, accurate information.

The consequence. The temporal validity problem systematically disadvantages DR systems relative to static-benchmark evaluation, particularly on benchmarks with factoid questions about entities that change over time (company leadership, political office holders, sports team rosters, economic statistics). The magnitude of this disadvantage grows with the age of the benchmark: NQ (2019) will have more temporally invalid answers than BrowseComp (2025). The paper does not quantify this effect, does not identify which benchmarks in its catalog are most affected, and does not discuss how to interpret benchmark scores in light of temporal validity concerns.

More subtly, the temporal validity problem creates a perverse incentive: systems that memorize training data (including benchmark answers) rather than genuinely searching and synthesizing may achieve higher benchmark scores than systems that faithfully execute the DR workflow, because memorization retrieves the benchmark's ground truth regardless of temporal changes, while live search retrieves whatever is currently correct. The paper's evaluation framework, as cataloged, cannot distinguish between these two capability profiles.

What evidence exists in the paper. The paper mentions LiveDRBench ([130]) in Section 5.2.2 as "a benchmark for DR tasks, offering challenging science and world-event queries," and notes that it is "evaluating systems via intermediate reasoning steps and factual sub-propositions." However, the paper does not describe LiveDRBench as addressing temporal validity specifically, nor does it discuss whether other benchmarks in its catalog suffer from temporal decay. The acknowledgment is passing rather than analytical.

Mitigation status. Minimally addressed. The mention of LiveDRBench suggests awareness that static benchmarks are insufficient for evaluating live-web systems, but the paper does not:

Propose temporal validity as an explicit evaluation dimension.
Identify which benchmarks are most vulnerable to temporal decay.
Suggest methods for creating temporally robust answer keys (e.g., "as of [date]" qualifiers, expected answer ranges rather than exact strings, evaluation protocols that check whether a retrieved answer was correct at the time of retrieval).
Discuss the tradeoff between evaluating systems against static ground truth (reproducible but potentially outdated) versus live evaluation (current but non-reproducible).

For a survey that positions DR as distinct from RAG specifically because of real-time information access, this gap is a significant omission in the evaluation framework.

The Paper's Optimization Paradigm Taxonomy Ignores the Interaction Between Component Architecture and Training Method

The assumption or constraint. Section 4 organizes optimization approaches into three paradigms — workflow prompting (Section 4.1), supervised fine-tuning (Section 4.2), and end-to-end agentic reinforcement learning (Section 4.3) — and presents them largely as alternative strategies for improving DR system performance. The paper's organization implies a clean separation: choose your components (Section 3), then choose how to optimize them (Section 4). This framing treats component architecture and training method as independent dimensions of the design space.

The paper does not investigate — and the taxonomy does not make visible — whether certain component architectures are necessary preconditions for certain training methods to work. For example, Section 4.3.3 describes end-to-end RL systems trained on multi-hop search (Search-R1, R1-Searcher) and notes training instability as a challenge (Section 6.3). But the paper does not ask whether the instability arises from the RL algorithm, from the component architecture being trained, or from their interaction. Could Search-R1 achieve stable training with a different retrieval architecture? Could Anthropic's multi-agent workflow be fine-tuned end-to-end, or does its design assume fixed, hand-crafted agent roles that would break under gradient-based optimization?

The consequence. A practitioner reading Sections 3 and 4 sequentially might reasonably conclude that the optimization paradigm can be chosen independently of the component architecture — first design the components, then decide whether to use prompting, SFT, or RL. If this assumption is false (i.e., if certain component designs are incompatible with certain training methods), then the paper's taxonomy is misleading as a design guide. It would lead practitioners to attempt combinations that are unlikely to work, or to avoid combinations that would work but are obscured by the taxonomy's separation of architecture and optimization.

The paper's own cited evidence hints at this interdependence without analyzing it. Section 4.2 notes that SFT is "commonly employed as the cold start... before online reinforcement learning" (Search-R1, WebDancer, R1-Searcher), suggesting that some level of SFT-derived architecture (the model must already know how to issue search queries, process retrieved documents, and generate answers before RL can optimize the policy) is a prerequisite for RL. But the paper does not explore what happens if you skip the SFT cold-start, or whether different cold-start architectures lead to different RL outcomes. Section 6.3.2 mentions that SFT "rapidly reduces output entropy, constraining the model's ability to explore," suggesting a tradeoff — SFT helps initial performance but may hurt final RL performance — but this is presented as a future direction, not analyzed as a fundamental interdependence between the optimization paradigms.

What evidence exists in the paper. None that systematically varies both architecture and training method. The paper catalogs systems that use specific combinations (Anthropic: multi-agent + prompting; Search-R1: single-agent + SFT + RL; WebDancer: single-agent + distillation + RL) but provides no head-to-head comparisons where the same architecture is trained with different methods or the same method is applied to different architectures. The GRPO vs. PPO comparison in Section 4.3.1 is a theoretical characterization, not an empirical comparison on the same architecture.

Mitigation status. Not addressed. The paper does not identify the architecture-training method interaction as a gap in current understanding, does not propose studies that would disentangle these factors, and does not warn practitioners that the choice of optimization paradigm may constrain or be constrained by component architecture choices.

The Difficulty Estimation and Adaptive Strategy Selection Problem Is Undefined for DR

The assumption or constraint. Unlike the reference example paper, which developed a concrete difficulty estimation mechanism (2048 samples per question, PRM-based binning, five difficulty quintiles) and demonstrated that a compute-optimal adaptive strategy yields 4× efficiency gains over best-of-N, this paper does not propose or evaluate any mechanism for adaptive resource allocation in DR. The four-component architecture (Section 3) describes what a DR system does but provides no framework for deciding how much of each component's capacity to deploy on a given task. The optimization paradigms (Section 4) describe how to train systems but not how trained systems should dynamically allocate their inference budgets.

The paper discusses retrieval timing (Section 3.2.2) as an adaptive capability — the system decides when to retrieve rather than retrieving on every step — but this is a binary decision (retrieve now or not?) embedded within a single component, not a global resource allocation strategy that spans components. The paper does not address questions like: Should the system spend more compute on query planning for complex questions? Should it retrieve more documents for ambiguous queries? Should it generate longer answers when evidence is conflicting? Should it allocate more memory consolidation effort when the research horizon is long?

The consequence. The paper's component taxonomy describes what DR systems do, and the optimization taxonomy describes how to train them to do it, but neither addresses how to operate them efficiently at inference time. This is a significant gap because DR systems are, by design, computationally expensive — they make many LLM calls, retrieval operations, and memory management decisions per task. Without an adaptive resource allocation framework, a DR system will spend the same compute on a simple factual lookup as on a complex multi-perspective analysis, wasting resources on easy tasks or under-resourcing hard ones.

The reference example paper demonstrated that adaptive allocation (using difficulty to select between search algorithms, sequential vs. parallel sampling ratios) is essential for compute-optimal inference-time scaling, achieving 4× efficiency improvements. This paper's DR systems face an analogous but more complex problem — the allocation spans multiple components with different cost structures and different sensitivity to compute investment — yet the paper provides no conceptual or empirical framework for addressing it.

What evidence exists in the paper. None directly. The paper describes Anthropic's system (Section 4.1.1) as having an "explicit research budget controlling agent count, tool usage, and reasoning depth," with effort scaling "from 1-2 agents for factual lookups to up to 10 or more for multi-perspective analyses." This suggests that manual, query-type-based resource allocation is practiced in production systems, but the paper does not analyze this as a general design problem, propose methods for automating it, or evaluate its impact on efficiency. The budget allocation in Anthropic's system is described as part of the orchestration logic, not as a separately studied capability.

Section 3.2.2's discussion of retrieval timing is the closest the paper comes to adaptive allocation, but it is scoped narrowly to information acquisition and does not generalize to decisions about how much planning, memory management, or answer generation effort to deploy.

Mitigation status. Not addressed. The paper does not identify adaptive resource allocation as a missing piece in the DR design space, does not discuss how difficulty estimation might be performed (the reference example paper's 2048-sample oracle method is not mentioned or adapted), and does not propose future work on compute-optimal DR operation. Given that efficiency is a first-order concern for deploying DR systems (as the paper's own cost omission in Limitation 2 highlights), this gap is both conceptually important and practically consequential.

7. Implications and Future Directions

How This Work Changes the Landscape

This survey does not introduce a new algorithm, model, or benchmark. Its impact is conceptual and methodological: it provides the first shared vocabulary and architectural decomposition for deep research, transforming a fragmented collection of incommensurate systems into a coherent design space where tradeoffs can be systematically analyzed. The magnitude of this shift is best understood as infrastructure-building rather than discovery-making — akin to establishing a standard taxonomy in biology before comparative physiology can proceed. Before this paper, the field had no answer to the basic question: what are the pieces any DR system must have, and how do design choices in one piece constrain options in others? After this paper, that question has a structured answer (Section 3) and a taxonomy of optimization approaches for coordinating those pieces (Section 4).

Reconciling prior contradictions. The paper implicitly resolves a tension that has plagued the DR-adjacent literature: different systems report widely varying performance on similar-sounding tasks, yet it has been unclear whether the variance reflects genuine capability differences or merely task framing differences. The paper's four-component decomposition provides a diagnostic lens. When two systems both claim to perform "deep research" but achieve dramatically different results on, say, multi-hop QA, the taxonomy enables systematic investigation: does System A outperform System B because of better query planning (it decomposes questions into more effective sub-queries), better information acquisition (it retrieves from more diverse sources or filters noise more effectively), better memory management (it maintains more relevant context across reasoning steps), or better answer generation (it synthesizes evidence more coherently)? The paper does not answer these questions — that requires future empirical work — but it makes them askable in a principled way, replacing "which system is better?" with "where in the pipeline does the performance gap originate?"

Which research directions become more attractive. The paper's most consequential reframing is its treatment of memory management as a first-class component rather than an implementation detail (Section 3.3). By decomposing memory into four sub-operations — consolidation, indexing, updating, and forgetting — and providing a taxonomy of approaches for each, the paper elevates memory from a storage problem (how to fit conversation history into a context window) to a relevance judgment and knowledge lifecycle management problem (what should be retained, how should it be organized, when should it be updated, what should be forgotten). This reframing makes memory management a rich research area in its own right, with open questions about consolidation strategies (unstructured summarization vs. structured knowledge graph construction), indexing mechanisms (signal-enhanced, graph-based, timeline-based), updating policies (when should old knowledge be revised vs. overwritten), and forgetting criteria (passive decay vs. active deletion). The connection to reinforcement learning — Memory-R1 training a dedicated memory manager agent to learn optimal ADD, UPDATE, DELETE policies — makes this a tractable research program with clear optimization objectives.

Equally significant is the paper's treatment of retrieval timing as a meta-cognitive capability (Section 3.2.2). By organizing adaptive retrieval approaches around four theories of knowledge boundary perception — probabilistic, consistency-based, internal-state probing, and verbalized confidence — the paper connects retrieval timing to the broader literature on model calibration, uncertainty quantification, and honest AI. This reframing makes retrieval timing a diagnosable capability: a DR system that over-retrieves may have poorly calibrated probabilistic confidence; a system that under-retrieves may fail to detect its own knowledge gaps through internal-state probing. Future research can systematically vary the confidence estimation mechanism while holding the retriever and generator fixed, enabling targeted improvement rather than trial-and-error hyperparameter tuning.

Which research directions become less attractive. The paper's optimization taxonomy (Section 4) implicitly deprioritizes purely heuristic pipeline engineering as a research contribution. The survey catalogs workflow prompting (Section 4.1), supervised fine-tuning (Section 4.2), and end-to-end RL (Section 4.3) as the three dominant paradigms, and the progression — from hand-designed orchestration through learned behaviors from teacher systems to autonomously discovered policies optimized against task outcomes — suggests that the field's trajectory is toward learned optimization. A new DR system that merely rearranges the same components with slightly different prompts, without demonstrating improved training methodology or novel component architecture, would be an engineering contribution but not a research advance under this taxonomy. The paper does not state this explicitly, but the structure of Section 4 — moving from "simple yet effective" prompting through SFT to the mathematically formalized RL section with PPO and GRPO derivations — implies a value gradient where learned optimization is the frontier.

The paper also reduces enthusiasm for benchmark-specific optimization without cross-benchmark generalization analysis. The evaluation taxonomy (Section 5, Tables 4-5) catalogs dozens of benchmarks but reveals systematic gaps: most benchmarks evaluate short-form QA (Section 5.1) despite DR's focus on long-form report generation; long-form evaluation relies on LLM-as-Judge with documented biases (Section 6.4.3); and Phase III benchmarks for AI-for-research are too small-scale and subjective to support claims about scientific capability (Section 5.3). A system that achieves state-of-the-art on a single benchmark — without demonstrating that the improvements transfer to other benchmarks within the same phase, or ideally across phases — would face skepticism under the paper's implicit evaluation framework, which treats the benchmark landscape as collectively measuring "deep research capability" rather than each benchmark measuring an isolated skill.

Follow-Up Research This Work Enables

Validating the four-component decomposition through systematic ablation. The paper proposes that all DR systems can be decomposed into query planning, information acquisition, memory management, and answer generation, but provides no empirical evidence that this decomposition captures independent variance in system performance. A strong validation study would: (1) select a representative DR architecture that cleanly instantiates all four components as separable modules; (2) create a grid of system variants where each component can be independently set to a "strong" or "weak" configuration (e.g., tree-based vs. parallel planning, dense retrieval vs. BM25, structured memory consolidation vs. simple context truncation, LLM-as-Judge supervised generation vs. autoregressive generation); (3) evaluate all 16 (2⁴) combinations across a diverse benchmark suite spanning the three phases (GAIA for Phase I, DeepResearch Bench for Phase II, PaperBench for Phase III); (4) perform variance decomposition to quantify how much of the performance variance is attributable to each component independently versus their interactions. If interactions dominate (e.g., tree-based planning only helps when paired with structured memory), the paper's implied independence of components is misleading and future taxonomies should emphasize component coupling. If main effects dominate, the decomposition is validated as a design framework where components can be optimized independently. The paper's catalog of representative systems for each component (Figure 2) provides a ready-made menu of "strong" and "weak" configurations for each module.

Cross-benchmark generalization as a measure of DR capability. The paper catalogs dozens of benchmarks (Section 5, Tables 4-5) but provides no analysis of whether performance on one benchmark predicts performance on another. A critical follow-up study would evaluate a diverse set of DR systems (at least 5-10, spanning the optimization paradigms in Section 4: workflow-prompted, SFT-distilled, RL-trained) on a representative benchmark suite spanning all three phases (e.g., GAIA, BrowseComp, HotpotQA for Phase I; DeepResearch Bench, ResearcherBench, LiveDRBench for Phase II; PaperBench, Scientist-Bench for Phase III). The key analysis is a correlation matrix showing whether performance clusters by phase (systems good at Phase I are also good at Phase II? Phase III?) or by benchmark type (systems good at short-answer QA are also good at report generation?). If cross-phase correlations are weak, the paper's three-phase roadmap represents orthogonal capability dimensions, not developmental stages — a finding that would fundamentally reshape how the field thinks about DR progress. If correlations are strong, the roadmap is validated as a genuine developmental trajectory and researchers can use cheaper Phase I benchmarks as proxies for more expensive Phase II/III evaluation. This study requires no new benchmarks or systems — it can be conducted with existing open-source DR frameworks (OWL, OpenManus, Alita) and existing benchmarks.

The cold-start problem in end-to-end RL for DR. Section 4.3.3 describes end-to-end RL-trained DR systems (Search-R1, R1-Searcher, DeepResearcher) and Section 4.2 notes that SFT cold-start is "commonly employed... before online reinforcement learning." Section 6.3.2 raises the concern that SFT "rapidly reduces output entropy, constraining the model's ability to explore." The critical experiment: train three variants of the same DR architecture — (a) RL from scratch with no SFT, (b) SFT cold-start followed by RL, (c) SFT cold-start with entropy regularization during RL to maintain exploration — on the same multi-hop search task (using Search-R1's setup). Measure final task performance, training stability (number of training steps before entropy collapse or Echo Trap onset), and policy diversity (do the three variants converge to qualitatively different search strategies, or does SFT pre-commit the model to a particular strategy that RL cannot escape?). If SFT consistently helps initial performance but constrains final performance, the field needs cold-start methods that balance initialization quality against exploration preservation. If SFT is always beneficial regardless of entropy regularization, the paper's concern about exploration loss is empirically minor and practitioners should confidently use SFT warm-start. The paper's mathematical formalization of PPO and GRPO (Equations 1-7) provides the algorithmic infrastructure; what is missing is the controlled experiment.

Memory forgetting as a trainable policy. Section 3.3.4 frames forgetting as a functional capability, and Memory-R1 trains a dedicated memory manager to learn DELETE and UPDATE policies. A natural extension: formulate memory management as a multi-objective RL problem where the agent receives rewards for (a) downstream task performance, (b) memory efficiency (penalizing excessive memory consumption), and (c) retrieval latency (penalizing slow memory access). Train variants with different forgetting mechanisms — passive FIFO (MemGPT-style baseline), passive Ebbinghaus decay (MemoryBank-style), active RL-trained forgetting (Memory-R1-style) — and measure the Pareto frontier of (task performance, memory size, retrieval speed). The hypothesis: RL-trained forgetting discovers non-obvious forgetting strategies that are task-adaptive, forgetting aggressively during information-dense phases to make room for new evidence, and retaining broadly during exploration phases to support backtracking. This connects directly to the paper's broader argument that forgetting is not a constraint to be managed but a capability to be optimized. The existing memory taxonomy (Section 3.3) provides the design space; the experiment provides the empirical validation that design choices in forgetting mechanisms causally affect system performance.

Multimodal retrieval as necessary for verifiable DR. The paper argues (Section 3.2.1, Table 2) that multimodal retrieval is essential for evidence-grounded DR because much of the world's information exists in non-textual formats. The critical stress test: construct a benchmark of research questions where the correct answer requires evidence from non-textual sources — revenue data embedded in a chart, experimental results stored in a table, product specifications captured in an image — and evaluate DR systems with and without multimodal retrieval capabilities on this benchmark. The prediction: text-only systems will either fail (missing the necessary evidence entirely) or hallucinate (generating plausible but incorrect information that would have been available from non-textual sources). If text-only systems achieve comparable accuracy to multimodal systems (by reasoning from textual context surrounding the non-textual evidence), then multimodal retrieval is an efficiency improvement, not a necessity, and the paper's strong claim about multimodality should be moderated. If multimodal systems substantially outperform, the claim is validated and the field should prioritize multimodal retrieval integration as a first-order requirement for trustworthy DR. The paper's catalog of multimodal retrieval tools (LayoutLM, Donut, CLIP, ChartReader) provides the technical infrastructure; what is needed is a benchmark that makes multimodal evidence necessary rather than merely available.

Difficulty-adaptive resource allocation for DR. The reference example paper demonstrated that adaptive allocation of test-time compute (selecting search algorithms, sequential-parallel ratios based on estimated prompt difficulty) yields ∼4× efficiency gains. This paper's DR taxonomy describes a more complex allocation problem — spanning query planning depth, retrieval breadth, memory consolidation effort, and answer generation length — but provides no framework for adaptive allocation. A natural extension: for a fixed DR architecture, train a meta-controller that observes the user query and initial retrieval results, estimates task difficulty (using internal-state probing or consistency-based confidence as described in Section 3.2.2), and dynamically allocates a fixed inference budget across the four components. The controller could learn (via RL) to spend more budget on query planning for complex multi-hop questions, more on retrieval breadth for ambiguous queries, more on memory consolidation for long-horizon tasks, and more on answer generation structure for tasks requiring nuanced synthesis. Evaluate whether difficulty-adaptive allocation outperforms uniform allocation (equal budget to all components), and whether the learned allocation strategy aligns with human intuitions about which components are most important for which task types. This directly extends the paper's optimization taxonomy (Section 4.3) from training-time RL to inference-time meta-control, connecting DR to the broader test-time compute scaling literature.

Practical Applications and Downstream Use Cases

Standardized DR system comparison for enterprise procurement. Organizations evaluating DR solutions — whether for market analysis, competitive intelligence, due diligence, or scientific literature review — currently face a comparison problem: each vendor reports results on different benchmarks using different metrics, making apples-to-apples evaluation impossible. The paper's evaluation taxonomy (Section 5, Tables 4-5) provides a directory of benchmarks organized by capability phase, enabling procurement teams to construct standardized evaluation suites. A pharmaceutical company evaluating DR systems for drug development literature review would select benchmarks from Phase II (comprehensive report generation: DeepResearch Bench, ResearcherBench) and Phase III (AI for research: PaperBench for experimental reproducibility, Scientist-Bench for scientific reasoning depth). By requiring vendors to report results on the same benchmark suite, the procurement team can make cost-normalized comparisons — accuracy per dollar of API cost or per hour of latency — rather than relying on vendor-selected benchmarks that maximize apparent capability. The paper's disclosure of LLM-as-Judge limitations (Section 6.4.3) also equips procurement teams to critically evaluate vendor claims: if a vendor reports stellar results on a benchmark using the same LLM family as the evaluator, self-preference bias may inflate scores, and the team should request human-validated evaluation or cross-judge consistency checks.

Architecture debugging for DR system developers. Teams building proprietary DR systems can use the paper's four-component decomposition as a systematic debugging framework. When a DR system produces poor-quality reports, the taxonomy suggests a diagnostic workflow: (1) Is query planning generating sub-queries that are too coarse or too granular? Check whether the sub-queries, when answered independently, collectively address the original question. (2) Is information acquisition retrieving relevant evidence? Check retrieval recall and precision on a held-out set of questions with known answer sources. (3) Is memory management retaining the right information? Check whether evidence retrieved early in the process is still accessible when answer generation begins, or whether it has been prematurely forgotten. (4) Is answer generation synthesizing evidence coherently? Check whether generated claims can be traced to specific retrieved documents (citation accuracy). By localizing failures to specific components, development teams can prioritize improvements rather than randomly tuning hyperparameters or switching model families. The paper's taxonomy of approaches for each component (e.g., three planning strategies in Section 3.1, three filtering strategies in Section 3.2.3, four memory operations in Section 3.3) provides a menu of design alternatives to try when a component is identified as the bottleneck.

Cost-aware DR deployment for high-volume inference pipelines. Organizations operating DR systems at scale — processing thousands of research queries per day for customer-facing applications or internal analysis — face a cost allocation problem: not all queries require the full DR workflow, yet deploying it uniformly wastes resources on simple factual lookups that could be answered with single-step RAG. The paper's discussion of Anthropic's budget scaling (Section 4.1.1: "effort scales with complexity: from 1-2 agents for factual lookups to up to 10 or more for multi-perspective analyses") provides a template for cost-tiered deployment. A practical implementation: deploy a lightweight query classifier (fine-tuned on query type and estimated difficulty) that routes queries to three tiers — Tier 1 (simple factual: single-agent RAG, < $0.01 per query), Tier 2 (moderate analysis: 2-4 agent DR pipeline with beam search retrieval, ~$ 0.10 per query), Tier 3 (complex research: full multi-agent orchestration with tree-based planning and iterative memory management, ~$1-5 per query). The paper's catalog of retrieval timing mechanisms (Section 3.2.2) can inform the query classifier: queries where the base model expresses high verbalized confidence (Self-RAG-style <retrieve> token is rarely issued) route to Tier 1; queries where consistency-based confidence is low across multiple samples route to Tier 3. This tiered approach directly operationalizes the paper's implicit argument that DR capability exists on a spectrum, not as a binary.

When to Prefer This Method

The paper does not propose a method — it is a survey and taxonomy. It does not position itself against named alternatives with clear tradeoff boundaries. The paper's contribution is providing a framework for choosing between methods, not a method whose selection criteria can be articulated against competitors. A "Prefer X when Y" matrix would be inappropriate here because the paper's three optimization paradigms (workflow prompting, SFT, end-to-end RL) are presented as points on a spectrum of hand-engineering to learned optimization, not as mutually exclusive alternatives with clearly defined preference conditions. The paper explicitly notes that real systems often combine paradigms (SFT warm-start before RL, as in Search-R1 and R1-Searcher), which further undermines a binary "prefer A over B" framing. The appropriate takeaway is not a decision rule but a design process: use the component taxonomy (Section 3) to architect the system's structure, then use the optimization taxonomy (Section 4) to select a training approach based on available resources (no training budget → workflow prompting; some teacher system or existing data → SFT; sufficient compute and environment → end-to-end RL), with the understanding that the strongest deployed systems will likely combine paradigms rather than selecting only one.