OpenResearcher: A Fully Open Pipeline for Long-Horizon Deep Research Trajectory Synthesis

1. Problem Statement

Training "deep research" agents—systems capable of iterative search, evidence aggregation, and multi-step reasoning over long horizons—faces three critical bottlenecks in existing pipelines:

• Cost and Scalability: Most existing methods rely on live web APIs (e.g., Google Search) for trajectory generation. This makes large-scale synthesis prohibitively expensive, as every failed search path incurs API costs.
• Instability and Reproducibility: Live web environments are dynamic; search results change over time, making it difficult to reproduce the exact same data pipeline or analyze specific failure modes consistently.
• Analytical Limitations: Benchmarks like BrowseComp often lack stable "gold document" annotations, making it difficult to control for retrieval success versus reasoning failure. Existing datasets often contain short trajectories (2–5 turns) that fail to capture the complexity of real-world deep research, which often requires 100+ tool calls.

2. Methodology: The OpenResearcher Pipeline

The authors propose OpenResearcher, a fully open, reproducible pipeline that decouples corpus construction from trajectory synthesis. The core innovation is moving the search-and-browse loop entirely offline after a one-time bootstrapping phase.

A. Offline Search Engine Construction

1. One-Time Online Bootstrapping: To ensure the offline corpus contains the necessary evidence, the authors perform a single online pass using the Serper API to retrieve "gold documents" (documents containing the answer) for ~6,000 challenging QA pairs from the MiroVerse dataset.
2. Corpus Merging: These 10,000 gold documents are merged with 15 million documents from the FineWeb dataset (approx. 10 trillion tokens). The FineWeb documents act as "distractors" to simulate the noise and ambiguity of the real web.
3. Indexing: The corpus is embedded using Qwen3-Embedding-8B and indexed with FAISS to create a local, deterministic search engine.

B. Explicit Browser Primitives

Unlike prior agentic systems that treat search as a simple retrieval operation, OpenResearcher models browsing explicitly using three minimal primitives:

1. Search: Returns top-K results with titles, URLs, and snippets (broad information retrieval).
2. Open: Fetches the full content of a document (mimicking clicking a link).
3. Find: Locates exact string matches within the currently opened document (critical for named-entity lookup and grounding hypotheses).
   This structure forces the agent to progress from corpus-level search to document-level inspection and finally to evidence localization.

C. Trajectory Synthesis

• Teacher Model: GPT-OSS-120B is used as the teacher model.
• Process: The teacher interacts with the offline search engine using the three primitives. It generates trajectories by reasoning step-by-step before each tool call, terminating only when confident in a final answer.
• Scale: The process generates 97,000+ trajectories, including a significant "long-horizon tail" where many questions require 100+ tool calls.
• Filtering: Trajectories are filtered for context length limits, malformed calls, or lack of conclusive answers.

D. Student Training

A 30B-A3B backbone model (initialized from Nemotron-3-Nano-30B-A3B) is fine-tuned via Supervised Fine-Tuning (SFT) on the synthesized trajectories. The training data is curated via rejection sampling, retaining only trajectories that yield correct final answers (~55K trajectories).

3. Key Contributions

1. Fully Open & Reproducible Pipeline: The first fully open-source pipeline for deep research trajectory synthesis that eliminates reliance on proprietary live-web APIs, reducing costs to near zero and ensuring perfect reproducibility.
2. Explicit Browser Abstraction: Introduction of a minimal, three-primitive browser interface (search, open, find) that better reflects human research behavior and enables systematic information seeking at multiple scales.
3. Empirical Insights: The offline, instrumented environment allows for controlled analysis of the deep research process, revealing:
   • Data Filtering: Correctness of the final answer is not the sole indicator of training value; failed trajectories also provide valuable supervision on search structure.
   • Corpus Coverage: One-time online bootstrapping is essential; without gold documents in the corpus, downstream performance collapses.
   • Tool Necessity: The open and find tools are critical; search-only agents perform significantly worse.
   • Retrieval vs. Reasoning: Retrieving a gold document is necessary but not sufficient; reasoning over the evidence is the primary bottleneck.

4. Experimental Results

The model trained on OpenResearcher data (OPENRESEARCHER-30B-A3B) was evaluated on several benchmarks:

• BrowseComp-Plus (Closed-Web): Achieved 54.8% accuracy.
  • This is a +34.0 point improvement over the base Nemotron-3-Nano model (20.8%).
  • It significantly outperforms strong proprietary baselines, including GPT-4.1 (36.4%), Claude-4-Opus (36.8%), and DeepSeek-R1 (16.4%).
• Open-Web Benchmarks (Generalization): Despite being trained only on offline data, the model generalized well to live-web environments:
  • BrowseComp: 26.3% (vs. 5.2% for ASearcher).
  • GAIA: 64.1% (vs. 52.8% for ASearcher).
  • xbench-DeepSearch: 65.0% (vs. 42.0% for ASearcher).

5. Significance

• Democratization of Deep Research: By removing the cost barrier of live API calls, OpenResearcher enables the open-source community to train and study long-horizon reasoning agents that rival proprietary systems.
• Scientific Rigor: The offline, instrumented environment provides a unique testbed for analyzing why agents fail (e.g., distinguishing between retrieval failure and reasoning failure), which is impossible in dynamic live-web settings.
• Efficiency: The pipeline demonstrates that high-quality, long-horizon training data can be synthesized cheaply and at scale, proving that SFT on well-structured offline trajectories is sufficient to unlock deep research capabilities without Reinforcement Learning (RL) or live interaction.

In summary, OpenResearcher establishes a new standard for training deep research agents by providing a scalable, cost-effective, and analytically rigorous framework that bridges the gap between open-source capabilities and proprietary performance.