acceptodds
Under review as a conference paper at ICLR 2027

SearchMapper: Structuring Deep Search as Dynamic DAG with Process-Guided Refinement

Abstract

LLM-based search agents have shown strong progress in complex multi-step retrieval and reasoning, yet errors introduced during early stages compound through subsequent steps. We term this phenomenon lost in search and trace it to implicit dependency tracking, where agents cannot identify which prior results a current action depends on or which downstream actions an earlier mistake would invalidate. We propose SearchMapper, a framework that makes these dependencies explicit by organizing the search process as a Directed Acyclic Graph (DAG) of sub-questions, constructing a search map that grows adaptively as reasoning unfolds. A hierarchical scoring model evaluates each sub-question along three dependency-grounded dimensions, namely redundancy, clarity, and progressiveness, producing scores and textual feedback that guide iterative refinement. A Non-descendant Error Attribution Region (NEAR)-guided detection algorithm exploits the DAG’s causal structure to localize critical errors via monotonic hypothesis space contraction, recovering 85.2% of failed trajectories at an average of 1.63 iterations. Both signals supervise a three-stage pipeline spanning imitation, alignment, and generalization, which lifts the five-benchmark average from 54.9 to 63.9. With only 30B parameters, SearchMapper leads all same-scale search agents on four of five benchmarks, while using 35.6% fewer reasoning steps than Tongyi-DeepResearch.

Primary area:
foundation or frontier models, including LLMs
Keywords:
Search Agent, Agentic Planning, Tool Use

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_udtXOpenReview ↗
Rating
3(+1)
Confidence
4
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper identifies a failure mode of LLM search agents that it calls “lost in search”: errors made in early retrieval steps propagate through later steps instead of being corrected. The authors attribute this to dependencies between steps being tracked only implicitly. SearchMapper has the agent propose sub questions in layers with explicit dependency annotations, which forms a DAG. Two training time mechanisms build on this structure:

  • Scoring model. A Qwen3-30B model distilled from Claude Sonnet 4.6 gives each sub-question binary scores and textual feedback on three dimensions: redundancy, clarity, and progressiveness. These outputs drive up to three rounds of sub-question refinement, filter the SFT trajectories, and serve as a dense reward in RL.
  • NEAR guided error detection. Given a failed trajectory, an LLM picks a suspicious node, corrects it, and reexecutes its descendants. The new answer is checked against the ground truth. If it is still wrong, the candidate set shrinks to the non-descendants of that node, and the process repeats.
Critical strengths
  • The DAG is used consistently across the method: for sub-question quality assessment, for error localization, for building preference data, and for layer-level credit assignment in RL. At inference the system is still a single ReAct policy with no auxiliary models. The Stage I ablation is well controlled: with the same teacher data, removing decomposition costs 4.8 average points. This gives fairly direct evidence that the structure itself helps, beyond better data alone. This is the main reason I think the core idea has merit.
  • Good accuracy efficiency trade-off at 30B scale. Within Table 1, the model is the best same-scale agent on four of five benchmarks. It also uses fewer reasoning steps and has lower latency despite issuing more tool calls, which the paper attributes to parallel dispatch within layers. If the comparisons hold up under a controlled protocol (see Weakness 2), this would be a practically useful result.
Critical weaknesses
  1. NEAR is framed as principled error attribution, but its contraction rule is a heuristic, and the 85.2% recovery figure lacks controls.

The rule makes two exclusions after a failed correction, and neither is justified:

It excludes qcq_c itself. This assumes the proposed correction was right. A wrong correction of the true error node would wrongly remove it. It excludes Desc(qc)\mathrm{Desc}(q_c). Descendants are only re-executed, not corrected. An independent error inside a descendant can therefore persist, yet that node is removed from the hypothesis space.

Co-occurring errors in independent branches also violate the implicit single-fault assumption. The “convergence guarantee” (Theorem B.1) is trivial: any procedure that removes at least one node per step terminates. It says nothing about whether the procedure localizes the right node.

On the empirical side, recovery is judged against the ground-truth answer, and re-execution is stochastic (sampled decoding plus live web search). Part of the 85.2% could therefore come from resampling combined with oracle filtering rather than from localization. The paper reports no baselines with matched budgets, such as:

correcting a random node, correcting the last node, resampling the full trajectory the same number of times.

There is also an internal inconsistency. Section 4.4 says 74 trajectories “stop before the candidate set is exhausted,” but no Kmax⁡K_{\max} value is given.

This matters because NEAR is a headline contribution (abstract and contribution 2). Its downstream benefit is evidenced only by the “w/o high-quality refinement” ablation, which shows +2.1 average points.

  1. The empirical comparisons are not controlled and have no statistical support.

