ArXiv: 2602.06540

🎯 Pitch

An 8B-parameter local model matches or surpasses Gemini-2.5-Pro on deep research benchmarks by alternating between drafting and outline revision—essentially learning to think by writing. The system’s Writing As Reasoning Policy dynamically detects logical gaps in the current draft and spawns targeted sub-inquiries, pushing Insight scores to 52.64 versus the proprietary giant's 49.45. This specialized process design substitutes for model scale, but the gains cluster in depth and insight rather than readability, where smaller models still trail.

1. Executive Summary

This paper introduces AgentCPM-Report, a fully local deep research system built on an 8B-parameter model that reformulates report generation as an iterative refinement process rather than the conventional plan-then-write paradigm. The core mechanism is WARP (Writing As Reasoning Policy) — a policy-level framework where the agent interleaves Evidence-Based Drafting (writing sections conditioned on accumulating narrative context) with Reasoning-Driven Deepening (inspecting the current draft to detect logical gaps, decompose shallow sections into sub-inquiries, and dynamically update the outline). A supporting Multi-Stage Agentic Training strategy — progressing from cold-start SFT through Atomic Skill RL to Holistic Pipeline RL with trajectory pruning to solve the optimal stopping problem — enables the 8B agent to match or surpass leading proprietary systems, achieving an Insight score of 52.64 on DeepResearch Bench compared to Gemini-2.5-Pro-deepresearch's 49.45 and attaining the highest scores on DeepResearch Gym across Depth, Breadth, and Insightfulness (all 100.0). The work establishes that specialized policy design can substitute for model scale in deep research, but that the gains concentrate in Insight and Comprehensiveness rather than Readability, where smaller models continue to lag behind closed-source counterparts.

2. Context and Motivation

The Core Problem: Open-Ended Deep Research Demands a Dynamic Coupling Between Planning and Writing

The paper addresses a fundamental tension in how automated systems generate long-form, research-intensive reports. When a human researcher tackles an open-ended question — say, "What are the economic implications of quantum computing on drug discovery?" — they do not first construct a perfect, exhaustive outline and then mechanically fill it in. Instead, the very act of writing reveals gaps in understanding, uncovers unexpected connections, and forces a re-evaluation of the initial plan. The process is inherently iterative: outline informs writing, but writing equally informs and reshapes the outline. This dynamic, which cognitive psychologists call knowledge-transforming (Scardamalia and Bereiter, 1987), is the hallmark of genuinely insightful research. The paper's central claim is that existing automated deep research systems systematically fail to replicate this dynamic, and that this failure is the root cause of both an insight ceiling and a practical barrier to deploying smaller, privacy-preserving models.

The paper frames this as a paradigm problem rather than a model-capability problem. The issue is not primarily that models are too small to write good reports — the authors demonstrate that an 8B model can match or beat proprietary giants when equipped with the right process. The issue is that the dominant architectures for deep research enforce a rigid, unidirectional flow from planning to writing that prevents the system from learning from its own output. This is the gap the paper sets out to close.

Why This Problem Matters: Practical and Research Implications

The problem carries weight on three distinct fronts:

1. Insight is the critical dimension of report quality. The paper repeatedly emphasizes that existing systems produce reports that are "structurally sound yet intellectually shallow" (Section 1). Achieving adequate coverage and coherence is necessary but insufficient for deep research — the value lies in synthesizing information into novel insights, identifying subtle contradictions, and drawing connections that are not obvious from the source material alone. If the best achievable results from plan-then-write systems hit an insight ceiling, then the entire category of automated deep research tools delivers diminished returns on their core promise.

2. Plan-then-write systems create an artificial dependency on large, often closed-source models. Constructing a comprehensive outline before any writing or retrieval occurs is a genuinely difficult reasoning task. It requires the model to anticipate the full scope of a topic from its parametric knowledge alone, with at most a few background searches. Smaller models — which are essential for on-device, privacy-preserving deployment — are substantially weaker at this kind of pre-factual planning. The paper argues that this dependency is not necessary: if the planning burden can be distributed across the entire research trajectory (i.e., planning as writing rather than planning then writing), the upfront reasoning demand is dramatically reduced, opening the door to effective 8B-scale agents.

3. Privacy and data sovereignty concerns are intensifying. The introduction explicitly identifies a practical bottleneck: "online deployment makes it difficult to support writing over users' local or private data, as uploading such data inevitably raises security and privacy concerns" (Section 1). For enterprises, researchers, and individuals working with proprietary or sensitive information — financial analyses, internal strategy documents, unpublished research findings — the inability to run deep research completely locally is a non-starter. The paper positions itself as building toward a "fully local, on-device deep research and writing solution that does not depend on external large-scale models" (Section 1). This is a concrete deployment goal, not just an academic exercise.

Where Prior Approaches Fall Short: A Taxonomy of Failures

The paper identifies two generations of existing systems, each with characteristic limitations:

Retrieval-then-write systems (Figure 1a). Early approaches (e.g., Step-DeepResearch by Hu et al., 2025) follow a loose sequence: retrieve information, then generate content based on what was retrieved, moving forward sequentially. The advantage is flexibility — the agent can adapt somewhat to what it finds. The fatal weakness is coherence collapse over long horizons. Without a stable structural scaffold, the agent gradually loses track of how sections relate to each other, leading to redundancy, contradiction, and fragmentation. The paper characterizes these systems as "frequently degenerates into incoherence over long horizons" (Section 1).

Plan-then-write systems (Figure 1b). The dominant current paradigm includes systems like WebWeaver (Li et al., 2025b), AutoSurvey (Wang et al., 2024), SurveyForge (Yan et al., 2025), and LLM MapReduce-v2 (Wang et al., 2025). These systems address the coherence problem by freezing a comprehensive outline before any section-level writing begins. The writer then executes this blueprint sequentially, ensuring global structure. This works well for structural stability, but the paper identifies two distinct failure modes:

  • The insight ceiling. Because the outline is constructed from the model's pre-existing knowledge (augmented by at most a few high-level searches), it cannot anticipate insights that would emerge only through the concrete act of drafting specific sections. The plan becomes a binding constraint on the writer, not an enabling scaffold. The paper's language is direct: "By reducing the downstream writer to an executor of a static blueprint, this rigid separation prevents agents from capturing emergent insights: subtle connections and refinements that surface only when articulating concrete arguments" (Section 1).

  • The upfront reasoning bottleneck for small models. Even when plan-then-write systems use large models as backbones, the requirement to produce a comprehensive, high-quality outline ex nihilo places extreme demands on reasoning ability and domain knowledge. The paper argues this is why "most existing deep research systems rely almost exclusively on closed-source or online large models" (Section 1). A small model tasked with the same upfront planning will produce a shallow or error-ridden outline, and the downstream writer — however competent at paragraph generation — cannot recover from a fundamentally flawed plan. This is a compounding failure: bad plan → constrained writer → structurally sound but substantively weak report.

A deeper diagnosis: information completeness assumptions. Both paradigms implicitly assume that what the model needs to know to structure a good report can be known in advance. Retrieval-then-write assumes the initial retrieval pass gathers sufficient information. Plan-then-write assumes the initial outline captures the necessary structure. In realistic open-ended research, neither assumption holds. The information landscape is opaque at the outset. The researcher does not know what they do not know until they try to write about it. This is not a weakness that can be patched with better retrieval or better prompting — it is a structural flaw in the paradigm itself.

How This Paper Positions Itself Relative to Existing Work

The paper's positioning is distinctive because it argues against the methodological premise of plan-then-write rather than proposing an incremental improvement to it. The key conceptual move is unifying planning and writing under a single sequential decision-making policy.

The paper formulates deep research as a process where the agent observes a global state Si=(Q,Oi,Di,Ci)S_i = (Q, O_i, D_i, C_i) — comprising the user query, the current dynamic outline, the current draft, and retrieved context — and selects actions from {Initialize, Search, Write, Expand, Terminate} (Section 2.1). Critically, outline modifications (Oi→Oi+1)(O_i \rightarrow O_{i+1}) and content generation (Di→Di+1)(D_i \rightarrow D_{i+1}) are "treated as equivalent state transitions driven by the policy" (Section 2.1). This means there is no privileged "planning phase" — the agent can alternate between writing a section and then, having learned something from that section, deciding to decompose a shallow subsection into more granular inquiries.

The authors call this WARP (Writing As Reasoning Policy) and emphasize that it is a policy-level reformulation, not a rule-based heuristic. In the Reasoning-Driven Deepening state, the agent must make autonomous decisions: should it continue deepening, or is the current draft sufficient? It evaluates the "semantic density and logical coherence of the current draft" (Section 2.2) to decide. When deepening is warranted, it generates expanded sub-sections — but these are not pre-planned expansions that were latent in the original outline. They are novel structural decompositions triggered by the concrete experience of having written and read the intermediate draft.

This positioning matters because it changes the nature of the research problem. Plan-then-write frameworks are fundamentally limited by the quality of their initial planner — which, the paper argues, is intractable to make perfect. WARP reframes the problem as one of dynamic credit assignment in a long-horizon policy: can an agent learn to detect, during the writing process itself, when a section is shallow, and can it learn to stop deepening when further expansion yields diminishing returns? These are difficult RL problems, but they are different from the impossible problem of pre-factual planning completeness that plan-then-write systems confront.

The paper is also careful to position WARP as complementary to, rather than competing with, the use of teacher models during training. While the inference-time system runs on an 8B model, the training pipeline relies on Qwen3-235B-A22B-Instruct-2507 as a teacher to generate trajectory data. The teacher is used not as the deployment model but as a source of supervision signals that the smaller model learns to reproduce and eventually surpass. This is a standard distillation pattern, but applied to the novel challenge of policy-level decision-making in open-ended research.

Finally, the paper positions its multi-stage training strategy as a necessary enabler for practical deployment. The WARP framework introduces two training challenges that standard pipelines cannot handle: ambiguous termination (even teacher models do not know when to stop deepening) and sparse rewards (report quality is only observable at the very end of a potentially very long trajectory). The trajectory pruning strategy and the Atomic RL → Pipeline RL curriculum are presented as the technical innovations that make WARP trainable on an 8B model within reasonable compute budgets (8 A100 GPUs, approximately 8 days total training across all three stages, per Appendix B.1).

The implicit argument is that the deep research community has been optimizing in the wrong parameter space: scaling model size rather than redesigning the cognitive architecture of the research process. The paper's results — an 8B model matching or exceeding Gemini-2.5-Pro on Insight and Comprehensiveness — are presented not as a claim that small models are inherently superior, but as evidence that the architectural bottleneck in current systems is more binding than the capability bottleneck. Fix the architecture, and the capability already present in small models can be unlocked.

3. Technical Approach

3.1 Reader Orientation

AgentCPM-Report is a fully local, 8B-parameter deep research agent that produces long-form research reports by alternating between writing content and dynamically revising its own outline based on what it discovers during the writing process. The system solves the problem that existing approaches — which force the agent to commit to a complete outline before writing — cannot, because the outline is created from the model's incomplete prior knowledge and misses insights that only become visible once concrete arguments are drafted; the solution restructures report generation as an iterative policy that treats outline revision and content generation as the same kind of action, allowing the agent to discover structural gaps mid-composition and expand shallow sections on demand.

3.2 Big-Picture Architecture (Diagram in Words)

The system has four major components that operate in a loop:

  1. The Agent Policy ($\pi_\theta$) — the core decision-maker, implemented as a MiniCPM4.1-8B model, that at each iteration observes the full state (user query, current outline, accumulated draft, retrieved evidence) and selects one of five actions: Initialize, Search, Write, Expand, or Terminate. This is the component that undergoes multi-stage training.

  2. The WARP Inference Loop — the execution framework that cycles the agent through two alternating macro-states: Evidence-Based Drafting (where the agent writes sections grounded in retrieved evidence) and Reasoning-Driven Deepening (where the agent reads its own draft, detects logical gaps or superficial coverage, and decomposes weak sections into sub-inquiries, updating the outline).

  3. The Retrieval Environment — a local database of approximately 2.86 million documents (2.71 million arXiv paper abstracts plus 150k web page summaries generated by Gemini 2.0-Flash) that the agent queries during both Drafting and Deepening phases to ground its writing and planning in evidence.

  4. The Training Pipeline — a three-stage curriculum (Cold-Start SFT → Atomic Skill RL → Holistic Pipeline RL) that progressively teaches the agent first to follow the WARP format, then to execute individual actions well, then to make globally optimal decisions about when to deepen and when to stop.

Information flows as follows: a user query enters → the agent executes Initialize to produce a sparse Level-1 outline and initial background searches → the agent enters Drafting, iterating through sections: for each section, it formulates a retrieval query conditioned on the accumulating draft context, retrieves evidence, and writes the section grounded in that evidence → after completing the outline, the agent shifts to Deepening: it inspects the full draft, decides whether to Expand a specific section or Terminate → if Expand, it generates new sub-sections for the identified weak point, updating the outline, then returns to Drafting to fill those sub-sections → this Drafting-Deepening loop repeats until the agent selects Terminate, at which point the final report is output.

3.3 Roadmap for the Deep Dive

  • First, the formal problem formulation (Section 2.1), which establishes the mathematical framework that treats planning and writing as equivalent policy decisions — this is the conceptual foundation everything else builds on.
  • Second, the WARP inference diagram (Section 2.2), explaining the two interleaved macro-states (Evidence-Based Drafting and Reasoning-Driven Deepening) and the coarse-to-fine initialization strategy, since this is the procedure the trained agent executes at inference time.
  • Third, the data preparation and trajectory pruning strategy (Section 2.3.1), because the quality of the training data — particularly the solution to the optimal stopping problem — determines whether the agent can learn meaningful deepening behavior at all.
  • Fourth, the three-stage curriculum training (Section 2.3.2) — Cold-Start SFT, Atomic Skill RL, and Holistic Pipeline RL — since each stage addresses a distinct failure mode and the progression from local action optimization to global report optimization is essential for stable convergence.
  • Fifth, the reward system (Appendix A.6), because the design of per-action and per-report reward functions is the mechanism that translates the paper's qualitative goals (Insight, Comprehensiveness) into trainable RL objectives for an 8B model.

