ArXiv: 2510.24701

🎯 Pitch

A 30B-parameter model with just 3B active parameters rivals or beats proprietary giants like OpenAI’s DeepResearch across seven deep research benchmarksβ€”while being fully open-source. The secret is an end-to-end training pipeline that first bakes agentic behavior into the base model during a novel 'mid-training' phase, then refines it via scalable reinforcement learning, all fueled by fully synthetic data and a surprising finding: controlled, purpose-built environments matter far more than algorithmic complexity for stable agent training.

1. Executive Summary

Tongyi DeepResearch introduces an open-source agentic large language model designed for long-horizon, deep information-seeking research tasks, trained through an end-to-end framework that unifies agentic mid-training and agentic post-training. Built on the Qwen3-30B-A3B-Base model and activating only 3.3 billion parameters per token out of 30.5 billion total, the system employs a fully automated synthetic data synthesis pipeline β€” generating research-level questions, planning trajectories, reasoning chains, and decision-making sequences β€” combined with stage-specific environments (prior world, simulated, and real-world) to enable scalable reinforcement learning via an adapted GRPO algorithm. Tongyi DeepResearch achieves state-of-the-art performance across a range of agentic deep research benchmarks, including 32.9 on Humanity's Last Exam, 43.4 on BrowseComp, 46.7 on BrowseComp-ZH, 72.2 on WebWalkerQA, 70.9 on GAIA, 75.0 on xbench-DeepSearch, and 90.6 on FRAMES, surpassing strong proprietary systems while maintaining substantially fewer activated parameters. The paper establishes that agentic capabilities can be effectively cultivated through a training paradigm that treats environments as actively designed components coupled to the training process β€” with synthetic data serving as the scalable engine and environmental stability proving more critical than algorithmic sophistication β€” enabling deployment-viable models that surpass larger systems only when the training pipeline integrates mid-training as a bridge between pretraining and post-training phases.

2. Context and Motivation

The Core Problem: Open-Source Models Cannot Conduct Autonomous Research

The fundamental problem this paper addresses is both simple to state and enormously complex to solve: no publicly available, open-source model can autonomously conduct deep research β€” the kind of multi-hour, multi-source investigation that synthesizes information across diverse web resources, academic literature, and computational tools to produce comprehensive, verified answers to complex questions. While proprietary systems like OpenAI DeepResearch, Gemini DeepResearch, and Claude Research have demonstrated this capability in closed-source deployments, the community lacks any systematic methodology or publicly available artifacts β€” models, training frameworks, data pipelines β€” that can reproduce or build upon these results.

This gap is not merely about benchmark scores. It represents a fundamental barrier to scientific understanding and democratic access to agentic AI. The paper makes this explicit in Section 1:

"most deep research systems remain closed-source, and their intermediate research processes are inaccessible. While the community has made preliminary explorations in this area... there is still a lack of a systematic methodology and publicly available models that can be fully open-sourced and shared across the community."

The absence of open-source deep research agents means that researchers cannot study how autonomous research capabilities emerge, cannot build upon or improve existing systems, and cannot adapt these capabilities to specialized domains or constrained deployment environments. Every team that wants to work on deep research agents must effectively start from scratch, reinventing training pipelines, data generation strategies, and environment designs without the benefit of shared reference implementations.

Why This Problem Is Important: The Twin Stakes of Scientific Transparency and Practical Deployment

Scientific transparency. Deep research is fundamentally different from the capabilities that existing open-source models demonstrate. A model that can browse the web, visit pages, run code, search academic literature, and synthesize findings across dozens or hundreds of interactions is not just a stronger version of a chat model β€” it is a qualitatively different kind of system. Understanding how such capabilities can be cultivated requires access to the training pipeline itself: what data was used, how environments were designed, what reinforcement learning strategies proved effective, and what failed. Without open artifacts, the field cannot conduct the kind of systematic ablation and analysis that drives scientific progress. The paper positions itself as filling this void:

"We release the model, framework, and end-to-end solutions to support and accelerate community research. This technical report summarizes our main insights and aims to inspire further progress toward scalable and capable agentic systems."

Practical deployment. The paper makes a deliberate choice to demonstrate that strong deep research capabilities can be achieved with a model that activates only 3.3 billion parameters per token (30.5B total with a Mixture-of-Experts architecture). This is not an accident β€” it reflects a conviction that smaller, efficient models are essential for real-world deployment. Section 5.2 states this explicitly:

"Smaller models are inherently more efficient to deploy on edge devices, broaden accessibility across diverse real-world scenarios, and deliver faster, more responsive interactions."

Proprietary deep research systems run on massive, undisclosed infrastructure with unknown computational costs. An open-source system that achieves competitive performance with 3.3B activated parameters demonstrates that autonomous research capability does not require datacenter-scale inference β€” it can, in principle, run on consumer hardware or edge devices, dramatically broadening who can access and deploy such systems.

A new training paradigm. Beyond the specific capability of deep research, the paper argues for a broader conceptual shift: that training models to be competent agents requires a fundamentally different approach than training conventional LLMs. This claim, if validated, has implications far beyond the specific task of web research. It suggests that the field's standard pipeline β€” pretrain on internet text, then SFT+RLHF on instruction-following data β€” is insufficient for cultivating the kind of planning, tool use, and information synthesis that agentic behavior demands. The paper proposes that mid-training β€” a dedicated phase that bridges pretraining and post-training with agentic data β€” is a missing piece of the training recipe. Establishing whether this claim holds, and under what conditions, requires open artifacts that the community can scrutinize and reproduce.

Where Existing Approaches Fall Short

The paper identifies several deficiencies in the current landscape of agentic deep research systems:

Proprietary systems are black boxes. The most capable deep research agents β€” OpenAI DeepResearch, Gemini DeepResearch, Claude Research, Grok-3 DeepSearch β€” are described in blog posts and system cards, but their training methodologies, data generation pipelines, environment designs, and failure modes are not disclosed. The paper notes that their "intermediate research processes are inaccessible" (Section 1). This means that the community cannot learn from their successes or their failures. We do not know, for example, whether the strong performance of these systems comes from massive model scale, clever prompting, specialized training data, or some combination β€” and therefore cannot make informed decisions about how to allocate resources when building our own systems.

Existing open-source efforts are preliminary and unsystematic. The paper acknowledges that "the community has made preliminary explorations in this area," citing works like Wu et al. (2025a), Li et al. (2025c), and Tao et al. (2025). However, these prior efforts β€” while valuable β€” do not constitute a complete, end-to-end training methodology. They tend to focus on individual components (e.g., data synthesis, or web navigation, or reasoning) rather than providing an integrated pipeline that takes a base pretrained model and produces a fully capable deep research agent. Critically, they do not address the mid-training phase at all β€” the idea that general pretrained models lack an "agentic inductive bias" and need a dedicated training stage to acquire it before post-training can be effective. This is the paper's central methodological claim, and it represents a gap in prior work that the paper explicitly aims to fill.

Standard LLM training pipelines are insufficient for agentic capabilities. The paper argues that there is a fundamental mismatch between how conventional LLMs are trained and what agentic behavior requires (Section 2). General foundation models are typically pretrained on plain text crawled from the internet β€” data that "lack[s] research-level questions and agentic behaviors" β€” and then post-trained on instruction-following data that teaches the model to be helpful and harmless in single-turn or short multi-turn interactions. When such a model is then asked to conduct deep research β€” planning multi-step investigations, deciding when to search versus when to reason, synthesizing information from dozens of sources, managing a limited context window across potentially hundreds of interactions β€” it is being asked to exhibit behaviors it has never seen during training. The paper's diagnosis is that this gap between pretraining distribution and agentic task distribution causes "sub-optimal outcomes and inherent optimization conflicts" when agentic post-training is applied directly to a general foundation model. The solution proposed β€” mid-training as a bridge β€” is not present in any prior open-source agent training pipeline.

Agentic data is scarce by nature, and human annotation is infeasible. A practical bottleneck that the paper identifies is the fundamental scarcity of training data for deep research agents. Unlike pretraining data (which is abundant on the web) or conventional instruction-tuning data (which can be relatively easily annotated by crowd workers), deep research trajectories are extraordinarily expensive to create manually:

"Research-level problems are difficult to obtain through natural texts from the web. Manually annotating these problems and agentic trajectories is extremely time-consuming and costly."

Consider what a single training example for deep research requires: a complex, multi-hop question whose answer requires synthesizing information from multiple sources; a complete trajectory showing the agent searching, visiting pages, running computations, making decisions about what to investigate next; and a verifiably correct final answer. Creating even one such example by hand might take hours of expert work. Scaling this to the volumes needed for training (the paper uses datasets where "over 20% of the samples exceed 32k tokens and involve more than 10 tool invocations") is economically prohibitive. The paper argues that synthetic data is not just a convenience but a necessity β€” the only way to achieve the scale and diversity required. However, prior work has not demonstrated a fully automated, end-to-end synthetic data pipeline that covers all stages of agent training (mid-training and post-training) with stage-specific data synthesis strategies. This is the gap the paper's data synthesis pipeline (described in Sections 3.3.2 and 3.4.1) aims to fill.

Environmental instability undermines agent training. The paper identifies a practical challenge that is often overlooked in agent research: the training environment itself is a source of noise and instability that can corrupt learning. Real-world web APIs have latency variation, rate limits, intermittent failures, and non-stationary content. When an agent's tool calls fail because of an API outage rather than a policy error, the resulting trajectory carries a misleading learning signal. The paper describes this problem in Section 3.4.3:

"The inherent volatility of external APIs, encompassing high latency, outright failures, and inconsistent returns, threatens to corrupt our training trajectories. This data contamination makes it nearly impossible to diagnose performance issues, obscuring whether a poor outcome is caused by a weakness in the agent's policy or by the instability of the environment itself."

Prior work on web agents often either accepts this noise as inevitable or sidesteps it by operating entirely in simplified simulated environments that lack real-world fidelity. The paper proposes a different approach: a unified sandbox that wraps real tools with fault-tolerance mechanisms (caching, automatic retries, graceful degradation, backup data sources) to create a deterministic interface, combined with a simulated Wikipedia environment for rapid experimentation. The key insight β€” that environments should be "actively designed as systems deeply coupled with the training process" (Section 2) rather than passively accepted as external constraints β€” represents a methodological contribution that prior work has not articulated or systematically implemented.

No systematic analysis of what makes agentic RL succeed. Several prior works have applied reinforcement learning to agent training β€” for example, WebSailor (Li et al., 2025c) and Kimi Researcher (Kimi, 2025) β€” but the literature lacks a systematic analysis of what factors matter most for training stability and performance. The paper reports a finding that challenges conventional wisdom:

"Through our experiments, we arrive at a critical insight: the success of agentic RL depends more on the quality of the data and the stability of the training environment than on the specific algorithm being used."

This is an empirically grounded claim about where to invest effort when building agent training systems. If algorithmic innovation matters less than data curation and environmental engineering, then the community's focus should shift accordingly β€” but without open verification of this claim (which the paper enables through its open-source release), it remains an untested hypothesis.

How This Paper Positions Itself

The paper positions itself not as an incremental improvement to an existing open-source agent, but as a foundational contribution that establishes a complete, reproducible paradigm for training deep research agents. This positioning is reflected in several key claims:

Unifying mid-training and post-training into a single framework. The paper introduces the concept of agentic mid-training as a first-class phase in the training pipeline, arguing that it is not optional but essential β€” it "endows the pre-trained base model with substantial agentic prior knowledge, thereby bridging the gap between pretraining and agentic post-training" (Section 2). This is the paper's most significant methodological claim, distinguishing it from prior work that applies post-training directly to general foundation models. The paper provides a concrete instantiation of this idea through two-stage Agentic CPT (Continual Pre-Training) with context length scaling (32K β†’ 128K) and a detailed data synthesis strategy covering question generation, planning, reasoning, and decision-making actions.

Treating synthetic data as a first-class engineering problem, not a shortcut. The paper does not treat synthetic data as a stopgap until human annotation becomes feasible. Instead, it argues β€” in Section 2 β€” that synthetic data is intrinsically superior to human annotation for agent training along multiple dimensions: it scales more easily, generalizes more diverse patterns, enables targeted capability enhancement by decomposing tasks into meta-capabilities, is easier to verify automatically, and supports data flywheels where improved models generate improved training data. The paper then backs this claim with an elaborate data synthesis pipeline that includes graph-based question generation with controllable uncertainty injection (Section 3.4.1), a formal set-theoretic model of information-seeking for QA verification (Section 3.4.1), and a PhD-level question engine for scaling task difficulty. This represents a significantly more principled approach to synthetic data than prior work, which typically treats data generation as an ad-hoc prompting exercise.

Environment design as a core research contribution. The paper reframes the role of environments in agent training from passive infrastructure to an active design choice that must be coupled to the training objectives. The three-tier environment taxonomy β€” Prior World (zero-cost, stable, but no feedback), Simulated (low-cost, controllable, but limited coverage), and Real-world (authentic, but expensive and noisy) β€” provides a framework for making deliberate tradeoffs at each training stage rather than defaulting to real-world interaction for everything. The paper uses this framework to justify its specific choices: Prior World + Simulated for mid-training (where scale matters more than fidelity), Simulated for rapid RL experimentation, and Real-world with a fault-tolerant sandbox for final training. This represents a more structured approach to environment design than seen in prior agent training work.

Open-sourcing the complete solution, not just the model weights. The paper's positioning as a foundational contribution is reinforced by its release strategy: model weights, training framework, tool implementations, evaluation prompts, and reproduction scripts are all made publicly available (Section 4.1). This goes beyond the typical open-source model release (weights only) and enables the community to actually reproduce and build upon the full training pipeline. The paper explicitly frames this as enabling a shift in how the community approaches agent research:

"We advocate for open-source models with emergent agency, which are essential for democratizing agentic intelligence and deepening our fundamental understanding of how agency can emerge and scale in open systems."

Efficiency as a first-order concern. The choice of a 30.5B-parameter model with only 3.3B activated parameters per token is not incidental β€” it represents a deliberate bet that agentic capability does not require massive model scale, and that training methodology can substitute for parameter count. This positions the paper against the prevailing trend of scaling model size to achieve capability gains, aligning instead with work like Belcak et al. (2025) that argues "small language models are the future of agentic AI." The paper validates this positioning through its competitive performance against much larger proprietary systems, though the comparison is not FLOPs-matched (the paper does not quantify the inference-time compute of proprietary systems, making direct efficiency comparisons challenging).

In summary, the paper positions itself as filling a structural gap in the research ecosystem: the absence of a complete, open, and systematic methodology for training models that can autonomously conduct deep research. It does not claim to invent any single component from scratch β€” ReAct rollouts, GRPO, synthetic data generation, and reinforcement learning for agents all have prior literature β€” but rather claims to provide the integration and engineering that transforms these components into a working, reproducible, state-of-the-art system, along with the empirical analysis and open artifacts that enable the community to build upon it.

3. Technical Approach

3.1 Reader Orientation

Tongyi DeepResearch is an agentic language model β€” a system that, given a complex research question, can autonomously plan a multi-step investigation, interact with web search engines and web pages, run Python code, consult academic literature, and parse uploaded files, ultimately producing a synthesized report with a verifiable answer. The problem it solves is the absence of open-source models capable of conducting deep, multi-source research autonomously; the shape of the solution is a complete training pipeline that transforms a general pretrained language model into a capable research agent through two sequential phases β€” agentic mid-training (to instill foundational agentic behaviors at scale) and agentic post-training (to refine those behaviors through supervised fine-tuning followed by reinforcement learning in both simulated and real environments) β€” with a fully automated synthetic data engine powering both stages.

3.2 Big-Picture Architecture (Diagram in Words)