Uncontrolled baselines. Baseline numbers appear to be copied from the original papers. Those papers use different search and visit tools, summarizers, turn budgets, and context lengths. The model behind the Visit tool’s summarization is not specified, and this could be a significant confound. Omitted baselines. Appendix D.1 lists MiroThinker-v1.5/v1.7-mini, WebResearcher, MiniMax-M2.1, and GLM-4.7, but none of them appear in Table 1. This directly affects the claim of leading all same-scale agents on four of five benchmarks. Small test sets and single runs. Both xBench-DS sets appear to have 100 questions, so one point equals one question. Many reported differences fall within plausible run-to-run variance. Examples: the claim of surpassing GPT-5 and DeepSeek-V3.2 by about 3 points, and several ablation gaps (layer progress reward: −1.2 average; KTO: −1.8 average). Tables 1 and 2 report single runs with no standard deviation. Teacher vs. student framing. DeepSeek-V3.2 is one of the trajectory teachers, which deserves discussion given the claim of surpassing it. Contamination. There is no check for overlap between the training sources (RedSearcher, OpenSeeker) and the evaluation sets.

Questions for authors
  1. NEAR assumes that (i) the model-declared dependency edges are correct and (ii) the root cause is a single existing node. Neither assumption is validated. A missing edge leaves a true descendant un-re-executed after a correction, so a correct fix can appear to fail and the true error node is wrongly excluded. A spurious edge prunes unrelated nodes. If the root cause is structural — a missing sub-question or a misreading of a clue in the first layer — it is not in VV at all, so no contraction of H(k)\mathcal{H}^{(k)} can reach it. Could the authors (a) report the accuracy of the declared dependency edges on a human-annotated sample, (b) break down the 14.8% unrecovered trajectories by error type (node-level vs. edge vs. missing node / wrong decomposition), and (c) clarify whether re-executing Desc(qc)\mathrm{Desc}(q_c) regenerates the descendant sub-questions or only re-runs retrieval for the existing ones?
  2. How is Ri(ℓt)R^i(\ell_t) aggregated from the sub-question scores and rprogr_{\text{prog}}, and with what weights? The advantage of each layer depends only on that layer’s reward, and the outcome reward is added only at the terminal layer. How do earlier layers receive any outcome signal? Is there a return or discounting?
  3. What are the recovery rates of the budget-matched baselines listed above (random node, last node, full resampling)? On a human-checked sample, how often is the node that NEAR finally corrects actually the true root cause? What is Kmax⁡K_{\max}?
4 comments

W1: NEAR's assumptions and downstream regeneration

We thank the reviewer for precisely identifying NEAR's limitations. We agree that a failed correction does not logically prove that the selected node and all descendants are error-free. NEAR should be understood as a dependency-guided candidate-search heuristic. Theorem B.1 guarantees finite termination only, not correct root-cause localization. We will revise the abstract, contribution statement, Sec. 3.3, and Appendix B to remove any stronger implication.

NEAR searches for a critical upstream error because a wrong upstream answer may contaminate the downstream reasoning state. Importantly, descendant re-execution does not merely rerun retrieval for fixed old subquestions. We truncate the trajectory at the selected node, retain the preceding prefix, inject correction feedback, and regenerate the subsequent reasoning, subquestions, and tool calls. The regenerated suffix can therefore revise downstream questions and add information missing from the original suffix. Nevertheless, incorrect or missing dependency edges may affect candidate pruning, and structural errors already present in the retained prefix are not guaranteed to be repaired.

The reported 85.2% is the answer-recovery rate of the complete repair pipeline, not root-cause localization accuracy. The recovery comparisons demonstrate NEAR's empirical value for offline repair, but do not replace an independent human audit of dependency-edge or localization accuracy. We do not currently have such annotations and will state this limitation explicitly rather than infer localization correctness from final-answer recovery.

The same distinction applies to the 74 unrecovered trajectories. They may involve a failed correction, incorrect or missing edges, a missing subquestion or wrong decomposition, multiple independent errors, unavailable evidence, or termination after the five-attempt cap or an invalid auditor output. Stopping reasons explain why the procedure ended; they do not by themselves identify the underlying error type. We will report the two separately.

W2: Comparison scope and statistical support

For method attribution, we reproduce the relevant internal controls below. All Stage-I variants use identical training questions and teacher models; the Stage-III variants share the same preceding structured training.

Training stageMethodFive-benchmark average
Stage ISearchMapper SFT54.9
Stage Iw/o scoring model51.5
Stage Iw/o subquestion decomposition (flat ReAct SFT)50.1
Stage IIISearchMapper63.9
Stage IIIw/o process rewards59.3
Stage IIIw/o KTO stage62.1