3.4 Detailed, Sentence-Based Technical Breakdown

This is primarily a systems and training methodology paper whose core idea is that open-ended deep research can be reformulated as a unified policy optimization problem where planning and writing are interleaved — and that a multi-stage curriculum with trajectory pruning makes this trainable on small models.

Problem Formulation: Deep Research as Sequential Decision-Making

The paper formally defines deep research as an iterative hierarchical decision-making process (Section 2.1). At any interaction loop $i$, the agent observes a global state:

Si=(Q,Oi,Di,Ci)S_i = (Q, O_i, D_i, C_i)

where $Q$ is the user query (the fixed task specification), $O_i$ is the dynamic outline at loop $i$ (a hierarchical structure of sections and sub-sections, each with a title and a writing intent), $D_i$ is the current draft at loop $i$ (the accumulated written content across all populated sections), and $C_i$ is the context retrieved during the current loop $i$ (documents and evidence fetched by the Search action).

What this state representation encodes: it captures everything the agent knows at any point — the original question, what it plans to cover (the outline), what it has actually written so far (the draft), and what external evidence it has gathered. This is the sufficient statistic for making decisions about what to do next.

At each step $t_{i,j}$ within loop $i$, the agent selects an action $A_{i,j}$ from a fixed action space:

Ai,j∈{Initialize,Search,Write,Expand,Terminate}A_{i,j} \in \{\text{Initialize}, \text{Search}, \text{Write}, \text{Expand}, \text{Terminate}\}

Why these five actions: they decompose the research process into atomic, well-defined operations. Initialize constructs the first outline; Search queries the retrieval environment; Write produces a section's content grounded in evidence; Expand decomposes a shallow section into sub-inquiries and updates the outline; Terminate signals that the report is complete. Critically, every action except Terminate changes either $O_i$ or $D_i$ or $C_i$, advancing the state.

The crucial conceptual step is the paper's explicit unification:

"outline adjustments $(O_i \rightarrow O_{i+1})$ and content generation $(D_i \rightarrow D_{i+1})$ are treated as equivalent state transitions driven by the policy."

Why this matters: in a plan-then-write system, outline creation is a privileged preliminary phase that happens once and is never revisited. Here, modifying the outline (via Expand) is just another action the policy can take at any point, triggered by the same observation-to-action mapping as writing a paragraph. This is what enables the agent to respond to discoveries made during drafting — the policy learns that after writing a section and observing that the resulting draft $D_{i+1}$ is shallow or has logical gaps, the optimal action is Expand, not Write the next pre-planned section. The formalism makes no structural distinction between "planning time" and "writing time."

The WARP Inference Diagram

WARP operates in two interleaved macro-states: Evidence-Based Drafting and Reasoning-Driven Deepening. The paper models research as an infinite loop alternating between these states, with termination possible only from the Deepening state.

Coarse-to-Fine Initialization

The process begins from the initial state $S_0$ (Section 2.2, Equation 1). The agent analyzes the query $Q$ to generate broad search queries $q_0$, retrieves background context $C_0$, and synthesizes an initial Level-1 outline:

O0←Initialize(Q,C0)O_0 \leftarrow \text{Initialize}(Q, C_0)

What "sparse" means concretely: the initial outline $O_0$ consists only of high-level section titles and brief writing intents — it does NOT contain nested sub-sections, detailed plans per section, or pre-populated retrieval queries. This is a deliberate design choice that the paper contrasts with static planners like WebWeaver (Li et al., 2025b):

"In contrast to static planners that attempt to generate a fully detailed hierarchy, our $O_0$ is intentionally sparse, consisting only of high-level section titles and brief writing intents. This design mitigates the risk of being ungrounded."

Why sparsity matters: the more detailed the initial outline, the more of it is fabricated from the model's parametric knowledge rather than grounded in retrieved evidence. A sparse outline commits the agent only to a broad topic structure — say, "Background," "Methods," "Applications," "Challenges" — without forcing premature decisions about what sub-topics those sections will contain. The sub-topics emerge organically through the Drafting-Deepening loop, each expansion grounded in the concrete draft content and supporting evidence.

Evidence-Based Drafting

Given a tentative outline $O_i$, the agent executes a retrieve-then-write cycle for each section (Section 2.2, Equations 2-3). The critical design choice is contextual conditioning: retrieval queries are not formulated independently per section but are conditioned on the accumulating narrative.

For a specific section $k$, the agent first formulates a search query:

qi,k←Search(Q,Oik,Di)q_{i,k} \leftarrow \text{Search}(Q, O_i^k, D_i)

where $Q$ is the original user query, $O_i^k$ is the writing intent for section $k$ (a brief description of what that section should cover), and $D_i$ is the current draft — the content of all previously written sections.

Why condition on $D_i$: this is how the paper enforces "contextual consistency" and avoids fragmentation. If sections are written independently, the agent might retrieve overlapping evidence for different sections, produce redundant coverage, or fail to build logical bridges between sections. By including the draft context in the retrieval query, the agent is prompted to ask: "Given what I have already written, what specific information does section $k$ need to extend the narrative rather than repeat it?" The paper describes this as:

"This ensures that new information strictly extends the logical flow of previous sections."

The retrieval tools then acquire new content $C_i^k$ based on the query $q_{i,k}$. The retrieval environment (Appendix A.3) is a local database of approximately 2.86 million documents: roughly 2.71 million arXiv paper abstracts sourced via Kaggle, and approximately 150k web page summaries generated by Gemini 2.0-Flash with controlled document length and quality. The use of a local, static database rather than live web search is deliberate — it ensures reproducibility and enables fully offline, privacy-preserving operation.

The agent then writes the section content:

Dik←Dik−1⊕Write(Q,Oik,Dik−1,Cik)D_i^k \leftarrow D_i^{k-1} \oplus \text{Write}(Q, O_i^k, D_i^{k-1}, C_i^k)

where $D_i^{k-1}$ is the draft after writing the previous $k-1$ sections, $C_i^k$ is the evidence retrieved for section $k$, and $\oplus$ denotes appending the new section content to the draft.

The objective of Drafting phase: the paper explicitly distinguishes between "information integration" and "mere aggregation." The Write action is trained (during Atomic Skill RL) to synthesize disparate sources into a coherent argument, not just to list facts from retrieved documents. The quality criteria for writing (Table 1, Appendix A.6.1) include Relevance, Coverage, Depth, and Novelty — dimensions that capture whether the generated paragraph integrates evidence to advance understanding rather than simply reporting it.

After iterating through all sections in $O_i$, the agent has produced a new draft $D_{i+1}$ that serves as both the output of the Drafting phase and the input observation for the subsequent Deepening phase.

Reasoning-Driven Deepening

This is the paper's core mechanism for breaking through the insight ceiling. After completing a draft $D_{i+1}$, the policy $\pi_\theta$ shifts from local drafting to global planning, treating the newly generated draft as a "fresh observation for reasoning and diagnosis" (Section 2.2).

Why the draft enables deeper reasoning: the agent now has concrete text to inspect. In the initial planning phase (Initialize), the agent only had the query $Q$ and some background context $C_0$. It could not know, for example, that a section on "neural scaling laws" would turn out to be shallow because the retrieved evidence only covered Chinchilla but not later critical work. But now, having written that section, the agent can read it and detect: this section is only 200 words, cites only 2 papers, and fails to address the compute-optimal frontier debate. The draft makes the gaps visible in a way that the abstract outline plan never could.

The Deepening phase proceeds as follows. The agent identifies a section $k^*$ that lacks depth and generates new sub-sections:

Oi+1←Oi⊕Expand{k∗}(Q,Oi,Di+1)O_{i+1} \leftarrow O_i \oplus \text{Expand}_{\{k^*\}}(Q, O_i, D_{i+1})

where $\text{Expand}_{\{k^*\}}$ takes the query, the current outline, and the full draft as input, and outputs new sub-sections to insert under section $k^*$. The $\oplus$ operator denotes updating the outline in-place — the new sub-sections become part of $O_{i+1}$, which will drive the next Drafting cycle.

What Expand produces concretely: from the prompts in Appendix A.1 (Figure 10), the Expand action outputs a JSON structure with a position indicator (e.g., "section-2.1"), a brief content description for the parent section, and a list of sub-sections, each with a title and a writing plan. These sub-sections are novel decompositions — they are not pre-planned expansions that were latent in the original outline. They are generated from the concrete experience of having drafted the parent section and recognized its inadequacy.

The key decision in the Deepening phase is: should the agent expand, or should it terminate? This is the $\text{Terminate}(Q, O_i, D_{i+1})$ action (Equation 5). The agent evaluates:

"the semantic density and logical coherence of the current draft"

and decides whether further expansion would yield meaningful improvement. The termination decision is learned — neither heuristic nor rule-based — and the training pipeline specifically addresses the difficulty of learning when to stop (via trajectory pruning, discussed below).

The loop structure in practice: the agent repeats Drafting → Deepening → Drafting → Deepening until it selects Terminate. The paper caps the number of deepening steps at 12 and the report structure at three hierarchical levels to ensure efficiency (Section 3.1). At each Deepening step, the agent can choose to expand zero, one, or (implicitly) multiple sections — though in practice the action space is designed around expanding one section at a time and then re-entering Drafting to fill the new sub-sections.

Data Preparation and Trajectory Pruning

Training the agent to execute the WARP loop requires high-quality demonstration trajectories. The paper identifies a critical problem with using large teacher models to generate these trajectories: the optimal stopping problem.

The Optimal Stopping Problem

Large teacher models (the paper uses Qwen3-235B-A22B-Instruct-2507), even at 235B parameters, cannot reliably decide when to stop deepening. The paper states:

"Teacher models often either expand indefinitely or terminate arbitrarily"

This is not surprising — determining when a research report is "complete" is genuinely ambiguous, and LLMs are not trained on this kind of meta-cognitive decision. If the teacher's raw trajectories are used for training, the student model will learn to stop at essentially random points, sometimes truncating reports before they achieve sufficient depth and sometimes continuing to expand beyond the point of diminishing returns.

Trajectory Pruning Strategy

The solution is a post-hoc trajectory pruning procedure that decouples the teacher's content generation (which is high-quality) from its termination decisions (which are unreliable). The procedure works as follows:

  1. Force over-expansion: during trajectory collection (Appendix A.4), the teacher is explicitly forced to select a position for outline deepening at each Deepening phase. It is NOT allowed to terminate autonomously. Instead, "the agent continuously expands the outline and revises the report until a maximum of 12 expansions is reached." This produces a sequence of drafts with monotonically increasing granularity: $\{D_1, D_2, ..., D_N\}$ where $N \leq 12$.

  2. Score every intermediate draft: each draft $D_i$ in the sequence is scored using the holistic report-level reward function described in Appendix A.6.2 (which evaluates Comprehensiveness, Insight, Instruction-Following, and Readability). This produces a score curve $\{s_1, s_2, ..., s_N\}$ as a function of deepening depth.

  3. Retroactively select the optimal stopping point: the optimal draft $D_{i^*}$ is identified as the one with the highest score. Formally:

i∗=arg⁡max⁡is(Di)i^* = \arg\max_i s(D_i)

  1. Prune and relabel: the trajectory is truncated at $i^*$, discarding all subsequent expansion-write cycles. The action at step $i^*$ is relabeled to Terminate — teaching the agent that THIS is where the report achieved maximum quality and that further expansion would have been counterproductive.

