Skip to content

DAGent: Evaluate-then-Grow Planning for Deep Research Agents

Conference: NeurIPS 2026
arXiv: 2609.39154
Code: https://github.com/hanwenliu6825/DAGent
Area: Others
Keywords: Deep Research Agents, DAG Planning, Multi-Agent Systems, Reinforcement Learning, Credit Assignment

TL;DR

DAGent introduces the Evaluate-then-Grow incremental planning paradigm and the topology-aware DAGRPO reinforcement learning algorithm, replacing brittle Plan-then-Patch workflows to achieve superior deep research accuracy with significantly lower token, tool-call, and step footprints.

Background & Motivation

Deep research tasks challenge artificial intelligence systems to autonomously navigate vast and heterogeneous knowledge repositories, retrieve multi-hop evidence across dozens or hundreds of online sources, and synthesize complex findings into verified conclusions. Directed acyclic graph (DAG)-based multi-agent systems have emerged as a natural and powerful foundation for this domain: by decomposing complex queries into structured sub-task graphs, they isolate each worker within a focused dependency context and facilitate parallel exploration across independent execution paths. However, existing DAG-based deep research architectures (such as Flash-Searcher and FlowSearch) predominantly follow a Plan-then-Patch paradigm, instantiating an entire task-covering graph prior to execution and relying on reactive patching operations only when intermediate failures or dead ends are subsequently uncovered.

This pre-commitment strategy introduces a fundamental tension between temporal planning and empirical certainty: the system makes its most comprehensive and rigid structural commitment at the exact moment when its comprehension of the problem space is shallowest and evidence is minimal. Because deep research trajectories are inherently non-stationary—where early intermediate findings routinely invalidate initial assumptions or illuminate unforeseen investigative avenues—a pre-committed graph commits execution resources to redundant and unviable branches. Later reactive patches incur heavy computational waste in repairing or rewiring these standing plans, leading to error compounding and degraded answer fidelity. Furthermore, standard group-relative policy optimization (GRPO) recipes treat the entire multi-turn interaction as a monolithic trajectory, uniformly distributing outcome-level scalar rewards across all rollout tokens and completely ignoring the disparate causal contributions of individual sub-tasks within the execution graph.

This paper tackles these challenges by tightly coupling incremental graph growth with real-time evidence evaluation, ensuring that both agent exploration and policy gradients reflect the evolving graph topology. Core idea: introduce the Evaluate-then-Grow planning paradigm and the DAGRPO reinforcement learning algorithm, where an Orchestrator dynamically expands the task DAG batch by batch conditioned on per-node confidence and uncertainty evaluations, supported by a two-tier context layer and topology-conditioned credit assignment over the answer-inclusive causal closure.

Method

Overall Architecture

The DAGent framework models deep research planning as an incrementally constructed directed acyclic graph \(\mathcal{G}=(V, E)\), orchestrated by a central planner (Orchestrator, \(\pi_O\)) and executed by a pool of parallel worker agents (ReAct Executors, \(\pi_R\)). Rather than committing to a static blueprint upfront, the framework iteratively alternates through a four-stage closed loop: state evaluation, targeted graph expansion, parallel tool-augmented execution, and structured evidence propagation.

At each planning iteration, the Orchestrator evaluates the structured evidence returned by the preceding batch of completed nodes, classifying their reliability and selectively triggering refinement retries or creating new sub-task nodes. Independent nodes within each newly instantiated batch are dispatched concurrently to ReAct Executors equipped with domain retrieval and page extraction tools. Completed nodes distill their findings into compact QueryDocs that propagate downstream strictly along dependency edges, while preserving full interaction transcripts for on-demand retrieval. Once sufficient upstream evidence is gathered, the Orchestrator terminates the loop by scheduling a singleton answer node to synthesize the final response. During offline training, the DAGRPO objective leverages the append-only topological invariant of the graph to trace the exact causal ancestry feeding the answer node, guiding role-separated optimization and structural regularization.