These results provide stage-specific evidence, not a fully matched end-to-end Flat-ReAct SFT-to-KTO-to-DAPO comparison, because NEAR-based KTO construction itself requires the DAG.

For the direct REDSearcher comparison, we use the same Google Search/Search/Visit tools, gpt-oss summarizer, interaction limit, and context setting. The shared reported benchmarks are reproduced here:

MethodBrowseCompBrowseComp-ZHGAIA-text-only
REDSearcher42.149.880.1
SearchMapper w/o KTO stage43.854.276.7
SearchMapper44.656.378.6

Other literature-reported baselines without a reproduced common environment will remain contextual comparisons only. We will clarify why Appendix D.1 models are absent when corresponding comparable benchmark results are unavailable and narrow the “all same-scale agents” claim.

We also reproduce the three-run results used to assess run-level stability:

BenchmarkRun 1Run 2Run 3Mean +/- sample std.
BrowseComp45.044.644.844.80 +/- 0.20
xBench-DS-250581.083.080.081.33 +/- 1.53

We will distinguish these repeated results from single-run external numbers and avoid significance claims for small gaps without corresponding repetitions.

Q2: Reward aggregation and credit assignment

The frozen post-KTO checkpoint computes Eq. 7, and the gold answer is visible only during reward calculation. The three binary quality dimensions are averaged per subquestion and then across subquestions in a layer. The subquestion-quality and layer-progress rewards each receive weight 0.3; the binary outcome reward receives weight 1.0 and is added only at the terminal layer. No format reward is used, so the maximum combined reward is 1.6. Earlier layers receive local quality and progress rewards, after which all layer rewards in the rollout group are jointly normalized to form layer-level advantages. Policy ratios are computed per generated token, while tool observations are excluded from the loss.

Q3: Recovery evidence and contamination

The complete recovery comparison on the same 500 failed trajectories is reproduced below:

MethodAnswer recovery rateRecovered / 500
Random-node selection26.8%134
Earliest-node selection34.6%173
Self-diagnosis and repair without NEAR pruning47.6%238
Last-node selection5.2%26
Up to three complete trajectory regenerations30.4%152
NEAR85.2%426

These values measure answer recovery under the stated repair protocols; they do not establish localization correctness. We will report repair cost and clearly state that independent human root-cause accuracy is not yet available.

Before training, our overlap check found zero shared questions between the SFT/KTO/DAPO data prepared for training and each of the five evaluation benchmarks, including the RedSearcher and OpenSeeker subsets. We will include the matching protocol and per-benchmark zero-overlap counts in the revision.

Thanks for your clarification, majority of my concern is solved I will raise my score to 3 accordingly.

We appreciate the reviewer's positive evaluation and feedback. We will continue to improve the quality of our research in future work. Thank you for the time you've spent and the valuable suggestions provided during the review process.

Reviewer_d1GmOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper identifies a failure mode of LLM search agents, "lost in search": an error in an early retrieval step compounds through later steps because dependencies between steps are only implicit in the accumulated context. SearchMapper has the agent write out its search as a layered DAG of sub-questions. Each layer contains mutually independent (parallelizable) sub-questions with declared dependency edges. Two training-time mechanisms use this structure:
(1) A hierarchical scoring model, a Qwen3-30B-A3B model distilled from Claude-4.6-Sonnet, gives each sub-question binary scores plus textual feedback on redundancy, clarity and progressiveness. These scores drive up to three rounds of refinement.
(2) NEAR-guided error detection works on failed trajectories. It repeatedly picks a suspicious node, corrects it, and re-executes the node's descendants. When a correction fails, it shrinks the candidate set to the intersection of the non-descendant regions. It recovers 85.2% of 500 failed SFT trajectories in 1.63 iterations on average.
These signals feed a three-stage pipeline: SFT on score-filtered trajectories (5k samples), KTO on NEAR-derived refinement data (2k), and DAPO (1k) with a layer-level reward. That reward combines the scoring-model scores, a "layer progress" term (the change in teacher-forced log-probability of the gold answer), the outcome reward and a format reward. On a Qwen3-30B-A3B-Thinking backbone, the five-benchmark average rises from 54.9 to 57.2 to 63.9 across the stages. The final model reports 44.6 / 56.3 / 78.6 / 81.0 / 59.0 on BrowseComp / BC-ZH / GAIA-text / xBench-DS-2505 / -2510, leading 30B agents on four of the five. On xBench-DS-2505 it also uses 35.6% fewer reasoning steps than Tongyi-DeepResearch.