What this procedure teaches: the student model learns that the optimal stopping criterion is not "am I tired of expanding" (which is what the teacher's raw termination decisions reflect) but rather "has the report achieved its maximum quality, and would further expansion reduce or maintain it?" The trajectory pruning embeds a supervision signal for information saturation — the point beyond which additional deepening yields zero or negative marginal gain.

Empirical validation of trajectory pruning: Table 5 shows the impact. An SFT model trained on raw (unpruned) teacher trajectories achieves an Overall score of 45.80 on DeepResearch Bench. An SFT model trained on pruned trajectories achieves 46.73, with consistent gains across all metrics — Comprehensiveness (44.95 → 46.24), Insight (47.35 → 48.10), Instruction-Following (46.71 → 47.61), and Readability (40.86 → 41.79). These gains are attributed to "cleaner training signals" — the pruned trajectories remove poorly-timed termination examples that would otherwise teach the agent to stop prematurely or continue past the quality peak.

Curriculum Policy Optimization

The training proceeds in three stages, each addressing a distinct failure mode. Figure 3 provides the overview; Table 7 provides hyperparameters.

Stage 1: Cold-Start SFT (Supervised Fine-Tuning)

Purpose: establish basic instruction-following and format adherence — the agent must learn what the five actions look like (their input/output formats, the XML/JSON structure of outlines, the expected citation format) before it can be optimized for quality.

Data: approximately 33k action-level samples extracted from 1,200 pruned teacher trajectories. These are the individual (state, action) pairs — the Initialize call that produced the first outline, the Search call that generated keywords for section 3, the Write call that produced the paragraph for section 2.1, etc. The action-level balanced sampling strategy (Appendix A.5) ensures that underrepresented but critical actions (Expand, Terminate) are sampled at higher rates than abundant but easier actions (Search, Write).

Training configuration: learning rate $1.5 \times 10^{-5}$, batch size 32, 4 epochs, approximately 2 days on 8 A100 GPUs.

What SFT alone achieves: as shown in Table 4, the SFT model averages 4.44 Expand actions and 21.24 Write actions per report, producing reports with an average of 6.27 Level-1 sections, 10.11 Level-2 sections, and 4.86 Level-3 sections. The reports are structurally sound but shallow — the SFT agent rarely deepens beyond the minimal outline, typically stopping within 6 deepening steps (Figure 6), well before reaching the empirically optimal depth of approximately 9 steps.

Stage 2: Atomic Skill RL

Purpose: master local execution of each action type — planning (Initialize, Expand), retrieval (Search), writing (Write), and decision-making (Terminate) — before attempting to coordinate them into an optimal global strategy. The paper's framing:

"To tackle the reward assignment problem, we first decompose the global objective to atomic abilities."

This decomposition addresses the sparse rewards challenge: in an end-to-end RL setting, the agent would only receive a single reward signal (the final report quality score) after a potentially very long trajectory. Credit assignment — determining which specific action contributed positively or negatively to that score — becomes intractable for an 8B model. By training on individual actions with dense, action-specific reward functions, the agent first learns "how" to execute each action well, after which global RL (Stage 3) only needs to optimize "when" to take which action.

Data: approximately 5,150 action-level samples from 300 pruned teacher trajectories. The teacher's actions serve as reference anchors — the RL objective encourages the agent to produce actions that match or exceed the teacher's quality according to the reward functions, but does not constrain the agent to exactly replicate the teacher's output.

Training configuration: learning rate $2.5 \times 10^{-6}$, batch size 8, 8 rollouts per sample, 200 optimization steps, approximately 2 days on 8 A100 GPUs. The use of rollouts (generating multiple candidate actions and scoring them against the reference) stabilizes exploration compared to pure on-policy RL.

Reward functions (Table 1, Appendix A.6.1): each action type has a tailored reward function combining rule-based checks and LLM-as-Judge evaluations. The judgment model for LLM-as-Judge evaluations is Qwen2.5-72B-Instruct.

  • Planning (Initialize, Expand): rewards are computed from three components:

    • Basic Properties: checks whether the number of sub-sections per section is between 2 and 7, and verifies language consistency via character statistics (e.g., no mixed-language output, no garbled formatting). No reference or LLM needed — purely rule-based.
    • Holistic Quality: evaluated by LLM on three dimensions adapted from OmniThink (Xi et al., 2025): Guidance (does the outline effectively guide content generation with comprehensive topic coverage?), Hierarchical Clarity (does the outline clearly define topic-subtopic relationships with logical, diverse structure?), and Logical Coherence (does the outline organize topics with smooth, natural flow and clear transitions?). Each dimension is scored on a 1–5 scale (detailed rubrics in Table 8, Appendix B.2).
    • Faithfulness: following FactScore (Min et al., 2023), checks whether factual claims in the outline's writing plans are verifiable — i.e., whether the planned content would correspond to real, citable information rather than fabricated assertions.

  • Retrieval (Search): reward uses Recall Score, comparing the documents retrieved by the agent's generated keywords against golden reference documents (from the teacher's trajectory). This is a reference-based metric that does not require LLM judgment.

  • Writing (Write): rewards are computed from four components:

    • Basic Properties: constrains paragraph length to 100–2000 tokens, citation count per paragraph to 0–12, and checks language consistency. All rule-based.
    • Holistic Quality: evaluated by LLM on four dimensions adapted from STORM (Shao et al., 2024): Relevance (maintaining focus despite the dynamic discourse), Coverage (in-depth exploration with good breadth), Depth (thorough exploration of the topic and related areas), and Novelty (covering aspects related to user intent but not directly derived from it). Scored 1–5 per dimension (detailed rubrics in Table 9, Appendix B.2).
    • Faithfulness: penalizes unsupported claims — if the generated paragraph asserts a fact that is not backed by any of the citations, the faithfulness score drops. This is LLM-evaluated.
    • Citation Precision: first checks for citation hallucination (any hallucination → score = 0). Then computes F1 score between the generated citations and the golden reference citations from the teacher's trajectory. This is a reference-based component.

  • Decision-Making (Terminate): reward is binary — 1.0 if the agent's termination decision matches the reference (i.e., it terminates at the pruned optimal point; it does NOT terminate when the reference indicates further expansion is warranted), 0.0 otherwise. This is the simplest reward function but addresses the hardest learning problem.

Why these reward components together: the combination of rule-based checks (ensuring basic format validity), LLM-as-Judge evaluations (capturing qualitative dimensions like coherence and novelty), and reference-alignment metrics (ensuring the agent produces outputs comparable to or better than the teacher) provides dense, multi-faceted feedback. A generation that is beautiful prose but full of hallucinated citations will score high on Holistic Quality but low on Citation Precision and Faithfulness — the combined reward prevents the agent from gaming any single dimension.

What Atomic RL achieves: Table 4 shows the behavioral shift. The Atomic RL agent dramatically increases its use of Write (from 21.24 to 36.89 actions) and Expand (from 4.44 to 8.88 actions), producing substantially more fine-grained sub-sectioning (Level-3 sections rise from 4.86 to 16.50). Figure 5 confirms that "RL training drives the agent to deepen more compared to SFT, ensuring at least 4 Expand steps in all cases." Critically, this is not blind expansion — the agent is learning to identify genuinely underdeveloped sections and expand them, not just to expand for expansion's sake.

Stage 3: Holistic Pipeline RL

Purpose: optimize global report quality by allowing the agent to deviate from the teacher's path and discover strategies that the teacher model never demonstrated. The paper frames this as:

"Local correctness (e.g., a valid paragraph) does not guarantee global coherence."

An agent that writes perfect individual paragraphs may still produce a report that is redundant (multiple sections covering the same ground), unbalanced (one section is 3,000 words, another is 100), or logically disconnected (the sections do not build on each other). Holistic Pipeline RL directly optimizes the end-to-end report score, enabling the agent to learn tradeoffs that are invisible at the per-action level.

Data: 500 user queries (from the 2,000-query dataset described in Appendix A.2), with no reference trajectories — the agent explores freely.

Training configuration: learning rate $1 \times 10^{-6}$, batch size 8, 4 rollouts per query, 50 training steps, approximately 4 days on 8 A100 GPUs.

Reward function (Appendix A.6.2): the final report is scored by Qwen3-32B (Yang et al., 2025) on four dimensions:

  • Comprehensiveness: breadth and coverage — does the report address all major aspects of the topic?
  • Insight: depth and novelty — does the report synthesize information into non-obvious conclusions, identify contradictions, or draw connections between disparate sources?
  • Instruction-Following: adherence to the user query — does the report answer what was asked, in the requested format and scope?
  • Readability: clarity and presentation — is the report well-structured, logically flowing, and easy to follow?

These dimensions echo the evaluation metrics on DeepResearch Bench (Section 3.1), creating alignment between what the training objective rewards and what the benchmarks measure.

The crucial learning dynamic: by propagating the holistic report score backward through the entire trajectory, the agent learns to trigger deepening "only when it yields significant informational gain" (Section 2.3.2). This is what the paper calls "refining the quality-efficiency frontier" — the agent discovers that some sections benefit from multiple rounds of expansion (because each round uncovers genuinely new evidence and insights), while others saturate quickly (because the topic is bounded and further retrieval yields only redundant or tangentially relevant documents). The teacher model could not teach this — its expansions were forced, not optimized — so the agent must discover it through trial-and-error exploration.

What Holistic Pipeline RL achieves: Table 2 shows the cumulative gains. On DeepResearch Bench, Comprehensiveness rises from 48.70 (Atomic RL) to 50.54 (Pipeline RL), Insight from 51.36 to 52.64, and Readability from 42.25 to 44.17. Figure 6 reveals the mechanism: the Pipeline RL agent shifts its stopping distribution toward 6–15 deepening steps, closely matching the empirically optimal depth identified by the forced expansion experiment (where quality plateaus at approximately 9 steps). The SFT agent typically stops at 4–6 steps and "rarely reaches the saturation regime"; the RL-trained agents push into the saturation regime and learn to stop there rather than continuing into diminishing returns.

Summary of Design Choices and Their Justifications

  • Unified state representation $S_i = (Q, O_i, D_i, C_i)$: by making outline and draft both part of the observable state, the policy can condition any action (Write, Expand, Terminate) on the full research context, enabling the dynamic planning-writing coupling that is the paper's central contribution.

  • Sparse initial outline vs. comprehensive pre-planning: deliberately avoiding detailed pre-factual planning reduces the risk that the outline encodes the model's parametric hallucinations or knowledge gaps as structural constraints that the writer cannot escape.

  • Contextual retrieval conditioning on $D_i$: prevents fragmentation and redundancy in multi-section reports by ensuring each new retrieval query builds on the accumulating argument rather than treating sections as independent tasks.

  • Trajectory pruning via $\arg\max_i s(D_i)$: decouples the teacher's high-quality content generation from its unreliable termination decisions, providing supervision for the optimal stopping point without requiring the teacher to know when to stop.

  • Three-stage curriculum (SFT → Atomic RL → Pipeline RL): addresses the stability challenge of training small models for long-horizon tasks by first establishing format adherence (SFT), then mastering local action quality with dense rewards (Atomic RL), and finally optimizing global strategy with sparse but holistic rewards (Pipeline RL). Without the intermediate Atomic RL stage, the agent would face the intractable credit assignment problem of mapping a single report score back to potentially dozens of individual actions.

  • Per-action reward decomposition in Atomic RL: the design of Basic Properties (rule-based sanity checks) + Holistic Quality (LLM-judged qualitative assessment) + Reference Alignment (metric-based comparison to teacher) provides multi-faceted feedback that prevents reward hacking — the agent cannot maximize Holistic Quality by generating eloquent but hallucinated text because Citation Precision and Faithfulness will penalize it.

  • Delay of global optimization to Stage 3: the agent first learns "how" to plan, search, write, and decide (Atomic RL), and only then learns "when" and "how much" (Pipeline RL). This ordering ensures that exploration in Stage 3 operates in a space of already-competent actions rather than wasting exploration budget on learning basic execution skills.

  • Local, static retrieval environment (2.86M documents): trades off coverage and timeliness for reproducibility and privacy — every experiment can be exactly replicated because the retrieval environment does not change, and no user data ever leaves the local system. The paper explicitly acknowledges this as a limitation in Section 4.

4. Key Insights and Innovations

Innovation 1: Planning and Writing Are Not Separate Phases But Equivalent Policy Decisions

The paper's most fundamental conceptual move is its reframing of deep research from a pipeline with structurally distinct phases (plan, then write) to a unified sequential decision-making process where modifying the outline and generating content are the same kind of action. This is not an architectural tweak — it is a rejection of the premise that has organized the entire prior generation of deep research systems.

What the field did before. Plan-then-write systems (WebWeaver, AutoSurvey, SurveyForge, and the commercial systems from OpenAI, Google, and Anthropic cited in Section 3.1) all operationalize the same assumption: constructing a comprehensive outline is logically prior to writing, and the writer's job is to faithfully execute that blueprint. This assumption is so ingrained that even systems which call their outlines "dynamic" (e.g., WebWeaver's dynamic outline) still treat outline construction as a separate stage that happens before section-level drafting, with at most minor adjustments during writing. The separation is baked into the system architecture: there is a planner component and a writer component, and they communicate unidirectionally.

What WARP does differently. The unified state $S_i = (Q, O_i, D_i, C_i)$ and the policy $\pi_\theta$ that selects from {Initialize, Search, Write, Expand, Terminate} make no structural distinction between "planning time" and "writing time." An Expand action — which modifies the outline by decomposing a section into sub-inquiries — is selected by the same policy, from the same state representation, as a Write action. The formalism treats $O_i \rightarrow O_{i+1}$ (outline change) and $D_i \rightarrow D_{i+1}$ (content generation) as "equivalent state transitions." This means there is no privileged phase, no frozen blueprint, and no architectural boundary that prevents writing discoveries from immediately reshaping the plan.

Why this is a fundamental shift, not an incremental one. The paper is not proposing a better planner or a better writer within the plan-then-write framework. It is arguing that the framework itself is the bottleneck — that "the rigid separation between planning and writing" (Section 1) is the root cause of both the insight ceiling and the dependency on large models. If planning and writing are separate, then any insight that emerges during writing cannot influence the plan, which means the report is structurally capped at whatever the planner could foresee. If they are unified, the plan can continuously improve as the agent learns from its own output. This reframing converts the deep research problem from "how do we build a better pre-factual planner?" (which is intractable, since the information landscape is opaque at the outset) to "how do we train a policy that learns to detect gaps mid-composition?" (which is difficult but feasible, as the paper demonstrates).

Evidence that the reframing matters, not just the training. Table 3 provides the cleanest test: a prompt-based comparison on DeepResearch Bench using the large Qwen3-235B model, with no training. The plan-then-write paradigm (where the model freezes an outline first) scores 49.90 Overall. The WARP paradigm (where the model starts from a sparse outline and interleaves drafting with deepening, controlled entirely through prompting) scores 50.72. The gain is concentrated in Insight (+1.19) and Comprehensiveness (+0.98). This matters because it isolates the paradigm effect from the training effect: even a 235B model, deployed zero-shot, benefits from interleaving planning and writing. The multi-stage training then amplifies this benefit for the 8B model, but the paradigm itself is doing genuine work independent of model scale.

Connecting to the paper's broader argument. The reframing is what enables the paper to claim that "the primary bottleneck lies not in model size, but in the design of effective cognitive and planning processes that fully leverage a model's inherent capabilities" (Section 3.2). If the bottleneck were model capability, then scaling from 8B to 235B with the same paradigm would yield large gains — but Table 3 shows that changing the paradigm (without changing model size) already delivers gains, and Table 2 shows that the 8B model with the right paradigm can match or exceed proprietary systems likely running on much larger models. The paradigm shift, not the model scale, drives the result.

Innovation 2: Trajectory Pruning as a Solution to the Optimal Stopping Problem in Open-Ended Tasks

The paper identifies and solves a training problem that is specific to open-ended generation with iterative refinement: even large teacher models cannot reliably determine when to stop deepening. This is not a minor implementation detail — it is a fundamental obstacle to training agents for any task where quality is a non-monotonic function of effort and the optimal stopping point depends on content that does not yet exist.