%%{init: {'flowchart': {'rankSpacing': 24, 'nodeSpacing': 28, 'padding': 6, 'wrappingWidth': 400}}}%%
flowchart TD
    A["Deep Research User Task"] --> B["Orchestrator State Evaluation<br/>Classify completed nodes via confidence and uncertainty"]
    B -->|Uncertain / Not Found within budget| C["Spawn Refine Nodes<br/>Adjust retrieval strategy (up to 3 attempts)"]
    B -->|Sufficient evidence / New branches| D["Evaluate-then-Grow Graph Expansion<br/>Instantiate sub-tasks with dependency edges"]
    C --> E["Parallel ReAct Executor Pool<br/>Execute tool actions: Search, OpenPage, Reasoning"]
    D --> E
    E --> F["Hierarchical Context Layer<br/>Propagate compact QueryDocs by default"]
    F -->|Downstream evidence insufficient| G["On-Demand RecallTool<br/>Goal-conditioned extraction from transcripts"]
    G --> E
    F -->|Evidence sufficient for synthesis| H["Singleton Answer Node<br/>Synthesize final response from causal closure"]
    H --> I["Topology-Aware RL: DAGRPO<br/>Role-separated advantages & closure-conditioned credit"]

Key Designs

1. Evaluate-then-Grow Graph Expansion: Batch-Wise Evidence Evaluation and Dynamic Graph Extension
To overcome the brittleness of pre-committing full plans under zero evidence, DAGent enforces an append-only, evidence-conditioned graph generation loop. The task graph \(\mathcal{G}\) begins empty. At iteration \(k\), the Orchestrator \(\pi_O\) inspects the primary task \(\mathcal{T}\) alongside the current graph state \(\mathcal{G}_k\) to output both an evaluation vector \(S_k\) and a new node set \(V_k^{\text{new}}\): $\(P_k = \pi_O(\mathcal{T}, \mathcal{G}_k) = (S_k, V_k^{\text{new}})\)$ The evaluation \(S_k\) assigns each completed node from the latest batch an explicit status grounded in its reported evidence: Success (high-confidence verified findings), Uncertain (preliminary findings exhibiting contradictions or incomplete data), or Not Found (valid execution returning no relevant evidence). Any node evaluated as Uncertain or Not Found that has not exceeded its retry cap automatically spawns a dedicated refine node with an adjusted query strategy, strictly bounded to three cumulative attempts (one initial execution and two refinements). Concurrently, \(V_k^{\text{new}}\) instantiates newly uncovered sub-task nodes, complete with functional task prompts \(p_i\), semantic descriptions \(\delta_i\), and an explicit prerequisite set \(\operatorname{dep}_i \subset V\). Disjoint nodes within \(V_k^{\text{new}}\) execute concurrently across parallel Executors. When the Orchestrator determines that the investigative chain is complete, it schedules a dedicated answer node alone in \(V_k^{\text{new}}\), ensuring that final synthesis accesses all validated upstream evidence without concurrent interference.

2. Hierarchical Context Layer: Compact Structured Summaries and On-Demand Transcript Recall
Information-intensive deep research generates vast observation streams that quickly overflow standard LLM attention windows or dilute key evidence if passed unconstrained. Conversely, naive full-trajectory compression risks dropping exact numbers, entity names, or critical tables. DAGent decouples context management into a two-level hierarchy: - Selective Propagation: Upon completing sub-task \(v_i\), the ReAct Executor outputs a compact structured QueryDoc: \(D_i = (\alpha_i, \operatorname{expl}_i, \operatorname{steps}_i, \operatorname{conf}_i, \operatorname{unc}_i)\), capturing the answer \(\alpha_i\), rationale \(\operatorname{expl}_i\), execution highlights \(\operatorname{steps}_i\), numerical confidence \(\operatorname{conf}_i \in [0, 1]\), and noted uncertainties \(\operatorname{unc}_i\). By default, downstream node \(v_i\) receives only the concatenated QueryDocs of its direct prerequisites: \(C_i = \bigoplus_{j \in \operatorname{dep}_i} D_j\). Context size is thus bounded strictly by node in-degree (fan-in) rather than total graph depth or cumulative history. - On-Demand RecallTool: Alongside the QueryDoc, each Executor archives its complete raw action-observation history as an InteractionTranscript \(T_i = \langle (a_1^{(i)}, o_1^{(i)}), \ldots, (a_n^{(i)}, o_n^{(i)}) \rangle\). When a downstream agent requires granular verbatim evidence (e.g., verifying an exact tabular figure or inspecting raw text from an earlier retrieval), it triggers the specialized recall function: $\(E = \operatorname{Recall}(v_j, \text{goal}, T_j)\)$ A targeted extractor scans the dependency's transcript \(T_j\) conditioned on the specific information \(\text{goal}\) and returns a focused snippet \(E\). Serving as a targeted fallback invoked in only 11%–22% of benchmark tasks, RecallTool guarantees fidelity while preserving context compactness across over 80% of routine sub-task executions.