Critical strengths
  1. Explicit dependency structure yields consistent, ablated gains. At the SFT stage, holding the teacher data fixed, removing decomposition costs 4.8 points of average and removing the score filter costs 3.4. In RL, removing process rewards costs 4.6. The idea of making the agent state its dependencies in a machine-readable form, and then reusing that structure for data filtering, error localization and reward shaping, is simple and general. The ablations suggest the gains do not come only from better teacher data. This is the main reason I see value in the paper.
  2. Strong results and a practical efficiency benefit at 30B. The model leads same-scale agents on four of five benchmarks, with large margins on BC-ZH (+6.5) and xBench-DS-2510 (+4.0). It needs fewer reasoning steps (20.8 vs 32.3) and has lower latency, because independent calls within a layer run in parallel. Training uses only about 8k samples in total, so the recipe is cheap to reproduce if code and data are released.
Critical weaknesses
  1. NEAR's localization claims are not supported by the evidence.
    (a) The contraction rule assumes that if correcting q_c does not fix the final answer, then neither q_c nor any of its descendants is the root cause. This does not follow. The correction itself may be wrong, the re-executed descendants may contain new errors, and there may be several co-occurring errors. "Monotonic hypothesis space contraction" is therefore a heuristic pruning rule, not a localization guarantee. The termination theorem is trivial: the set loses at least one element per step.
    (b) The 85.2% "recovery" figure uses the gold answer as the stopping oracle, and it re-samples the whole downstream subgraph. A correct answer can therefore appear by re-rolling rather than through correct localization. There is no measurement of localization accuracy, for example against human-annotated root causes. There is also no baseline under an equal re-execution budget, such as random node selection, always picking the earliest node, LLM self-diagnosis without NEAR pruning, or simply re-running the full trajectory k times. Without these, we cannot tell whether NEAR adds anything beyond "retry with the answer oracle".
    This matters because NEAR is a headline contribution and is the source of all Stage II data. Yet Stage II adds only 2.3 points of average, and skipping KTO costs only 1.8 after RL.
  2. The main comparison is not controlled, so the gain cannot be attributed to the DAG.
    (a) Baseline numbers appear to be copied from the original papers, which used different search/visit tools, summarizer models, context budgets and turn limits. SearchMapper uses Serper top-10, 128k context, 200 turns, and distilled data from DeepSeek-V3.2 and Claude-4.6-Sonnet.
    (b) The most informative control is missing: a flat ReAct agent trained on the same data with the same SFT → KTO → DAPO budget and outcome-only rewards. The only flat reference in Table 1 is the untrained backbone, and the Stage I flat ablation never goes through RL.
    (c) Results come from a single run. xBench-DS has about 100 questions, so 1 point is 1 question, and several ablation gaps (1.0–1.8) are within run-to-run noise. Avg@3 is reported only for three benchmarks, and not for BrowseComp or xBench-2505.
    Together these make the size of the method's own contribution uncertain.
Questions for authors

Clarifications that could change my assessment:

  1. NEAR: can you report localization accuracy against human-labeled root-cause nodes on a sample of trajectories? Can you also compare recovery rate at equal re-execution budget against (i) random node choice, (ii) earliest-node choice, (iii) self-diagnosis without NEAR pruning, and (iv) k full re-rollouts? How many tool calls and how much compute does NEAR use per trajectory? Why do 14.8% of trajectories stop "before the candidate set is exhausted"? Is this K_max, and what is K_max?
  2. Can you provide a flat-ReAct baseline trained with the same data sources and the same three-stage budget (outcome reward for RL)? Can you re-run the key baselines (e.g., Tongyi-DeepResearch, REDSearcher) under your exact tool/turn/context setup?
  3. Eq. 7: which model computes log P(y|·), the current policy, a frozen reference, or another model? How do you prevent hacking, for example by copying candidate answers into context or by learning to raise the gold-answer likelihood without valid evidence? How are the binary scores of the sub-questions in a layer aggregated with r_prog, r_outcome and r_format, and with what weights? Is ρ_i(ℓ_t) a sequence-level ratio over all tokens of the layer?
  4. Figure 1(b)/(c): how was the "origin of deviation" determined, and by whom (human or LLM)? On how many trajectories, and from which benchmarks? This analysis is the paper's motivation.
  5. Contamination: did you check for overlap between the RedSearcher/OpenSeeker training questions and the five benchmarks?
  6. Please give mean ± std over at least 3 runs for all benchmarks in Tables 1 and 2.