The system has five major interconnected components:

  1. Synthetic Data Engine β€” an automated pipeline that generates research-level question-answer pairs and complete agent trajectories (planning, reasoning, decision-making sequences) at massive scale, without human annotation. It produces data for both mid-training and post-training stages using different synthesis strategies tailored to each stage's objectives.

  2. Agentic Mid-Training (Agentic CPT) β€” a two-stage continual pre-training phase that takes the pretrained Qwen3-30B-A3B-Base model and exposes it to large-scale agentic behavior data (synthesized questions, planning actions, reasoning chains, decision-making sequences, and function-calling data) using standard next-token prediction loss. Stage 1 uses 32K context; Stage 2 expands to 128K context with long-sequence agentic data.

  3. Supervised Fine-Tuning (SFT) for Cold Start β€” a post-training phase that trains the model to imitate high-quality, curated agent trajectories before reinforcement learning begins. It uses a mixed training paradigm combining standard ReAct mode samples and Context Management mode samples (which require the model to synthesize compressed summaries and plan strategically), with a two-stage context length strategy (40K then 128K).

  4. Agentic Reinforcement Learning (RL) Framework β€” an on-policy training loop built on an adapted GRPO algorithm where the model generates complete research trajectories (rollouts) by interacting with tools, receives binary (0/1) reward signals based on answer correctness, and updates its policy. The framework includes a unified sandbox that wraps real-world tools (Search, Visit, Python Interpreter, Google Scholar, File Parser) with fault-tolerance mechanisms, a simulated Wikipedia environment for rapid experimentation, and an asynchronous rollout architecture for parallel agent-environment interaction.

  5. Dynamic Data Curation System β€” a background process that monitors training progress and continuously refreshes the RL training set by removing problems the model has mastered and adding new, challenging problems identified by sampling from a larger pool with intermediate policy checkpoints.

Information flows as follows: the synthetic data engine generates questions and trajectories β†’ mid-training consumes large-scale synthetic agentic behavior data to produce a model with agentic inductive bias β†’ SFT cold-start trains on high-quality filtered trajectories (both ReAct and Context Management modes) β†’ the RL framework deploys the model into real and simulated environments, collecting trajectories and binary reward signals β†’ the dynamic curation system filters the training set to maintain appropriate difficulty β†’ model merging combines multiple policy variants into the final agent.

3.3 Roadmap for the Deep Dive

  • First, the formal rollout definition (ReAct and Context Management). This establishes the fundamental primitives β€” thoughts, actions, observations β€” and the two operating modes that all subsequent training stages build upon. Understanding these is prerequisite for understanding what the model is being trained to do.

  • Second, the overall training recipe and mid-training phase. This covers the initial transformation from general pretrained model to agentically-biased foundation model through two-stage Agentic CPT, including the large-scale data synthesis strategy that generates planning, reasoning, and decision-making sequences.

  • Third, the post-training data synthesis pipeline. This explains how super-human-difficulty question-answer pairs are generated through graph construction, subgraph sampling, and uncertainty injection, plus the PhD-level question engine β€” the data that powers SFT and RL.

  • Fourth, the SFT cold-start phase. This covers the mixed training paradigm (ReAct + Context Management modes), the two-stage context length strategy, and why this phase is necessary before RL.

  • Fifth, the agentic RL framework in full detail. This is the most complex component: the adapted GRPO algorithm, the real-world and simulated environments, the unified sandbox, the asynchronous rollout infrastructure, the reward design, and the negative sample filtering strategy.

  • Sixth, the dynamic data curation and model merging. These are the mechanisms that maintain training efficiency as the policy improves and that combine diverse policy variants into the final model.

3.4 Detailed, Sentence-Based Technical Breakdown

This is primarily a systems and methodology paper whose core idea is that autonomous deep research capability can be cultivated through a training pipeline that treats agentic mid-training as an essential bridge between pretraining and post-training, and that synthetic data combined with deliberately designed environments can substitute for both human annotation and massive model scale.

Formal Rollout Definition: ReAct and Context Management Modes

The paper defines the fundamental operation of the agent at each timestep through three components (Section 3.1):

  • Thought ($\tau_t$): The internal cognitive process β€” analyzing context, recalling information, planning next steps, self-reflecting to adjust strategy. This is the model's reasoning trace, generated as text before each external action.
  • Action ($a_t$): An external operation executed via one of five tools β€” Search, Visit, Python Interpreter, Google Scholar, or File Parser. Intermediate actions ($a_t$ for $t < T$) are tool calls; the final action ($a_T$) is the generation of a comprehensive report containing the answer.
  • Observation ($o_t$): The feedback from the environment after executing an action β€” search results, webpage content, Python output, academic references, or parsed file content. This updates the agent's internal state and informs the next thought.

The paper defines two distinct rollout modes that structure how these components are assembled into a trajectory.

ReAct Mode. This is the standard ReAct paradigm (Yao et al., 2023) where reasoning and acting are interleaved. The trajectory $H_T$ is a sequence of thought-action-observation triplets:

HT=(Ο„0,a0,o0,…,Ο„i,ai,oi,…,Ο„T,aT)H_T = (\tau_0, a_0, o_0, \ldots, \tau_i, a_i, o_i, \ldots, \tau_T, a_T)

where $a_T$ is the final answer to the task. At any step $t \leq T$, the policy $\pi$ generates the current thought and action based on the complete history:

Ο„t,atβˆΌΟ€(β‹…βˆ£Htβˆ’1)\tau_t, a_t \sim \pi(\cdot | H_{t-1})

What it computes: For a given interaction history up to step $t-1$, the policy produces a reasoning trace followed by a concrete action (either a tool call or the final answer). The observation from that action extends the history, and the cycle repeats.