3. Topology-Aware Reinforcement Learning: Role-Separated Normalization and Causal Closure Credit Assignment
In complex multi-agent execution graphs, rollouts at different topological positions contribute unequally to the final outcome: some lie directly on the causal dependency path leading to the final synthesis, while others explore exploratory branches whose findings are ultimately bypassed. Standard GRPO averages rewards uniformly across all rollout tokens. DAGent introduces DAGRPO to harness the structural invariants of the append-only graph: - Role-Separated Normalization: Because the Orchestrator generates a modest number of high-level planning turns while parallel Executors produce hundreds of granular environment interaction steps, pooling their statistics together allows Executor gradients to overwhelm the Orchestrator's planning signal. DAGRPO isolates sampled trajectories into separate Orchestrator and Executor groups, computing group statistics \((\mu_u, \sigma_u)\) independently for each role \(u \in \{\text{orch}, \text{exec}\}\). - Topology-Conditioned Credit: Let \(t_{\text{answer}}\) denote the terminating answer node. Because Evaluate-then-Grow never deletes or rewires existing nodes, the answer-inclusive closure \(S(\tau)\)—defined as \(t_{\text{answer}}\) combined with all of its topological ancestors in \(\mathcal{G}\)—accurately represents the exact causal evidence chain consumed during synthesis. Executors residing within this closure (\(v_i \in S(\tau)\)) receive the unattenuated trajectory reward \(R(\tau) \in \{0, 1\}\), whereas off-chain exploratory nodes (\(v_i \notin S(\tau)\)) have their reward scaled by an attenuation factor \(\alpha \in [0, 1]\) (optimally set to \(0.5\)): \(\tilde{r}_i = \alpha R(\tau)\). This multiplicative scaling preserves exploration value on successful trajectories without unfairly boosting tangential branches.

Loss & Training

The DAGRPO policy gradient is optimized end-to-end with an asymmetric clipping ratio building upon the DAPO framework, combined with a structural compliance penalty for planning decisions. Given \(G\) sampled on-policy trajectories \(\tau\), the objective function is: $\(\mathcal{J}_{\text{DAGRPO}}(\theta) = \mathbb{E}\left[\frac{1}{|y_\tau|} \sum_{i, t} \min\left(\rho_{i, t}(\theta) \hat{A}_i^{(u)}, \operatorname{clip}(\rho_{i, t}(\theta), 1-\epsilon_\ell, 1+\epsilon_h) \hat{A}_i^{(u)}\right)\right]\)$ where \(\rho_{i, t}(\theta)\) is the token-level policy importance weight, \(|y_\tau|\) denotes total response tokens, and clipping parameters are set to \(\epsilon_\ell = 0.20\) and \(\epsilon_h = 0.28\). The role-separated advantage is defined as \(\hat{A}_i^{(u)} = (\tilde{r}_i^{(u)} - \mu_u) / \sigma_u\), with modified rewards: $\(\tilde{r}_i^{(u)} = \begin{cases} R(\tau), & u = \text{exec},\ v_i \in S(\tau) \\ \alpha R(\tau), & u = \text{exec},\ v_i \notin S(\tau) \\ R(\tau) + r_{\text{proc}}(\tau), & u = \text{orch} \end{cases}\)$ The term \(r_{\text{proc}}(\tau) = -\lambda_{\text{proc}} \min(N(\tau), K_{\text{proc}})\) provides structural compliance regularization (\(\lambda_{\text{proc}} = 0.3, K_{\text{proc}} = 5\)), where \(N(\tau)\) counts Orchestrator turns that violate framework constraints (such as failing to assign explicit node statuses, exceeding refine retry limits, packing non-singleton answer batches, generating duplicate prompts, or emitting unparseable JSON). The model is trained using LoRA on all linear projections with an auxiliary KL penalty coefficient of 0.001 to ensure policy stability.