Suggestions (not affecting score): discuss the closely related DAG-based parallel search (Flash-Searcher) and root-cause localization work (Liang et al. 2026; Samanta et al. 2026) more concretely, and say what is new relative to them; report the efficiency comparison under identical parallel tool-dispatch infrastructure.

5 comments

W1: Clarification and Additional Experiments on NEAR

We thank the reviewer for raising these concerns. We provide the following clarifications and additional experimental results.

First, as stated in §3.3, NEAR is a heuristic for identifying candidate error nodes based on model-declared dependencies, rather than a root-cause localization algorithm with formal correctness guarantees. Theorem B.1 only guarantees finite termination through strict candidate-set reduction, not correct localization under erroneous dependencies, multiple independent errors, or failed corrections.

NEAR prioritizes critical upstream errors because incorrect upstream answers can propagate through downstream subquestions, evidence, and conclusions. Correcting such errors and re-executing their descendants can recover affected states more effectively than fixing isolated downstream symptoms. However, descendant exclusion is a heuristic based on the assumption of a dominant upstream error, not a correctness guarantee. It may fail with multiple independent errors, missing subquestions, incorrect dependencies, or unsuccessful corrections. We will explicitly acknowledge these limitations.

To evaluate the contribution of NEAR relative to alternative repair strategies, we conducted additional experiments on the same 500 initially failed trajectories. We compared random-node selection, earliest-node selection, self-diagnosis without NEAR pruning, last-node selection, and up to three full-trajectory regenerations (k = 3). All methods used the same model, tools, and success evaluator. Node-level repair methods followed the same correction and downstream re-execution procedure.

MethodAnswer recovery rateRecovered trajectories / 500NEAR's relative improvement
Random-node selection26.8%134+58.4%
Earliest-node selection34.6%173+50.6%
Self-diagnosis + correction and downstream re-execution (without NEAR pruning)47.6%238+37.6%
Last-node selection5.2%26+80.0%
Up to three complete trajectory regenerations (k = 3)30.4%152+54.8%
NEAR85.2%426— (reference)

As shown in the table above, NEAR substantially improves the answer recovery rate, suggesting that its primary gains stem from targeted correction of suspected erroneous nodes rather than simple rerolling or answer-oracle-based selection of random samples. These results provide empirical evidence supporting the effectiveness of NEAR as an offline trajectory repair strategy.

Finally, we clarify the stopping rule. The implementation permits at most five correction attempts, including the first attempt. A trajectory may stop earlier when the answer is recovered, the candidate set is exhausted, or the auditor returns no valid new candidate. Consequently, the 74 unrecovered trajectories did not necessarily exhaust all candidates. We will replace the ambiguous statement in Sec. 4.4 and report the tool-call and token costs of each repair baseline.

W2: Controlled attribution, evaluation consistency, and stability

We agree that literature-reported numbers obtained under different environments should not be used for strict causal attribution. For the directly relevant comparison with REDSearcher, however, SearchMapper uses the same Google Search/Search/Visit environment, gpt-oss webpage summarizer, interaction limit, and context setting. We will state this scope explicitly rather than generalizing it to every model in Table 1.

Table 2 provides an internal Stage-I control under the same training questions and teacher models: flat ReAct SFT obtains 50.1 on average, compared with 54.9 for structured SFT; retaining decomposition but removing the scoring model obtains 51.5. At Stage III, removing process rewards reduces the average from 63.9 to 59.3, while skipping KTO yields 62.1. These results support each component within its controlled stage. We acknowledge that they are not identical to a fully matched Flat-ReAct SFT-to-KTO-to-DAPO pipeline: NEAR uses DAG dependencies to choose repair locations and construct targeted KTO data, so removing the DAG also removes that data-construction mechanism. We will make this evidence boundary explicit rather than claiming that Table 2 completely isolates the end-to-end DAG contribution.

We repeated the complete model evaluation on the two benchmarks for which the reviewer highlighted run-level uncertainty:

BenchmarkRun 1Run 2Run 3Mean +/- sample std.
BrowseComp45.044.644.844.80 +/- 0.20
xBench-DS-250581.083.080.081.33 +/- 1.53

We will distinguish these repeated results from single-run external numbers and avoid interpreting small 1.0-1.8 point ablation gaps as statistically conclusive without corresponding repetitions. Models listed in Appendix D.1 but absent from Table 1 did not provide public results on the corresponding benchmarks under a sufficiently comparable protocol; we will clarify the inclusion rule and narrow “all same-scale agents” to “all same-scale agents included in Table 1.” DeepSeek-V3.2 generated part of the offline data, but the student subsequently undergoes multi-source SFT, KTO, and online RL; surpassing one teacher's single-run inference is therefore possible, although we will not use this comparison as causal evidence for the DAG.