The problem the field has been ignoring. In most RL training setups for language agents, termination is either (a) triggered by an environment signal (the task is complete when a test passes, a goal state is reached, or a fixed budget is exhausted), or (b) learned through imitation of a teacher's termination decisions. The paper points out that neither approach works for open-ended deep research. There is no environment signal for "the report is insightful enough" — the quality function is holistic and unobservable during generation. And teacher models, as the paper explicitly observes, "often either expand indefinitely or terminate arbitrarily" (Section 2.3.1). The teacher's termination decisions are not a reliable supervision signal; they are effectively noise. This means the standard approach of behavioral cloning from teacher trajectories would teach the student to stop at essentially arbitrary points.

What trajectory pruning does conceptually. The paper's solution is to decouple the teacher's execution quality (which is high) from its termination decisions (which are unreliable). The procedure — force the teacher to over-expand, score every intermediate draft using the holistic reward function, retroactively identify the highest-scoring draft $D_{i^*}$, and prune the trajectory at that point — relabels the problem from "when did the teacher choose to stop?" to "when should the agent have stopped to maximize report quality?" This transforms a noisy imitation signal into a clean optimization signal for information saturation.

Why this is a general insight, not just a data-cleaning trick. The optimal stopping problem is not unique to deep research. It arises in any task where iterative refinement can both improve and degrade output quality: code generation with repeated debugging passes, multi-turn dialogue where additional turns can clarify or confuse, iterative text editing where each revision can fix or introduce errors. The trajectory pruning strategy — force over-generation, score all intermediate outputs, retroactively select the peak, and train on the truncated trajectory — is a general recipe for extracting clean termination supervision from teachers that produce high-quality intermediate states but unreliable stop decisions. The paper formalizes this insight in the specific context of deep research but the concept transfers.

Evidence that the problem is real and the solution works. Table 5 provides the controlled ablation: SFT trained on raw (unpruned) teacher trajectories scores 45.80 Overall; SFT trained on pruned trajectories scores 46.73. The gains are consistent across all dimensions, but notable in Insight (47.35 → 48.10) and Readability (40.86 → 41.79). The Insight gain suggests that unpruned trajectories sometimes teach the agent to stop before it has extracted the deepest insights from its evidence; the Readability gain suggests that unpruned trajectories sometimes teach the agent to continue expanding beyond the point where added content degrades clarity. Both failure modes are corrected by pruning to the quality peak.

A limitation the paper does not fully explore. The trajectory pruning requires access to a holistic reward function that can score intermediate drafts — in this paper, Qwen3-32B evaluating Comprehensiveness, Insight, Instruction-Following, and Readability. This means the pruning quality is bounded by the judge model's reliability. If the judge model has systematic biases (e.g., always preferring longer reports, or failing to detect subtle logical contradictions), the pruned trajectories will embed those biases. The paper does not ablate the judge model choice, leaving open the question of how sensitive the results are to the specific reward function used for pruning.

Innovation 3: Proof That Policy Design Can Substitute for Model Scale in Deep Research

The paper's headline result — an 8B model matching or exceeding Gemini-2.5-Pro, Claude, OpenAI's deep research system, and others — is not just a benchmark victory. It is empirical evidence for a claim that has been circulating but rarely demonstrated at this level of rigor: that for deep research tasks, the architecture of the agent's cognitive process is more binding than the raw capability of the underlying model.