Key Quantitative Results

Main Results

Evaluated on BrowseComp-Plus (local dense retrieval over a verified corpus), GAIA (103-task text-only validation subset with live Google search and Jina page extraction), and xbench-DeepSearch (100 Chinese deep research tasks), DAGent consistently outperforms leading single-agent and multi-agent baselines across diverse backbone scales and training paradigms:

Backbone Agent Paradigm Context Window BrowseComp-Plus (Pass@1 %) GAIA (Pass@1 %) xbench-DS (Pass@1 %)
Qwen3-8B (Training-free) ReAct Agent 32K 20.0 29.1 39.0
ReAct Agent 109K 28.0 34.0 44.0
Summary Agent 32K × N 32.7 35.0 54.0
Fold Agent 32K × N 34.7 35.0 52.0
Flash-Searcher (Plan-then-Patch) 32K × N 34.7 38.8 55.0
DAGent (Ours) 32K × N 40.0 46.6 60.0
Qwen3-32B (Training-free) ReAct Agent 109K 31.3 39.8 58.0
Flash-Searcher (Plan-then-Patch) 32K × N 38.7 44.7 58.0
FlowSearch (Plan-then-Patch) 32K × N 43.3 51.5 63.0
DAGent (Ours) 32K × N 47.3 55.3 65.0
Qwen3-235B (Training-free) ReAct Agent 109K 52.0 57.3 64.0
Summary Agent 32K × N 56.0 52.4 60.0
Fold Agent 32K × N 54.7 53.4 62.0
Flash-Searcher (Plan-then-Patch) 32K × N 52.7 55.3 70.0
DAGent (Ours) 32K × N 61.3 63.1 72.0
Qwen3-8B (RL Trained) GRPO-ReAct Agent 109K 34.7 ± 2.4 36.9 ± 1.9 48.0 ± 2.0
GRPO-Fold Agent 32K × N 41.3 ± 1.3 38.8 ± 2.6 56.0 ± 3.0
GRPO-DAGent (Outcome-only) 32K × N 46.0 ± 1.2 50.8 ± 1.1 63.0 ± 1.0
DAGRPO-DAGent (Full Ours) 32K × N 49.6 ± 1.0 53.4 ± 1.0 65.7 ± 1.5

Ablation Studies

Systematic ablations isolate the contribution of each architectural component using Qwen3-32B in training-free mode (Table 2), followed by a sweep over DAGRPO structural credit and regularization components on Qwen3-8B (Table 3):

Study Configuration BrowseComp-Plus (%) GAIA (%) xbench-DS (%) Overall Mean (%) Margin (\(\Delta\))
Framework Ablation DAGent (Full) 47.3 55.3 65.0 55.9 —
(Qwen3-32B Training-free) Plan-then-Patch Variant 42.0 50.5 61.0 51.2 -4.7
w/o Evaluate-then-Grow (Single Upfront Plan) 33.3 42.7 55.0 43.7 -12.2
w/o Selective Propagation (All Upstream History) 34.7 44.7 57.0 45.5 -10.4
w/o QueryDoc (Raw Unstructured Summary) 39.3 47.6 60.0 49.0 -6.9
w/o InteractionTranscript (No RecallTool Fallback) 43.3 52.4 63.0 52.9 -3.0
DAGRPO RL Ablation DAGRPO (\(\alpha=0.50\), Regularization On) 49.6 53.4 65.7 56.2 —
(Qwen3-8B RL Trained) \(\alpha=0.00\) (Zero Off-Chain Credit) 44.0 49.5 61.0 51.5 -4.7
\(\alpha=0.25\) 48.7 52.4 64.0 55.0 -1.2
\(\alpha=0.75\) 48.0 52.4 64.0 54.8 -1.4
\(\alpha=1.00\) (w/o Topology Credit) 47.3 51.5 64.0 54.3 -2.0
w/o Structural Regularization (\(r_{\text{proc}}\)) 48.0 52.4 65.0 55.1 -1.1
Outcome-Only GRPO Baseline 46.0 50.8 63.0 53.3 -3.0