Q3: Layer-progress model, reward aggregation, and optimization

Equation 7 uses the frozen post-KTO checkpoint to compute the mean conditional log-probability of the gold-answer tokens:

r_prog(l_t) = log P_phi(y | Q, H_t, l_t, O_t) - log P_phi(y | Q, H_t),

where phi is the same frozen likelihood model in both terms. The gold answer is visible only to the reward and final-answer verification modules and is never exposed to the rollout policy.

For each subquestion, we first average the binary Redundancy, Clarity, and Progressiveness scores, and then average across all subquestions in the layer, so the quality reward does not increase with the number of nodes. The complete reward is:

R(l_t) = 0.3 * r_quality(l_t) + 0.3 * r_prog(l_t) + I[l_t = terminal] * 1.0 * r_outcome.

The two process rewards, subquestion quality and layer progress, each have weight 0.3, while the binary outcome reward has weight 1.0 and is added only at the terminal layer. Thus, the maximum combined reward is 0.3 + 0.3 + 1.0 = 1.6; no format reward is used. Earlier layers receive dense local supervision from quality and progress rewards; we do not claim that the terminal outcome is directly returned to every earlier layer. Layer rewards are normalized jointly across all layers in the rollout group to produce layer-level advantages. Importance ratios are computed and clipped per policy-generated token; tool-return tokens do not participate in the policy loss. We will revise Eqs. 7-9 to make these details explicit.

Q4-Q5: Motivation analysis and contamination

For Figure 1(b), we randomly sampled 100 failed DeepSeek-V3.2 trajectories from the benchmark evaluation data with a recorded seed. Two annotators independently marked the earliest step that introduced a claim unsupported by evidence, contradicted retrieved evidence, or violated a question constraint and was subsequently used by the trajectory. Mere retrieval misses and reasonable candidate elimination were not counted as deviations. A third annotator adjudicated disagreements. We will add inter-annotator agreement and representative examples, and present this as descriptive error analysis rather than localization evidence.

For Figure 1(c), DeepSeek-V3.2 performed one generic self-reflection continuation on the same trajectories, with at most 50 additional agent interaction turns. The gold answer was hidden from the model and used only for final evaluation. We will report tool calls and token usage; this result characterizes the stated prompt and budget, not an upper bound on all self-reflection methods.

Before training, we checked the exact data versions prepared for SFT, KTO, and DAPO, including the RedSearcher and OpenSeeker subsets, against all five evaluation sets. We found zero overlaps with BrowseComp, BrowseComp-ZH, GAIA-text-only, xBench-DS-2505, or xBench-DS-2510. We will add the matching procedure, data versions, and per-benchmark counts. We will also expand the discussion of Flash-Searcher, Liang et al., and Samanta et al. to distinguish their contributions from our use of a dynamic search DAG for filtering, repair, KTO data construction, and layer-level RL supervision.

Reviewer_wXkeOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

This paper proposes a trajectory synthesis and three-stage post-training pipeline for training deep search agents. Specifically, at each step the agent is prompted to explicitly decompose the problem into parallelizable sub-questions and declare their dependencies as a DAG. A distilled 30B scoring model evaluates each sub-question along three dimensions to filter/refine SFT trajectories and provide process rewards during RL. Experiments based on Qwen3-30B-A3B-Thinking show strong empirical gains across five search benchmarks.

Critical strengths
  • The empirical improvements across deep-search benchmarks are strong, and the trained 30B model achieves competitive performance against existing 30B search agents.
Critical weaknesses

W1 Over-engineering query formulation into a rigid DAG does not align with the nature of deep search. The core challenge of deep search lies in progressively narrowing down the search space, cross-referencing noisy retrieved snippets, and synthesizing scattered clues to pinpoint the final answer, for which a standard ReAct loop with Search and Visit tools is already sufficient and much more flexible. In contrast, heavily constraining and scoring sub-question formulation into a DAG is unconvincing for two reasons:

  • Penalizing similar queries hurts exploration: In real-world deep search, it is natural and often necessary to issue semantically similar queries from slightly different angles to probe for specific information. Strictly penalizing overlapping or "same-intent" queries as redundant overly restricts this exploratory process.
  • A rigid DAG over-simplifies deep research: Forcing every step into atomic, single-interrogative sub-questions with pre-declared dependencies cannot represent general deep research workflows (such as open-ended report generation). Even on multi-hop benchmarks like BrowseComp, it is questionable whether solving these tasks genuinely requires an explicit DAG rather than adaptive sequential probing.