What makes this evidence distinctive. Many papers show that a smaller model with extensive fine-tuning can approach a larger model's performance on a specific task. What distinguishes this result is the direction of the gains. The 8B model does not win on Readability (44.17, below Gemini's 50.00 and Claude's 44.66 — it actually loses to Claude here) or Instruction-Following (48.87, below several baselines). It wins on Insight (52.64 vs. Gemini's 49.45) and Comprehensiveness (50.54 vs. Gemini's 49.51). These are the dimensions that plan-then-write systems' architecture should inherently cap — Insight because static outlines cannot capture emergent connections, Comprehensiveness because pre-factual planning cannot anticipate the full scope of a topic. The 8B model with WARP exceeds large models precisely where the paradigm difference should matter most. Meanwhile, on Readability — a dimension that depends more on surface-level language quality (vocabulary, sentence flow, transitions) and less on structural reasoning — the large models retain an advantage, as one would expect from their greater parametric capacity for fluent generation.

The implication for the scaling-versus-architecture debate. The paper provides a concrete counterexample to the default assumption that better deep research requires bigger models. If the bottleneck were fundamentally capability-based, then proprietary systems running on models likely 1–2 orders of magnitude larger than 8B should dominate across all dimensions. The fact that they do not — and that the specific dimensions where the small model wins are exactly those that the WARP architecture is designed to improve — suggests that the current generation of deployed systems is architecture-limited, not capability-limited. This does not mean model scale is irrelevant (the 8B model loses on Readability, and the paper acknowledges that the 8B model's presentation quality — tables, figures, formatting — is weaker, per Section 4's discussion of "Better report presentation"). But it does mean that allocating research effort to architectural innovation may have higher marginal returns than further scaling, at least for Insight and Comprehensiveness.

The significance of the DeepResearch Gym result. Figure 4 shows AgentCPM-Report achieving 100.0 on Depth, Breadth, and Insightfulness — perfect scores on the dimensions most directly tied to the dynamic deepening mechanism. This is not just "competitive with proprietary systems"; it is ceiling performance on the metrics that measure exactly what the paper's method is designed to improve. The near-perfect scores strongly suggest that the WARP loop is operating as intended: it detects shallow sections, expands them, retrieves targeted evidence, and continues until saturation, producing reports that leave essentially no obvious gaps or unexplored angles detectable by the GPT-4.1-mini judge.

Caveats that prevent overclaiming. The paper is careful to note that the gains are concentrated — readability and presentation remain weak points, and the FLOPs comparison (Appendix B.1: the 8B model trains on 8 A100 GPUs for ~8 days) does not account for the teacher model's inference cost during data generation. The Qwen3-235B teacher that generates the training trajectories is a large model itself — so the claim is not that an 8B model can be trained entirely without large-model supervision, but rather that once trained, the 8B model can operate independently and match systems that require large-model inference at deployment time. This is a meaningful distinction for privacy-sensitive deployment: the large model is used during training (which can happen in a controlled environment) but never sees user queries at inference time.

Innovation 4: Diagnosing and Mitigating Reward Over-Optimization Through Curriculum Design

The paper's three-stage curriculum — Cold-Start SFT, Atomic Skill RL, and Holistic Pipeline RL — is not just a scheduling choice. It embodies a specific hypothesis about how to train agents for long-horizon tasks with sparse rewards without encountering the pathologies that plague end-to-end RL: reward hacking, credit assignment collapse, and premature convergence to locally optimal but globally poor strategies.

The diagnostic move. The paper identifies two distinct training challenges that interact destructively if addressed simultaneously: (a) the agent does not yet know how to execute individual actions well (poor planning, shallow writing, imprecise retrieval), and (b) the agent does not yet know which sequences of actions lead to good final reports. End-to-end RL faces both problems at once — the agent must simultaneously learn action quality and global strategy from a single sparse reward signal at the end of a long trajectory. This is the classic credit assignment problem, made worse by the fact that report quality (Insight, Comprehensiveness) is genuinely difficult to evaluate automatically and the reward signal is noisy.

The curriculum as a decomposition of the learning problem. By inserting Atomic Skill RL between SFT and Holistic Pipeline RL, the paper creates an intermediate stage where the agent can master "how" (producing valid plans, precise searches, coherent paragraphs) with dense, action-specific reward signals, without having to worry about "when" and "how much" (which sections to expand, when to stop). The dense rewards in Atomic RL — Basic Properties (rule-based sanity checks), Holistic Quality (LLM-judged), and Reference Alignment (metric-based comparison to teacher outputs) — provide per-action feedback that would be impossible to extract from a single end-of-trajectory report score. Once the agent can execute individual actions competently, Holistic Pipeline RL can focus exclusively on the global strategy problem — when to deepen, which sections to expand, when to terminate — because the quality floor for each action is already established.

Why this matters beyond this paper. The curriculum design addresses a general problem in RL for language agents: the tension between exploration efficiency and reward signal density. If rewards are dense (per-action feedback), the agent can learn quickly but may over-optimize local metrics at the expense of global coherence (e.g., writing beautiful individual paragraphs that are redundant or contradictory). If rewards are sparse (end-of-trajectory feedback), the agent struggles with credit assignment and may never discover good strategies. The three-stage curriculum is a principled compromise: learn local competence with dense rewards, then freeze or slow local learning and optimize global strategy with sparse rewards. This pattern — local mastery before global optimization — should transfer to other long-horizon agent tasks (multi-step tool use, code generation with execution feedback, interactive dialogue systems).

Evidence that the curriculum prevents reward hacking. Figure 6 and Table 4 together show that the agent does not simply learn to maximize the number of Expand actions (which might artificially inflate Comprehensiveness scores by adding more sections regardless of quality). The SFT agent averages 4.44 Expand actions; Atomic RL increases to 8.88; Pipeline RL settles at 8.63 — slightly fewer than Atomic RL, suggesting the agent has learned that some expansions are counterproductive. The forced expansion experiment in Figure 6 confirms that report quality plateaus around 9 deepening steps, and the Pipeline RL agent's stopping distribution clusters around 6–15 steps — it learns to stop near the empirically optimal depth rather than continuing indefinitely. This is evidence that the Holistic Pipeline RL stage successfully teaches the agent to balance depth against efficiency, suppressing redundant expansions that Atomic RL alone might have encouraged.

A subtlety the paper does not fully explain. The per-action reward functions in Atomic RL include Holistic Quality dimensions evaluated by Qwen2.5-72B-Instruct — a large model. This means Atomic RL is not "dense" in the sense of being cheap or automatic; it requires running a 72B judge model for every training action. The paper does not ablate whether the same curriculum would work with purely rule-based rewards (Basic Properties + Reference Alignment, without Holistic Quality), which would be substantially cheaper. This leaves open the question of whether the curriculum's effectiveness depends on the quality of the LLM-as-Judge signal or whether rule-based rewards would suffice for the Atomic RL stage.

5. Experimental Analysis

Evaluation Methodology

  • Dataset. The paper evaluates on three benchmarks: DeepResearch Bench (100 PhD-level scientific tasks spanning 22 academic domains, constructed by Du et al., 2025), DeepConsult (102 business and financial analysis queries, sourced from a public GitHub repository), and DeepResearch Gym (100 general-purpose information-seeking tasks sampled from the top 1,000 test queries of the Researchy Questions dataset, following the evaluation protocol of Coelho et al., 2025). The training data consists of approximately 2,000 internally constructed user queries — roughly 700 from academic survey topics (reverse-generated from arXiv surveys) and 1,300 from general research reporting questions — each paired with a scoring checklist for reward computation. Of these, approximately 1,500 were used for trajectory data construction (SFT and Atomic RL), and the remaining 500 were reserved for end-to-end Holistic Pipeline RL.

  • Base model(s). The agent backbone is MiniCPM4.1-8B (Team et al., 2025), chosen to demonstrate that a fully local, on-device model can achieve deep research capability without relying on external large-scale systems. For the prompt-based paradigm comparison in Section 3.3.1, the paper uses Qwen3-235B-A22B-Instruct-2507 (Yang et al., 2025) as a larger-model reference point. The teacher model for trajectory data generation during training is also Qwen3-235B-A22B-Instruct-2507. For LLM-as-Judge evaluations during Atomic Skill RL, the paper uses Qwen2.5-72B-Instruct; for Holistic Pipeline RL and benchmark evaluation scoring, the judge model is Qwen3-32B. The benchmark judges per standard protocols are Gemini-2.5-Pro (DeepResearch Bench), o3-mini-2025-01-31 (DeepConsult), and GPT-4.1-mini-20250414 (DeepResearch Gym).

  • Metrics. On DeepResearch Bench (Table 2), evaluation follows the RACE and FACT frameworks: Comprehensiveness (breadth of topic coverage), Insight (depth and novelty of synthesis), Instruction-Following (adherence to the query specification), and Readability (clarity and structural flow), with an Overall score aggregating these dimensions. On DeepConsult (Table 2), evaluation is via pairwise comparison against an OpenAI-DeepSearch baseline, reporting average quality score (1–10 scale), Win rate, Tie rate, and Loss rate across dimensions including instruction following, comprehensiveness, completeness, and writing quality. On DeepResearch Gym (Figure 4), six aspects are scored: Clarity, Depth, Balance, Breadth, Support, and Insightfulness, each on a continuous scale where 100.0 represents ceiling performance. All metrics are computed by the benchmark-specific judge models described above, not by the paper's internal reward functions.

  • Baselines. The paper compares against three categories of systems (Section 3.1, Table 2, Figure 4):

    • Proprietary Systems: Doubao-research (ByteDance, 2025), Claude-research (Anthropic, 2025), OpenAI-deepresearch (OpenAI, 2025), and Gemini-2.5-Pro-deepresearch (Google, 2025). These are commercial deep research products accessed through their respective APIs; their underlying model architectures and scales are not disclosed.
    • Prompt-Based Frameworks: WebWeaver configured with two backbones — Qwen3-30B-A3B and Claude-Sonnet-4 (Li et al., 2025b); Enterprise DR using Gemini-2.5-Pro as backbone (Prabhakar et al., 2025); and RhinoInsight using Gemini-2.5-Pro as backbone (Lei et al., 2025). These are published frameworks that use prompting to orchestrate deep research on top of existing LLMs, with no task-specific training.
    • Trained Open Models: WebShaper-32B (Tao et al., 2025), WebThinker-32B-DPO (Li et al., 2025a), and DR Tulu-8B (Shao et al., 2025). These are open-source models that have undergone training specifically for research or information-seeking tasks. DR Tulu-8B is the closest comparison point in model scale.
    • Ablation baselines (our system variants): AgentCPM-Report at three training stages — SFT only, Atomic RL, and Pipeline RL — to isolate the contribution of each curriculum stage.

  • Generation budget / compute accounting. The primary compute constraint is the number of deepening steps, capped at 12 during both training and inference (Section 3.1). Each deepening step triggers an Expand action followed by a full Drafting cycle (Search + Write actions for all sections in the updated outline), so the total generation budget per report is variable and depends on the agent's learned termination policy. The report structure is capped at three hierarchical levels. The paper does not report FLOPs or token counts for individual reports, nor does it compare inference-time compute across systems. For training compute: all experiments use 8 A100 GPUs, with SFT taking approximately 2 days, Atomic Skill RL approximately 2 days, and Holistic Pipeline RL approximately 4 days (Appendix B.1, Table 7). The teacher model (Qwen3-235B) inference cost for generating the 1,500 training trajectories is not reported.

  • Cross-validation / statistical protocol. The paper does not report cross-validation for benchmark evaluation — results in Table 2 and Figure 4 are single-run evaluations on the standard test sets of each benchmark. For the compute-optimal strategy selection problem that motivated the reference example paper (Snell et al.), this paper faces an analogous issue: the agent's learned policy implicitly encodes a "strategy" (when to deepen, when to stop) that was optimized on training data but evaluated on held-out benchmarks. The paper reports no variance estimates, confidence intervals, or statistical significance tests for any benchmark results. For the forced expansion experiment (Figure 6), multiple k values from 0 to 15 are evaluated, but each k represents a single configuration run, and the measurement is the mean performance across the 100-question DeepResearch Bench test set.

Main Quantitative Results

Overall Benchmark Performance: AgentCPM-Report vs. Proprietary and Open Systems

The paper's central quantitative claim is that an 8B model, trained with WARP and the multi-stage curriculum, matches or exceeds leading proprietary deep research systems, with gains concentrated in Insight and Comprehensiveness. Table 2 (DeepResearch Bench) and Figure 4 (DeepResearch Gym) provide the primary evidence.

DeepResearch Bench (Table 2). AgentCPM-Report (Pipeline RL) achieves an Overall score of 50.11, surpassing Gemini-2.5-Pro-deepresearch at 49.71 and every other proprietary system (Doubao-research: 44.34, Claude-research: 45.00, OpenAI-deepresearch: 46.45). Among prompt-based frameworks, only WebWeaver with Claude-Sonnet-4 (50.58) and RhinoInsight with Gemini-2.5-Pro (50.92) score higher — but both use large proprietary backbones, not the 8B MiniCPM model. Among trained open models, AgentCPM-Report substantially outperforms WebShaper-32B (34.93), WebThinker-32B-DPO (no Overall reported, but Insight 35.40 vs. AgentCPM-Report's 52.64), and DR Tulu-8B (no Overall reported, but Insight 41.80 vs. 52.64).

The dimensional breakdown reveals where the gains concentrate. On Comprehensiveness, AgentCPM-Report scores 50.54, exceeding Gemini-2.5-Pro-deepresearch (49.51), WebWeaver with Qwen3-30B-A3B (45.15), and DR Tulu-8B (41.70, though this number appears in a differently structured row of Table 2 and may not be directly comparable). On Insight, the advantage is larger: 52.64 for AgentCPM-Report vs. 49.45 for Gemini-2.5-Pro-deepresearch, 50.02 for WebWeaver with Claude-Sonnet-4, and 51.45 for RhinoInsight. On Instruction-Following, AgentCPM-Report scores 48.87, below Gemini (50.12) and several prompt-based frameworks (RhinoInsight: 51.72, Enterprise DR: 50.03, WebWeaver with Claude-Sonnet-4: 50.81). On Readability, AgentCPM-Report scores 44.17, the lowest among the top-tier systems (Gemini: 50.00, WebWeaver with Qwen3-30B-A3B: 47.34, OpenAI-deepresearch: 47.22). This pattern — winning on Insight and Comprehensiveness, losing on Readability — directly supports the paper's claim that WARP addresses the insight ceiling but that smaller models retain surface-level fluency disadvantages.

DeepConsult (Table 2). AgentCPM-Report (Pipeline RL) achieves an average quality score of 6.60, with a Win rate of 57.60%, Tie rate of 13.73%, and Loss rate of 28.68% against the OpenAI-DeepSearch baseline. This compares favorably to WebWeaver with Claude-Sonnet-4 (6.96 average, 66.86% Win, 10.47% Tie, 22.67% Loss) and Enterprise DR (6.82, 71.57% Win, 19.12% Tie, 9.31% Loss), but outperforms WebWeaver with Qwen3-30B-A3B (4.57, 28.65% Win, 34.90% Tie, 36.46% Loss) and WebShaper-32B (1.63, 3.25% Win, 3.75% Tie, 93.00% Loss). The paper does not report dimensional scores for DeepConsult, so it is unclear whether the Insight-Comprehensiveness advantage observed on DeepResearch Bench replicates in the business consulting domain.

DeepResearch Gym (Figure 4). AgentCPM-Report achieves perfect or near-perfect scores on multiple dimensions: Depth: 100.0, Breadth: 100.0, Insightfulness: 100.0, Balance: 96.89, Clarity: 95.75, Support: 98.22. The overall average of 98.48 is reported as state-of-the-art, though the paper does not provide a direct comparison table with other systems on this benchmark in the main text — Figure 4 is a bar chart showing AgentCPM-Report's scores without competitor overlaid values, so the "state-of-the-art" claim rests on the text statement rather than a side-by-side table.

Curriculum Training Stage Progression: Does Each Stage Help?

Table 2 provides ablation over training stages, showing monotonic improvement from SFT → Atomic RL → Pipeline RL across all metrics on DeepResearch Bench:

  • Overall: 46.73 (SFT) → 48.81 (Atomic RL) → 50.11 (Pipeline RL), a total gain of +3.38 points.
  • Comprehensiveness: 46.24 → 48.70 → 50.54 (+4.30)
  • Insight: 48.10 → 51.36 → 52.64 (+4.54)
  • Readability: 41.79 → 42.25 → 44.17 (+2.38)

The Insight gain is the largest absolute improvement (+4.54), consistent with the claim that Reasoning-Driven Deepening, which is learned primarily through the RL stages, drives insight generation. Readability improves the least (+2.38), consistent with the finding that surface-level fluency is more a function of base model capability than training paradigm.

On DeepConsult, the progression is also monotonic: average score 6.04 (SFT) → 6.06 (Atomic RL) → 6.60 (Pipeline RL); Win rate 54.17% → 56.13% → 57.60%; Loss rate 35.54% → 32.84% → 28.68%. The jump from Atomic RL to Pipeline RL is substantially larger than from SFT to Atomic RL (average score: +0.54 vs. +0.02), suggesting that holistic pipeline optimization contributes more to business-style report quality than atomic skill refinement alone — possibly because business reports require tighter global coherence and strategic depth that per-action rewards cannot capture.

Key observation about SFT-only performance: The SFT model already achieves 46.73 Overall, which is competitive with OpenAI-deepresearch (46.45) and exceeds Doubao-research (44.34) and WebShaper-32B (34.93). This means that even without RL, the WARP paradigm trained via supervised fine-tuning on pruned teacher trajectories produces a competent deep research agent. The RL stages provide meaningful but incremental gains, raising the question of whether the paradigm (WARP) or the training (RL curriculum) is the larger driver of the final performance.

Paradigm Comparison: Does WARP Work Without Training?

Table 3 isolates the paradigm effect by comparing plan-then-write vs. WARP using the large Qwen3-235B model with prompting only, no training. WARP achieves an Overall score of 50.72 vs. plan-then-write's 49.90, with gains in Comprehensiveness (50.33 vs. 49.35, +0.98) and Insight (52.79 vs. 51.60, +1.19). Readability improves modestly (47.20 vs. 46.46, +0.74). Instruction-Following is essentially flat (50.32 vs. 50.13, +0.19).

This is a critical result for the paper's argument: it demonstrates that interleaving drafting with deepening provides gains independent of the multi-stage training, validating the paradigm itself as a contributor to report quality. However, the gain magnitude (+0.82 Overall) is modest compared to the gap between the SFT 8B model (46.73) and the 235B prompt-only WARP system (50.72) — a 3.99-point gap attributable to model scale — and compared to the gain from adding Pipeline RL to SFT (+3.38 on the 8B model). This suggests that while the paradigm helps, the combination of paradigm + training on paradigm-appropriate data is what produces the largest gains.

Behavioral Analysis: How Does Agent Behavior Evolve Across Training Stages?

Table 4 and Figures 5–6 examine how the agent's internal behavior changes as training progresses, providing mechanistic evidence for the paper's claims about what the curriculum teaches.

Action frequency changes (Table 4): The Write action count increases from 21.24 (SFT) to 36.89 (Atomic RL) to 39.51 (Pipeline RL). Since Write actions correspond to individual section/sub-section generations, this reflects the increasing structural granularity of reports. The Expand action count nearly doubles from 4.44 (SFT) to 8.88 (Atomic RL) and then slightly decreases to 8.63 (Pipeline RL). The expansion from SFT to Atomic RL is attributed to RL teaching the agent to identify and expand underdeveloped sections; the slight decrease from Atomic RL to Pipeline RL suggests the agent is learning efficiency — suppressing some expansions that Atomic RL encouraged but that do not improve the final report score.

Hierarchical structure changes (Table 4): Level-1 sections remain roughly constant (6.27 → 6.49 → 6.52), indicating that the top-level topic structure is largely determined by the initial outline and does not change much with training. Level-2 sections grow from 10.11 (SFT) to 14.17 (Atomic RL) to 15.75 (Pipeline RL) — a 56% increase, reflecting the agent's learned tendency to decompose high-level sections into sub-topics. Level-3 sections show the most dramatic growth: from 4.86 (SFT) to 16.50 (Atomic RL, +240%) to 17.32 (Pipeline RL, +256%). This is the signature of Reasoning-Driven Deepening: the agent is learning to produce fine-grained sub-sub-sections that the initial sparse outline never anticipated.

Expand step distribution (Figure 5): The SFT agent's Expand step distribution is concentrated at lower values (the figure shows a sharp drop after ~4 steps). The Atomic RL and Pipeline RL agents shift the distribution rightward, with Pipeline RL "ensuring at least 4 Expand steps in all cases" and reaching up to the maximum of 12 steps in some trajectories. This shift is presented as evidence that RL training teaches the agent to deepen beyond the minimal level learned during SFT.

Forced expansion experiment (Figure 6): When the Pipeline RL agent is forced to expand exactly k times (for k = 0 to 15), report quality increases steadily from shallow depths, plateaus around k = 9 steps, and shows slight decline or noise beyond that. This inverted-U shape validates the trajectory pruning logic: there exists an optimal deepening depth, and expanding beyond it yields diminishing or negative returns. The figure also overlays the actual stopping distributions of the SFT, Atomic RL, and Pipeline RL agents: the SFT agent typically stops at 4–6 steps (below the plateau), while the Atomic RL and Pipeline RL agents shift toward 6–15 steps, with a mode around 8–10 — closely matching the empirically optimal depth. This is the paper's strongest evidence that the curriculum successfully teaches the agent when to stop, not just how to expand.

Ablation Studies and Robustness Checks

Trajectory pruning (Table 5): Training SFT with pruned vs. unpruned teacher trajectories. With pruning: Overall 46.73, Comprehensiveness 46.24, Insight 48.10, Instruction-Following 47.61, Readability 41.79. Without pruning: Overall 45.80, Comprehensiveness 44.95, Insight 47.35, Instruction-Following 46.71, Readability 40.86. The pruning gain is +0.93 Overall, with Insight (+0.75) and Comprehensiveness (+1.29) showing the largest improvements. This ablation isolates the contribution of the trajectory pruning strategy specifically — the exact same SFT training procedure, differing only in whether the teacher's raw (arbitrary) termination points or the reward-optimized pruned termination points are used as supervision. The finding is that pruning improves all dimensions, confirming that teacher termination decisions are indeed suboptimal and that retroactive quality-peak selection provides cleaner training signals.

Why this ablation matters: It directly addresses the concern that the gains from WARP could be entirely attributable to the multi-stage RL curriculum rather than the data quality intervention. The SFT-only ablation with vs. without pruning shows that even without any RL, improving the termination supervision signal yields measurable gains. This supports the paper's diagnosis of the optimal stopping problem as a genuine bottleneck in teacher-supervised training for open-ended generation.

Training stage ablation (Table 2, discussed above): The SFT → Atomic RL → Pipeline RL progression serves as an implicit ablation of the curriculum design. The monotonic improvement across stages validates that each stage contributes, but the paper does not run the inverse ablations: What happens if you go directly from SFT to Pipeline RL without Atomic RL? What happens if Atomic RL is trained for more steps and Pipeline RL is omitted? These missing ablations leave open the question of whether the three-stage decomposition is necessary or merely sufficient.

Does the paradigm work without training? (Table 3, discussed above): This serves as an ablation of the training pipeline — running WARP purely via prompting on a large model isolates the paradigm effect from the multi-stage training effect. The +0.82 Overall gain on the 235B model confirms the paradigm contributes independently.

Missing ablations: The paper does not ablate several design choices that would strengthen the causal claims:

  • Sparse vs. detailed initial outline: The paper claims that WARP's sparse initial outline is important because it "mitigates the risk of being ungrounded," but never compares against a variant where the Initialize action produces a detailed multi-level outline (as in plan-then-write systems) and the subsequent WARP loop operates on top of it. This would isolate whether the benefit comes from dynamic deepening per se or specifically from starting sparse.
  • Contextual vs. independent retrieval conditioning: The Drafting phase conditions retrieval queries on the accumulating draft $D_i$ to enforce contextual consistency. No ablation compares against independent per-section retrieval queries to quantify how much the contextual conditioning contributes to the reported Comprehensiveness and coherence gains.
  • Edit-distance-based pairing for revision training: This is not applicable — the paper does not use per-section revision in the style of the reference example paper. However, an analogous design choice is the trajectory pruning threshold: what if the optimal stopping point were selected by a different criterion (e.g., when the marginal gain drops below a threshold) rather than the global maximum? This is not explored.
  • RL reward function components: The Atomic RL stage uses multi-component rewards (Basic Properties + Holistic Quality + Reference Alignment). The paper does not ablate which components are necessary — could the same gains be achieved with only rule-based rewards, or only reference alignment, without the expensive LLM-as-Judge evaluations? This matters because LLM-as-Judge with Qwen2.5-72B-Instruct is computationally expensive.
  • Teacher model scale: All training trajectories are generated by Qwen3-235B. What would happen with a smaller teacher (e.g., Qwen3-72B or even the 8B model itself in a self-play or distillation loop)? The paper's claim that "the primary bottleneck lies not in model size" is partially undercut by the reliance on a 235B teacher for training data.
  • Number of training queries: The paper uses 1,200 queries for SFT, 300 for Atomic RL, and 500 for Pipeline RL. No ablation varies these numbers to establish a scaling trend — does performance saturate at these data volumes, or would more queries continue to improve results?

Negative result: Readability ceiling. Although not framed as an ablation, the consistent Readability gap between AgentCPM-Report and large proprietary systems (44.17 vs. ~50.00) is a de facto negative result: the WARP paradigm and multi-stage training do not close the fluency gap between 8B and much larger models. The paper acknowledges this in Section 4 ("Better report presentation") and attributes it partly to the coupling of content generation with formatting/structural reasoning. This is an honest but significant limitation — for deployment scenarios where presentation quality matters as much as analytical depth, the 8B model may not be sufficient even with optimal training.

Negative result or missing data: compute scaling. The paper does not report how AgentCPM-Report's performance scales with inference compute (number of deepening steps, total generation budget, or wall-clock time per report). The forced expansion experiment (Figure 6) provides a partial picture by varying k, but this is a controlled post-hoc intervention that overrides the agent's learned policy — it does not show how the agent naturally allocates compute across queries of varying difficulty. Without this analysis, it is unclear whether the agent is compute-efficient compared to baselines or simply achieves higher quality by using more inference-time computation. The paper caps deepening at 12 steps and structure at 3 levels, but does not report the average actual deepening depth, generation token count, or total retrieval calls per report for any system, making cost-quality tradeoffs impossible to assess from the reported data.

Critical Assessment

Claim: "AgentCPM-Report matches or outperforms the leading closed-source deep research systems." (Abstract, Section 3.2)

This claim is supported with qualifications. On DeepResearch Bench Overall, AgentCPM-Report (50.11) edges past Gemini-2.5-Pro-deepresearch (49.71) but is surpassed by WebWeaver with Claude-Sonnet-4 (50.58) and RhinoInsight with Gemini-2.5-Pro (50.92) — both prompt-based frameworks running on large proprietary backbones. The paper's narrative emphasizes the Insight and Comprehensiveness wins (52.64 vs. 49.45, 50.54 vs. 49.51), which is fair but selective — on Instruction-Following and Readability, the closed-source systems maintain clear leads. The DeepResearch Gym result (100.0 on Depth, Breadth, Insightfulness) is ceiling performance, but Figure 4 does not overlay competitor scores for direct comparison, and the text only asserts "state-of-the-art" without a side-by-side table. On DeepConsult, AgentCPM-Report (6.60 average, 57.60% Win) is competitive but not dominant — several prompt-based systems score higher averages and win rates.

The more important qualification: the comparison is not controlled for inference compute. Proprietary deep research systems are black boxes — their underlying models, search budgets, and report generation costs are unknown. AgentCPM-Report may achieve its 50.11 Overall using substantially more or less inference-time computation than Gemini-2.5-Pro-deepresearch uses to achieve 49.71. Without FLOPs or token counts, the claim of "matching" is about output quality only, not efficiency. The paper does not report generation cost for any system.

Claim: "The primary bottleneck lies not in model size, but in the design of effective cognitive and planning processes." (Section 3.2)

The evidence supports a qualified version of this claim: paradigm matters more than expected for Insight and Comprehensiveness, but model scale still matters for Readability and likely for the upper bound of achievable quality. The strongest evidence is (a) the 8B model beating much larger systems on Insight (52.64 vs. 49.45), and (b) the paradigm comparison in Table 3 where WARP outperforms plan-then-write on the same 235B model. However, the claim is weakened by the reliance on a 235B teacher model for training data — the 8B model's capabilities are distilled from a model ~30x larger, so the "model size" bottleneck is still present in the training pipeline even if not at inference time. The paper's formulation "the primary bottleneck lies not in model size" would be more strongly supported if the training pipeline used a teacher model of comparable scale (e.g., a 7–13B teacher) and achieved similar results.

Claim: "Trajectory pruning effectively improves the quality of supervision" by solving the optimal stopping problem. (Section 2.3.1, Section 3.3.4)

Supported. Table 5 shows consistent improvement from pruning across all dimensions for SFT training. The +1.29 gain in Comprehensiveness and +0.75 gain in Insight are meaningful given that this is a pure data-quality intervention with no change to the training algorithm. The forced expansion experiment in Figure 6 provides converging evidence by showing that report quality follows an inverted-U shape with deepening depth, validating the premise that there exists a quality-maximizing stopping point that the raw teacher trajectories fail to identify.

Claim: "The multi-stage agentic training strategy enables stable and efficient learning" for small models on long-horizon tasks. (Section 2.3, Section 3.3.2)

The monotonic improvement across training stages (Table 2) supports that the curriculum works, but "stable and efficient" is not fully demonstrated. The paper does not report training curves, reward convergence, or variance across random seeds. The claim of stability is supported only by the fact that the final model performs well — no evidence is provided about training dynamics (e.g., whether Atomic RL prevents the collapse that would occur with end-to-end RL from scratch, whether Holistic Pipeline RL exhibits the reward hacking that the curriculum is designed to prevent). The claim of efficiency is supported by training time (8 days on 8 A100s) but this is not compared to alternative training strategies — how much longer would end-to-end RL take to converge? Would a simpler two-stage curriculum (SFT → end-to-end RL) work with more training steps? These comparisons are absent.

Genuine weaknesses in experimental design:

  • Missing cost analysis. The paper never reports the total inference compute (tokens generated, retrieval calls, wall-clock time) for AgentCPM-Report or any baseline. Without cost, claims of "matching" proprietary systems are about quality only, and the practical value of the 8B local solution cannot be assessed against the alternative of simply calling a cloud API.
  • Small evaluation sets with no variance reporting. DeepResearch Bench has 100 questions, DeepConsult 102, DeepResearch Gym 100. With no confidence intervals or error bars on any results, differences of 0.5–1.0 points on the 0–100 scale (e.g., AgentCPM-Report's 50.11 vs. Gemini's 49.71) may not be statistically meaningful. The DeepConsult pairwise comparison has 102 queries; a 57.60% win rate against OpenAI-DeepSearch with a 28.68% loss rate leaves significant room for variance.
  • Uncontrolled baseline comparisons. The proprietary systems (Gemini, Claude, OpenAI) are evaluated via their commercial deep research products, which may use search APIs, tool integrations, and report formatting pipelines that differ substantially from AgentCPM-Report's local retrieval environment. The prompt-based frameworks use different base models (Claude-Sonnet-4, Gemini-2.5-Pro, Qwen3-30B) — so the comparison is confounded: is AgentCPM-Report winning because WARP is better than WebWeaver's dynamic outline approach, or because the specific base models differ? The WebWeaver with Qwen3-30B-A3B comparison (Table 2: AgentCPM-Report 50.11 vs. WebWeaver-Qwen 46.77) partially addresses this, but the 30B vs. 8B parameter difference favors AgentCPM-Report's claim.
  • No diversity of base models. All experiments use MiniCPM4.1-8B. The paper does not demonstrate that WARP + multi-stage training transfers to other 7–13B model families (Llama, Mistral, Qwen, Gemma). The claim that "policy design is a viable alternative to model scaling" requires evidence that the paradigm works across architectures, not just on one specifically optimized model.
  • The forced expansion experiment overrides the agent's policy. Figure 6 forces k Expand actions regardless of the agent's judgment about which sections to expand or whether expansion is warranted. This measures the effect of any expansion on quality but does not measure the quality of the agent's selection of which sections to expand — a critical component of the WARP loop. An experiment that compares the agent's chosen expansion sequence against random expansion or against a baseline that expands the longest sections first would better isolate whether the agent has learned targeted deepening.
  • No analysis of retrieval quality or hallucination. The paper's local retrieval environment (2.86M documents) is static and substantially smaller than the live web search available to proprietary systems. No metrics report citation precision, factual accuracy, or hallucination rates in the generated reports. The Faithfulness reward in Atomic RL (Appendix A.6.1) penalizes unsupported claims, but final report faithfulness is never evaluated on the benchmarks, leaving open whether the Insight gains come at the cost of factual reliability.
  • The trajectory pruning relies on a judge model (Qwen3-32B) that may have systematic biases. If the judge model prefers longer reports, the pruned trajectories will favor later stopping points; if it penalizes repetition, earlier stopping points are favored. The paper does not validate the judge model's quality against human evaluations or against alternative judges, making the pruning criterion a potential source of unmeasured bias in the training data.

Experiments that would have strengthened the paper:

  • Ablation of retrieval conditioning: Compare Drafting with contextual retrieval (conditioned on $D_i$) vs. independent per-section retrieval, to quantify the contribution of "contextual consistency."
  • Inference compute scaling curves: Report performance vs. maximum allowed deepening steps (0, 3, 6, 9, 12, 15), vs. total generation tokens, for both AgentCPM-Report and at least one baseline (e.g., WebWeaver with Qwen3-30B), to assess whether quality gains come from more compute or better allocation of a fixed budget.
  • Human evaluation of Insight. The benchmarks use LLM-as-Judge for Insight scoring. A small-scale human evaluation (even 20–30 reports) comparing AgentCPM-Report against Gemini-2.5-Pro-deepresearch on Insight specifically would substantially strengthen the paper's central quality claim, given that Insight is the dimension most sensitive to judge model biases.
  • Multi-model replication. Run WARP (prompt-only, no training) on at least one additional model family (e.g., Llama-3.1-8B or Qwen2.5-7B) to test whether the paradigm benefit transfers. Run the full training pipeline on a different 7–8B base model to test whether the 8B results are specific to MiniCPM4.1.
  • Hallucination and factuality evaluation. Report citation precision, factuality scores (using FactScore or similar), and hallucination rates on a subset of generated DeepResearch Bench reports, to ensure the Insight gains are not achieved by generating plausible-sounding but unsupported claims.

Overall assessment of the experiments relative to claims:

The experiments convincingly demonstrate that the WARP paradigm plus multi-stage training produces an 8B agent that generates research reports scoring highly on Insight and Comprehensiveness according to LLM judges, competitive with much larger proprietary systems on those dimensions. The experiments also provide mechanistic evidence (action distributions, deepening depth, forced expansion curves) that the agent learns non-trivial behaviors — deeper sub-sectioning, adaptive stopping near the quality plateau — that distinguish it from SFT baselines. The trajectory pruning ablation is clean and informative.

Where the experimental support is thinner: (1) the claim of "matching closed-source systems" is true on some dimensions but not others, and the comparison is neither controlled for compute nor statistically validated; (2) the claim that model size is not the bottleneck is supported directionally but undercut by the reliance on a 235B teacher during training; (3) the three-stage curriculum is shown to work but not shown to be necessary — no ablation compares against alternative training schedules; (4) the complete absence of inference cost reporting and factual accuracy evaluation leaves practical deployment viability unaddressed. The paper demonstrates a genuine advance in architectural design for deep research agents, but the experimental evidence supports a narrower claim than the abstract and introduction suggest: WARP + multi-stage training on pruned trajectories produces an 8B model that excels at LLM-judged Insight and Comprehensiveness on select benchmarks, while trailing on Readability and Instruction-Following, with unknown inference cost and factuality characteristics.

6. Limitations and Trade-offs

6.1 Inference Compute and Latency Are Unreported, Making Cost-Quality Tradeoffs Impossible to Assess

The assumption or constraint. The paper establishes a 12-step deepening cap and a 3-level structural limit for efficiency (Section 3.1), but never reports the actual inference compute consumed by AgentCPM-Report or any baseline system. There is no measurement of total tokens generated, retrieval calls made, wall-clock time per report, or FLOPs consumed during inference. The paper does track training compute (8 A100 GPUs, ~8 days; Appendix B.1, Table 7), but the cost that matters for deployment — how much computation is needed to generate each report — is entirely absent.

The consequence. Without inference cost data, the central claim that AgentCPM-Report "matches or outperforms" proprietary systems (Abstract, Section 3.2) is only about output quality, not efficiency. It is entirely possible that AgentCPM-Report achieves its 50.11 Overall on DeepResearch Bench by using substantially more inference compute than Gemini-2.5-Pro-deepresearch uses to achieve its 49.71. The agent may be generating longer reports, performing more retrieval calls, or spending more wall-clock time than the proprietary baselines — but the paper provides no way to evaluate this. For a practitioner deciding between deploying the 8B model locally versus calling a cloud API, the missing cost data makes the comparison incomplete. Worse, the distinction between sequential and parallel operations matters practically: WARP's interleaved Drafting-Deepening loop is inherently sequential (each Deepening phase must wait for the Drafting phase to complete, and each section's retrieval is conditioned on prior sections' content), which may make latency substantially higher than the parallel generation strategies used in best-of-N or independent-section-writing approaches. The paper does not discuss this latency-vs-throughput tradeoff.

What evidence exists in the paper. None. The paper does not report tokens, retrieval calls, or wall-clock time for any system. The forced expansion experiment (Figure 6) varies deepening depth but does not translate this into compute units, so the quality-vs-compute scaling curve is observable only in terms of a proxy variable (number of Expand actions) whose relationship to actual computational cost is undefined. The paper's 12-step cap and 3-level limit (Section 3.1) indicate an awareness of efficiency concerns, but these constraints are not calibrated against any measured cost model.

Mitigation status. Not addressed. The paper does not acknowledge the absence of inference cost reporting as a limitation, nor does it suggest that future work should include cost analysis. This is a significant omission given that one of the paper's explicit motivations is enabling "fully local, on-device deep research" (Section 1) — a deployment scenario where inference efficiency is paramount.

6.2 The 8B Model's Gains Depend on Training Data from a 235B Teacher, Complicating the "Model Scale Is Not the Bottleneck" Claim

The assumption or constraint. All training trajectories — the 1,500 trajectories used for SFT and Atomic RL, containing approximately 100k actions (Appendix A.5) — are generated by Qwen3-235B-A22B-Instruct-2507, a model approximately 30× larger than the 8B deployment model. The trajectory pruning procedure (Section 2.3.1) uses Qwen3-32B as a judge model to score intermediate drafts and determine the optimal stopping point. The Atomic Skill RL stage uses Qwen2.5-72B-Instruct as the LLM-as-Judge for Holistic Quality evaluations of plans and paragraphs (Appendix A.6.1). The Holistic Pipeline RL stage uses Qwen3-32B to score final reports (Appendix A.6.2). At no point in the training pipeline is the 8B model trained without supervision from substantially larger models.

The consequence. The paper's headline argument — that "the primary bottleneck lies not in model size, but in the design of effective cognitive and planning processes" (Section 3.2) — is weakened by the dependence on large-model supervision during training. The 8B model's capabilities are distilled from a 235B teacher and refined using reward signals from 32B and 72B judge models. This means the claim is more precisely: given access to a large teacher model during training, a small model can be trained to match large models at inference time on specific dimensions. This is a meaningful result for privacy-sensitive deployment (the large model is never exposed to user queries), but it does not demonstrate that model scale is unimportant for deep research capability — it demonstrates that large-model capability can be compressed into a small model through careful training design. A practitioner without access to a 235B-class teacher model cannot replicate the full training pipeline. The paper does not test whether a smaller teacher (e.g., a 32B or 72B model) could produce trajectories of sufficient quality, or whether self-play or iterative distillation could close the gap without a large teacher.

What evidence exists in the paper. The reliance on large models is documented across the appendices: Appendix A.4 names Qwen3-235B as the teacher; Appendix A.6.1 names Qwen2.5-72B-Instruct as the Atomic RL judge; Appendix A.6.2 names Qwen3-32B as the Holistic RL judge. No ablation varies teacher or judge model scale. The paper does not claim that the training pipeline works with a smaller teacher, nor does it acknowledge this as a limitation.

Mitigation status. Not addressed. The paper frames the contribution as demonstrating that small models can achieve deep research capability when equipped with the right paradigm, but it does not discuss the teacher-model dependency or its implications for replicability. The distinction between "model scale matters at training time but not at inference time" is practically important (training can happen in a controlled environment; inference must be local and private) but is never made explicit in the limitations discussion.

6.3 Readability Remains a Persistent Weakness of the 8B Model, Creating an Uneven Quality Profile

The assumption or constraint. The paper's multi-stage training optimizes for Comprehensiveness and Insight through reasoning-driven deepening, but surface-level language quality — vocabulary, sentence fluency, structural transitions, and presentation formatting — receives less direct optimization. The Readability dimension in evaluation captures this construct, and the paper acknowledges in Section 4 ("Better report presentation") that "constructing tabular layouts requires a reasoning process fundamentally different from writing prose, placing heavy demands on a model's structural and formatting abilities" and that "this coupling partly explains why agent systems based on smaller models often underperform large ones in presentation quality."

The consequence. AgentCPM-Report's Readability scores are consistently the weakest dimension relative to proprietary systems. On DeepResearch Bench (Table 2), the Pipeline RL agent scores 44.17 on Readability versus Gemini-2.5-Pro-deepresearch's 50.00 (-11.7%), Claude-research's 44.66 (-1.1%), and OpenAI-deepresearch's 47.22 (-6.5%). The Readability gap partially offsets the Insight and Comprehensiveness advantages, producing an Overall score (50.11) that only narrowly edges Gemini (49.71) despite much larger Insight and Comprehensiveness leads. On DeepResearch Gym (Figure 4), Clarity scores 95.75 — high but below the perfect 100.0 achieved on Depth, Breadth, and Insightfulness — suggesting that even on the benchmark where AgentCPM-Report is strongest, presentation quality is the relative weak point. This uneven quality profile means the 8B model produces reports that are analytically deep but may read less fluently than those from larger models — a tradeoff that matters differently depending on the use case (a researcher analyzing the report's content may care primarily about Insight; a client reading a consulting report may care at least as much about Readability).

What evidence exists in the paper. Table 2 provides the Readability numbers across all systems and training stages. The Readability improvement from SFT (41.79) to Pipeline RL (44.17) is only +2.38 points, compared to +4.30 for Comprehensiveness and +4.54 for Insight — evidence that the training pipeline improves Readability less than it improves content depth. The paper's discussion in Section 4 explicitly acknowledges the problem and proposes decoupling presentation from content generation in future work, confirming that the authors view this as a genuine limitation rather than a measurement artifact.

Mitigation status. Partially addressed through future work suggestions. Section 4 proposes "decoupling presentation from content generation and assigning it to a dedicated rendering agent," and suggests that "current readability evaluation remains largely text-based and weakly reflects the true visual structure of rendered reports, suggesting the need for visual-modality evaluation." These are reasonable directions but are not implemented or tested. The paper does not provide evidence that the proposed decoupling would close the readability gap, nor does it quantify how much of the gap is attributable to model scale versus the coupling of content and presentation in the WARP framework.

6.4 Benchmark Evaluations Are Based on Small Test Sets with No Statistical Significance Testing, and LLM-as-Judge Reliability Is Not Validated for the Key Metrics

The assumption or constraint. All benchmark evaluations use small test sets: DeepResearch Bench has 100 questions, DeepConsult has 102, and DeepResearch Gym has 100 (sampled from a larger pool per the protocol in Appendix B.2). All metrics are computed by LLM judges (Gemini-2.5-Pro, o3-mini, GPT-4.1-mini) with no human validation of judge reliability on these specific benchmarks. The paper reports no confidence intervals, standard errors, or statistical significance tests for any comparison. For the DeepConsult benchmark, evaluation is pairwise (AgentCPM-Report vs. OpenAI-DeepSearch), so the 102 queries produce Win/Tie/Loss rates whose statistical reliability depends on the agreement rate between the judge's pairwise preferences and true quality differences.

The consequence. Differences of 0.5–2.0 points on the 0–100 scale of DeepResearch Bench — such as the crucial 50.11 vs. 49.71 Overall comparison between AgentCPM-Report and Gemini-2.5-Pro-deepresearch — cannot be interpreted as meaningful without knowing the variance. If the standard error of the mean on a 100-question test set is, say, 1.5–2.0 points (plausible given the wide difficulty range of PhD-level questions across 22 domains), then a 0.4-point difference is well within noise and the claim of "surpassing" Gemini is not supported. Similarly, the 57.60% Win rate on DeepConsult (102 pairwise comparisons) could be consistent with no true difference if the confidence interval around that rate is wide. The Insight metric — the paper's strongest result — is evaluated by LLM judges whose ability to distinguish genuine analytical depth from fluent-but-shallow prose is unvalidated. If the judge model exhibits a length bias (preferring longer reports regardless of insight quality), the Insight gains may partially reflect the increased structural granularity documented in Table 4 (Level-3 sections rising from 4.86 to 17.32) rather than truly deeper synthesis.

What evidence exists in the paper. The paper reports mean scores without any measure of dispersion (no standard deviations, no confidence intervals, no error bars on figures). The LLM judges are specified (Appendix B.2) but no judge agreement metrics (e.g., inter-annotator agreement with human evaluators, correlation between judge scores and downstream task performance) are reported. The paper does not discuss the reliability of LLM-based evaluation for deep research report quality, despite this being a known concern in the literature.

Mitigation status. Not addressed. The paper treats the benchmark scores as point estimates and draws comparative conclusions from them without qualification. This is standard practice in much of the LLM evaluation literature, but it is a genuine limitation for a paper whose core qualitative claim — that an 8B model matches or exceeds proprietary systems — rests on narrow numerical margins on small test sets evaluated by unvalidated automated judges. A small-scale human evaluation (even 20–30 reports) comparing AgentCPM-Report against one strong baseline on Insight specifically would substantially strengthen the claim but is not conducted.

6.5 The Agent's Learned Behaviors Are Demonstrated on a Single Model Architecture with No Evidence of Transferability

The assumption or constraint. All experiments — both the multi-stage training and the final evaluation — use MiniCPM4.1-8B as the base model (Section 3.1). The paradigm comparison in Table 3 uses Qwen3-235B, but this is a prompt-only test (no training) on a single large model. The full training pipeline (SFT + Atomic RL + Pipeline RL) is never tested on any other 7–13B model family — not Llama, not Mistral, not Qwen at comparable scale, not Gemma. The paper's claim that "policy design is a viable alternative to model scaling for advancing deep research capabilities" (Section 4) requires the implicit assumption that the WARP paradigm and multi-stage training would transfer to other model architectures, but this assumption is untested.

The consequence. It is unknown whether the paper's results are specific to MiniCPM4.1-8B's particular strengths — its instruction-following behavior, its retrieval-conditioning capabilities, its in-context learning profile — or whether any competent 7–13B model could achieve similar results with the same training pipeline. For a practitioner choosing a base model for a local deep research system, the paper provides no guidance on whether MiniCPM4.1-8B is uniquely well-suited or whether a Llama-3.1-8B or Qwen2.5-7B would perform comparably. If the results are architecture-specific, the paper's broader claim about paradigm-over-scale is weakened — it may be that the particular combination of MiniCPM4.1-8B plus WARP plus multi-stage training works well, but that the paradigm itself does not generalize.

What evidence exists in the paper. None. The paper does not ablate base model choice. The paradigm comparison (Table 3) on Qwen3-235B shows that the paradigm transfers to a different architecture at large scale in a prompt-only setting, but this does not test whether the training pipeline transfers to different small architectures. The choice of MiniCPM4.1-8B is motivated by its status as an "ultra-efficient LLM on end devices" (Team et al., 2025, cited in Section 3.1), which aligns with the paper's on-device deployment goal, but the paper does not argue that MiniCPM4.1-8B has any properties that make WARP uniquely effective on it.

Mitigation status. Not addressed. The paper does not identify single-model evaluation as a limitation, nor does it call for multi-architecture replication in future work. The "Future Works" section (Section 4) focuses on presentation quality and information source expansion, not on model architecture generalization.

6.6 The Training Pipeline Uses a Static Local Retrieval Environment That Limits Coverage and Timeliness, and the Paper Does Not Characterize How Retrieval Quality Affects Report Quality

The assumption or constraint. All training and evaluation use a local database of approximately 2.86 million documents (2.71 million arXiv abstracts plus 150k web page summaries; Appendix A.3). Proprietary deep research systems (Gemini, OpenAI, Claude) have access to live web search and substantially larger, more up-to-date retrieval corpora. The paper acknowledges this in Section 4: "Our system relies on a locally deployed textual knowledge base (e.g., arXiv abstracts and web summaries), which ensures stability and reproducibility but limits coverage and timeliness. It also lacks access to images, videos, domain-specific corpora, and personalized data." The retrieval environment is explicitly designed to be static for reproducibility, but this is a constraint on both coverage (a query about recent events won't find relevant documents) and domain specificity (the query construction process in Appendix A.2 uses arXiv surveys and "general research reporting topics," so the retrieval corpus and training distribution are aligned — performance may degrade on queries from domains poorly covered by arXiv and general web summaries).

The consequence. The paper's benchmark results reflect performance in a specific retrieval environment whose characteristics — coverage, noise level, document quality — are unknown relative to the retrieval environments of the proprietary baselines. It is possible that AgentCPM-Report's Insight advantage would shrink or reverse if the proprietary systems' live web access provides them with higher-quality or more comprehensive evidence that compensates for their weaker planning paradigms. Conversely, it is possible that the static environment gives AgentCPM-Report an advantage on the specific benchmarks (whose questions may be well-covered by arXiv) while performance would degrade on queries requiring real-time information or domain-specific sources (financial filings, legal documents, medical literature). The paper provides no analysis of retrieval quality — no metrics on recall, precision, or relevance of retrieved documents for any benchmark queries — making it impossible to assess whether the report quality results are driven by the WARP paradigm or by fortuitous alignment between the retrieval corpus and the benchmark question distribution.

What evidence exists in the paper. Section 4 briefly acknowledges the limitation and proposes "expanding the knowledge base to support multi-modal content, local and personalized sources, and continuous updates" as future work. Appendix A.3 describes the retrieval corpus composition but provides no quality metrics. The main results (Table 2, Figure 4) do not include any retrieval-specific evaluation, and no ablation varies the retrieval environment (e.g., comparing against a larger or web-search-based retrieval setup, or injecting noise to test robustness). The DeepResearch Gym results (100.0 on Depth, Breadth, Insightfulness; Figure 4) may partially reflect ceiling effects if the retrieval corpus happens to contain comprehensive coverage of the sampled queries — but this cannot be assessed without retrieval quality metrics.

Mitigation status. Acknowledged in passing but not characterized. The paper treats the static retrieval environment as a constraint imposed by the privacy-preserving local deployment goal, which is a legitimate design choice. However, the limitation is deeper than acknowledged: because retrieval quality is never measured, it is unknown how much of the reported report quality depends on retrieval quality, how robust the WARP paradigm is to noisy or incomplete retrieval, and whether the paradigm's gains would persist in retrieval environments with different characteristics. The paper's future work suggestions (multi-modal, personalized sources) imply that retrieval quality matters but do not address the more fundamental question of whether WARP's dynamic deepening provides more benefit when retrieval is high-quality (because there is more evidence to discover through iterative expansion) or when retrieval is poor (because the initial outline is even more under-informed and needs more correction).

7. Implications and Future Directions

How This Work Changes the Landscape

This paper fundamentally reframes the deep research problem. The dominant paradigm — plan-then-write — treats research as a pipeline with structurally distinct phases: first construct an exhaustive outline, then execute it. The paper argues this separation is the root cause of two failures that the field had accepted as inherent: an insight ceiling (reports are structurally sound but intellectually shallow because the outline cannot anticipate discoveries that emerge only during writing) and a dependency on large models (small models are too weak at pre-factual planning to produce adequate outlines). By unifying planning and writing under a single policy — treating outline modification and content generation as equivalent state transitions — the paper demonstrates that both failures are artifacts of the architecture, not of model scale.

The magnitude of this shift is substantial but bounded. It is not a paradigm shift in the sense of overthrowing a fundamental assumption across the entire field — plan-then-write still dominates commercial systems and most research frameworks. But it is a reframing with teeth: the paper provides a concrete alternative architecture, a training methodology that makes it work on small models, and benchmark results showing that the alternative beats proprietary systems on the dimensions where the old paradigm is theoretically weakest (Insight: 52.64 vs. Gemini's 49.45; Comprehensiveness: 50.54 vs. 49.51, Table 2). The results are not incremental improvements within the plan-then-write framework — they come from rejecting it.

The paper also resolves a tension that had been latent in the literature. Plan-then-write systems produce structurally coherent but shallow reports; retrieval-then-write systems are flexible but degenerate into incoherence over long horizons (Section 1). The WARP loop offers a synthesis: iterative deepening provides structural stability (the outline evolves rather than dissolving) while the conditioning of both retrieval queries and expansions on the accumulating draft maintains coherence. The forced expansion experiment (Figure 6) provides mechanistic evidence for how this synthesis works — quality rises with depth to a saturation point, and the trained agent learns to stop near that point. This converts a design tension into a solved coordination problem.

The paper redirects research attention in two ways. More attractive: policy design and training methodology for long-horizon agent tasks — the demonstration that a carefully constructed curriculum (SFT → Atomic RL → Pipeline RL) with trajectory pruning can train an 8B model to execute a complex, self-directed research loop suggests that similar approaches could work for other open-ended generation tasks where quality depends on iterative refinement and the optimal stopping point is unknown. Less attractive: further work on static planning heuristics for deep research — if the bottleneck is the paradigm itself, incremental improvements to outline quality (better prompting, more retrieval during planning) hit diminishing returns against the fundamental problem that pre-factual planning cannot anticipate insights that emerge mid-composition. The paradigm comparison in Table 3, where even a 235B model benefits from WARP over plan-then-write, suggests that static planning is inherently capped regardless of model scale.

The trajectory pruning strategy is a transferable methodological contribution beyond deep research. The insight that teacher models produce high-quality intermediate states but unreliable termination decisions — and that retroactive quality-peak selection can decouple these — applies to any iterative refinement task where quality follows an inverted-U shape with effort. Training agents for code debugging, multi-turn dialogue, or iterative text editing all face the same optimal stopping problem, and the pruning procedure provides a general recipe for extracting clean supervision from noisy teacher trajectories.

Follow-Up Research This Work Enables

Ablation of sparse vs. detailed initial outlines with a controlled retrieval corpus. The paper claims that WARP's sparse initial outline "mitigates the risk of being ungrounded" but never tests this against a variant where Initialize produces a detailed multi-level outline and the subsequent WARP loop operates on top of it. A direct comparison would isolate whether the benefit comes from dynamic deepening per se or specifically from starting with an intentionally minimal plan. A strong experiment: on the 100-question DeepResearch Bench, compare WARP-sparse (current) against WARP-detailed (three-level outline at initialization, generated by the same base model with additional retrieval), measuring whether the detailed variant produces equivalent Insight gains or whether the pre-committed structure constrains subsequent deepening. If WARP-sparse wins, it validates the claim that outline sparsity is causal; if performance is equivalent, the paper's central architectural claim about initialization strategy is overstated.

Self-play training loop with a small teacher to eliminate the 235B dependency. The paper's 8B agent is distilled from Qwen3-235B teacher trajectories, complicating the claim that model scale is not the bottleneck. A natural follow-up would test whether the same training pipeline works with a teacher model of comparable or only moderately larger scale (e.g., Qwen3-32B, or even the 8B model itself in a bootstrapping loop where each generation's best outputs become training data for the next iteration). The key measurement would be the performance gap between AgentCPM-Report trained with a 235B teacher versus a 32B teacher, evaluated on DeepResearch Bench Insight and Comprehensiveness. If the gap is small, the paper's paradigm-over-scale argument strengthens substantially — the training pipeline works with accessible models. If the gap is large, the 8B model's capabilities are genuinely dependent on large-model distillation, and the paper's claim needs to be re-scoped to "small models can match large models at inference time given large-model training data."

Human evaluation of Insight on a stratified sample of DeepResearch Bench reports. The paper's headline result — 52.64 Insight vs. Gemini's 49.45 — is evaluated entirely by LLM judges (Gemini-2.5-Pro on this benchmark, Table 2). Given known concerns about LLM-as-Judge reliability for nuanced dimensions like analytical depth (length bias, stylistic preference, difficulty distinguishing genuine insight from fluent-but-shallow prose), a small-scale human evaluation would substantially strengthen the claim. A feasible design: sample 30–40 reports from DeepResearch Bench, stratified by difficulty and topic domain, comparing AgentCPM-Report (Pipeline RL) against Gemini-2.5-Pro-deepresearch and one prompt-based baseline (e.g., WebWeaver with Claude-Sonnet-4). Use domain-expert raters (PhD students or postdocs in relevant fields) to score Insight on a rubric aligned with the benchmark's Insight dimension, blind to system identity. Measure inter-rater reliability and correlation with LLM judge scores. If human raters confirm the Insight advantage, the paper's central claim is validated independent of judge model biases; if they do not, the result may be an artifact of LLM-as-Judge evaluation.

Inference compute scaling curves for WARP vs. plan-then-write baselines. The paper never reports inference cost — tokens generated, retrieval calls, wall-clock time — for any system, making cost-quality tradeoffs impossible to assess. A follow-up study would measure performance (DeepResearch Bench Overall, Insight, Comprehensiveness) as a function of total generation tokens for AgentCPM-Report, WebWeaver with Qwen3-30B-A3B, and the SFT ablation of AgentCPM-Report, across varying maximum deepening steps (4, 8, 12, 16). This would reveal whether AgentCPM-Report's quality advantage comes from better allocation of a fixed compute budget or from simply using more compute. If WARP achieves equivalent quality at lower token counts, it strengthens the efficiency argument for dynamic deepening over static planning. If WARP uses substantially more compute for the same quality, the deployment case shifts from "better" to "better but more expensive," which is still valuable but differently positioned.

Cross-model transfer of the full training pipeline to Llama-3.1-8B or Qwen2.5-7B. All experiments use MiniCPM4.1-8B. To establish that WARP + multi-stage training is a general method rather than a model-specific recipe, a replication on a different 7–8B base model is essential. The experiment would train Llama-3.1-8B or Qwen2.5-7B using the identical pipeline (same 1,500 teacher trajectories from Qwen3-235B, same Atomic RL rewards, same Holistic Pipeline RL setup) and evaluate on DeepResearch Bench. If the other base model achieves comparable Insight and Comprehensiveness gains (within ~2–3 points of MiniCPM4.1-8B on DeepResearch Bench Overall), it confirms that the paradigm generalizes across architectures. If performance collapses, it indicates that MiniCPM4.1-8B has specific properties (instruction-following behavior, retrieval-conditioning capability) that WARP exploits and that the method does not transfer cleanly. This experiment also serves as a stress test that would refine our understanding of whether the paradigm or the specific model drives the result.

Hallucination and factuality evaluation of generated reports. The paper's Atomic RL stage includes Faithfulness and Citation Precision rewards (Table 1), but final report factuality is never evaluated on any benchmark. The concern is that the Insight gains might come partially from generating plausible-sounding but unsupported claims that an LLM judge interprets as novel synthesis. A follow-up would measure citation precision (fraction of cited claims actually supported by the cited document) and factuality (using FactScore or a similar atomic claim verification framework) on a sample of 50–100 DeepResearch Bench reports from AgentCPM-Report, Gemini-2.5-Pro-deepresearch, and the SFT baseline. If AgentCPM-Report's factuality is comparable to or better than the baselines, it validates that the Insight gains are genuine. If factuality is worse, the paper's results need to be interpreted as trading off factual reliability for perceived insightfulness — a genuine tradeoff that the current evaluation does not capture. This experiment would also characterize whether the static retrieval environment (2.86M documents) is sufficient to support the factual claims made in the reports, or whether the agent sometimes fabricates citations or misrepresents retrieved content.

Practical Applications and Downstream Use Cases

On-device, privacy-preserving research report generation for sensitive enterprise data. The paper's explicit motivation — "fully local, on-device deep research and writing solution that does not depend on external large-scale models" (Section 1) — directly addresses enterprise settings where uploading proprietary data to cloud APIs is prohibited. An organization conducting internal strategic analysis (market research, competitive intelligence, technology landscape reports) could deploy AgentCPM-Report on local hardware (8 A100 GPUs for training, then inference on a single GPU or even CPU-quantized deployment given the 8B model size) and generate research reports without any data leaving the organization's network. The benchmark results suggest reports would be analytically deep (Insight 52.64 on DeepResearch Bench, 100.0 Insightfulness on DeepResearch Gym) but would lag in presentation quality (Readability 44.17) compared to cloud alternatives. For use cases where analytical depth and data sovereignty matter more than surface fluency — internal research memos, technical due diligence, scientific literature reviews — this is a viable deployment today.

Cost-efficient batch report generation for academic literature surveys. The paper's query construction includes 700 academic survey tasks reverse-generated from arXiv papers (Appendix A.2), and the retrieval corpus is primarily ArXiv abstracts (2.71M of 2.86M documents). This directly supports automated survey generation for researchers who need to map a new field, track developments across sub-disciplines, or generate draft literature reviews. The 8B model's strong Insight performance (52.64, exceeding Gemini's 49.45) suggests it can identify non-obvious connections and contradictions in the literature, while the Retrieval Recall reward in Atomic RL (Table 1) ensures evidence grounding. A practical workflow: a researcher provides a topic query, the system generates a draft survey with dynamic deepening to expand shallow sections, and the researcher reviews and edits rather than writing from scratch. The fully local operation means the system can run on institutional compute without exposing unpublished research directions to external APIs. The limitation is the static retrieval corpus — surveys will be current only up to the last ArXiv update in the local database, and domains not well-covered by ArXiv will be underserved.

Self-improving data generation for fine-tuning research-capable models. The paper's training pipeline demonstrates that small models can learn complex research behaviors from teacher-generated trajectories with trajectory pruning to improve supervision quality. This establishes a template for bootstrapping research capability in new model families: use a strong teacher (or an already-trained research agent) to generate high-quality trajectories on a diverse query set, apply trajectory pruning to select optimal stopping points, train a target model via the three-stage curriculum, and then use that model to generate improved trajectories for the next iteration. The key enabling property is that trajectory pruning converts a teacher model's noisy termination decisions into clean supervision based on output quality, making the bootstrap loop more stable than naive behavioral cloning. Organizations developing specialized models for legal research, medical literature review, or policy analysis could adapt this pipeline to their domain-specific retrieval corpora and evaluation rubrics, progressively improving report quality across iterations without requiring ever-larger base models.

When to Prefer This Method Over Alternatives

The paper's architecture positions WARP against plan-then-write (WebWeaver, AutoSurvey, SurveyForge) and retrieval-then-write (Step-DeepResearch) alternatives. The tradeoffs are:

  • Prefer WARP + multi-stage training (AgentCPM-Report) when: (a) Insight and Comprehensiveness are the primary quality dimensions — the method wins on these specifically (52.64 vs. 49.45 Insight, 50.54 vs. 49.51 Comprehensiveness vs. Gemini, Table 2) and the dynamic deepening mechanism is designed to produce exactly these gains; (b) data privacy requires fully local operation — the 8B model runs entirely on-device with a local retrieval corpus, and the training pipeline can be executed once in a controlled environment before deployment; (c) the domain is well-covered by the available retrieval corpus — the method's performance depends on being able to find relevant evidence during iterative deepening, and gaps in retrieval coverage cannot be compensated for by the planning paradigm; (d) a large teacher model is available during training but not at inference — the pipeline requires 235B-class trajectory generation and 32–72B judge models, but these are used only offline.

  • Prefer plan-then-write (or commercial proprietary systems) when: (a) Readability and presentation quality are critical — the 8B model trails large proprietary systems on these dimensions (44.17 vs. Gemini's 50.00, Table 2), and the paper explicitly acknowledges that presentation formatting is a weakness for small models; (b) the retrieval corpus requires live web search for timeliness or coverage — the static local database limits relevance for queries about recent events or domains not well-represented in ArXiv and general web summaries; (c) latency is critical and the sequential Drafting-Deepening loop is too slow — WARP's interleaved structure is inherently sequential (each Deepening phase must wait for the Drafting phase to complete), which may produce higher wall-clock time than parallel-section-generation approaches used in some plan-then-write systems, though the paper does not report latency data to quantify this; (d) no large teacher model is available for trajectory generation — the training pipeline has not been demonstrated with smaller teachers, and attempting to bootstrap from an 8B teacher may produce substantially weaker results.

  • Prefer retrieval-then-write when: the task is short-form and does not require long-horizon structural coherence — the paper cites retrieval-then-write as suffering from coherence collapse over long horizons (Section 1), but for concise reports (1–3 sections, minimal cross-section dependencies), the overhead of WARP's deepening loop may not be justified. The paper provides no data on this threshold, so this preference is inferred from the problem characterization rather than empirical comparison.