Why this form: The authors deliberately choose ReAct over more complex single-agent or multi-agent paradigms because of its simplicity and alignment with the principle that "general methods leveraging scalable computation ultimately outperform approaches that rely on complex, human-engineered knowledge" (Section 3.1, citing Sutton's "Bitter Lesson"). Complex prompt engineering or rigid operational structures risk becoming obsolete as model capabilities scale. ReAct provides a minimal, general scaffold that the model can learn to use flexibly.

Context Management Mode. The paper identifies a critical bottleneck for long-horizon tasks: the finite context window. As trajectories grow to hundreds of interactions, the naive ReAct approach of conditioning on the complete history becomes infeasible β€” the context fills up, and the model's reasoning degrades. To address this, the paper proposes a Context Management paradigm based on Markovian state reconstruction.

In this mode, the agent is not conditioned on the complete history. Instead, at each step $t$, it is conditioned on a strategically reconstructed workspace containing only three essential elements: the original question $q$, an evolving report $S_t$ serving as compressed memory, and the immediate context from the most recent interaction ($a_t$ and $o_t$). For every step $0 < t < T$, the core update process is:

St,Ο„t+1,at+1βˆΌΟ€(β‹…βˆ£Stβˆ’1,at,ot)S_t, \tau_{t+1}, a_{t+1} \sim \pi(\cdot | S_{t-1}, a_t, o_t)

where $S_t$ is the updated report summary, $\tau_{t+1}$ is the next thought, and $a_{t+1}$ is the next action.

What it computes: Given the previous summary $S_{t-1}$, the most recent tool call $a_t$, and the observation returned by that tool $o_t$, the model produces three outputs simultaneously: (1) an updated report $S_t$ that synthesizes the new information into the evolving understanding, (2) a reasoning thought $\tau_{t+1}$ that decides what to do next, and (3) the next action $a_{t+1}$. This replaces the full history with a learned compression.

Why this form: The Markovian structure ensures that the model's reasoning capacity remains constant regardless of exploration depth β€” it never faces a context window that grows unboundedly. The requirement to explicitly synthesize and prioritize information into $S_t$ at each step enforces structured reasoning analogous to how human researchers periodically summarize their findings to maintain coherent long-term investigations. This is not just a computational convenience; the paper argues it "naturally aligns with human research patterns, where periodic synthesis and reflection are essential for maintaining coherent long-term investigation" (Section 3.1). The compressed reports $S_T$ later become crucial for the Heavy Mode (Section 4.3), where multiple parallel agents' reports can be synthesized without exceeding context limits.

Overall Training Recipe

The complete training pipeline is initialized from the pretrained base model Qwen3-30B-A3B-Base (a 30.5B total parameter Mixture-of-Experts model with 3.3B activated per token) and proceeds through three sequential phases (Figure 2 in the paper):

Phase 1: Agentic Mid-Training (Agentic CPT). A two-stage continual pre-training process using standard next-token prediction loss. Stage 1 operates at 32K context length; Stage 2 expands to 128K context length and introduces long-sequence (64K–128K) agentic behavior data. Throughout both stages, a small proportion of general pre-training data is interleaved to preserve the model's broad linguistic competence.

Phase 2: Supervised Fine-Tuning (SFT) for Cold Start. The mid-trained model is fine-tuned on high-quality, rejection-sampled agent trajectories in both ReAct and Context Management modes. This establishes a stable behavioral baseline for tool use and research workflows before reinforcement learning begins.

Phase 3: Agentic Reinforcement Learning (RL). The SFT model is deployed into real and simulated environments for on-policy RL training using an adapted GRPO algorithm with binary answer-correctness rewards. Training data is dynamically curated to maintain appropriate difficulty. Finally, multiple model variants are merged to produce the final agent.

The paper's central methodological claim is that this three-phase structure β€” specifically the inclusion of mid-training β€” is essential for avoiding the "sub-optimal outcomes and inherent optimization conflicts" that arise when agentic post-training is applied directly to a general foundation model.

Agentic Mid-Training: Two-Stage Agentic Continual Pre-Training

The mid-training phase serves as a bridge between the distribution of general internet text (on which the base model was pretrained) and the distribution of agentic behavior (which the model will be post-trained to perform). The paper argues that general foundation models "lack agentic inductive bias" because their pretraining data contains no "research-level questions and agentic behaviors" (Section 2). Mid-training injects this bias before post-training begins.

Training Configuration. Both stages use standard next-token prediction as the optimization objective β€” the model is trained to predict the next token in sequences of agentic behavior data, exactly as in pretraining, but with data specifically constructed to teach agentic patterns (Section 3.3.1). The two-stage design with increasing context length is "strategically optimized for both efficiency and progressive capability scaling" β€” the first stage at 32K builds basic agentic patterns at lower computational cost, then the second stage at 128K introduces long-horizon behaviors that require the expanded context window. A small proportion of general pre-training data is interleaved in both stages to prevent catastrophic forgetting of the model's broad linguistic knowledge. The paper does not specify the exact mixing ratio, training duration, or optimization hyperparameters for this phase.

Large-Scale Agent Behavior Data Synthesis. The data for mid-training is generated through a synthesis pipeline covering what the paper calls the "complete lifecycle of agent workflows" (Section 3.3.2, Figure 3). The pipeline generates data for four critical components:

1. Large-Scale Multi-Style Question Synthesis. The foundation is an "entity-anchored open-world memory" β€” a structured knowledge base constructed by consolidating information from diverse real-world sources (web-crawled data, agent interaction trajectories) into representations of entities and their associated knowledge. From this memory, the system samples entities along with their related knowledge and generates diverse questions that embed specific behavioral pattern requirements β€” multi-hop reasoning questions that require connecting facts across multiple entities, and numerical computation questions that require quantitative analysis. The key design choice is anchoring questions to real entities rather than generating them from scratch; this ensures the questions are grounded in factual knowledge that the model can actually verify through web interaction, avoiding the problem of training on impossible or hallucinated questions.

2. Planning Action Data. The paper identifies planning accuracy as "highly correlated with whether an agent can successfully complete a task." To generate planning data, open-source models are employed to analyze synthesized questions, decompose them into sub-problems, and predict initial actions. The entities and knowledge used in question construction serve as the basis for rejection sampling β€” generated plans that are inconsistent with the known entity relationships are filtered out, ensuring high-quality planning outputs. This creates training examples showing the model what to do first given a complex question.

3. Reasoning Action Data. When the agent receives massive, unstructured responses from external tools, it must distill critical knowledge from noise and construct coherent reasoning paths. To train this capability, the synthesis pipeline takes a question and its dependent knowledge (from the entity-anchored memory), and guides large models through a two-stage process to generate complete reasoning chains. A dual filtering mechanism then applies: generated reasoning chains must satisfy both a minimum length criterion (ensuring depth) and an answer consistency check (ensuring correctness). This creates training examples showing the model how to think through heterogeneous evidence.

4. Decision-Making Action Data. The paper explicitly models decision-making as a distinct action type, noting that it is "often implicit within agent cycles." Each step of an agent's trajectory implicitly involves choosing among multiple potential reasoning and action paths. To train this capability, the synthesis pipeline first thoroughly explores the feasible action space at each step of existing demonstration trajectories (identifying what alternative actions could have been taken), then reconstructs the original trajectories into multi-step decision sequences that preserve the original choices while making the decision points explicit. This creates training examples showing the model how to choose among alternatives.

General Function-Calling Data via Environment Scaling. Beyond the specific research workflow patterns above, the paper generates general function-calling data by systematically scaling the diversity of environments in which agents are trained (Section 3.3.2). The principle is that "the breadth of function-calling competence is closely tied to the diversity of environments" (Fang et al., 2025). Each environment is instantiated as a "read–write database" β€” a fully simulated environment with a defined state, tools for reading and writing that state, and deterministic responses. The scalable framework automatically constructs heterogeneous environments, producing function-calling scenarios with diverse APIs and interaction patterns. This data is incorporated into the mid-training phase alongside the agent behavior data. The key insight is that by training the model to interact with many different simulated environments during mid-training, it develops a general ability to use tools and interpret tool responses that transfers to the specific research tools it will encounter during post-training.

High-Quality Data Synthesis for Post-Training

The post-training phase requires data of substantially higher quality and complexity than mid-training, because it will be used for supervised fine-tuning (where the model must learn to replicate expert behavior) and reinforcement learning (where the model must receive unambiguous reward signals). The paper develops an end-to-end solution for generating "complex, high-uncertainty and super-human level question and answer pairs" (Section 3.4.1, Figure 4) that requires no human intervention.

Graph-Based Question Generation with Uncertainty Injection. The synthesis process begins by constructing a highly interconnected knowledge graph via random walks, leveraging web search to acquire relevant knowledge and isomorphic tables from real-world websites to ensure realistic information structure. From this graph, the system samples subgraphs and subtables to generate initial question-answer pairs.

The pivotal step is strategically increasing uncertainty to enhance difficulty. The paper grounds this in a theoretical framework where QA difficulty is modeled as a series of controllable "atomic operations" on entity relationships. For example, merging entities with similar attributes creates ambiguity β€” the agent must distinguish between entities that appear superficially similar but are actually different. By applying a controlled sequence of such operations, the system can systematically increase question difficulty while maintaining answer verifiability.

Set-Theoretic Formalization for Quality Assurance. To further reduce inconsistencies between the organized information structure and the reasoning structure of QA pairs, and to enable more controllable difficulty scaling, the paper proposes a formal modeling of the information-seeking problem based on set theory (Tao et al., 2025). The details of this formalization are not elaborated in the current paper (it is cited as a separate work), but the key benefit is practical: it allows the system to expand problems in a controlled manner that minimizes reasoning shortcuts and structural redundancy, leading to higher-quality QA pairs, and it provides a formal framework for efficient verification of QA correctness β€” addressing one of the central challenges of synthetic data for post-training, which is ensuring that generated answers are actually correct.

PhD-Level Question Engine. For the most challenging training examples, the paper develops an automated data engine specifically for generating PhD-level research questions (Qiao et al., 2025). The engine starts from a multi-disciplinary knowledge base and creates seed QA pairs requiring multi-source reasoning. These seeds undergo iterative complexity upgrades: a question-crafting agent, equipped with the corresponding tools, progressively expands the scope and abstraction of each question. Each iteration refines and compounds prior outputs, enabling a "systematic and controllable escalation of task difficulty." The engine can generate questions that require synthesizing information across multiple academic disciplines, evaluating contradictory sources, and drawing conclusions that are not explicitly stated in any single source.

Scale and Complexity Evidence. The paper reports a statistical analysis demonstrating the complexity of the resulting SFT dataset: "over 20% of the samples exceed 32k tokens and involve more than 10 tool invocations" (Section 4.4). This is intended as empirical evidence that the synthetic data pipeline produces genuinely complex, multi-step research trajectories β€” not superficial or trivial interactions.

Supervised Fine-Tuning for Cold Start

The SFT phase is positioned as a critical prerequisite for reinforcement learning β€” it establishes a "robust initial policy" and a "stable behavioral baseline" that prevents the RL phase from collapsing during early exploration (Section 3.4.2). The paper argues that "behavior cloning alone tends to produce mimicry without exploration," but that exploration without a good prior produces chaos. SFT provides the prior.

Data Preparation and Filtering. Starting from the synthesized high-quality QA data, the system generates complete training trajectories by having high-performing open-source models produce full thought-action-observation sequences. These trajectories undergo "rigorous rejection sampling" β€” a comprehensive filtering protocol that retains only those trajectories exhibiting diverse problem-solving patterns while meeting quality thresholds. The paper does not specify the exact filtering criteria, but the filtering ensures "only high-quality trajectories" enter the training set.

Mixed Training Paradigm. The cold-start training leverages data from two different formulations β€” ReAct Mode and Context Management Mode β€” to "enhance model robustness and generalization" (Section 3.4.2).

For ReAct Mode training samples, the input is the historical state $H_{t-1}$ (the complete interaction history up to the previous step), and the training target is the current step's thought $\tau_i$ and tool call $a_i$.

For Context Management Mode training samples, the input is the previous step's trajectory summary $S_{t-1}$, the previous tool call $a_{i-1}$, and the previous tool response $o_{i-1}$. The training target is the current step's trajectory summary $S_i$, thought $\tau_i$, and tool call $a_i$.

The paper argues that Context Management Mode data "particularly strengthens the agent's capabilities in state analysis and strategic decision-making, as it requires the model to synthesize complex observations into coherent summaries while maintaining task focus across extended trajectories." This synthesis-oriented training produces "more deliberate reasoning patterns" compared to purely ReAct training, because the model must explicitly decide what information is important enough to include in the compressed summary β€” a form of learned attention and prioritization.

Two-Stage Training Strategy. Training proceeds in two stages based on context length (Section 3.4.2):

  • Stage 1: Context length is set to 40K tokens. Training data consists of all ReAct Mode samples with context lengths shorter than 40K, plus all Context Management Mode samples (since these are all within 40K by construction).
  • Stage 2: Context length is extended to 128K tokens. Training data consists of ReAct Mode samples with context lengths between 40K and 128K, along with a small portion of shorter (40K) data for stability. The inclusion of short-context data in the long-context stage prevents the model from forgetting how to handle simpler tasks while learning to handle extended trajectories.

The paper does not specify training hyperparameters (learning rate, batch size, optimizer settings) for the SFT phase.

Agentic Reinforcement Learning: Algorithm, Environments, and Infrastructure

The RL phase is where the model moves beyond imitating demonstrations to discovering its own strategies through environmental interaction and reward feedback. The paper describes a complete framework encompassing the algorithm, real and simulated environments, tool infrastructure, and rollout architecture (Section 3.4.3, Figure 5).

RL Algorithm: Adapted GRPO. The core algorithm is a tailored adaptation of GRPO (Group Relative Policy Optimization, Shao et al., 2024). The objective function is:

J(ΞΈ)=E(q,y)∼D,{Hi}i=1GβˆΌΟ€ΞΈold(β‹…βˆ£context)[1βˆ‘i=1G∣Hiβˆ£βˆ‘i=1Gβˆ‘j=1∣Hi∣min⁑(ri,j(ΞΈ)A^i,j,clip(ri,j(ΞΈ),1βˆ’Ξ΅low,1+Ξ΅high)A^i,j)]J(\theta) = \mathbb{E}_{(q,y) \sim D, \{H_i\}_{i=1}^G \sim \pi_{\theta_{\text{old}}}(\cdot | \text{context})} \left[ \frac{1}{\sum_{i=1}^G |H_i|} \sum_{i=1}^G \sum_{j=1}^{|H_i|} \min\left( r_{i,j}(\theta) \hat{A}_{i,j}, \text{clip}\left( r_{i,j}(\theta), 1 - \varepsilon_{\text{low}}, 1 + \varepsilon_{\text{high}} \right) \hat{A}_{i,j} \right) \right]

where $(q, y)$ is a question-answer pair sampled from the training distribution $D$, $\{H_i\}_{i=1}^G$ are $G$ complete rollout trajectories (each consisting of a sequence of tokens) sampled from the old policy $\pi_{\theta_{\text{old}}}$, and $|H_i|$ is the number of tokens in trajectory $i$.

What it computes: For each token $j$ in each rollout $i$, the objective computes a clipped surrogate loss between the new policy $\pi_\theta$ and the old policy $\pi_{\theta_{\text{old}}}$. The clipping controls how much the policy can change at each update β€” if the ratio $r_{i,j}(\theta)$ (the probability ratio between new and old policy for that token) moves outside the range $[1 - \varepsilon_{\text{low}}, 1 + \varepsilon_{\text{high}}]$, the gradient contribution is clipped, preventing excessively large policy updates.

The importance sampling ratio $r_{i,j}(\theta)$ and advantage estimator $\hat{A}_{i,j}$ are defined as:

ri,j(ΞΈ)=πθ(Hi,j∣context)πθold(Hi,j∣context)r_{i,j}(\theta) = \frac{\pi_\theta(H_{i,j} | \text{context})}{\pi_{\theta_{\text{old}}}(H_{i,j} | \text{context})}

A^i,j=Riβˆ’mean({Ri}i=1G)\hat{A}_{i,j} = R_i - \text{mean}(\{R_i\}_{i=1}^G)

where $\pi_\theta(H_{i,j} | \text{context})$ is the probability the current policy assigns to token $j$ of rollout $i$ given the context, and $R_i \in \{0, 1\}$ is the binary reward for rollout $i$ (1 if the final answer is correct, 0 otherwise).

Why this form: Several design choices are motivated by specific challenges in agent training:

  • Token-level policy gradient loss (following DAPO, Yu et al., 2025): Rather than computing the loss only on the entire trajectory, the loss is computed at every token. This provides a denser learning signal β€” every token that contributed to a successful rollout receives a positive update, and every token that contributed to a failed rollout receives a negative update. Without token-level loss, the model would only receive feedback at the trajectory level, making credit assignment much harder for long trajectories where most tokens are correct even in a failed rollout.

  • Clip-higher strategy (also following DAPO): The asymmetric clipping ($1 - \varepsilon_{\text{low}}$ vs. $1 + \varepsilon_{\text{high}}$) allows slightly larger increases in probability for successful actions than decreases for unsuccessful ones, encouraging exploration. The exact values of $\varepsilon_{\text{low}}$ and $\varepsilon_{\text{high}}$ are not specified.

  • Leave-one-out advantage estimation (following Chen et al., 2025): The advantage for rollout $i$ is computed as its reward minus the mean reward of all other rollouts in the group $G$ (excluding rollout $i$). This reduces variance in advantage estimates compared to using the global mean across all rollouts from all questions, because the control variate (the mean) is computed from rollouts for the same question, which share the same difficulty level. Without this, easy questions would consistently produce positive advantages and hard questions would consistently produce negative advantages, distorting the learning signal.

  • Strict on-policy regimen: Trajectories are always sampled using the most up-to-date policy, ensuring the learning signal is relevant to the model's current capabilities. This means $r_{i,j}(\theta) = 1.0$ for strictly on-policy training (the new and old policies are the same at generation time, before any update is applied), though the notation is retained for generality.

  • Pure 0/1 reward (RLVR): The reward is solely based on whether the final answer matches the ground truth. The paper deliberately excludes any format reward (e.g., 0.1 for producing a correctly formatted answer), arguing that "the preceding cold start stage ensures the model is already familiar with the required output format" β€” SFT has already taught the model how to interact, so RL can focus purely on what answers to produce.

Negative Sample Filtering. The paper reports a critical empirical finding: "directly optimizing on an unfiltered set of negative rollouts significantly degrade training stability and can lead to policy collapse after extended training" (Section 3.4.3). To mitigate this, certain negative samples are selectively excluded from the loss calculation β€” specifically, rollouts that "do not yield a final answer because they exceed a length limit." These truncated rollouts are not informative failures (the model tried but got the wrong answer) but rather mechanical failures (the model ran out of context before finishing), and including them in training would penalize the policy for a constraint violation rather than a reasoning error. The paper frames these algorithmic modifications not as innovations but as "the pragmatic pursuit of a more efficient and stable training paradigm."

Real-World Environment and Unified Sandbox. The agent's action space comprises five tools: Search (Google web search, accepts multiple concurrent queries, returns top-10 results with title, snippet, and URL), Visit (extracts information from web pages using Jina.ai for page content parsing followed by a summary model for goal-directed extraction), Python Interpreter (sandboxed Python execution where code must be enclosed in <code> tags and results must be explicitly printed), Google Scholar (academic publication search, also returns standard web search results), and File Parser (handles multiple file formats β€” PDF, DOCX, PPTX, TXT, CSV, XLSX, DOC, ZIP, MP4, MP3 β€” by converting to text and then summarizing). Full tool descriptions with function signatures are provided in Appendix A of the paper.

The critical infrastructure challenge is that real-world web APIs are inherently unstable: they have varying latency, rate limits, intermittent failures, and non-stationary content. The paper describes how this volatility "threatens to corrupt our training trajectories" because it becomes impossible to determine whether a poor outcome stems from a policy error or an environmental failure.

The solution is a unified sandbox β€” a central scheduling and management layer that orchestrates every tool call through robust infrastructure (Section 3.4.3). For each tool, the sandbox implements: proactive QPS (queries per second) rate constraints to prevent API throttling, result caching to avoid redundant calls, automatic timeout-and-retry protocols for transient failures, graceful service degradation for non-critical failures, and seamless failover to backup data sources (e.g., a backup search API if the primary one is unavailable). This design "abstracts the tool invocation into a deterministic and stable interface for the agent and thereby insulates the training loop from real-world stochasticity while also significantly reducing operational costs."

Simulated Environment: Wiki Environment. Directly using real-world web APIs for all experimentation would be prohibitively expensive and slow. The paper reports that "QPS impact significantly degrade our development efficiency and compromise the reliability during our early-stage ablation studies" (Section 3.4.3, footnote). To enable rapid iteration, the team built an offline environment based on the 2024 Wikipedia database and developed a suite of local RAG (Retrieval-Augmented Generation) tools to simulate web search, visiting pages, and extracting information. The data synthesis pipeline is reused to create "high-quality, structurally complex QA specifically for this offline environment." This provides a "low-cost, high-efficiency, and fully controllable platform that enables high-frequency, rapid experimentation," which the paper analogizes to a "wind tunnel laboratory" β€” a controlled environment where algorithms can be tested and validated before deployment to the noisy real world.

On-Policy Asynchronous Rollout Framework. The iterative nature of agentic rollouts β€” each requiring numerous sequential interactions with the environment (search, wait for results, visit pages, wait for extraction, run code, etc.) β€” creates a significant bottleneck in RL training. The model cannot generate the next token until it receives the tool response, meaning a single rollout can take minutes of wall-clock time.

To overcome this, the paper implements a "custom, step-level asynchronous RL training loop" built on the rLLM framework (Tan et al., 2025). The architecture uses two separate asynchronous online servers: one for model inference (generating thoughts and actions), and another for tool invocation (executing search, visit, Python, etc.). A centralized interaction handler processes outputs from both, formatting the feedback into a unified message list. This allows "multiple agent instances to interact with the environment in parallel, each completing its rollout independently." Rather than waiting for one rollout to finish before starting the next, hundreds of rollouts can be in-flight simultaneously, dramatically increasing throughput.

The paper does not specify the exact number of parallel rollouts, the hardware configuration of the inference and tool servers, or the latency characteristics of the system.

Dynamic Data Curation and Model Merging

Automatic Data Curation. Training on a static dataset quickly leads to diminishing returns: as the policy improves, problems that were initially challenging become too easy, and the model receives little learning signal from solving them. Conversely, problems that are too hard yield only negative rollouts, also providing minimal signal.

The paper implements a "fully automated data filtering pipeline that dynamically adjusts the training set based on the improved policy model" (Section 3.4.3). The process works as follows:

  1. Initial filtering. Starting from a large dataset $D$, the initial SFT model (the baseline policy) generates multiple rollouts for each problem. Problems where the model always fails or always succeeds are filtered out, creating an initial training set $D'$ containing only problems of "moderate difficulty" β€” those where the model sometimes succeeds and sometimes fails, providing a meaningful learning gradient.

  2. Continuous monitoring. During RL training, the rollouts for problems in $D'$ are continuously monitored to detect when problems become too easy for the improved policy (e.g., the model now succeeds on every attempt).

  3. Background sampling. In parallel, a separate process uses intermediate policy checkpoints to sample from the entire original dataset $D$, identifying a "backup pool" of new problems that have become moderately difficult for the now-stronger model.

  4. Training set refresh. When training reaches a certain step count or the reward plateaus, the active training set $D'$ is refreshed: mastered problems are removed, and new challenging problems from the backup pool are added. The entire pipeline "runs independently, never interrupting the main RL training loop."

This design allows the training data to co-evolve with the policy, maintaining a curriculum of appropriate difficulty without manual intervention. The key insight is that difficulty is not a property of the problem alone but of the interaction between the problem and the current policy β€” a problem that is moderately difficult for the initial model may become trivial for the trained model, and a problem that was impossible for the initial model may become moderately difficult for the trained model.

Model Merging. The final stage of the pipeline combines multiple model variants into a single model through parameter averaging (Section 3.4.4). The approach is motivated by the observation that "when different model variants are derived from the same pre-trained model, their parameters can be effectively combined through averaging or interpolation."

The merging process selects several model variants that share the same base model but exhibit "different capability preferences" (the paper does not specify what these variants are β€” they could be checkpoints from different stages of RL training, models trained on different data subsets, or models trained with different hyperparameters). The merged model is computed as a weighted average:

ΞΈmerged=βˆ‘kΞ±kβ‹…ΞΈ(k),s.t.βˆ‘kΞ±k=1,Ξ±kβ‰₯0\theta_{\text{merged}} = \sum_k \alpha_k \cdot \theta^{(k)}, \quad \text{s.t.} \quad \sum_k \alpha_k = 1, \alpha_k \geq 0

where $\theta^{(k)}$ is the parameter vector of the $k$-th model variant and $\alpha_k$ is its merge weight.

What it computes: The parameter values of the merged model are element-wise weighted averages of the corresponding parameter values from the contributing models. The constraint ensures the weights form a valid convex combination β€” no negative weights, and the weights sum to 1.

Why this form: Model averaging is known to improve generalization by combining diverse solutions β€” it is analogous to ensembling at the output level but integrated directly into the parameter space. The paper reports that "this interpolation strategy not only preserves the core strengths of each contributing model but also equips the merged model with robust generalization abilities" and that "in complex scenarios requiring a synthesis of these varied capabilities, the merged model performs comparably to the best-performing source model in its respective area of strength, all without incurring additional optimization costs." The convex combination constraint ensures the merged model stays within the convex hull of the contributing models' parameter space, which empirically maintains stability compared to extrapolation (weights summing to more than 1 or including negative weights).

The paper does not specify the number of variants merged, how the variants were generated, the specific weights used, or any ablation analysis comparing different merging strategies.

4. Key Insights and Innovations

Innovation 1: Agentic Mid-Training as a Missing Phase in the Agent Training Pipeline

The paper's most fundamental conceptual contribution is the claim that training capable agents requires a dedicated mid-training phase situated between pretraining and post-training β€” and that omitting this phase is the root cause of suboptimal agent performance that prior work has implicitly accepted as inevitable. This is not an incremental training recipe tweak; it is a diagnostic reframing of why conventional LLM training pipelines fail to produce competent agents.

What the field assumed before this work. The dominant paradigm for training LLMs β€” pretrain on web text, then apply SFT + RLHF for instruction following β€” has been ported to agent training largely unchanged. Prior work on open-source deep research agents (WebSailor, WebDancer, WebResearcher) and proprietary systems (OpenAI DeepResearch, Gemini DeepResearch) either applied post-training directly to general foundation models or did not disclose their methodology at all. The implicit assumption was that if a model has sufficient reasoning capability from pretraining, post-training with agent demonstrations and RL can teach it to use tools and conduct research. The paper's Section 2 directly challenges this:

"Most general foundation models are typically pretrained on plain text crawled from the internet and then post-trained on instruction-following data. These datasets lack research-level questions and agentic behaviors, resulting in the model learns agentic capabilities and alignment simultaneously during the post-training phase. Agentic post-training on these general foundation models can result in sub-optimal outcomes and inherent optimization conflicts."

What the paper argues instead. The core diagnostic move is recognizing that general pretrained models lack an "agentic inductive bias" β€” the structural prior that the world is something you interact with through sequential actions, observations, and state management. Pretraining on static text does not teach a model that it can search for information it doesn't have, that tool outputs are feedback to be interpreted, or that long-horizon tasks require explicit state synthesis. When post-training attempts to teach these behaviors simultaneously with alignment and task performance, the optimization conflicts because the model is learning what to do (agentic patterns) and how well to do it (quality) at the same time, on a model whose parameter space was never shaped to accommodate agentic representations.

The proposed solution β€” injecting large-scale agentic behavior data during mid-training via standard next-token prediction β€” is significant not because next-token prediction on synthetic trajectories is novel (it's the same loss as pretraining), but because of the architectural role this phase plays: it creates a separation of concerns between acquiring the basic patterns of agency (mid-training) and refining them into competent, reliable behavior (post-training). This is analogous to how computer vision models are often pretrained on ImageNet before fine-tuning on specialized tasks β€” the pretraining doesn't solve the final task, but it provides a representation space where fine-tuning can succeed. The paper argues that without this phase, post-training is effectively trying to build agentic representations from scratch in a parameter space optimized for static text prediction.

Evidence. The paper does not provide a direct ablation comparing mid-trained vs. non-mid-trained models β€” this is a notable gap in the evaluation. The evidence for mid-training's importance is therefore indirect but systematic: the training pipeline as a whole (which includes mid-training) achieves state-of-the-art results across seven benchmarks (Table 1) with a model activating only 3.3B parameters, substantially smaller than proprietary alternatives. The paper's position is that this architecture β€” mid-training + post-training β€” constitutes a complete paradigm, and the burden of proof for mid-training's necessity lies in the performance ceiling achieved. The RL training dynamics (Figure 8, stable reward growth and entropy convergence) provide circumstantial support: if the base model lacked agentic inductive bias, the RL phase would likely exhibit higher instability as it attempted to learn both representation and policy simultaneously.

Significance beyond performance. Whether or not mid-training proves necessary (future work could potentially integrate agentic data directly into pretraining), the paper's framing of the problem β€” that agentic capability acquisition has a distinct representation-learning phase that should be separated from policy optimization β€” is conceptually valuable. It provides a language and diagnostic framework for understanding why previous agent training efforts have been unstable or plateaued early. It also suggests a research agenda: what exactly does mid-training teach? What data distributions are sufficient? Can the benefits be achieved through architectural innovations rather than an explicit training phase?

This is a fundamental contribution to training methodology, not an incremental recipe refinement, because it changes what phases we believe are necessary rather than just how we implement existing phases.

Innovation 2: Synthetic Data as a First-Class Engineering Principle, Not a Shortcut

The paper makes a strong conceptual argument β€” backed by an elaborate implementation β€” that synthetic data is intrinsically superior to human annotation for agent training, not merely a cost-saving substitute. This inverts the conventional wisdom that synthetic data is a stopgap until sufficient human-labeled data becomes available.

What the field assumed before this work. The standard hierarchy of training data quality places human annotation at the top: human experts provide the most reliable, nuanced, and diverse examples, while synthetic data is seen as noisy, potentially hallucinated, and requiring careful filtering to be useful. This assumption has driven massive investment in human annotation for LLM training (RLHF, constitutional AI, specialized domain annotation). For agent training specifically, the assumption manifests in the widespread belief that the difficulty of creating agent trajectories manually is a fundamental bottleneck β€” one to be reduced or circumvented, not embraced.

What the paper argues instead. Section 2 lists five explicit advantages of synthetic data over human annotation:

  1. Scale: Synthesizing research-level questions with LLMs is far more efficient than manual annotation β€” a claim supported by the paper's ability to generate datasets where "over 20% of samples exceed 32k tokens and involve more than 10 tool invocations" (Section 4.4), a scale that would be economically impossible with human annotators.

  2. Pattern diversity: LLMs "usually have rare insight into diverse patterns" for structuring hard problems, while training human annotators to understand and produce such patterns is time-consuming and expensive. The synthetic data engine can systematically vary difficulty through controlled operations (uncertainty injection, entity merging, scope expansion) in ways that would be difficult to specify as annotation guidelines.

  3. Targeted meta-capability enhancement: By decomposing complex agent tasks into fundamental meta-capabilities (planning, information synthesis, memory management), the paper can generate synthetic data that specifically targets and strengthens individual skills β€” a form of curriculum design that would be nearly impossible with human annotation, which tends to produce whole-task trajectories.

  4. Automatic verifiability: Synthetic data generated through the graph-based pipeline with set-theoretic formalization can be automatically verified for correctness, eliminating the quality assurance bottleneck that plagues human annotation at scale.

  5. Data flywheels: After one round of training, the improved model can generate synthetic data with "stronger reasoning and planning patterns," creating an iterative improvement cycle. This self-bootstrapping property is unique to synthetic data β€” human annotators do not become better annotators as a result of model improvement.

The paper's implementation makes this argument concrete through an elaborate synthesis pipeline that is not merely "prompt an LLM to generate questions" but involves graph construction via random walks, subgraph sampling, strategic uncertainty injection through atomic operations on entity relationships, a set-theoretic formal model for quality assurance, and a separate PhD-level question engine with iterative complexity escalation (Section 3.4.1). The sophistication of this pipeline β€” which the paper treats as a core contribution in its own right β€” demonstrates that synthetic data generation for agent training is a first-class research problem requiring its own methodology, not a trivial application of existing LLM capabilities.

Evidence. The main results (Table 1) demonstrate that models trained entirely on synthetic data can surpass proprietary systems on seven benchmarks. The scale and complexity statistics of the synthetic dataset (20% exceeding 32K tokens, 10+ tool invocations) provide quantitative evidence of the pipeline's output quality. The training stability metrics (Figure 8) show that RL on synthetic data produces stable, monotonically improving rewards without collapse β€” an indirect validation that the synthetic data provides consistent, learnable signal.

Significance beyond performance. This argument, if validated, has implications far beyond deep research agents. It suggests that for any task where:

  • The space of possible behaviors is combinatorially large
  • Manual annotation is prohibitively expensive per example
  • Correctness can be automatically verified
  • Diversity and coverage matter more than per-example precision

...synthetic data may be not just acceptable but preferable to human annotation. This reframes the research agenda from "how do we reduce our dependence on synthetic data?" to "how do we design synthetic data generation pipelines that maximize learning efficiency?" β€” a shift analogous to how the field moved from hand-crafted features to learned representations in other domains.

This is a fundamental reframing of the role of synthetic data in training, moving it from a practical compromise to a principled methodology with its own design space and optimality conditions.

Innovation 3: Environment as a Designed Component of Training, Not a Passive Constraint

The paper introduces a taxonomy of environments β€” Prior World, Simulated, and Real-world β€” and argues that the choice of environment at each training stage is a deliberate design decision that must be coupled to training objectives, not an external constraint to be accepted. This systematizes what is typically an ad-hoc aspect of agent research into a principled framework.

What the field assumed before this work. Most agent training work either:

  • Uses only real-world environments, accepting the noise, cost, and non-stationarity as inevitable (e.g., web agents that train by interacting with live websites)
  • Uses only simulated environments, accepting the sim-to-real gap as a necessary tradeoff for controllability (e.g., text-based game environments, synthetic web navigation tasks)
  • Does not explicitly consider environment choice as part of the methodology at all, treating it as infrastructure rather than a research variable

The implicit assumption is that environments are what they are β€” external systems that the agent learns to interact with β€” and that the researcher's job is to build agents robust enough to handle whatever the environment throws at them.

What the paper argues instead. The key conceptual move is in Section 2:

"Environments should not be passively viewed as external reality, but actively designed as systems deeply coupled with the training process."

This reframing treats environments as having a cost-fidelity-stability tradeoff surface that can be navigated strategically at each training stage:

  • Prior World Environment (zero interaction cost, perfect stability, no real feedback): useful for mid-training where scale matters more than feedback fidelity β€” the model can autonomously mine interaction trajectories from pretrained knowledge without incurring any API costs.
  • Simulated Environment (low cost, controllable, limited coverage): useful for rapid experimentation and algorithm validation β€” the "wind tunnel laboratory" analogy captures the idea that you can test designs under controlled conditions before exposing them to real-world turbulence.
  • Real-world Environment (authentic distribution, expensive, noisy): useful for final training and evaluation β€” but even here, the paper engineers stability through a unified sandbox with caching, retries, failover, and rate limiting.

The paper's concrete implementation demonstrates this philosophy at every training stage: Prior World + Simulated for mid-training (Section 3.3), Simulated (Wiki environment) for RL algorithm development and hyperparameter tuning (Section 3.4.3), and Real-world with fault-tolerant sandbox for final RL training (Section 3.4.3). The deployment of the simulated Wiki environment as a development platform is particularly notable β€” the paper reports that the reward curve from the simulated environment (Figure 10b) closely matches the real environment (Figure 8), validating the simulation's utility as a development proxy.

Evidence. Figure 10b shows the RL reward curve in the simulated Wiki environment, which the paper explicitly compares to Figure 8 (real environment) as evidence that "this Wiki simulation environment provides functionality analogous to a wind tunnel laboratory, enabling fast algorithm iteration and significantly improved our development efficiency." The unified sandbox's effectiveness is validated indirectly by the training stability in Figure 8 β€” the sustained monotonic reward improvement without sudden drops or instability is evidence that the sandbox successfully insulates training from environmental noise. The paper notes that "QPS impact significantly degrade our development efficiency and compromise the reliability during our early-stage ablation studies" (Section 3.4.3, footnote), providing a concrete before/after contrast for the sandbox's value.

Significance beyond performance. This contribution provides a vocabulary and framework for reasoning about environment design that applies across agent training domains. The three-tier taxonomy gives researchers a way to discuss tradeoffs that are typically implicit: "We're using a Simulated environment for this ablation because we need causal attribution, then validating in Real-world" is a more principled methodological statement than "we tested it in our simulator." The paper also implicitly argues that environmental engineering is a core research contribution, not just infrastructure work β€” a claim with implications for how agent research should be evaluated and resourced.

This is a methodological innovation rather than an algorithmic one. It does not propose a new algorithm or architecture, but systematizes a design space that previously lacked formal structure, enabling more deliberate and communicable research decisions about how agents interact with their training environments.

Innovation 4: The Primacy of Data and Environment Stability Over Algorithmic Sophistication in Agentic RL

The paper reports an empirically grounded finding that challenges a widespread assumption in the RL for language models literature: for agentic RL, success depends more on data quality and environmental stability than on the specific RL algorithm used. This is a negative result about the importance of algorithmic innovation relative to engineering fundamentals, and it has significant implications for where the community should invest research effort.

What the field assumed before this work. The rapid proliferation of RL algorithms for language models β€” PPO, DPO, GRPO, REINFORCE variants, each with their own clipping strategies, advantage estimators, and KL penalties β€” reflects an implicit assumption that algorithmic choice is a primary driver of training success. Papers proposing new RL algorithms typically demonstrate improvements over prior algorithms on benchmarks, reinforcing the narrative that better algorithms unlock better performance. The community's attention and publication incentives are disproportionately directed toward algorithmic innovation.

What the paper finds instead. Section 3.4.3 contains a striking statement:

"Through our experiments, we arrive at a critical insight: the success of agentic RL depends more on the quality of the data and the stability of the training environment than on the specific algorithm being used. Consequently, we concentrate our efforts on designing a stable environment and curating high-quality data, making only a few essential modifications to the algorithm itself, mainly for the purpose of stabilizing the training process."

The paper's adapted GRPO algorithm incorporates several modifications (token-level loss, clip-higher, leave-one-out advantage, negative sample filtering), but the authors explicitly frame these as "the pragmatic pursuit of a more efficient and stable training paradigm" rather than as algorithmic innovations. The substantive engineering effort went into: (1) the unified sandbox that wraps real-world tools with fault-tolerance; (2) the simulated Wiki environment for rapid experimentation; (3) the on-policy asynchronous rollout framework with separate inference and tool servers; and (4) the dynamic data curation system that maintains appropriate difficulty.

The implication is clear: if you have high-quality, appropriately-difficult training data and a stable, deterministic environment, a simple RL algorithm will work. If you have noisy data and an unstable environment, no amount of algorithmic sophistication will save you. This echoes Sutton's "Bitter Lesson" β€” general methods leveraging computation and data scale outperform specialized algorithmic complexity β€” but applied to the specific domain of agentic RL training.

Evidence. The training dynamics in Figure 8 provide primary evidence: reward increases monotonically over 500+ steps with stable entropy, and this stability is achieved using an algorithm the authors describe as having "only a few essential modifications" from standard GRPO. Figure 10b demonstrates that the same algorithm transfers effectively from simulated to real environments. The negative sample filtering ablation (Section 3.4.3) shows that "directly optimizing on an unfiltered set of negative rollouts significantly degrade training stability and can lead to policy collapse" β€” evidence that data filtering (an engineering concern) matters more than algorithmic details. The dynamic data curation system's design β€” monitoring training progress and refreshing the dataset when the reward plateaus β€” produces sustained improvement (Figure 8) without requiring algorithmic changes.

Significance beyond performance. This finding has direct implications for research resource allocation. If the bottleneck for agentic RL is data quality and environment stability, then:

  • Teams building agent training systems should invest in synthetic data pipelines and sandbox infrastructure rather than in developing novel RL algorithms.
  • Conference reviewing should value environment design and data curation as first-class research contributions, not as "just engineering."
  • The community's metric for evaluating RL algorithms should control for data quality and environmental stability, since these confound algorithmic comparisons.
  • The path to better agentic RL performance likely runs through better verifiers, more principled difficulty estimation, and more sophisticated data generation β€” not through more complex policy gradient estimators.

This is a diagnostic contribution β€” it identifies what actually matters for a class of problems based on empirical experience β€” rather than a positive algorithmic contribution. Its significance lies in redirecting research attention and resource allocation, similar to how scaling laws papers redirected attention from architectural innovation to compute-efficient training.

Innovation 5: Markovian State Reconstruction as a Scalable Alternative to Full-History Conditioning

The paper's Context Management paradigm β€” where the agent operates on a compressed summary rather than the full interaction history β€” represents a principled solution to the context-length bottleneck that differs fundamentally from the dominant approaches in the field (longer context windows, retrieval-augmented generation, or simple truncation). It treats context management not as a memory limitation to be worked around but as a learned cognitive skill that improves reasoning quality.

What the field assumed before this work. The standard response to long-horizon agent tasks has been to increase context window sizes β€” from 4K to 32K to 128K to 1M+ tokens β€” under the assumption that more context enables better reasoning. When context limits are hit, the typical fallback is either naive truncation (keeping the most recent N tokens and discarding the rest) or retrieval-based approaches (storing the full history in an external vector database and retrieving relevant segments). Both approaches treat the full history as the ground truth and the context limit as an unfortunate constraint. The implicit model is that an ideal agent would have unlimited context and perfect memory.

What the paper argues instead. The Context Management paradigm inverts this framing in two ways (Section 3.1):

First, it argues that compression is not a compromise but an active reasoning skill. By requiring the model to explicitly synthesize observations into a coherent report $S_t$ at each step, the paradigm enforces a form of deliberate reasoning: the model must decide what information matters, how it relates to the investigation, and what gaps remain. This mirrors how human researchers maintain a mental model of an investigation β€” not by memorizing every paper they've read, but by continuously updating a synthesized understanding. The paper argues this "naturally aligns with human research patterns, where periodic synthesis and reflection are essential for maintaining coherent long-term investigation."

Second, it provides a mechanism for test-time scaling through the Heavy Mode (Section 4.3). Because each parallel agent produces a compressed report $S_T$ rather than a full trajectory, the synthesis model can assess multiple diverse solution strategies within a manageable context window β€” something that would be "computationally prohibitive" with full trajectories, which could exceed context limits with "just 2-3 agents." The Context Management paradigm thus enables a form of ensemble reasoning that scales with the number of parallel agents without the quadratic context explosion that aggregating full trajectories would impose.

Evidence. The Heavy Mode results (Figure 6) demonstrate the practical value: Tongyi DeepResearch with Heavy Mode achieves 38.3% on Humanity's Last Exam (vs. 32.9% standard), 58.3% on BrowseComp (vs. 43.4%), and 58.1% on BrowseComp-ZH (vs. 46.7%). These gains come entirely from test-time scaling β€” running multiple parallel agents and synthesizing their compressed reports β€” and would not be feasible without the Context Management paradigm's compact report representation. The interaction scaling curve (Figure 10a) shows that performance on BrowseComp improves consistently as context length and number of interactions grow, validating that the Context Management approach enables productive use of extended contexts rather than just tolerating them.

Significance beyond performance. This contribution challenges the "more context is better" assumption that has driven much of the long-context language model research. It suggests that structured, learned compression may be superior to exhaustive memory for tasks requiring synthesis across diverse information β€” not just more efficient, but actually producing better reasoning by forcing explicit prioritization. This has implications for agent design beyond deep research: any agentic task requiring long-horizon reasoning could potentially benefit from learned state compression rather than full-context conditioning. It also connects to broader cognitive science questions about how humans manage complex investigations β€” suggestive evidence that the Markovian state reconstruction approach captures something about effective reasoning that raw memory does not.

This is a conceptual and architectural innovation. It does not propose a new compression algorithm but rather identifies a design pattern β€” learnable, task-aware state summarization as an integral part of the agent's policy β€” that has implications for how future agents should structure their internal state management.

5. Experimental Analysis

Evaluation Methodology

  • Dataset. The paper evaluates on seven public information-seeking benchmarks: Humanity's Last Exam (2,154 text-only questions; Phan et al., 2025), BrowseComp (1,266 examples; Wei et al., 2025), BrowseComp-ZH (289 examples; Zhou et al., 2025), GAIA (full validation set, 166 examples; Mialon et al., 2023), xbench-DeepSearch (100 examples; Xbench Team, 2025), WebWalkerQA (680 examples; Wu et al., 2025b), and FRAMES (Krishna et al., 2025). An additional benchmark, xbench-DeepSearch-2510 (100 examples), is evaluated later on October 28, 2025. The benchmarks span both English and Chinese tasks, covering long-term reasoning and long-horizon tool use.

  • Base model(s). The model is built on Qwen3-30B-A3B-Base (Yang et al., 2025), a Mixture-of-Experts architecture with 30.5 billion total parameters and only 3.3 billion activated per token. The paper does not train or evaluate on any other base model family or scale β€” all results are from this single architecture. The choice is motivated by a belief that "training agentic capabilities on relatively small models is highly valuable" for deployment efficiency and accessibility (Section 5.2).

  • Metrics. The primary metric is Average@3: each benchmark is evaluated three times independently with fixed inference parameters, and the mean accuracy across these three runs is reported. For completeness, the paper also reports Pass@1 (best single result over the three runs) and Pass@3 (whether any of the three runs yields the correct answer). All scores are computed using each benchmark's official evaluation scripts. For GAIA and WebWalkerQA, Qwen2.5-72B-Instruct serves as the judging model following Li et al. (2025d); for xbench-DeepSearch and xbench-DeepSearch-2510, Gemini-2.0-Flash-001 is the judge; for BrowseComp and BrowseComp-ZH, GPT-4o-2024-08-06 judges; for Humanity's Last Exam, o3-mini evaluates following Chai et al. (2025). For AIME25 and HMMT25, manual evaluation is used due to small dataset size. For SimpleQA, the official evaluation script is used.

  • Baselines. The paper compares against two families of systems. LLM-based ReAct agents: GLM-4.5 (Zeng et al., 2025), Kimi-K2 (Team et al., 2025), DeepSeek-V3.1 (DeepSeek Team, 2025), Claude-4-Sonnet (anthropic, 2025), OpenAI o3 and o4-mini (OpenAI, 2025b). End-to-end deep-research agents: OpenAI DeepResearch (OpenAI, 2025a), Gemini DeepResearch (Gemini Team, 2025), Kimi Researcher (Kimi, 2025). For xbench-DeepSearch-2510, additional baselines include ChatGPT-5-Pro, SuperGrok, Doubao Deep Research, Manus Agent, and Minimax Agent. Baseline scores are taken from each benchmark's official leaderboard or published results; the paper does not independently re-evaluate any baseline system.

  • Generation budget / compute accounting. The paper does not use a standardized compute metric (e.g., FLOPs, inference tokens) to compare against baselines. For its own evaluations, the constraint is operational rather than computational: a maximum of 128 tool invocations per task and a context length of 128K tokens. Inference uses fixed parameters: temperature = 0.85, repetition penalty = 1.1, top-p = 0.95. For Heavy Mode (Section 4.3), the paper deploys n parallel agents and a synthesis model, but does not specify n, the total inference compute consumed, or how the compute cost compares to the standard mode. For RL training, compute is measured implicitly through training steps (500+ steps visible in Figure 8), but no total FLOPs, GPU-hours, or wall-clock time for training is reported. This makes direct efficiency comparisons with baselines impossible β€” we know the model activates fewer parameters per token, but we do not know total inference compute per task or total training compute.

  • Cross-validation / statistical protocol. No cross-validation, statistical significance testing, or confidence intervals are reported for any benchmark result. The three-run evaluation provides some measure of variance, and the paper notes in Section 4.4 that "despite the unstable evaluation environment, our final Avg@3 results are consistent with the Pass@1 results," suggesting that score variance across runs is modest. However, no quantitative variance metrics (standard deviation, standard error, min/max) are reported. For the RL training dynamics (Figure 8), no replicates with different random seeds are shown, so we cannot assess whether the monotonic reward improvement and entropy stability are robust to initialization.

Main Quantitative Results

Benchmark Performance (Table 1, Figure 1)

Tongyi DeepResearch achieves the highest scores on nearly all evaluated benchmarks among open-source and proprietary systems. The headline Average@3 results are:

BenchmarkTongyi DeepResearch (30B-A3B)Best Proprietary Competitor (score)
Humanity's Last Exam32.9OpenAI DeepResearch (26.6)
BrowseComp43.4OpenAI DeepResearch (51.5) ← higher than Tongyi
BrowseComp-ZH46.7OpenAI DeepResearch (42.9)
GAIA70.9Claude-4-Sonnet (68.3)
xbench-DeepSearch75.0Kimi Researcher (69.0)
WebWalkerQA72.2OpenAI o3 (71.7)
FRAMES90.6OpenAI o3 (84.0)

On six of seven benchmarks, Tongyi DeepResearch ranks first. The exception is BrowseComp, where it scores 43.4 versus OpenAI DeepResearch's 51.5 β€” a gap of 8.1 percentage points. On Humanity's Last Exam, the margin over the next-best system (OpenAI DeepResearch at 26.6) is 6.3 percentage points in Tongyi's favor. On FRAMES, the margin over OpenAI o3 (84.0) is 6.6 percentage points.

Among LLM-based ReAct agents, the strongest competitor varies by benchmark β€” DeepSeek-V3.1 achieves 29.8 on HLE and 49.2 on BrowseComp-ZH, OpenAI o3 achieves 71.7 on WebWalkerQA, and Claude-4-Sonnet achieves 68.3 on GAIA β€” but none consistently ranks second across all benchmarks.

On xbench-DeepSearch-2510 (evaluated on October 28, 2025, separately from the other benchmarks evaluated on September 16, 2025), Tongyi DeepResearch ranks second with a score described qualitatively as "75+," behind ChatGPT-5-Pro (also "75+") but ahead of SuperGrok ("55+"), Doubao Deep Research ("40+"), Manus Agent ("35+"), and Minimax Agent ("35+"). The paper uses approximate ranges (75+, 55+, etc.) rather than exact scores for this benchmark, making precise comparison infeasible.

Heavy Mode Results (Figure 6)

The Heavy Mode β€” which deploys n parallel agents following the Context Management paradigm and synthesizes their compressed reports β€” yields substantial improvements over the standard (single-agent) mode:

BenchmarkStandard ModeHeavy ModeAbsolute Gain
Humanity's Last Exam32.938.3+5.4
BrowseComp43.458.3+14.9
BrowseComp-ZH46.758.1+11.4

On BrowseComp, Heavy Mode (58.3) surpasses OpenAI DeepResearch (51.5) by 6.8 percentage points. On BrowseComp-ZH, Heavy Mode (58.1) surpasses OpenAI DeepResearch (42.9) by 15.2 percentage points. On Humanity's Last Exam, Heavy Mode (38.3) extends the lead over OpenAI DeepResearch (26.6) to 11.7 percentage points.

The paper does not report how many parallel agents n are used in Heavy Mode, what the synthesis model is (presumably a separate model from the research agent), or the total compute cost relative to standard mode. The key architectural claim β€” that compressed reports enable synthesis of multiple trajectories that would exceed context limits with full trajectories β€” is asserted but not empirically quantified (e.g., there is no ablation showing degradation when attempting to synthesize full trajectories).

Pass@1 and Pass@3 Analysis (Figure 7)

The paper reports a finer-grained analysis beyond Average@3, showing Pass@1 (best result over 3 runs) and Pass@3 (any correct over 3 runs) for six benchmarks. The key numbers:

BenchmarkAvg@3Pass@1Pass@3
HLE32.933.445.9
BrowseComp43.444.259.6
BrowseComp-ZH46.748.463.7
WebWalkerQA72.272.982.8
xbench-DeepSearch73.076.086.0
GAIA70.972.785.5

The consistent proximity of Avg@3 and Pass@1 scores (differences of 0.5–3.0 percentage points) suggests low variance across the three evaluation runs, which the paper interprets as demonstrating "the robustness of our deep research approach." The substantially higher Pass@3 scores reveal significant unrealized potential: on BrowseComp, the model gets the answer right in at least one run 59.6% of the time but averages only 43.4% β€” suggesting that test-time selection mechanisms (beyond the three-run average) could recover substantial additional performance. On HLE, the gap between Pass@3 (45.9) and Avg@3 (32.9) is 13.0 percentage points, the largest relative gap among the benchmarks.

Training Dynamics: Reward and Entropy (Figure 8)

The RL training process over approximately 500 steps shows:

  • Reward (left panel): A clear monotonic upward trend from approximately 0.45 to 0.65 (both original and EMA-smoothed curves shown). The sustained improvement over the full training horizon is attributed to the dynamic data curation system, which "prevents learning from stagnating by consistently providing challenging material." No plateau is visible within the 500-step window, suggesting further training might yield additional gains.

  • Entropy loss (right panel): An initial brief increase (from approximately 0.2 to 0.6) followed by convergence to a stable value around 0.6–0.7 for the remainder of training. The paper interprets this as evidence for "exceptional stability," noting that it "avoids both collapse and explosion." The stable entropy regime coincides with the period of sustained reward improvement, suggesting the policy is learning effectively without mode collapse.

The absence of replicates means we cannot assess whether the specific shape of these curves (the exact slope of improvement, the entropy convergence value) is robust to different random seeds.

Context Length Scaling in RL (Figure 9)

Three models with different context length limits (32K, 48K, 64K) are trained using the same dynamic data curriculum, where the curriculum is populated by problems deemed moderately difficult by the 64K model. The findings:

  • Reward (left panel): All three models show effective and stable learning with monotonically increasing reward, confirming robustness of the training framework to context length variation. However, performance ceilings diverge: the 64K model achieves the highest reward (approximately 0.62 at step 350), the 48K model reaches approximately 0.45, and the 32K model reaches approximately 0.42. The paper attributes this hierarchy to curriculum mismatch β€” many problems in the curriculum, having been selected as moderately difficult for the 64K model, inherently require long reasoning that shorter-context models simply cannot accommodate.

  • Average response length (right panel): The 64K model shows a steady increase in response length over training (from approximately 18,000 to 33,000 tokens), learning to leverage its expanded context. The 48K model maintains approximately constant response length (around 22,000 tokens) throughout training. The 32K model displays a clear downward trend (from approximately 22,000 to 16,000 tokens). The paper interprets this as the 32K model discovering "more concise, potent action sequences that fit within its limit" in response to the implicit pressure from the curriculum β€” since problems whose solutions exceed 32K tokens will yield zero reward, the model is incentivized to find shorter solution paths.

This finding is notable because it demonstrates that RL training with a curriculum designed for a more capable model can produce unanticipated positive effects on less capable models β€” forced efficiency rather than mere performance degradation.

Interaction Test-Time Scaling (Figure 10a)

Performance on BrowseComp is evaluated at context lengths of 8K, 16K, 32K, 64K, and 128K (which correspond to increasing numbers of environment interaction turns). The accuracy curve shows consistent improvement as context and interactions grow: approximately 12.5% at 8K, rising to approximately 50% at 128K. The curve does not show obvious saturation or diminishing returns within the evaluated range, suggesting further scaling of interactions might continue to yield improvements. The paper presents this as evidence that "our approach scales along a different dimension, the number of environment interactions" compared to reasoning models that scale by increasing output tokens.

Synthetic Data Scale and Complexity (Section 4.4)

The paper reports statistics on the SFT dataset without a dedicated figure: "over 20% of the samples exceed 32k tokens and involve more than 10 tool invocations." This is presented as evidence of the synthetic data pipeline's ability to generate complex, multi-step trajectories. No comparative statistics are provided for human-annotated agent datasets, so the claim that this represents "super-human level" data cannot be quantitatively assessed against human baselines.

Simulated vs. Real Environment Validation (Figure 10b)

The adapted GRPO algorithm is tested in the simulated Wiki environment before deployment to the real environment. The reward curve in the simulated environment (Figure 10b) shows monotonically increasing reward from approximately 0.45 to 0.85 over 300 steps. The paper claims this "closely matches the one observed in the real environment" (Figure 8), validating the simulation as a development proxy. However, the real environment curve spans approximately 500 steps and reaches approximately 0.65, while the simulated curve spans 300 steps and reaches approximately 0.85 β€” the absolute reward values and training horizons differ, making the claimed "close match" imprecise. The paper does not compute correlation or any quantitative similarity metric between the two curves.

General Benchmark Performance (Figure 11)

Tongyi DeepResearch is evaluated on three general benchmarks β€” AIME25 (30 math problems), HMMT25 (30 math problems), and SimpleQA (4,326 knowledge questions) β€” and compared against two reasoning-only variants of the same base architecture: Qwen3-30B-A3B-Thinking-2507 and Qwen3-235B-A22B-Thinking-2507. Results:

BenchmarkTongyi DeepResearch (30B-A3B)30B Reasoning235B Reasoning
AIME2585.071.492.3
HMMT2519.2N/AN/A
SimpleQA47.1N/AN/A

On SimpleQA, Tongyi DeepResearch (47.1) substantially outperforms the 30B reasoning model (19.2), demonstrating that web search and tool use provide information that reasoning alone cannot access. On AIME25, Tongyi DeepResearch (85.0) outperforms the 30B reasoning model (71.4) by 13.6 points, attributed to Python Interpreter enabling computational verification. However, the much larger 235B reasoning model (92.3) still surpasses Tongyi DeepResearch on AIME25 by 7.3 points, suggesting that for pure mathematical reasoning, model scale provides capability that tool use cannot fully substitute for.

The fact that HMMT25 and SimpleQA scores for the 30B and 235B reasoning models are "N/A" (only reported for Tongyi DeepResearch for HMMT25, and only the 30B reasoning and Tongyi DeepResearch for SimpleQA) makes the comparison incomplete β€” we cannot see how the larger reasoning model performs on these benchmarks.

Ablation Studies and Robustness Checks

Context length limit during RL training (Figure 9): Models with 32K, 48K, and 64K context limits all achieve stable training, but performance ceilings diverge substantially (64K reaches ~0.62, 48K reaches ~0.45, 32K reaches ~0.42). The 32K model exhibits a counterintuitive efficiency gain β€” its average response length decreases over training β€” attributed to implicit pressure from a curriculum designed for the 64K model. This is a non-trivial finding: constrained models can discover more efficient strategies when trained on curricula that exceed their capacity limits.

Simulated vs. real environment validation (Figures 8, 10b): The adapted GRPO algorithm trained in the simulated Wiki environment produces a reward curve that the paper claims "closely matches" the real environment curve. However, absolute reward values (0.45β†’0.85 in simulation vs. 0.45β†’0.65 in real) and training horizons (300 vs. 500 steps) differ, and no quantitative similarity metric is reported. The validation is suggestive but not rigorous.

Negative sample filtering in RL (Section 3.4.3): The paper reports that "directly optimizing on an unfiltered set of negative rollouts significantly degrade training stability and can lead to policy collapse after extended training." This is presented as an empirical observation rather than a formal ablation β€” no figure or table compares filtered vs. unfiltered training. The specific filtering criterion (excluding rollouts that exceed a length limit without producing a final answer) is described but its quantitative impact on training dynamics is not shown.

Format reward exclusion (Section 3.4.3): The paper deliberately excludes a format reward (e.g., 0.1 for producing a correctly formatted answer), arguing that the SFT cold-start phase "ensures the model is already familiar with the required output format." No ablation comparing training with and without format reward is provided to validate this claim.

Model merging (Section 3.4.4): The paper describes merging multiple model variants through weighted parameter averaging but provides no ablation comparing the merged model against individual variants, no analysis of how many variants were merged, what weights were used, or how variant diversity was achieved. The claim that the merged model "performs comparably to the best-performing source model in its respective area of strength" is presented without supporting data.

Pass@3 as upper-bound analysis (Figure 7): While not an ablation in the traditional sense, the Pass@3 results serve as a robustness check revealing significant headroom: the gap between Pass@3 and Avg@3 ranges from 3.4 points (BrowseComp-ZH: 63.7 - 46.7 = 17.0? No, wait β€” let me re-examine: Pass@3=63.7, Avg@3=46.7, gap=17.0) to 14.5 points (GAIA: 85.5 - 70.9 = 14.6) across benchmarks. This demonstrates that the single-run performance substantially understates what the model could achieve with better test-time selection mechanisms, but the paper does not propose or evaluate such mechanisms beyond the Heavy Mode synthesis approach.

General benchmark evaluation (Figure 11): This serves as an out-of-distribution robustness check, showing that the agentic training preserves and in some cases enhances performance on standard benchmarks (SimpleQA improvement from 19.2 to 47.1 via tool use). However, the incomplete reporting of baselines (missing HMMT25 for reasoning models, missing SimpleQA for 235B reasoning model) weakens the comparison.

Critical Assessment

Claim 1: "Tongyi DeepResearch achieves state-of-the-art results across a range of agentic deep research benchmarks."

Supported, with an important caveat. Table 1 demonstrates that Tongyi DeepResearch achieves the highest Average@3 scores on 6 of 7 benchmarks. However, the caveat is BrowseComp, where OpenAI DeepResearch (51.5) substantially outperforms Tongyi DeepResearch (43.4) in standard mode β€” a gap of 8.1 percentage points. The Heavy Mode partially addresses this (58.3 vs. 51.5), but Heavy Mode uses unspecified additional test-time compute (parallel agents + synthesis model), making it an asymmetric comparison β€” we do not know what OpenAI DeepResearch could achieve with equivalent test-time scaling, since OpenAI's system is closed-source and its test-time compute budget is unknown. The paper's claim to "surpass strong proprietary systems" is true in aggregate but elides the BrowseComp gap in standard mode.

Additionally, the baseline scores are taken from official leaderboards and published results, not from independent re-evaluation under identical conditions (same hardware, same API latency, same date). Environmental factors β€” search engine results changing over time, API availability, page content updates β€” could confound cross-system comparisons. The paper acknowledges "unstable evaluation environment" (Section 4.4) as a general challenge, and the fact that xbench-DeepSearch-2510 was evaluated on a different date (October 28, 2025) than the other benchmarks (September 16, 2025) illustrates the temporal sensitivity of these evaluations. Without contemporaneous re-evaluation of all baselines on the same dates, we cannot rule out the possibility that some performance differences are attributable to environmental changes rather than model capability.

Claim 2: "Agentic capabilities can be effectively cultivated through a training paradigm that integrates mid-training as a bridge between pretraining and post-training."

Plausible but not directly tested. The paper does not include an ablation comparing the full pipeline (mid-training + post-training) against a pipeline that applies post-training directly to the base model without mid-training. Without this ablation, we cannot attribute any performance gains to mid-training specifically β€” the observed performance could be entirely due to the SFT and RL phases, or to the synthetic data quality, or to the environmental engineering. The paper's argument for mid-training is conceptual and diagnostic (Section 2), not empirical. The RL training stability (Figure 8) is consistent with the hypothesis that mid-training provides a beneficial inductive bias, but stability could also be explained by the SFT cold-start, the negative sample filtering, the dynamic data curation, or the sandbox infrastructure β€” all of which are present in the pipeline and could independently contribute to stability. The paper does not isolate mid-training's contribution from these other factors.

This is the most significant missing experiment in the paper. Given that the paper's central methodological claim is the importance of mid-training, the absence of a direct mid-training ablation is a substantial gap. An experiment comparing Qwen3-30B-A3B-Base + mid-training + post-training vs. Qwen3-30B-A3B-Base + post-training only, with all other factors (synthetic data, SFT protocol, RL algorithm, environment design) held constant, would be the minimum evidence needed to support the claim.

Claim 3: "Synthetic data serves as the scalable engine, with environmental stability proving more critical than algorithmic sophistication."

Partially supported. The synthetic data pipeline's effectiveness is demonstrated indirectly through the benchmark results β€” the model trained on synthetic data achieves state-of-the-art performance, and the dataset statistics (20% of samples >32K tokens, 10+ tool invocations) demonstrate scale. However, the paper does not compare synthetic data against any alternative data source. There is no experiment showing that synthetic data outperforms human-annotated data, or that the specific synthesis strategies (graph-based construction, uncertainty injection, set-theoretic formalization) outperform simpler alternatives (e.g., prompting a strong LLM to generate questions and answers without the formal scaffolding). The claim that synthetic data is "intrinsically superior" (Section 2) to human annotation remains an untested assertion rather than an empirically validated finding.

The claim about environmental stability over algorithmic sophistication is supported by the training dynamics (Figure 8) and the authors' description of their methodology β€” they "concentrate our efforts on designing a stable environment and curating high-quality data, making only a few essential modifications to the algorithm itself." However, this is presented as an insight derived from their experiments, not as a controlled comparison. There is no experiment showing that a simpler RL algorithm (e.g., vanilla REINFORCE) would perform equally well given the same data and environment, or that a more complex algorithm (e.g., PPO with a learned value function) would fail to provide additional benefit. The claim is a qualitative lesson from engineering experience rather than a quantitative finding.

Claim 4: "Test-time scaling through Heavy Mode enables further performance gains via parallel exploration and intelligent aggregation."

Supported, with incomplete reporting. Figure 6 demonstrates substantial gains from Heavy Mode across three benchmarks: +5.4 on HLE, +14.9 on BrowseComp, +11.4 on BrowseComp-ZH. The mechanism β€” parallel agents producing compressed reports that are synthesized by a separate model β€” is clearly described. However, critical details are missing: the number of parallel agents n, the identity and scale of the synthesis model, the total compute cost of Heavy Mode relative to standard mode, and whether the synthesis model was specifically trained for this task or is a general-purpose model. Without these details, the Heavy Mode results are difficult to interpret or reproduce. Is the gain coming from the diversity of parallel exploration, from the synthesis step, or simply from increased total compute? Could a single agent with equivalent total compute achieve similar gains? These questions are unanswered.

Additionally, Heavy Mode is evaluated on only three benchmarks (HLE, BrowseComp, BrowseComp-ZH). Results on the other four benchmarks (GAIA, xbench-DeepSearch, WebWalkerQA, FRAMES) are not reported, so we don't know whether the gains generalize or whether Heavy Mode was selectively evaluated only where it helped.

The missing efficiency analysis

The paper repeatedly emphasizes efficiency β€” 3.3B activated parameters, smaller models for deployment β€” but provides no quantitative efficiency analysis. We do not know the total inference compute per task (FLOPs or tokens) for Tongyi DeepResearch versus baseline systems. We do not know the total training compute (GPU-hours). We do not know the cost of the synthetic data pipeline. The comparison is purely on accuracy β€” Tongyi DeepResearch achieves higher accuracy while activating fewer parameters per token, but this tells us nothing about total inference cost because parameter count per token does not capture total tokens generated, which varies with interaction depth. A model that activates 3.3B parameters per token but generates 100K tokens per task may consume more total compute than a model that activates 100B parameters but generates only 10K tokens. Without total tokens or FLOPs per task, the efficiency claim is suggestive but unquantified.

The missing mid-training ablation (revisited)

Beyond the claim about mid-training's importance, the two-stage Agentic CPT design (32K β†’ 128K context) is presented as "strategically optimized for both efficiency and progressive capability scaling" (Section 3.3.1), but no ablation compares this two-stage design against a single-stage 128K approach, or against alternative context length sequences. We don't know whether the two-stage progression provides benefits over directly training at 128K, or whether the specific transition point (32K β†’ 128K) is optimal versus alternatives.

The missing data synthesis ablation

The paper describes an elaborate synthetic data pipeline with multiple components (graph construction, subgraph sampling, uncertainty injection, set-theoretic formalization, PhD-level question engine), but provides no ablation studying which components matter for downstream performance. Would a simpler pipeline β€” prompting a strong LLM to generate questions and using web search to verify answers β€” achieve comparable results? The paper's claim that the formal machinery (uncertainty injection, set theory) is important for data quality is asserted but not tested.

Single model family and architecture

All experiments use a single base model (Qwen3-30B-A3B-Base). We do not know whether the training methodology transfers to other architectures (dense models, other MoE configurations, other model families). The paper claims the methodology is general, but provides no evidence beyond this single instantiation.

Summary

The paper provides convincing evidence that its complete training pipeline produces a model that achieves strong benchmark performance β€” often the best among both open-source and proprietary systems. However, the paper's more ambitious claims β€” about the necessity of mid-training, the superiority of synthetic data to human annotation, the primacy of environmental stability over algorithmic sophistication, and the efficiency advantages of smaller models β€” are asserted based on the pipeline's overall success rather than isolated through controlled experiments. The most important missing experiments are: (1) a mid-training vs. no-mid-training ablation; (2) a synthetic data vs. alternative data source comparison; (3) a total compute accounting (training + inference) enabling efficiency claims to be verified; and (4) evaluation of Heavy Mode on all benchmarks rather than a subset. The paper's primary contribution is therefore better characterized as demonstrating that a carefully engineered training pipeline can produce state-of-the-art deep research capability, rather than isolating which components of that pipeline are necessary or sufficient.

6. Limitations and Trade-offs

6.1 The Mid-Training Claim Is Not Empirically Validated

The assumption or constraint. The paper's central methodological claim is that agentic mid-training is an essential phase that bridges pretraining and post-training, without which "sub-optimal outcomes and inherent optimization conflicts" arise (Section 2). The paper states that general foundation models "lack agentic inductive bias" and that mid-training "endows the pre-trained base model with substantial agentic prior knowledge" (Section 2). The entire training pipeline is structured around this assumption β€” mid-training is not presented as an optional enhancement but as a necessary architectural phase.

The consequence. Without a direct ablation comparing the full pipeline (mid-training + post-training) against a pipeline that applies post-training directly to the base Qwen3-30B-A3B model, we cannot determine whether mid-training contributes anything to the final performance. The observed state-of-the-art results could be entirely attributable to the SFT and RL phases, the quality of the synthetic data, the environmental engineering (unified sandbox, simulated Wiki environment), or the dynamic data curation β€” all of which are present in the pipeline and could independently explain the model's success. A practitioner implementing a deep research agent faces a consequential decision: invest substantial compute in a mid-training phase with large-scale agentic data synthesis (Section 3.3.2 describes four distinct data generation components β€” question synthesis, planning actions, reasoning actions, decision-making actions β€” plus environment-scaling for function-calling data), or allocate that compute to more post-training data and RL steps. The paper provides no evidence to guide this decision.

The two-stage Agentic CPT design (32K context β†’ 128K context, with long-sequence agentic data introduced in stage 2) is presented as "strategically optimized for both efficiency and progressive capability scaling" (Section 3.3.1), but no ablation compares this against a single-stage 128K approach. We do not know whether the two-stage progression provides benefits over directly training at the full context length, or whether the specific transition point (32K β†’ 128K) is optimal.

What evidence exists in the paper. None. The paper contains no experiment that isolates mid-training's contribution from the rest of the pipeline. The RL training dynamics (Figure 8, showing stable reward growth and entropy convergence) are consistent with the hypothesis that mid-training provides a beneficial inductive bias, but stability could equally be explained by the SFT cold-start phase (which "establishes a stable behavioral baseline," Section 3.4.2), the negative sample filtering (Section 3.4.3), the dynamic data curation (Section 3.4.3), or the unified sandbox that "insulates the training loop from real-world stochasticity" (Section 3.4.3). All of these are present simultaneously, and their individual contributions are not isolated.

Mitigation status. The paper does not acknowledge this as a limitation, does not propose a mid-training ablation experiment, and does not discuss alternative hypotheses for why the pipeline succeeds. The absence of this experiment is particularly notable given that mid-training is the paper's most distinctive methodological claim relative to prior work β€” the paper explicitly states that "most work only applies post-training phase for DeepResearch agents" while "we novelly introduce mid-training for agentic learning" (Section 2). The claimed novelty makes the missing evidence more consequential, not less.

6.2 Efficiency Claims Are Unquantified and Potentially Misleading

The assumption or constraint. The paper repeatedly emphasizes efficiency as a core contribution: the model activates "only 3.3 billion parameters per token" (Abstract), the choice of a smaller model is motivated by the argument that "smaller models are inherently more efficient to deploy on edge devices, broaden accessibility across diverse real-world scenarios, and deliver faster, more responsive interactions" (Section 5.2), and the paper positions itself as demonstrating "a new state-of-the-art with substantially fewer parameters" (Section 1). The efficiency framing pervades the paper's narrative.

The consequence. Parameter count per token is not a valid efficiency metric for agentic systems. An agent that activates 3.3B parameters per token but generates 100K tokens per task (through extensive web searching, visiting dozens of pages, running Python code, and producing a long synthesis report) may consume substantially more total inference compute than a model that activates 100B parameters but completes the same task in 10K tokens. The paper provides no information about total inference tokens generated per task, total FLOPs per task, or total wall-clock time per task β€” for Tongyi DeepResearch or for any baseline system. The fixed constraint of "a maximum of 128 tool invocations" and "128K context length" (Section 4.1) provides an upper bound but no information about typical consumption. Without total compute accounting, statements about efficiency and deployment viability are unverifiable.

The Heavy Mode results (Section 4.3) exacerbate this gap. Heavy Mode uses an unspecified number of parallel agents n, each independently conducting research and producing compressed reports, plus a separate synthesis model. The gains over standard mode (+5.4 on HLE, +14.9 on BrowseComp, +11.4 on BrowseComp-ZH, Figure 6) are presented without any accounting of the additional compute cost. A practitioner cannot determine whether the Heavy Mode gains are cost-effective β€” if Heavy Mode consumes 10Γ— more compute for a 14.9-point gain, the tradeoff may or may not be worthwhile depending on the application, but the paper provides no basis for making that judgment.

The training compute is also unreported. Figure 8 shows approximately 500 RL training steps, but we do not know the total GPU-hours, the number of rollouts per step, the cost of generating the synthetic data (which involves running large models through elaborate graph construction, subgraph sampling, and uncertainty injection pipelines; Section 3.4.1), or the cost of the mid-training phase with its two-stage Agentic CPT and large-scale behavior data synthesis. The difficulty estimation for dynamic data curation β€” continuously sampling from the full dataset with intermediate policy checkpoints to identify moderately difficult problems (Section 3.4.3) β€” consumes additional inference compute that is not accounted for anywhere.

What evidence exists in the paper. Only the activated parameter count (3.3B) is provided as a quantitative efficiency metric. The interaction scaling curve (Figure 10a) shows that performance improves with context length and interaction count, indirectly suggesting that the model uses substantial compute per task (achieving ~50% accuracy at 128K context). The dataset statistics β€” "over 20% of the samples exceed 32k tokens and involve more than 10 tool invocations" (Section 4.4) β€” hint at the scale of trajectories during training. But none of this is organized into a systematic efficiency comparison against baselines. We do not know whether Tongyi DeepResearch is more or less compute-efficient than OpenAI DeepResearch, DeepSeek-V3.1, or any other baseline β€” only that it activates fewer parameters per token.

Mitigation status. The paper does not acknowledge this as a limitation. Section 5.2 ("Model Scale") argues that "training agentic capabilities on relatively small models is highly valuable" and cites smaller models' benefits for edge deployment, accessibility, and faster interactions β€” but these benefits depend on total compute consumption, not just per-token parameter count. The paper does not propose future work on efficiency measurement or suggest that efficiency comparisons require total compute accounting.

6.3 The Synthetic Data Claims Are Untested Against Alternatives

The assumption or constraint. The paper makes a strong claim about synthetic data: it is not merely a cost-saving substitute for human annotation but is "intrinsically superior" along multiple dimensions β€” scalability, pattern diversity, targeted capability enhancement, automatic verifiability, and data flywheel potential (Section 2). The synthesis pipeline is elaborate, involving graph construction via random walks, subgraph sampling, strategic uncertainty injection through "atomic operations" on entity relationships, a set-theoretic formal model for quality assurance, and a separate PhD-level question engine with iterative complexity escalation (Section 3.4.1). The paper treats this pipeline as a core contribution and presents the resulting model's benchmark performance as validation of the synthetic data approach.

The consequence. Without a comparison against any alternative data source β€” human-annotated trajectories, trajectories generated by simpler prompting strategies, or even synthetic data generated by a different (less elaborate) pipeline β€” we cannot determine whether the sophistication of the synthesis pipeline matters. The state-of-the-art benchmark results demonstrate that the pipeline produces sufficiently good data to train a capable agent, but they do not demonstrate that this specific pipeline produces better data than alternatives. A practitioner deciding whether to invest in building a graph-based question generation system with uncertainty injection and set-theoretic formalization β€” versus simply prompting a strong LLM to generate questions and using web search to verify answers β€” receives no guidance from this paper.

The claim that synthetic data enables "targeted meta-capability enhancement" by decomposing agent tasks into fundamental skills (Section 2) is particularly undersupported. The paper describes generating separate data for planning, reasoning, and decision-making (Section 3.3.2), but provides no ablation showing that this decomposition matters β€” would training on a comparable volume of unspecialized agent trajectories achieve the same result? The paper also claims synthetic data enables "data flywheels" where improved models generate improved training data, but the ReST^EM experiment described in the prior analysis (where the omission was noted) is not presented in the paper itself, and no iterative training results are reported.

The dataset complexity statistics β€” "over 20% of the samples exceed 32k tokens and involve more than 10 tool invocations" (Section 4.4) β€” demonstrate scale but not quality relative to alternatives. Human-annotated agent datasets of comparable size do not exist in the open literature, making direct comparison infeasible, but the paper could have compared against simpler synthetic baselines (e.g., prompting GPT-4 to generate questions and trajectories, then filtering by answer verifiability).

What evidence exists in the paper. Only the downstream benchmark performance and the scale statistics. There are no experiments comparing synthetic data quality against human-annotated data, against simpler synthetic data generation strategies, or against ablations that remove specific components of the synthesis pipeline (no graph construction, no uncertainty injection, no set-theoretic formalization, no PhD-level question engine). The paper's claim that synthetic data is "intrinsically superior" to human annotation remains an untested assertion.

Mitigation status. The paper does not acknowledge this as a limitation. The synthetic data advantages are listed in Section 2 as design principles rather than as hypotheses to be tested. The paper does not propose comparisons against alternative data sources as future work.

6.4 Heavy Mode Is Evaluated on Only Three of Seven Benchmarks with Unspecified Compute Cost

The assumption or constraint. Heavy Mode is presented as a test-time scaling mechanism that "further unlocks the potential of deep research agents" (Section 4.3). It operates by deploying n parallel agents, each following the Context Management paradigm and producing a compressed report, then having a synthesis model consolidate all reports into a final answer. The paper claims that "the key advantage of this approach lies in the compressed nature of context management reports" β€” without compression, "aggregating full trajectories" would "exceed context limits with just 2-3 agents" (Section 4.3).

The consequence. Heavy Mode is evaluated on only three of the seven primary benchmarks: Humanity's Last Exam, BrowseComp, and BrowseComp-ZH (Figure 6). Results on GAIA, xbench-DeepSearch, WebWalkerQA, and FRAMES are absent. This selective reporting creates uncertainty about whether Heavy Mode generalizes or was only evaluated where it helped. Given the substantial gains on the reported benchmarks (+5.4 to +14.9 points), a practitioner needs to know whether these gains extend to other deep research tasks or are specific to the characteristics of HLE, BrowseComp, and BrowseComp-ZH.

More critically, the compute cost of Heavy Mode is entirely unspecified. The number of parallel agents n is not stated. The synthesis model's identity and scale are not disclosed. The total inference tokens or FLOPs consumed by Heavy Mode relative to standard mode are not reported. Without this information, we cannot determine whether the gains come from increased total compute (which would be expected to improve performance in any system with non-zero variance across runs) or from the specific architecture of parallel exploration with compressed synthesis. The paper's own Pass@1 vs. Pass@3 analysis (Figure 7) shows substantial gains from multiple runs without any Heavy Mode β€” for example, BrowseComp Pass@3 is 59.6 versus Avg@3 of 43.4, a gain of 16.2 points from simply taking the best of three independent runs. Heavy Mode on BrowseComp achieves 58.3 (Figure 6), which is close to the Pass@3 result. Without knowing n and the synthesis model's compute cost, we cannot distinguish Heavy Mode from a parallel best-of-N strategy.

The claimed advantage of compressed reports β€” enabling synthesis of more agents than full trajectories would allow β€” is asserted but not empirically demonstrated. There is no ablation comparing Heavy Mode (compressed reports) against an alternative that synthesizes full trajectories from the same number of agents, or that shows degradation when attempting full-trajectory synthesis.

What evidence exists in the paper. Figure 6 provides three data points (HLE, BrowseComp, BrowseComp-ZH) showing gains over standard mode, with comparisons against other systems' standard-mode scores. No information about n, the synthesis model, or compute cost is provided. The Pass@1 and Pass@3 analysis (Figure 7) demonstrates significant multi-run variance that Heavy Mode could partially exploit, but no direct comparison between Heavy Mode and alternative multi-run aggregation strategies is made.

Mitigation status. The paper does not acknowledge the selective evaluation, the unspecified compute cost, or the absence of comparisons against simpler multi-run strategies. Heavy Mode is presented as an unqualified improvement, and no limitations or caveats are discussed.

6.5 The Training Methodology Is Validated on a Single Model Architecture and Family

The assumption or constraint. All experiments β€” mid-training, SFT, RL, evaluation β€” use a single base model: Qwen3-30B-A3B-Base (Yang et al., 2025), a Mixture-of-Experts architecture with 30.5B total parameters and 3.3B activated per token. The paper presents its training methodology as a general paradigm for cultivating agentic capabilities, stating that it "establishes a new paradigm for training agentic models" (Section 3.2) and that "agentic models represent an emerging trend for the future" (Section 1).

The consequence. We cannot assess whether the training methodology β€” specifically, the claimed importance of mid-training, the synthetic data pipeline, the RL adaptations, and the environment design β€” transfers to other model architectures or families. The methodology could be effective specifically for Qwen3's MoE architecture, for models in the 30B-parameter range, or for models pretrained on Qwen's particular data distribution. A practitioner using a different base model (e.g., a dense architecture, a different model family like Llama or DeepSeek, a different parameter scale) cannot assume the pipeline will work without modification.

Several aspects of the methodology could be architecture-dependent. The Context Management paradigm's requirement that the model simultaneously produce a report summary, thought, and action at each step (Section 3.1) depends on the model's ability to generate structured outputs with multiple components β€” a capability that may vary across model families. The mid-training phase's effectiveness may depend on how much "agentic inductive bias" the base model already possesses, which could vary with pretraining data composition. The synthetic data pipeline uses open-source models for trajectory generation and rejection sampling (Section 3.3.2, Section 3.4.2); the quality of this generated data may depend on the specific models used and could degrade with different generator models.

The general benchmark results (Figure 11) provide minimal cross-architecture evidence: Tongyi DeepResearch is compared against reasoning-only variants of the same Qwen3 architecture (30B and 235B), not against agentic models built on different base architectures trained with the same methodology. The comparison demonstrates that tool use improves over reasoning-only within the same model family, but says nothing about transferability across families.

What evidence exists in the paper. None. There are no experiments with any base model other than Qwen3-30B-A3B-Base. The paper does not report results from applying the same training pipeline to a different architecture, a different model scale, or a different model family.

Mitigation status. The paper does not acknowledge this as a limitation. The focus on a single model is inherent in the project's scope β€” building and releasing one state-of-the-art agent β€” but the paper's claims about the generality of the methodology are not tempered by this constraint. Section 5.3 ("What's Next") mentions developing "the next-generation agent foundation model" but frames this as a capability advance rather than a validation of methodology transfer. The paper does not propose multi-architecture validation as future work.

6.6 The Hardest Problems Remain Unsolved, and No Diagnostic Is Provided

The assumption or constraint. The paper's benchmark results demonstrate strong average performance but provide no difficulty-stratified analysis. Unlike the prior example paper in this analysis (which partitioned MATH into five difficulty quintiles and showed qualitatively different scaling behavior at each level), Tongyi DeepResearch reports only aggregate scores and Pass@1/Pass@3 variants. The paper acknowledges that "the current 128K context length remains insufficient for handling the most complex long-horizon tasks" (Section 5.1), but does not characterize what fraction of benchmark problems fall into this "most complex" category, whether the model fails systematically on certain problem types, or whether additional compute (beyond the 128-tool-call, 128K-context budget) would help or is fundamentally insufficient.

The consequence. A practitioner deploying this system cannot estimate its failure modes on their specific problem distribution. The aggregate scores (e.g., 43.4 on BrowseComp) mask potentially enormous variation: the model may achieve near-perfect accuracy on simple factual lookup questions while failing almost entirely on questions requiring synthesis across many contradictory sources. Without difficulty stratification, the practitioner cannot determine whether their use case β€” which may be concentrated in a particular difficulty regime β€” is well-served by the system. The Pass@3 vs. Avg@3 gaps (Figure 7) are substantial (e.g., 59.6 vs. 43.4 on BrowseComp), suggesting that failure is not deterministic β€” the model sometimes succeeds and sometimes fails on the same problems β€” but we do not know whether this variance is concentrated on particular problem types or is uniform.

More fundamentally, the paper provides no insight into why the model fails on the hardest problems. Is it a search capability limitation (the model cannot find the right pages)? A reasoning limitation (the model finds relevant information but cannot synthesize it correctly)? A context management limitation (the model loses track of earlier findings)? A verification limitation (the model finds the answer but judges it insufficient and keeps searching)? Without diagnostic analysis, the path to improving the system on its failure modes is unclear. The paper's limitation statement (Section 5.1) identifies context length as a constraint and proposes "extended context windows or more advanced context management mechanisms" as solutions, but this assumes context length is the bottleneck without evidence that other factors are not equally or more limiting.

What evidence exists in the paper. None beyond aggregate scores. There are no difficulty-stratified results, no error analysis, no categorization of failure modes, and no ablation that isolates which component of the system (search, reasoning, synthesis, context management) limits performance on the hardest problems. The interaction scaling curve (Figure 10a) shows that performance on BrowseComp improves with context length, suggesting that longer interactions help, but does not indicate whether a plateau exists or whether further scaling would eventually saturate.

Mitigation status. The paper partially acknowledges this in Section 5.1, noting that "the current 128K context length remains insufficient for handling the most complex long-horizon tasks" and proposing future work on "extended context windows or more advanced context management mechanisms." However, this framing assumes context length is the binding constraint β€” a hypothesis that is not tested against alternatives (reasoning capability, search quality, verification accuracy). The paper does not propose diagnostic error analysis as future work, and does not release per-problem evaluation results that would enable the community to conduct such analysis independently.

7. Implications and Future Directions

How This Work Changes the Landscape

This paper does not introduce a new algorithm, a new architecture, or a new theoretical insight. It introduces something arguably more consequential for the practice of agent research: a complete, working, open-source reference implementation of a state-of-the-art deep research agent, along with the training pipeline that produced it. The magnitude of this contribution is not best measured by the benchmark scores in Table 1 β€” though those are impressive β€” but by what the release enables the community to do that was previously impossible.

From black-box competition to reproducible science. Before this work, the frontier of deep research capability was exclusively occupied by closed-source proprietary systems β€” OpenAI DeepResearch, Gemini DeepResearch, Claude Research, Grok-3 DeepSearch. Researchers studying how autonomous research capabilities emerge had no access to the training pipelines, data generation strategies, environment designs, or failure modes of these systems. They could only treat them as black boxes: prompt them, observe outputs, and speculate about internals. This paper's full open-source release β€” model weights, training framework, tool implementations, evaluation prompts, and reproduction scripts β€” transforms deep research agent development from a proprietary engineering competition into a subject of scientific inquiry. For the first time, a researcher can modify a specific component of the training pipeline (say, the mid-training data mixture, or the RL reward function, or the Context Management compression strategy), retrain the agent, and measure the causal effect on downstream research capability. This is the difference between astronomy (observing distant objects you cannot manipulate) and laboratory science (running controlled experiments on accessible systems). The paper itself does not conduct such controlled experiments β€” as Section 6 argued, the most important ablations are missing β€” but it provides the platform on which those experiments can now be run.

Resolving the tension between capability and openness. The paper demonstrates that open-source systems can compete with β€” and in several cases surpass β€” proprietary deep research agents. On Humanity's Last Exam, Tongyi DeepResearch (32.9) outperforms OpenAI DeepResearch (26.6) by 6.3 points. On FRAMES, it achieves 90.6 versus OpenAI o3's 84.0. On GAIA, it achieves 70.9 versus Claude-4-Sonnet's 68.3. These results challenge the implicit assumption that frontier agentic capability requires massive, undisclosed infrastructure. The paper's model activates only 3.3 billion parameters per token β€” a scale that makes the system potentially deployable on consumer hardware, though the paper does not demonstrate such deployment or measure on-device performance. The practical implication is that organizations building deep research systems no longer face a binary choice between using closed-source APIs (with their opacity, cost, and data privacy concerns) and building from scratch (with the enormous engineering investment that entails). They can start from Tongyi DeepResearch's open artifacts and adapt the system to their specific domains, data, and deployment constraints.

Reframing the agent training problem from algorithm design to systems engineering. Perhaps the paper's most quietly radical contribution is its empirical claim β€” stated explicitly in Section 3.4.3 β€” that "the success of agentic RL depends more on the quality of the data and the stability of the training environment than on the specific algorithm being used." If validated by subsequent work, this reframes the research agenda for agentic RL. Instead of asking "what is the best RL algorithm for training agents?", the question becomes "how do we generate high-quality synthetic agent trajectories at scale, and how do we build environments that provide stable, deterministic feedback?" The paper's answer β€” an elaborate data synthesis pipeline (graph construction, uncertainty injection, set-theoretic formalization, PhD-level question engine), a three-tier environment taxonomy (Prior World, Simulated, Real-world), and a unified sandbox with fault-tolerance β€” is one instantiation of this research program. But the reframing itself is more important than any specific component: it redirects attention and resources toward data engineering and infrastructure, which are often undervalued in academic research relative to algorithmic novelty.

This reframing also provides a lens for interpreting prior work's mixed results. Earlier attempts at training web agents often reported unstable training, sensitivity to hyperparameters, or performance ceilings that defied explanation. The paper's diagnosis β€” that these failures stem from noisy environments and insufficiently curated data, not from algorithmic inadequacy β€” offers a coherent explanation and a concrete remediation strategy. It suggests that many negative results in the agent training literature may be revisited with better environmental engineering and data curation rather than better algorithms.

The mid-training hypothesis as a new axis of investigation. While the paper does not empirically validate the necessity of mid-training (the missing ablation is the most significant gap in the experimental design, as Section 6 argued), it introduces a conceptual hypothesis that now becomes testable: that general pretrained models lack an "agentic inductive bias" and require a dedicated training phase to acquire the structural prior that the world is something to be interacted with through sequential actions, observations, and state management. Whether this hypothesis is correct or not, it opens a new dimension of investigation that was previously absent from the agent training literature. Researchers can now ask: what exactly does mid-training teach? Can it be replaced by architectural innovations (e.g., specialized attention patterns for tool interaction)? Can it be integrated directly into pretraining rather than added as a separate phase? The paper provides the open artifacts needed to test these questions β€” the first community resource where mid-training can be ablated, varied, or replaced.

Changing the relationship between model scale and capability. The paper's demonstration that a 30.5B-parameter model (3.3B activated) can match or exceed much larger proprietary systems on deep research benchmarks provides evidence that training methodology can substitute for parameter count β€” at least for this class of tasks. This aligns with work like Belcak et al. (2025) arguing that "small language models are the future of agentic AI," but Tongyi DeepResearch provides a concrete, benchmark-validated instance of the claim rather than a theoretical argument. The implication is that the path to better deep research agents may not require scaling model size but rather improving training methodology β€” better synthetic data, better environments, better curriculum design, better context management. This makes agent research more accessible to academic labs and smaller organizations that cannot train 100B+ parameter models, and it shifts the bottleneck from compute budget to engineering sophistication.

Which research directions become more attractive. This work makes several directions substantially more tractable:

  • Synthetic data quality for agent training becomes a first-class research problem rather than an ad-hoc engineering concern, because the paper provides both a baseline pipeline and a benchmarked model against which improvements can be measured.
  • Environment design for agent training becomes a systematic discipline rather than an afterthought, because the paper provides a taxonomy and concrete examples (Prior World, Simulated Wiki, Real-world with sandbox) that can be extended and formalized.
  • Open-source agent development becomes a viable path to frontier capability, lowering the barrier to entry and enabling a broader research community to contribute.
  • Ablation studies of training pipeline components become feasible, because the paper provides the complete pipeline and a set of benchmarks on which component contributions can be measured.

Which research directions become less attractive. Conversely, several directions become less promising:

  • Proprietary deep research as the only path to capability is challenged by the paper's results β€” the open-source option is now competitive, reducing the value of closed-source exclusivity.
  • Algorithmic complexity in RL for agents is de-emphasized by the paper's finding that data and environment matter more β€” researchers focused on developing novel policy gradient estimators for agent training should justify why their algorithmic innovation provides value beyond what careful engineering of data and environment would achieve.
  • Scale as the primary driver of agent capability is called into question β€” the paper demonstrates that a relatively small model with the right training can outperform much larger systems, suggesting that "just make it bigger" is an incomplete strategy for deep research agents.

Follow-Up Research This Work Enables

Direct mid-training ablation: train the same pipeline without mid-training and measure the gap. The most critical missing experiment is a controlled comparison between the full pipeline (Qwen3-30B-A3B-Base β†’ Agentic CPT β†’ SFT β†’ RL β†’ merge) and a pipeline that omits mid-training (Base β†’ SFT β†’ RL β†’ merge), with all other factors held constant β€” same synthetic data for post-training, same SFT protocol, same RL algorithm and hyperparameters, same model merging. The comparison should report: (a) benchmark performance across all seven evaluation suites (Table 1), (b) RL training dynamics (reward curves and entropy, analogous to Figure 8), and (c) qualitative analysis of behavioral differences (e.g., does the no-mid-training model exhibit more frequent tool misuse, earlier context saturation, or poorer planning?). If the gap is small, the paper's central methodological claim is weakened and mid-training can be deprioritized. If the gap is large, the finding validates mid-training's importance and motivates research into what specific capabilities it provides. A stronger variant would ablate the mid-training data components individually β€” removing question synthesis, planning actions, reasoning actions, decision-making actions, or function-calling data β€” to identify which mid-training data types drive the benefit. The paper's open-source release makes this ablation immediately feasible for any lab with sufficient compute to run the mid-training stage.

Synthetic data pipeline ablation: which components of the data synthesis actually matter? The paper's data synthesis pipeline is elaborate but unvalidated. A controlled experiment would compare the benchmark performance of models trained on data from: (a) the full pipeline (graph construction + subgraph sampling + uncertainty injection + set-theoretic formalization + PhD-level question engine), (b) a simplified pipeline that prompts a strong LLM (e.g., GPT-4 or Claude) to generate complex questions and answers with web-search verification but without the formal graph/scaffolding machinery, (c) a pipeline that uses the simplified LLM-generated questions but adds only uncertainty injection (the paper's "atomic operations" on entity relationships), and (d) a pipeline using only the PhD-level question engine without the graph-based components. Each resulting dataset would be used identically for SFT cold-start and RL training, with benchmark performance compared across all seven evaluation suites. This ablation would determine whether the formal machinery of the data synthesis pipeline is necessary or whether simpler prompting-based approaches achieve comparable data quality. The paper's claim that synthetic data enables "targeted meta-capability enhancement" (Section 2) could be tested by training separate models on data targeting individual meta-capabilities (planning-only, reasoning-only, decision-making-only) and measuring whether the combined multi-capability training produces synergistic gains over the sum of single-capability improvements.

Efficiency-calibrated comparison: normalize benchmark scores by total inference compute. The paper's efficiency narrative is built on per-token activated parameter count (3.3B), which is insufficient. A rigorous follow-up would measure total inference FLOPs or tokens consumed per task for Tongyi DeepResearch (standard mode), Tongyi DeepResearch Heavy Mode (varying n), and a set of baseline systems (DeepSeek-V3.1, OpenAI o3, Claude-4-Sonnet) on the same benchmarks under identical evaluation conditions. The comparison would produce efficiency curves plotting benchmark accuracy against total inference compute, revealing whether Tongyi DeepResearch's smaller per-token footprint is offset by longer trajectories. This study would also measure how Heavy Mode's gains scale with n β€” the number of parallel agents β€” to determine the Pareto frontier of accuracy versus compute. A particularly informative variant would compare Heavy Mode against a best-of-N baseline where N standard-mode runs are executed independently and the best answer is selected (either by majority vote or by a verifier), using the same total compute budget. If Heavy Mode significantly outperforms best-of-N at equivalent compute, the Context Management compression is providing value beyond simple parallelization. This experiment requires instrumenting the inference pipeline to record token counts and FLOPs, which the paper's open-source release makes possible.

Difficulty-stratified error analysis: where does the system fail and why? The paper reports only aggregate benchmark scores with no diagnostic breakdown. A follow-up study would classify benchmark problems by difficulty characteristics β€” number of required information sources, degree of contradiction among sources, required reasoning depth, domain specificity β€” and measure the model's accuracy within each category. For each failure, the study would categorize the failure mode: (a) search failure (the model did not find the right pages or used ineffective queries), (b) extraction failure (the model visited the right pages but failed to extract the relevant information), (c) reasoning failure (the model had the necessary information but synthesized an incorrect answer), (d) context management failure (the model lost track of earlier findings or exceeded context limits before completing the task), or (e) premature termination (the model stopped searching before gathering sufficient evidence). The analysis would use the model's own trajectory β€” its search queries, visited pages, extracted information, and reasoning traces β€” to classify each failure, following a protocol similar to the diagnostic analyses in the WebWalkerQA or BrowseComp papers. This would directly inform prioritization of future improvements: if search failures dominate, invest in better query generation and search tool design; if reasoning failures dominate, invest in stronger base models or longer reasoning chains; if context management failures dominate, invest in better compression strategies. The open-source nature of Tongyi DeepResearch β€” including its intermediate thoughts and tool calls β€” makes this analysis feasible, unlike studies of proprietary systems where trajectories are hidden.

Cross-architecture validation: does the training methodology transfer to other model families? The paper's entire methodology is validated on a single base model (Qwen3-30B-A3B-Base, MoE architecture). A strong test of generality would replicate the pipeline β€” or a simplified version for cost feasibility β€” on two additional base models representing different architectures and scales: (a) a dense model of comparable total parameters (e.g., Llama-3-30B or a similarly-sized dense architecture) and (b) a smaller MoE or dense model (e.g., a 7B or 13B-parameter model). The replication would use the same synthetic data pipeline, SFT protocol, and RL algorithm, with only the base model varying. Key measurements: does the relative improvement from mid-training versus no-mid-training generalize? Does the Context Management paradigm work equally well on dense models that may have different in-context learning and structured generation capabilities? Does the training stability (Figure 8) replicate, or does the Qwen3 architecture provide stability properties that other architectures lack? A negative result β€” the pipeline works well on Qwen3 but not on other architectures β€” would bound the methodology's generality and motivate investigation into which architectural properties (MoE routing? pretraining data composition? attention mechanism?) are necessary conditions. A positive result would strengthen the paper's claim to a "new paradigm for training agentic models" (Section 3.2).

Iterative self-improvement: close the data flywheel loop. The paper argues that synthetic data enables "data flywheels" where improved models generate improved training data, but reports no iterative training results. A follow-up would implement a full iteration: train Tongyi DeepResearch on the initial synthetic dataset, use the trained model to generate new trajectories on a held-out set of questions, filter these trajectories by correctness (using the ground-truth answers from the synthesis pipeline), add the correct trajectories to the training set, and retrain. This cycle would be repeated for 3-5 iterations, measuring benchmark performance after each iteration. The critical questions are: (a) does performance continue to improve, or does it plateau after one iteration? (b) does the distribution of generated trajectories shift in undesirable ways (e.g., the model converges to a narrow set of search strategies rather than maintaining diversity)? (c) does the quality of the model's own generated training data β€” measured by correctness rate and trajectory diversity β€” improve over iterations? The paper's observation that the ReST^EM-trained revision model "degraded" in the prior analyzed example (though not featured in this paper) provides a cautionary note: iterative self-improvement can backfire if data quality degrades. A study measuring whether the data flywheel spirals up (improvement) or spirals down (collapse) would directly test one of the paper's strongest claims about synthetic data's advantages.

Practical Applications and Downstream Use Cases

Domain-specialized research agents for scientific and technical organizations. The paper's open-source release β€” model weights, training framework, tool implementations β€” enables organizations to fine-tune Tongyi DeepResearch on domain-specific research questions and literature. A pharmaceutical company could fine-tune the agent on biomedical research questions, using the synthetic data pipeline (Section 3.4.1) adapted to generate questions from PubMed-indexed papers and clinical trial databases, producing an agent that autonomously conducts literature reviews spanning hundreds of papers, evaluates contradictory findings, and synthesizes evidence on drug efficacy or disease mechanisms. The key enabler is that the full training pipeline β€” not just the model weights β€” is open-sourced, so the domain adaptation can target mid-training, SFT, and RL stages, not just superficial fine-tuning. The efficiency profile (3.3B activated parameters per token) makes deployment on organizational infrastructure plausible without datacenter-scale GPU clusters, though the paper does not provide on-device benchmarks to confirm this.

Cost-efficient batch evaluation for benchmark and competition organizers. The heavy compute consumption implied by the interaction scaling curve (Figure 10a: ~50% BrowseComp accuracy at 128K context, suggesting tens of thousands of tokens per task) makes large-scale evaluation expensive. However, organizations that need to evaluate many research questions β€” for example, benchmark creators validating new question sets, or research labs running systematic capability audits β€” can use Tongyi DeepResearch's standard mode as a cost-controlled baseline and selectively deploy Heavy Mode (Section 4.3) only on questions where additional compute is likely to help. The Pass@3 results (Figure 7) provide a basis for such selective deployment: on BrowseComp, Pass@3 is 59.6 versus Avg@3 of 43.4, a 16.2-point gap suggesting that running three independent standard-mode agents and selecting the best answer recovers substantial performance without the Heavy Mode's synthesis infrastructure. A deployment strategy that runs one agent (cost: C), runs three agents and selects the best (cost: 3C, expected gain: ~16 points on BrowseComp), or runs Heavy Mode with n agents plus synthesis (cost: nC + synthesis cost, gain: ~15 points on BrowseComp) can be optimized based on the specific cost-accuracy tradeoff of the application. The paper's open tool implementations and evaluation scripts make this kind of cost modeling feasible.

Foundation for research on autonomous scientific discovery systems. The paper's most ambitious downstream implication is its role as a platform for building systems that conduct not just literature review but autonomous scientific investigation β€” generating hypotheses, designing experiments, analyzing results, and iterating. This is beyond what Tongyi DeepResearch itself does (it synthesizes existing information rather than generating new knowledge), but the training pipeline's core components β€” multi-step planning, tool use, information synthesis, context management β€” are prerequisite capabilities for any autonomous discovery system. The open-source release means that researchers building such systems do not need to reinvent the agentic training infrastructure; they can build on Tongyi DeepResearch's pipeline while extending it with additional tools (laboratory equipment APIs, simulation environments, data analysis pipelines) and additional training objectives (hypothesis generation quality, experimental design efficiency). The PhD-level question engine (Section 3.4.1) is particularly relevant: it demonstrates the ability to generate questions that require genuine research synthesis, and the same methodology could be adapted to generate hypotheses rather than just questions. The paper's insistence on automatic verifiability β€” that synthetic data must have unambiguously correct answers β€” both enables and constrains this extension: scientific hypotheses are not "correct" or "incorrect" in the same way that research questions have answers, requiring new reward structures beyond the binary RLVR signal used in the paper's RL phase.

Educational tools for teaching research methodology. The paper's Context Management paradigm β€” where the agent periodically synthesizes its findings into a compressed report β€” produces a natural pedagogical artifact: a step-by-step research trace showing how the agent's understanding evolves as it gathers information. Unlike a static answer, this trace reveals the process of investigation: what questions the agent asked, which sources it found credible, how it resolved contradictions, and when it decided it had gathered enough evidence. For students learning research methodology, interacting with Tongyi DeepResearch and studying its trajectories provides a concrete model of systematic investigation β€” not as a black-box oracle but as a transparent process whose decisions can be critiqued and improved. The open-source release makes this feasible in educational settings where proprietary systems would be cost-prohibitive or privacy-concerning. The model's 3.3B activated parameters per token and the availability of reproduction scripts suggest that deployment on a university server or even a high-end consumer GPU is plausible, though again the paper does not provide deployment benchmarks to confirm this.