W2 Confounded empirical gains and missing end-to-end comparison against the standard ReAct RFT + Outcome RL paradigm. It is unclear how much of the reported improvement actually comes from the proposed DAG framework versus the curated data mixture and stronger teacher models:

  • Confounded training resources: SearchMapper combines training queries from multiple strong open-source datasets (REDSearcher and OpenSeeker) and re-distills trajectories using frontier teachers (Claude 4.6 Sonnet and DeepSeek-V3.2), on top of a three-stage pipeline with an extra 30B scoring model. Even so, in their original papers on the same 30B backbone, OpenSeeker (using pure flat ReAct SFT) and REDSearcher (using standard ReAct SFT + RL) already achieve competitive or even higher scores on several benchmarks without any DAG decomposition or process-scoring model.
  • Missing end-to-end standard baseline: While Table 2 ablates sub-question decomposition at Stage I only and process rewards at Stage III only, the paper never evaluates the most standard end-to-end baseline on the exact same curated dataset and teacher pool, standard ReAct RFT (retaining trajectories by answer correctness) followed directly by outcome-based RL. Without showing that the full DAG pipeline outperforms this standard practice under identical data and teachers, the heavy methodological complexity is hard to justify.
Questions for authors

Please see my weaknesses thanks

4 comments

We thank the reviewer for raising this concern. We would like to clarify three key aspects: the dynamic construction of the DAG, the distinction between subquestions and search queries, and the practical value of explicit search structures.

W1: Does an Explicit DAG Constrain the Search?

First, SearchMapper does not generate a fixed DAG in advance; instead, it incrementally expands the graph throughout the retrieval process. As described in §3.1, the model first generates a layer of subquestions, gathers evidence and answers them through multiple Search/Visit interactions, and then summarizes and reflects on the results. Based on newly discovered entities, constraints, and unresolved information needs, it generates the next layer of subquestions. Thus, the DAG serves as an incremental record of information needs and their dependencies rather than a fixed search plan. The model can dynamically adjust its search direction, expand nodes, or perform refinement without being required to generate a new subquestion at every ReAct step.

Second, the redundancy score penalizes redundant subquestions rather than similar search queries. A subquestion represents an information need, whereas a search query is a tool input used to retrieve evidence. The same subquestion can be explored through complementary queries with different phrasings, sources, or perspectives. Appendix G explicitly encourages multiple complementary queries within a single tool call. The redundancy criterion in §3.2 aims to reduce repetitive decomposition that provides no additional information, rather than restricting exploration or cross-source verification.

Finally, compared with flat ReAct, an explicit DAG provides an actionable search structure. It organizes subquestions, answers, and their dependencies, supports stage-wise reflection, enables parallel retrieval of independent subquestions, and facilitates error localization and targeted refinement. The Stage I ablation in Table 2 shows that, under the same teacher-data setting, the score decreases from 54.9 with decomposition to 50.1 without decomposition, demonstrating the effectiveness of structured decomposition.

We agree that open-ended report generation may require more flexible query organization. However, our work focuses on deep-search QA involving verifiable answers, multi-step retrieval, and compositional constraints. We will further clarify the scope of our method and the above mechanisms in the revised manuscript.

W2: Are the performance gains attributable to the DAG rather than the data and teacher models?

We thank the reviewer for raising this concern. We would like to clarify the following points.

First, SearchMapper w/o KTO stage in Table 2 retains the DAG structure and RL training while removing only the KTO stage. Compared with REDSearcher, which adopts Flat ReAct + RL, this variant achieves higher performance on both BrowseComp and BrowseComp-ZH. These results show that, even without KTO, our DAG-based approach outperforms an existing Flat ReAct + RL method on two shared benchmarks, suggesting that the gains do not depend entirely on the additional KTO optimization.

Furthermore, w/o sub-question decomposition in Table 2 provides a controlled comparison. This variant uses exactly the same training questions, number of samples, teacher models, correct-answer filtering criteria, Qwen3-30B-A3B-Thinking backbone, and SFT training budget as SearchMapper. The primary difference is that its training trajectories are represented as flat ReAct trajectories, without explicitly generating subquestions or their DAG dependencies. Under this setting, the average score across five benchmarks decreases from 54.9 to 50.1, a drop of 4.8 points. This indicates that structured decomposition itself provides substantial benefits even when the data and teacher models are held constant.

MethodBrowseCompBrowseComp-ZHGAIA-text-onlyxBench-DS-2505xBench-DS-2510Average
Flat ReAct SFT34.939.265.170.041.050.1
SearchMapper w/o KTO stage43.854.276.780.056.062.1
OpenSeeker29.548.4–74.0––
REDSearcher42.149.880.1–––
SearchMapper44.656.378.681.059.063.9