Key Findings

  • Superiority of Incremental Planning over Plan-then-Patch: Under an identical multi-agent codebase, replacing Evaluate-then-Grow with Plan-then-Patch degrades Pass@1 by 4.7 points overall (55.9% \(\rightarrow\) 51.2%), while eliminating replanning entirely drops accuracy by 12.2 points. Incremental evidence gathering is the primary driver of high-precision research decomposition.
  • Substantial Footprint and Latency Reductions: Because Plan-then-Patch instantiates unverified branches that must be subsequently explored or patched, its off-chain node ratio reaches 0.40 / 0.30 versus 0.25 / 0.20 for DAGent. As a result, Plan-then-Patch incurs 40%, 29%, and 18% higher token footprints, makes 35%, 27%, and 21% more external search tool calls, and requires 23%–35% longer wall-clock time across the three benchmarks.
  • Topology-Conditioned RL Balance: Setting the off-chain credit parameter to \(\alpha=0.5\) achieves optimal balance across all benchmarks. Completely discarding off-chain rollouts (\(\alpha=0.0\)) severely impairs exploration and drops performance below standard GRPO (51.5% vs 53.3%), whereas failing to attenuate off-chain rollouts (\(\alpha=1.0\)) dilutes credit assignment along the true causal answer chain.

Highlights & Insights

  • Append-Only Construction Preserves Clean Structural Invariants: By restricting graph growth to strictly append-only batches, every node's observed context during execution perfectly matches its ancestral lineage in the completed DAG. This structural property enables closed-form, counterfactual-free causal credit attribution via ancestor reachability.
  • Two-Tier Context Propagation Decouples Overhead from Depth: Defaulting to lightweight structured QueryDocs bounds routine context size to the node's local fan-in rather than total graph size, while retaining complete raw transcripts for targeted on-demand extraction via RecallTool.
  • Emergent Execution Efficiency from RL Alignment: Even without explicit efficiency penalties in the DAGRPO objective, aligning the agent with causal graph credit naturally reduces per-task nodes by 1.3–1.9 and lowers off-chain exploration by up to 0.09, demonstrating that accurate policy credit naturally prunes redundant actions.

Limitations & Future Work

  • Text-Centric Native Loop: The internal Orchestrator and Executor interaction representations are native to text. Processing multi-modal documents, diagrams, and audio files currently requires pre-processing via external inspector tools rather than dynamic native multimodal graph reasoning.
  • Retriever Bottlenecks: The framework's evidence-conditioned growth depends strictly on the quality of search engine and dense retriever observations; failure to retrieve relevant initial evidence can cause the Orchestrator to wander along uninformative exploration branches.
  • Evaluation Restricted to Closed-Ended Queries: Benchmarks are evaluated on objective factual queries with ground-truth validation; extending evaluate-then-grow mechanics to open-ended long-form research synthesis or literature review authoring requires developing new structural evaluation metrics.
  • vs FlowSearch / Flash-Searcher: Both baseline DAG architectures adopt a Plan-then-Patch methodology, creating full initial task graphs before execution begins and applying reactive edits later. DAGent plans one batch at a time conditioned on intermediate evidence, eliminating redundant branch exploration.
  • vs Linear Context-Folding / Summary Agents (HiAgent, FoldAct): Linear memory compression and folding architectures discard fine-grained multi-parent dependency structures. DAGent preserves parallel branch isolation and employs graph reachability for fine-grained RL credit assignment.

Score

  • Novelty: ⭐⭐⭐⭐⭐ Replaces the dominant Plan-then-Patch paradigm with evidence-grounded incremental DAG expansion and introduces graph-topology-conditioned RL.
  • Experimental Rigor: ⭐⭐⭐⭐⭐ Comprehensively benchmarked across three diverse datasets, multiple open-source scales, four distinct model vendors, and frontier models with detailed cost analyses.
  • Writing Quality: ⭐⭐⭐⭐⭐ Rigorous formulation, lucid architectural motivation, and insightful ablation tracking across mechanisms and compute footprints.
  • Impact: ⭐⭐⭐⭐⭐ Offers an efficient and robust blueprint for scalable deep research multi-agent systems and structural agent reinforcement learning.