Finally, the additional scoring model and NEAR are used only for training-data construction and process supervision during training. At inference time, SearchMapper requires neither the scoring model nor NEAR nor any other auxiliary model: a single 30B policy performs the search using Search/Visit tools. Thus, the additional complexity is concentrated in training, while inference introduces no additional models. Moreover, parallel retrieval of independent subquestions within the same layer can reduce sequential reasoning steps and end-to-end latency.

Dear Reviewer wXke,

We wish have addressed the concerns and questions raised in your reviews through our rebuttal. As the deadline for the discussion phase approaches, we would value your feedback on whether our responses have sufficiently clarified the issues. We are happy to provide further details if any points remain unclear.

Thank you for your time and effort!

Best regards,

The Authors

Dear Reviewer wXke,

We would like to kindly follow up on our previous message, as the discussion phase is nearing its end. We would greatly appreciate it if you could take a moment to review our rebuttal and let us know whether your concerns have been adequately addressed.

If any questions or concerns remain, we would be happy to provide further clarification before the discussion closes.

Thank you again for your valuable time and consideration!

Best regards,
The Authors

AuthorsOpenReview ↗

Author Summary for the Area Chair — Submission #17530

Author Summary for the Area Chair — Submission #17530

Dear Area Chair,

We sincerely thank the reviewers and the Area Chair for their time and constructive feedback. The rebuttal has allowed us to clarify the central contributions of SearchMapper, provide additional experimental evidence, and address important questions regarding methodological validity and empirical attribution. We would like to highlight the following points for your final consideration.

1. Core contribution: A unified structural framework for reliable deep-search agents.

The key contribution of SearchMapper goes beyond representing search trajectories as DAGs. We identify lost in search as a fundamental challenge arising from implicit dependencies between intermediate retrieval steps, and introduce an explicit, dynamically evolving search structure that enables three complementary capabilities: dependency-aware sub-question assessment, targeted error recovery, and fine-grained process supervision during training.

Importantly, SearchMapper does not impose a rigid, predefined search plan. The DAG is incrementally constructed as new evidence emerges, while individual sub-questions can still be investigated through multiple complementary search queries. This preserves the flexibility of exploratory search while making intermediate dependencies actionable. Moreover, the scoring model and NEAR are used during training.

2. Controlled experiments support the value of structured search beyond stronger training data.

A central concern was whether improvements could be attributed to the proposed method rather than stronger teachers or curated datasets. Our controlled Stage-I comparison uses identical training questions, teacher models, filtering criteria, backbone, and training budget. Under these conditions, structured decomposition improves the five-benchmark average from 50.1 to 54.9 (+4.8 points), while removing the scoring model reduces performance to 51.5.

Furthermore, removing process rewards reduces final performance from 63.9 to 59.3 (−4.6 points). These findings provide direct, stage-specific evidence that the proposed structural supervision contributes meaningfully to performance.

3. Additional rebuttal experiments substantially strengthen the empirical evidence for NEAR.

In response to reviewers' concerns, we conducted additional comparisons on the same 500 failed trajectories. NEAR achieves an 85.2% answer-recovery rate, compared with 47.6% for self-diagnosis without NEAR pruning, 34.6% for earliest-node correction, 26.8% for random-node correction, and 30.4% for up to three complete trajectory regenerations.

These results provide substantial new evidence for the practical effectiveness of dependency-guided repair. We have also clarified that NEAR is a heuristic for efficient offline recovery, not a formally guaranteed root-cause localization method. Its contribution lies in exploiting search dependencies to guide corrective exploration and construct more informative training trajectories.

4. Strong overall performance, practical efficiency, and constructive reviewer feedback.

SearchMapper achieves a 63.9 average across five challenging benchmarks, leading the same-scale search agents included in our comparison on four of five benchmarks. On xBench-DS-2505, it requires 35.6% fewer reasoning steps than Tongyi-DeepResearch while achieving higher accuracy and lower latency.

During rebuttal, we additionally provided three-run evaluations, clarified reward computation and training details, and reported zero question overlap between the prepared training sets and all five evaluation benchmarks. We are particularly encouraged that Reviewer udtX explicitly acknowledged that the majority of their concerns had been resolved and raised their rating to Weak Acceptance.

We believe the paper makes a meaningful contribution by demonstrating how explicit dependency structures can serve as a unified foundation for improving search-agent training, refinement, and efficiency.

We respectfully hope that the Area Chair will consider the combination of methodological contribution, controlled ablation evidence, strong empirical performance, and substantial additional rebuttal experiments when making the final recommendation.

Thank you again for your careful consideration.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.