AgentFrontier: Expanding the Capability Frontier of LLM Agents with ZPD-Guided Data Synthesis

🎯 Pitch

A small 30B model trained on data calibrated to its own capability frontier outperforms proprietary deep-research agents like OpenAI and Gemini DeepResearch on Humanity’s Last Exam. The key is an automated pipeline that only keeps training questions the model cannot answer alone but can solve with tool-guided scaffolding, embodying Vygotsky’s Zone of Proximal Development. This same engine generates a self-evolving benchmark where the model scores 93.4%, exposing a massive gap between base competence and tool-augmented reasoning in all leading LLMs.

1. Executive Summary

This paper introduces AgentFrontier Engine, a data synthesis framework that operationalizes the educational theory of the Zone of Proximal Development to automatically generate training data at the precise frontier of an LLM's capabilities—tasks unsolvable by a base model alone (the Less Knowledgeable Peer) but solvable with tool-augmented guidance (the More Knowledgeable Other). The engine synthesizes multidisciplinary, knowledge-fusion QA pairs through a three-stage pipeline—seed generation from thematically coherent document triplets, iterative agentic refinement along four escalation dimensions (knowledge expansion, conceptual abstraction, factual grounding, computational formulation), and ZPD-based filtering via adversarial LKP–MKO calibration—and produces both knowledge-intensive data for continued pre-training and frontier-level reasoning trajectories for rejection-sampling fine-tuning. Training the AgentFrontier-30B-A3B model (Qwen3-30B-A3B with 50B tokens of continued pre-training followed by 12,000 ZPD-calibrated trajectories) achieves 28.6% on Humanity's Last Exam text-only, surpassing proprietary deep-research agents like OpenAI DeepResearch (26.6%) and Gemini DeepResearch (26.9%), and reaches 93.4% on the simultaneously introduced ZPD Exam-v1, a self-evolving benchmark constructed from the same engine that assesses agentic research capabilities through problems requiring cross-document synthesis and tool-orchestrated reasoning. A FLOPs-matched comparison is not performed, but the paper establishes that ZPD-guided data synthesis unlocks expert-level performance across disciplines only when the training data is calibrated to the model's capability frontier, as evidenced by the +3.8 to +3.9 absolute point advantage over the next-best fine-tuning dataset on HLE across 8B and 32B backbones and the 19.0-point pass@1-to-pass@8 gap that reveals a rich distribution of alternative correct trajectories suitable for subsequent reinforcement learning.

2. Context and Motivation

The Core Problem: We Don't Know How to Generate Training Data That Teaches LLMs to Reason Across Documents

The central challenge this paper addresses is deceptively simple: how do you create training data that teaches an LLM to perform complex, multi-step research—the kind that requires synthesizing information across multiple sources, not just retrieving facts from one? This is not a question about scaling up existing data pipelines; it's a question about the kind of data those pipelines produce. The paper argues that current data synthesis methods, even when scaled to enormous volumes, systematically fail to cultivate the integrative reasoning skills necessary for agentic behavior—the ability to use tools, reflect on intermediate findings, plan multi-step investigations, and fuse knowledge across heterogeneous documents.

This gap is significant because it represents a bottleneck in the path toward more capable AI agents (Section 1):

"The development of such abilities is slowed by the deficit in existing training corpora, which provide little systematic support for cultivating these agentic skills in a unified manner."

In other words, we have models with enough raw knowledge to answer questions when the answer is localized in a single document, but we lack training data that teaches them to behave like researchers—to connect, contrast, and integrate information across an entire corpus the way a human expert would when conducting a literature review or solving a novel scientific problem.

Why This Problem Matters: The Gap Between Retrieval and Research

The paper draws a sharp distinction between two modes of question-answering that existing benchmarks and training datasets conflate:

Localized retrieval (what current systems do well): The answer can be found by reading and comprehending a single document. A student might answer a question by reading one chapter of a textbook. RAG systems excel here because they retrieve the relevant context and feed it to the model.

Knowledge fusion (what current systems fail at): The answer requires integrating information from multiple documents that may use different terminology, provide complementary or contradictory evidence, or require the model to derive insights not explicitly stated in any single source. This is what a human researcher does when surveying a field—they don't just find one paper and stop; they synthesize across the literature.

The paper explicitly connects this to the limitations of retrieval-augmented generation (Section 1):

"While retrieval-augmented generation (RAG) excels when the answer can be grounded in a single document, its performance degrades on tasks requiring reasoning across heterogeneous information. This deficiency traces back to the dominant data-synthesis paradigms."

This is not a minor technical limitation—it's a fundamental capability gap. Real-world tasks like academic research, legal analysis, medical diagnosis, and engineering design all require this synthetic reasoning. If we cannot create training data that cultivates it, we are training models to be sophisticated search engines rather than reasoning agents.

The Failure of Existing Data Synthesis Paradigms

The paper identifies two dominant paradigms for synthetic data generation, both of which fall short for teaching knowledge fusion (Section 1):

Paradigm 1: Query-Centric Methods

These methods (exemplified by works like Yan et al., 2025) start from existing question-answer pairs and generate variations—rephrasing questions, changing numbers, or introducing minor perturbations. The problem is structural: if the original QA pair only requires single-document comprehension, varying it doesn't change the fundamental cognitive demand. It's like giving a student 100 variations of a textbook exercise rather than one comprehensive exam question that draws on the entire course. The model learns to pattern-match against question formats, not to reason across information boundaries.

Paradigm 2: Document-Centric Methods

These methods (exemplified by Fan et al., 2025; Yuan et al., 2025) ground QA generation in a document corpus—they extract passages, ask questions about them, and produce answers. While this improves factual richness, the paper argues it still falls short:

"Both approaches primarily assess localized comprehension, akin to examining a student on individual textbook chapters rather than their ability to synthesize insights across an entire curriculum."

The key insight is that document-centric methods typically generate questions from single documents or pairs of closely related documents. They test whether the model understood what it read, not whether it can actively search for, evaluate, and integrate information across a diverse corpus. The training signal reinforces retrieval, not research.

Why Existing Complexity Escalation Strategies Are Insufficient

The paper acknowledges that prior work has attempted to generate more difficult data through heuristics—incrementally adding constraints (Patel et al., 2025), stacking requirements, or using probes to distinguish reasoning from recitation (Yan et al., 2025). However, it identifies a critical missing piece (Section 1):

"Existing approaches typically rely on coarse-grained difficulty annotations or heuristically stacked constraints, without a precise mechanism for targeting this frontier. In practice, self-generated approaches tend to yield data that remain within the model's own expressive ceiling, making difficulty escalation noisy and unscalable."

This is a subtle but devastating critique. If you ask a model to generate "harder" questions, it will produce questions that it considers hard—which are, by definition, questions it can still reason about at some level. The generated data never escapes the model's own competence horizon. You get harder versions of the same kind of reasoning, not qualitatively different reasoning that requires new cognitive strategies. This is the "expressive ceiling" problem: self-play data generation cannot bootstrap capabilities that exceed the generating model's own limits because the generator can't reliably produce correct answers for problems it can't solve, making supervision impossible.

The Missing Ingredient: A Principled Framework for Difficulty Calibration

This brings us to the paper's central motivation: the need for a theory-driven mechanism that precisely targets the frontier of a model's capabilities—difficult enough to require new skills, but solvable with appropriate scaffolding so that correct supervision signals exist.

The paper draws this directly from Vygotsky's Zone of Proximal Development (Vygotsky, 1978), a foundational concept in educational psychology (Section 1). The ZPD defines the cognitive space between what a learner can do independently and what they can achieve with guidance from a more capable teacher. Tasks within this zone are maximally informative for learning: they're impossible alone, so they force the development of new competencies, but they're achievable with support, so the learner receives correct feedback rather than floundering.

The paper operationalizes this through two personas (Figure 2):

The Less Knowledgeable Peer (LKP): a base LLM without tools, representing the model's current independent capability.
The More Knowledgeable Other (MKO): a superior tool-augmented agent with access to search, scholarly literature retrieval, web browsing, and code execution, representing what the model can achieve with optimal scaffolding.

The ZPD is then defined as the set of tasks where: IsSolvableBy(LKP) = 0 AND IsSolvableBy(MKO) = 1. This is not a heuristic—it's a precise, operational definition that the data synthesis pipeline can verify automatically. Tasks that are solvable by the LKP are too easy (they go to continued pre-training). Tasks that even the MKO cannot solve are either flawed or genuinely beyond current capability frontiers (they go to human review). Only the middle tier—where the base model fails but the tool-augmented agent succeeds—provides the optimal training signal.

Reconciling Contradictory Pressures in Agent Training

A reader might reasonably ask: if tool-augmented agents already solve these problems, why train a model to do what the MKO already does? The answer lies in the distinction the paper draws between having access to tools and knowing how to orchestrate them. The MKO demonstrates successful trajectories—sequences of reasoning steps interleaved with tool calls—that the training model learns to emulate through rejection-sampling fine-tuning (Equation 1). The model isn't just learning answers; it's learning the meta-cognitive process of when to search, when to read deeply, when to compute, and how to synthesize findings.

This is fundamentally different from simply giving a model tool access at inference time. As the paper shows in its ZPD Exam analysis (Section 3.2), many models with access to identical tools perform poorly because of a "reasoning bottleneck"—they can call tools but cannot plan effectively across multiple calls or synthesize across the results. The training data from AgentFrontier teaches not just tool use but tool orchestration.

The Evaluation Gap: Static Benchmarks Cannot Track Moving Frontiers

The paper's motivation extends beyond training data to evaluation. Expert-crafted benchmarks like Humanity's Last Exam (Phan et al., 2025) are invaluable but have fundamental limitations (Section 1):

"Their prohibitive cost and lack of scalability underscore the urgent need for automated, frontier-level data synthesis pipelines."

Human experts are expensive, and once a benchmark is released, its questions are fixed. As models improve, performance saturates, and the benchmark ceases to differentiate top-tier systems. This is already happening: the paper notes that MMLU and similar benchmarks are approaching saturation for frontier models (Section 6). The field needs self-evolving benchmarks that recalibrate to the current capability frontier—precisely what the ZPD Exam provides by regenerating from fresh scientific papers (2023–2025) and re-applying the LKP–MKO filter against the current baseline model.

How This Paper Positions Itself

The paper positions its contribution not as a new model architecture or training algorithm, but as a data-centric intervention—a principled method for generating training data that is qualitatively different from what existing pipelines produce. The framing is explicitly pedagogical: rather than treating data synthesis as a scaling problem (generate more data, of higher stated difficulty), it treats it as a curriculum design problem (generate data at precisely the right difficulty for learning).

This positions the work at the intersection of several active research threads while distinguishing it from each:

Against programmatic generation methods (TaskCraft, Shi et al., 2025): These produce agentic tasks with verifiable trajectories but don't calibrate difficulty to the model's ZPD—they may generate tasks that are trivially easy or impossibly hard for a given model.
Against document-grounded methods (MegaScience, MiroVerse): These improve factual richness but remain tethered to single-document comprehension paradigms, failing to teach cross-document synthesis.
Against self-improvement methods (STaR, ReST $^{EM}$ ): These rely on the model generating its own training data, which the paper argues is fundamentally capped by the model's expressive ceiling—you cannot bootstrap past your own competence boundary.
Against static benchmarks (HLE, GPQA, MMLU): These are valuable for measurement but saturated and unscalable; the ZPD Exam offers a self-evolving alternative.

The paper's empirical contribution—demonstrating that ZPD-calibrated data enables a 30B-A3B MoE model to surpass proprietary research agents on HLE—serves as validation of the framework, not as an end in itself. The deeper claim is that the ZPD framework is a general principle for data synthesis that can be applied to any model, any domain, and any capability level to produce curriculum data that is optimally challenging at each stage of development.

The Stakes: Why Calibrated Difficulty Matters for the Path to AGI

The paper situates its work within the broader pursuit of artificial general intelligence, arguing that the gap between current models and human-level research capability is fundamentally a gap in synthetic reasoning—the ability to actively construct understanding from diverse sources rather than passively retrieve pre-existing answers. The ZPD framework addresses this by forcing models to develop the meta-cognitive skills of research: identifying what you don't know, formulating search strategies, evaluating source credibility, resolving contradictions, and integrating partial findings into a coherent whole. These are not skills that emerge from scaling pretraining alone; they require deliberate practice on tasks that are calibrated to be just beyond current reach. The AgentFrontier Engine provides the mechanism for generating such tasks at scale, which the paper argues is the critical missing infrastructure for advancing toward more capable, agentic AI systems.

3. Technical Approach

3.1 Reader Orientation

The AgentFrontier Engine is an automated data synthesis pipeline that generates question–answer pairs with solution trajectories designed to teach LLMs complex, multi-step research skills—specifically, the ability to search for, evaluate, and synthesize information across multiple documents rather than simply retrieving facts from a single source. It solves the problem of difficulty calibration: how do you automatically create training data that is precisely at the frontier of what a model can learn—impossible for the base model alone but solvable with appropriate tool support—so that every training example provides a maximally informative supervision signal? The shape of the solution is a three-stage adversarial pipeline: (1) generate seed questions from thematically related document triplets to force cross-document reasoning, (2) iteratively escalate their complexity using a tool-augmented refinement agent, and (3) filter to retain only tasks where a weak base model fails but a strong tool-augmented agent succeeds, operationalizing Vygotsky's Zone of Proximal Development as a data selection criterion.

3.2 Big-Picture Architecture (Diagram in Words)

The system has three major stages that transform a raw document corpus into calibrated training data, plus a parallel benchmark construction pipeline:

Stage I — Seed Question Generation: Takes a corpus of 1 million public web documents, chunks and cleans them, builds a retrieval index, identifies thematically coherent document triplets, and generates initial QA pairs that inherently require fusing information across at least three related sources. Output: D_seed, a set of seed question–answer pairs.
Stage II — Agentic Refinement: Takes each seed QA pair and passes it through an iterative escalation loop driven by a refinement agent A_refine equipped with four tools (web search, scholarly literature search, web browsing, Python code execution). The agent applies four escalation dimensions—knowledge expansion, conceptual abstraction, factual grounding, and computational formulation—to produce progressively more complex QA pairs over up to 30 iterations, stopping when the question becomes unsolvable by the base model (the LKP). Output: D_refined, a dataset of highly complex QA pairs.
Stage III — ZPD-based Filtering and Calibration: Takes each refined QA pair and evaluates it against two personas—a Less Knowledgeable Peer (base LLM, no tools) and a More Knowledgeable Other (strong tool-augmented agent). Pairs solvable by the LKP are routed to continued pre-training. Pairs unsolvable by the LKP but solvable by the MKO (via Best-of-3 verification) are retained for post-training as D_ZPD. Pairs unsolvable by both are flagged for human review. A semantic redundancy filter with threshold epsilon = 0.7 ensures diversity. Outputs: D_ZPD (frontier reasoning data), D_pretrain (knowledge-intensive data), D_human (flagged for review).
Parallel Benchmark Construction — ZPD Exam: Uses the same engine with a disjoint corpus of 30,000 recent scientific papers (2023–2025) and a stricter dual constraint: a problem must be unsolvable by the baseline model in three unaided attempts AND consistently solvable with tools in three attempts. This produces a 1,024-question benchmark that self-evolves as models improve.

Information flows through the system as: raw corpus → chunked texts → thematic triplets → seed QA pairs → iteratively refined QA pairs (with tool-call trajectories embedded in the refinement process) → ZPD-filtered pairs sorted into three quality tiers → model training (CPT on D_pretrain, RFT on D_ZPD) or human review (D_human).

3.3 Roadmap for the Deep Dive

First, the formal objective of rejection-sampling fine-tuning (Equation 1), the optimization target that determines what makes a "good" training trajectory, and the conditional likelihood decomposition that separates model learning from tool observations.
Second, Stage I — the document chunking, thematic coherence filtering, and seed QA generation process, including the retrieval-based triplet search strategy and the hyperparameters that control its behavior.
Third, Stage II — the agentic refinement loop: the four escalation dimensions, the tool suite, how the refinement agent A_refine is prompted, and the stopping criterion tied to ZPD.
Fourth, Stage III — the LKP–MKO adversarial calibration mechanism: how solvability is judged (via GPT-4o as automated judge), how Best-of-N verification stratifies data quality, and how the semantic redundancy filter operates.
Fifth, the ZPD Exam construction pipeline as a special case of the engine, including the corpus selection (2023–2025 papers), the stricter dual constraint, and the tiered diagnostic framework.
Sixth, the holistic training pipeline that combines continued pre-training (Equation 2) with rejection-sampling fine-tuning, including the 50B-token CPT corpus composition and the RFT training hyperparameters.

3.4 Detailed, Sentence-Based Technical Breakdown

This is primarily a data synthesis paper whose core idea is that training data for complex agentic reasoning must be calibrated to the model's Zone of Proximal Development—the frontier where tasks are unsolvable alone but solvable with scaffolding—and that an automated pipeline can operationalize this through adversarial filtering between a weak base model (LKP) and a strong tool-augmented agent (MKO).

Formal Objective: Rejection-Sampling Fine-Tuning (RFT)

The paper frames the training of the agent model as a supervised learning problem over reasoning trajectories. The core mathematical object is the conditional log-likelihood of a reasoning report given the research question and the history of previous reasoning steps and tool observations.

What is a trajectory? A trajectory for research question $q^{(i)}$ consists of $L_i$ rounds. In each round $j$ , the model generates a reasoning report $r_j^{(i)}$ —a natural language analysis that summarizes accumulated evidence, evaluates progress toward the answer, and specifies the next action (either invoking a tool or outputting a final answer). After generating $r_j^{(i)}$ , the model executes the specified tool call and receives an observation $o_j^{(i)}$ (search results, scholarly metadata, web page content, or code execution output). The next round conditions on the pair $(r_j^{(i)}, o_j^{(i)})$ . The initialization sets $r_0^{(i)} = o_0^{(i)} = \emptyset$ , meaning the first reasoning report is conditioned only on the question.

The training objective for a collection of $K$ accepted trajectories is:

$\mathcal{L}_{\text{RFT}}(\theta) = -\sum_{i=1}^{K} \sum_{j=1}^{L_i} \log p_\theta \left( r_j^{(i)} \;\middle|\; q^{(i)}, r_{j-1}^{(i)}, o_{j-1}^{(i)} \right)$

where $\theta$ denotes the model parameters, $q^{(i)}$ is the $i$ -th research question, $r_j^{(i)}$ is the reasoning report at round $j$ of trajectory $i$ , $o_{j-1}^{(i)}$ is the tool observation from the previous round (included as conditioning context), and $L_i$ is the total number of rounds in trajectory $i$ .

What it computes: For each accepted trajectory, the loss is the sum of negative log-probabilities of each reasoning report token, conditioned on the research question and all preceding reasoning reports and tool observations. The model is trained only on the reasoning report tokens—tool observations are included in the context window (so the model sees them when generating the next report) but their tokens are excluded from backpropagation. This is a standard autoregressive language modeling loss with selective token masking.

Why this form: The key design choice is training only on reasoning report tokens, not on tool observations. Tool observations are produced by external systems (search APIs, web scrapers, code interpreters) and contain information the model should learn to utilize but not to predict. If the loss included tool observations, the model would waste capacity learning to generate search result snippets or webpage content—a form of hallucination training. By conditioning on observations but backpropagating only through reasoning, the model learns the meta-cognitive skill of what to do with information rather than what information will look like. This is the fundamental distinction between training an agent and training a knowledge base.

The conditioning structure $p_\theta(r_j \mid q, r_{j-1}, o_{j-1})$ is Markovian in the sense that only the most recent reasoning–observation pair is explicitly conditioned on, but since the auto-regressive generation attends to all previous tokens through the transformer's self-attention mechanism, the model effectively has access to the full trajectory history.

Rejection sampling: The paper uses rejection sampling to select only high-quality trajectories for training. A trajectory is "accepted" if the final answer exactly matches the ground truth, as judged by an automated evaluator (GPT-4o with the official HLE evaluation prompt, as described in Appendix D.1). This ensures that the model is trained only on correct solution paths, avoiding the risk of reinforcing incorrect reasoning patterns. The RFT procedure generates many trajectories per question and retains only the successful ones—this is standard practice but has the important consequence that the training data represents successful reasoning strategies, which may not cover the full diversity of valid approaches (a limitation the paper acknowledges in its discussion of the pass@1-to-pass@8 gap and the potential for RL).

Stage I: Seed Question Generation for Knowledge Fusion

The first stage of the data engine transforms a raw document corpus into seed QA pairs that inherently demand cross-document reasoning. The goal is not to generate maximally difficult questions at this stage—difficulty escalation happens in Stage II—but to ensure that the structure of each question forces knowledge integration across multiple sources from the start.

Corpus preprocessing. The input is a diverse, multi-disciplinary corpus C_raw of 1 million public documents (web pages, e-books, papers, as shown in Figure 3). The paper does not specify the exact composition or provenance of this corpus beyond describing it as "public documents," but the diversity is critical—the whole point is to create questions that span disciplinary boundaries. A powerful LLM, Qwen3-235B-A22B, serves as the chunking function Phi_chunk, which performs two operations on each document: (1) cleaning artifacts such as HTML tags, navigation elements, and boilerplate text, and (2) condensing long texts into information-dense chunks. The output is:

$C_{\text{chunk}} = \bigcup_{d \in C_{\text{raw}}} \Phi_{\text{chunk}}(d)$

where $C_{\text{chunk}}$ is the set of all processed text chunks, each representing a coherent, self-contained unit of information suitable for question generation.

Retrieval-based triplet search. The central challenge is constructing groups of chunks that are thematically related enough to form coherent questions but diverse enough that answering requires synthesis rather than simple retrieval. The most straightforward approach—enumerating all possible chunk triplets and scoring them—would be combinatorially infeasible for a corpus of this scale. The paper adopts an efficient retrieval-based approach:

Build a vector index over $C_{\text{chunk}}$ to enable fast similarity search.
For each chunk $c_i$ , retrieve its $k_{nn} = 10$ nearest neighbors (the paper does not specify the embedding model used for vector construction, but given the Qwen3 theme, it likely uses Qwen3 embedding models or the Qwen3-235B-A22B model's internal representations).
Within each local neighborhood of size $k_{nn}$ , search for triplets $(c_i, c_j, c_k)$ that satisfy high pairwise thematic coherence:

$\text{Sim}(c_x, c_y) > \tau_{\text{theme}} \quad \text{for all distinct pairs}$

where $\text{Sim}(\cdot, \cdot)$ is a semantic similarity function and $\tau_{\text{theme}} = 0.8$ is the thematic coherence threshold.

The threshold choice of $0.8$ represents a deliberate balance: set too high (e.g., $0.95$ ), and triplets would be near-duplicates of the same content, producing questions that require simple fact-lookup rather than fusion. Set too low (e.g., $0.5$ ), and triplets would be incoherent noise, producing nonsensical questions. The value $0.8$ ensures that chunks are clearly related (e.g., three papers on the same disease mechanism, or three documents about the same historical event from different perspectives) but contain distinct, non-redundant information.

Seed QA generation. Each thematically coherent triplet $U_c = \{c_i, c_j, c_k\}$ is fed to a generator model M_gen (again, Qwen3-235B-A22B, though the paper is not explicit about whether this is the same model as the chunker) to synthesize an initial question–answer pair:

$D_{\text{seed}} = \{(q_0, a_0) = M_{\text{gen}}(U_c) \mid U_c \text{ is a composite unit}\}$

The generator is prompted to create questions whose answers require information from all three chunks—not just any one or two. This is the critical design choice at Stage I: by construction, the seed questions demand knowledge fusion. Figure 4 illustrates the progression with a biomedical example: an initial seed question asks about diagnostic tests for Greater Trochanteric Pain Syndrome, already requiring synthesis of clinical presentation, anatomical knowledge, and diagnostic criteria from the triplet.

Why triplets? The choice of three chunks (as opposed to pairs or larger groups) reflects a balance between complexity and coherence. Pairs of chunks often produce questions that can be answered by simple comparison or contrast. Triplets introduce the need for multi-way integration—the answer is not just A vs. B, but a synthesis requiring elements from A, B, and C. Larger groups (quadruplets, etc.) would increase combinatorial complexity without proportionally increasing the quality of knowledge fusion; they would more likely produce unfocused questions that dilute the training signal across too many sources.

Why retrieval-based rather than combinatorial? The retrieval-based approach with $k_{nn} = 10$ is an efficiency hack that is quietly important. A full combinatorial search over all triplets would cost $O(|C_{\text{chunk}}|^3)$ similarity computations, which is intractable for even a moderately sized corpus. By limiting the search to $k_{nn}$ -neighborhoods around each chunk, the cost drops to $O(|C_{\text{chunk}}| \cdot k_{nn}^2)$ , which is linear in corpus size for fixed $k_{nn}$ . The tradeoff is that some thematically coherent triplets spanning distant parts of the similarity space will be missed (e.g., three chunks on different aspects of quantum computing that are semantically far apart in embedding space but conceptually related). The paper implicitly accepts this tradeoff in favor of computational feasibility, assuming that the $k_{nn}$ -neighborhood captures the vast majority of useful triplets.

The seed dataset: The output of Stage I, $D_{\text{seed}}$ , serves as the foundation for complexity escalation. It is designed to be "correct but simple"—the answers are accurate, but the questions lack the multi-step reasoning, quantitative computation, and deep contextual grounding that characterize frontier-level research tasks. These properties are layered on in Stage II.

Stage II is the core of the pipeline—an iterative refinement loop that progressively increases the cognitive demands of each QA pair. The central component is the refinement agent A_refine, which is a tool-augmented LLM (the paper uses Qwen3-235B-A22B, as specified in Section 2.2 and consistent with the models used in Stage I) that applies a structured escalation operator to transform a QA pair $(q_k, a_k)$ at iteration $k$ into a more sophisticated pair $(q_{k+1}, a_{k+1})$ at iteration $k+1$ :

$(q_{k+1}, a_{k+1}) = \Psi_{\text{escalate}}(q_k, a_k, A_{\text{refine}})$

The tool suite. The refinement agent has access to four tools (Section 2.2), each designed to provide a different type of information that enriches the QA pair:

T_search: Performs parallel web searches using the Google Search API, returning structured results with titles, snippets, and URLs. This provides broad, up-to-date information from the open web—news, Wikipedia, institutional websites, blogs, and general reference material. In the training pipeline, this tool averages 0.32 calls per trajectory (Table 1).
T_scholar: Queries the Google Scholar API to navigate scientific literature, returning structured metadata including authors, publication venues, citation counts, and abstracts. This provides authoritative, peer-reviewed sources—essential for questions requiring academic grounding. Averages 0.66 calls per trajectory.
T_browser: Extracts targeted information from specific URLs. The agent provides a goal (e.g., "extract the dataset and evaluation metrics"), and the tool first fetches the full page content using Jina Reader (Jina.ai, 2025) and then uses Qwen3 to synthesize a focused answer based on the goal. This enables deep reading of specific sources identified by search or scholar. Averages 0.82 calls per trajectory.
T_code: Provides a sandboxed Python environment with standard scientific libraries (NumPy, SciPy) where the agent can write and execute code for computation, simulation, data analysis, or verification. Outputs (stdout, stderr, figures) are captured as text. Averages 0.52 calls per trajectory.

The tool usage distribution in Table 1 is deliberately balanced—no single tool dominates. This is by design: the paper explicitly contrasts this with baselines like MiroVerse (0.93 code calls per trajectory, code-centric) and TaskCraft (1.19 browser calls per trajectory, search-centric). The balanced distribution forces the model to learn inter-tool synergy—knowing when to search broadly, when to drill into academic literature, when to read a specific source in depth, and when to compute or verify numerically, rather than over-relying on a single capability.

The four escalation dimensions. The refinement agent applies the escalation operator along four axes (Section 2.2), each targeting a different facet of question complexity:

Knowledge Expansion: The agent uses search, scholar, or browser tools to discover and retrieve relevant background knowledge not present in the original seed question, then weaves this new information into the refined question. For example, a question about a clinical test might be expanded to include epidemiological context, historical development of the diagnostic criteria, or comparative effectiveness data from recent studies. This broadens the informational scope—the answer now requires awareness of a wider knowledge landscape.
Conceptual Abstraction: The agent analyzes the core concepts in the current QA pair and identifies higher-level principles, subtle relationships, or non-obvious analogies. The refined question demands reasoning at a more abstract level—not just "what is X?" but "why does X exhibit property Y in context Z, and how does this relate to principle W?" The agent may use the scholar tool to find established theoretical frameworks that support this abstraction.
Factual Grounding: The agent performs multi-source cross-validation of all factual claims in the current answer, using search and scholar to verify accuracy, precision, and currency. The refined answer must include precise quantitative data, specific named entities (authors, institutions, dates), and direct citations to authoritative sources. This dimension addresses a common failure mode of LLM-generated training data: plausible-sounding but factually incorrect statements that, if included in training data, teach the model to be confidently wrong.
Computational Formulation: The agent uses the code tool to design a new question that requires quantitative calculation or algorithmic simulation. The refined answer must contain: (1) the complete, executable Python code used to solve the problem, and (2) the final output with explanation. This transforms qualitative reasoning problems into quantitative challenges—for example, evolving a question about diagnostic criteria into one that requires computing the force deficit in hip abductor muscles given biomechanical parameters (as shown in Figure 4).

Iterative refinement process. The refinement proceeds in rounds, with the output of one iteration becoming the input for the next. The agent is prompted (full prompt in Appendix D.3) with a structured specification of its role, the current QA pair, and the mandatory refinement protocol requiring it to apply at least one of the four dimensions and log all tool usage. The prompt explicitly instructs the agent to produce a "new, superior QA pair" and to "weave" retrieved information seamlessly into the question.

A critical implementation detail: the refinement is not open-ended. The paper specifies $K_{\text{max}} = 30$ as an upper bound on the number of iterations, preventing infinite loops or runaway resource consumption. In practice, as reported in Appendix A.3.1, the average number of refinement iterations per data point is 7.81—substantially below the maximum, suggesting that most QA pairs reach the ZPD threshold (where the LKP cannot solve them) well before 30 iterations.

Stopping criterion tied to ZPD. The paper specifies that refinement terminates "when the generated question $q_k$ becomes unsolvable by the Less Knowledgeable Peer ( $A_{\text{LKP}}$ ), a baseline model formally defined in Stage III." This means Stage II and Stage III are interleaved: during refinement, the system periodically tests the current QA pair against the LKP (the base LLM without tools) to check whether the difficulty threshold has been crossed. Once the LKP fails, refinement stops—the question is now at the frontier. If the LKP would still solve it, refinement continues; if $K_{\text{max}}$ is reached without crossing the threshold, the pair is considered insufficiently challenging and may be discarded or routed to $D_{\text{pretrain}}$ .

This stopping criterion is what makes the refinement principled rather than heuristic. The goal is not "make the question as hard as possible" (which could produce impossible questions) but "make the question exactly hard enough that the base model cannot solve it." The LKP provides a measurable, reproducible threshold that can be checked automatically.

Why this four-dimensional escalation framework? The choice of four dimensions—expansion, abstraction, grounding, computation—covers the qualitatively distinct ways a question can become harder. A question can be harder because it requires more information (expansion), deeper insight (abstraction), more precise facts (grounding), or quantitative reasoning (computation). Each dimension targets a different cognitive skill, and the refinement agent's freedom to choose among them (including combining multiple dimensions) produces diverse training examples that exercise different aspects of agentic reasoning. This is fundamentally different from naive difficulty escalation strategies (e.g., "make it longer" or "add more constraints"), which tend to produce homogeneous complexity along a single axis.

Computational cost of Stage II (from Appendix A.3.1). The paper provides unusually detailed cost accounting:

Average 7.81 refinement iterations per candidate
Per API call: 18,614 input tokens, 11,643 output tokens
LLM cost per candidate: $7.81 \times (18,614 \times \$0.56/\text{M} + 11,643 \times \$1.68/\text{M}) \approx \$0.234$
Tool call costs: $1.31$ search/scholar calls at $\$0.00275$/call $\approx \$0.0036$; $1.21$ browser calls at $10,000$ tokens/call at $\$0.00005$/token $\approx \$0.0006$
Total Stage II cost per candidate: $\sim \$0.24$

This $\$0.24$ figure is the raw cost of refinement, but it does not account for the fact that only candidates that pass Stage III filtering contribute to the final dataset. The effective cost per accepted data point is higher (as will be discussed in Stage III).

Stage III: ZPD-based Filtering and Calibration

Stage III is where the Zone of Proximal Development is operationally defined and applied as a data selection criterion. It answers the question: of all the refined QA pairs from Stage II, which ones are actually worth training on?

The LKP–MKO framework. The paper instantiates two personas with different capabilities (Section 2.3):

Less Knowledgeable Peer ( $A_{\text{LKP}}$ ): The base LLM without tools—specifically, Qwen3-30B-A3B-Thinking-2507 in its pre-fine-tuning state, prompted to answer questions using only its parametric knowledge. This represents what the model can do independently, before any agentic training.
More Knowledgeable Other ( $A_{\text{MKO}}$ ): A powerful, tool-augmented agent—the paper specifies this as the same tool-augmented agent used in Stage II (Qwen3-235B-A22B with access to search, scholar, browser, and code tools), but run as a research agent rather than a refinement agent. This represents what the model could achieve with optimal scaffolding.

The ZPD is defined extensionally: a QA pair $(q, a)$ is in the ZPD if and only if the LKP cannot solve it but the MKO can. Formally, this uses a binary solvability function:

$\text{IsSolvableBy}(A, q, a) \in \{0, 1\}$

implemented by an automated judge—specifically GPT-4o (OpenAI, 2024), guided by the evaluation prompt in Appendix D.1—which compares the agent's final answer to the ground truth $a$ and returns $1$ if correct, $0$ otherwise.

The three-way filtering logic. For each candidate pair $(q, a) \in D_{\text{refined}}$ , the filtering proceeds as a decision tree (Section 2.3, Algorithm 1 lines 21–34):

Too easy → Continued Pre-training ( $D_{\text{pretrain}}$ ): If $\text{IsSolvableBy}(A_{\text{LKP}}, q, a) = 1$ , the question is within the model's current independent capability. It does not require tool use or multi-step research—the model can answer it from parametric knowledge alone. These pairs are allocated to $D_{\text{pretrain}}$ , a dataset of knowledge-intensive QA pairs used for continued pre-training rather than agentic fine-tuning. The intuition: these questions still contain valuable factual knowledge, but they don't teach research skills.
Too hard → Human Review ( $D_{\text{human}}$ ): If $\text{IsSolvableBy}(A_{\text{LKP}}, q, a) = 0$ (the LKP fails) but the MKO also fails after $N = 3$ attempts (i.e., $\sum_{i=1}^{N} \text{IsCorrect}(s_i, a) = 0$ where $s_i$ are the MKO's independent solutions), the pair is either flawed (contains errors or ambiguities that make correct answering impossible) or genuinely beyond current capability frontiers (even the strongest tool-augmented agent cannot solve it). These are routed to human experts for analysis rather than used for training.
Just right → Frontier Training Data ( $D_{\text{ZPD}}$ ): If $\text{IsSolvableBy}(A_{\text{LKP}}, q, a) = 0$ AND $\exists i \in \{1, \ldots, N\}: \text{IsCorrect}(s_i, a)$ (the MKO gets at least one correct answer in $N = 3$ attempts), the pair is in the ZPD. It is challenging enough to require scaffolding (the LKP fails) but learnable (the MKO demonstrates a successful solution trajectory). These pairs form the final training set $D_{\text{ZPD}}$ .

Best-of-N verification with $N = 3$ . The MKO generates $N = 3$ independent solutions for each candidate question. The paper uses $N = 3$ rather than $N = 1$ to reduce variance—a single failure might be due to unlucky sampling rather than genuine unsolvability. By requiring the MKO to succeed at least once in three attempts, the system is more confident that the question is genuinely solvable. The choice of $N = 3$ (rather than $N = 5$ or $N = 10$ ) balances reliability against computational cost—each verification attempt is expensive, as detailed in Appendix A.3.2.

Why not use correctness probability rather than binary solvability? A natural alternative would be to use the MKO's pass rate (e.g., 1/3 vs. 2/3 vs. 3/3) as a continuous difficulty measure rather than thresholding at $\geq 1$ correct. The paper's binary approach (any correct answer qualifies) is conservative: it ensures that even marginally solvable questions are included in $D_{\text{ZPD}}$ , providing challenging training examples. A higher threshold (e.g., requiring 2/3 or 3/3 correct) would produce an easier dataset that might not push the model hard enough.

The automated judge. The binary solvability function $\text{IsSolvableBy}$ is implemented using GPT-4o as an LLM judge, guided by the official HLE evaluation prompt (Appendix D.1). The judge compares the agent's final answer (extracted from the response) against the ground truth answer $a$ . The prompt instructs the judge to output a structured verdict including: extracted_final_answer, reasoning (explaining why answers match or don't match), correct (yes/no), and confidence. The use of a strong external model as judge—rather than simple string matching—is necessary because open-ended short answers can have multiple valid phrasings, mathematical expressions in different forms, and numerical answers with varying precision. GPT-4o provides the semantic flexibility to recognize equivalent answers.

Semantic redundancy filter. After a QA pair passes the ZPD filter, it undergoes a final diversity check to prevent the dataset from being dominated by near-duplicate questions (Section 2.3). A newly generated pair $(q', a')$ is discarded if its question $q'$ is too similar to any question already in $D_{\text{ZPD}}$ :

$\max_{(q,a) \in D_{\text{ZPD}}} \text{Sim}(q', q) \geq \epsilon$

where $\text{Sim}(\cdot, \cdot)$ is measured by a reranker model (specifically, the Qwen3 embedding-based reranker described in Zhang et al., 2025) and the threshold is $\epsilon = 0.7$ . This is a semantic similarity check, not a lexical one—it catches paraphrased versions of the same underlying question that might use different wording but demand identical reasoning.

Why a reranker rather than cosine similarity of embeddings? Rerankers are specifically trained on relevance matching tasks and are more discriminative for fine-grained semantic equivalence detection than generic embedding cosine similarity. A standard embedding similarity at threshold 0.7 might reject genuinely distinct questions on related topics (e.g., two different questions about the same disease). The reranker's training on query-document relevance makes it better at distinguishing "same question, different words" from "different question, same topic."

Why $\epsilon = 0.7$ ? The paper does not provide an explicit justification for this threshold value, but in the reranker literature, scores above 0.7 typically indicate high confidence in semantic equivalence. Setting the threshold lower (e.g., 0.5) would be overly conservative, rejecting questions with moderate topical similarity that are genuinely distinct. Setting it higher (e.g., 0.9) would accept near-duplicates, reducing dataset diversity.

Computational cost of Stage III (from Appendix A.3.2). The verification cost per candidate:

3.32 API calls on average (across $N = 3$ MKO attempts)
Per call: 20,182 input tokens, 24,170 output tokens
LLM cost: $3.32 \times (20,182 \times \$0.56/\text{M} + 24,170 \times \$1.68/\text{M}) \approx \$0.172$
Tool calls: 0.50 search + 0.92 scholar at $\$0.00275$/call $\approx \$0.0039$; 1.30 browser at 10,000 tokens at $\$0.00005$/token $\approx \$0.00065$
Raw verification cost per candidate: $\sim \$0.18$

But not all candidates pass—the amortized cost matters. The paper reports a 33% success rate: only one-third of candidates that reach Stage III satisfy the ZPD criterion (LKP fails, MKO succeeds at least once). This means:

$\text{Amortized verification cost per accepted pair} = \$0.18 / 0.33 \approx \$0.54$

Combined with Stage II refinement ($\$0.24$ per candidate, all of which go to verification), the total end-to-end amortized cost per frontier QA pair is:

$\$0.24 + \$0.54 = \$0.78$

This $\$0.78$ figure is the paper's estimate for producing one high-quality, verified, PhD-level QA pair with its solution trajectory. The paper frames this as a "quality-over-quantity" investment—$\$0.78$ per training example is non-trivial at scale, but it's orders of magnitude cheaper than hiring human PhDs to manually create equivalent problems.

Why the 67% rejection rate? The high attrition from Stage II to Stage III reflects the difficulty of the ZPD calibration problem. Candidates fail for several reasons: the refinement may not have escalated difficulty enough (the LKP still solves it), the refinement may have introduced errors or ambiguities that make the question unsolvable even by the MKO, or the MKO may simply lack the capability despite tool access. The paper does not provide a breakdown of failure modes, but the 33% yield rate is consistent with the challenge of hitting a narrow capability frontier—too easy or too hard are both much larger target regions than "just right."

The three output datasets. The filtering process partitions the refined data into three tiers with different training purposes:

$D_{\text{pretrain}}$ — Knowledge-intensive QA pairs for continued pre-training. The paper uses these in a 50B-token CPT stage comprising 1 million summarized text chunks and 20 million QA pairs (Section 5.3). These strengthen the model's foundational knowledge without teaching agentic research skills per se.
$D_{\text{ZPD}}$ — Frontier-level reasoning trajectories for post-training via rejection-sampling fine-tuning. The paper uses 12,000 such trajectories (normalized to 25,600 rounds with a 40,960-token cap per round, trained for 3 epochs).
$D_{\text{human}}$ — Flagged for human expert review. The paper does not report the volume of this dataset or the outcomes of human review, but the existence of this tier is important: it acknowledges that automated pipelines can produce flawed outputs that require human judgment, and it provides a feedback mechanism for improving the engine over time.

ZPD Exam Construction: The Pipeline in Benchmark Mode

The ZPD Exam is constructed using the same AgentFrontier Engine but with key differences in corpus selection and filtering criteria that make it suitable for evaluation rather than training (Section 3.1).

Corpus: Frontier scientific papers. Rather than using the general web corpus of 1 million documents, the ZPD Exam is grounded in a curated corpus of 30,000 recent scientific papers published between 2023 and 2025, spanning mathematics, computer science, physics, and other disciplines. This date restriction is crucial: it ensures the questions probe genuinely new knowledge that was not in the pretraining data of models trained before 2023. Any model scoring well must perform active research—searching for, reading, and synthesizing papers it has never seen—rather than retrieving memorized facts.

Stricter filtering: dual constraint with three attempts each. The ZPD Exam applies a stricter version of the ZPD filter than the training data pipeline. For a problem to be included:

The baseline model must fail in three unaided attempts (no tools, three independent generations): $\sum_{i=1}^{3} \text{IsSolvableBy}(A_{\text{baseline}}, q, a) = 0$ . This is stronger than the single-attempt LKP check in the training pipeline—it requires consistent failure, not just a single failure that could be sampling noise.
The same baseline model must succeed in all three tool-augmented attempts: $\sum_{i=1}^{3} \text{IsSolvableBy}(A_{\text{baseline+tool}}, q, a) = 3$ . This is much stronger than the "at least 1 out of 3" threshold for training data. It requires consistent solvability, ensuring the problem is reliably within the ZPD and not marginally solvable only through lucky sampling.

The dual constraint (fail 3/3 unaided) AND (succeed 3/3 with tools) creates a "sharp" ZPD boundary: the problem is definitively beyond the model's independent reach and definitively within its tool-augmented reach. This is appropriate for evaluation (where we want high confidence that the problem measures what it claims to measure) but would be too strict for training data (where marginal cases still provide useful learning signal).

Disjoint corpus guarantee. The paper explicitly states that the ZPD Exam corpus is "strictly disjoint from the corpus used to construct our training data, ensuring a fair and uncontaminated evaluation." This prevents the model from benefiting from having seen the same underlying documents during training.

Question format and composition. All questions are open-ended short-answer format, facilitating automated grading using the same GPT-4o judge with the HLE evaluation prompt. After multiple rounds of validation and deduplication, ZPD Exam-v1 was sampled to 1,024 public questions with a corresponding private set (the paper does not disclose the private set's size or whether it was publicly released). The composition across nine disciplines (Figure 5) is: Mathematics (37%), Computer Science/AI (24%), Physics (11%), History (7%), Humanities (5%), Chemistry (5%), Biology/Medicine (4%), Engineering (4%), Geography (3%).

The self-evolving property. The paper claims the ZPD Exam is a "living benchmark resistant to saturation." The mechanism: as models improve, the ZPD Exam can be regenerated by (a) expanding the corpus to include even more recent papers, and (b) using the improved model as the new baseline $A_{\text{baseline}}$ in the dual constraint filter, which automatically produces harder questions calibrated to the new capability frontier. This flywheel effect means the benchmark co-evolves with models rather than becoming obsolete. The paper provides ZPD Exam-v1 as the first instantiation but envisions future versions (v2, v3, etc.) produced by the same pipeline with updated corpora and baselines.

Diagnostic framework. The paper proposes interpreting ZPD Exam scores through a three-zone framework (Section 3.2):

Zone 1: Intrinsic Competence (Score < 20). Models without tools cluster here (GPT-5 at 9.9%, Gemini-2.5-Pro at 9.6% in Figure 1b). This establishes the "closed-book" baseline—any score above this is attributable to tool-augmented reasoning, not memorized knowledge.
Zone 2: The Reasoning Bottleneck (Score 20–60). Models with tools that achieve partial success but lack mastery (GPT-4o with tools at 51.3%, WebShaper-72B at 54.4% in Figure 1b). These agents can use tools but struggle with orchestration—strategic planning across multiple calls, synthesis of findings, and adaptive strategy adjustment.
Zone 3: Emergent Mastery (Score > 60). Agents that demonstrate robust multi-step planning and synthesis (DeepSeek-V3.1 with tools at 93.1%, AgentFrontier-30B-A3B at 93.4%). These have transcended the reasoning bottleneck and function as genuine research agents.

This diagnostic power is what the paper claims distinguishes the ZPD Exam from leaderboard-style benchmarks—it doesn't just rank models; it characterizes their developmental stage along a capability continuum from closed-book reasoner to autonomous research agent.

The Holistic Training Pipeline: CPT + RFT

The paper's final technical component is the two-stage training procedure applied to the Qwen3-30B-A3B-Thinking-2507 base model (Section 5.3). This is conducted only on this specific MoE backbone due to the large-scale GPU computation required for continued pre-training.

Stage 1: Continued Pre-Training (CPT). The model undergoes one epoch of training on a 50B-token corpus comprising two types of data generated by the ZPD pipeline:

1 million summarized text chunks: Dense, cleaned text passages extracted and condensed by the Phi_chunk function in Stage I. These provide broad knowledge coverage across the 1-million-document corpus.
20 million knowledge-intensive QA pairs: These are the $D_{\text{pretrain}}$ output of Stage III—questions that the LKP could solve without tools. While not at the capability frontier, they reinforce foundational knowledge across disciplines.

The CPT objective is the standard autoregressive language modeling loss:

$\mathcal{L}_{\text{CPT}}(\theta) = -\sum_{t=1}^{T} \log p_\theta(x_t \mid x_{<t})$

where $x_t$ is the token at position $t$ in the training sequence, $x_{<t}$ is the sequence of preceding tokens, $\theta$ denotes the model parameters, and $T$ is the sequence length.

What it computes: For each token in the training corpus, the negative log-probability assigned by the model. The sum over all tokens yields a scalar loss that measures how surprised the model is by the actual data. Minimizing this loss trains the model to predict text that matches the distribution of the CPT corpus.

Why this form: This is the standard language modeling pretraining objective—no bells and whistles because CPT is fundamentally about knowledge absorption, not skill acquisition. The 50B-token scale (one epoch over a curated corpus) is designed to inject domain-specific knowledge without overfitting or catastrophic forgetting of the model's original capabilities. The paper does not specify a learning rate or other CPT hyperparameters beyond the data composition, which is a notable omission for reproducibility.

Stage 2: Rejection-Sampling Fine-Tuning (RFT). Following CPT, the model is fine-tuned on $D_{\text{ZPD}}$ using the RFT objective described earlier (Section 4.1, Equation 1). The key hyperparameters (Table 5 for the MoE model):

Training epochs: 3
Max sequence length: 40,960 tokens
Batch size: 256
Learning rate: $7.0 \times 10^{-6}$ with linear decay to $7.0 \times 10^{-7}$
Model parallelism: Tensor parallel (MP) = 4, Expert parallel (EP) = 2, Pipeline parallel (PP) = 1
Framework: Megatron-LM (Shoeybi et al., 2019)

For the dense models (8B and 32B), Table 6 specifies different hyperparameters:

Batch size: 64
Learning rate: $4.0 \times 10^{-5}$
LR scheduler: Cosine decay with warmup ratio 0.1
Max sequence length: 40,960

Training data normalization. To ensure a fair comparison across datasets, the paper normalizes the training data volume to 25,600 rounds for each dataset, with each round capped at 40,960 tokens, trained for 3 epochs (Section 4.1). This means all competing baselines (TaskCraft, MegaScience, MiroVerse, AgentFrontier) are trained on the same total number of reasoning rounds, isolating the effect of data quality (difficulty calibration, tool-use distribution, knowledge fusion demands) from data quantity. The 12,000 trajectories from AgentFrontier are thus selected to fill exactly 25,600 rounds—each trajectory averages $25,600 / 12,000 \approx 2.13$ rounds, which is lower than the 3.32 average reported in Table 1, suggesting that only shorter, higher-quality trajectories are selected for RFT.

Why CPT before RFT? The paper's ablation (Table 4, final row) shows that CPT consistently boosts performance: +2.9 on HLE, +2.0 on ZPD Exam, +2.7 on RBench-T, +7.0 on xBench-ScienceQA. The interpretation (Section 5.3): strengthening the model's foundational knowledge via CPT "directly enhances its capacity for complex agentic tasks." This makes intuitive sense—if the model doesn't understand the domain concepts, no amount of agentic training will enable it to reason about them. CPT fills knowledge gaps; RFT teaches research methodology. The two stages are complementary.

Why not interleave CPT and RFT? A natural alternative would be to mix knowledge-intensive and frontier data in a single training stage, or to iterate between CPT and RFT in multiple cycles. The paper's two-stage approach (CPT then RFT) is simpler and likely reflects computational constraints—full CPT on 50B tokens is expensive, and multiple CPT-RFT cycles would multiply that cost. However, the paper does not discuss this design choice or ablate staged vs. mixed training.

Inference configuration. For all generation tasks (evaluation), the paper uses nucleus sampling with temperature = 0.6 and top-p = 0.95 (Section 4.1). The relatively low temperature (0.6, compared to typical values of 0.8–1.0 for creative generation) balances diversity and coherence—high enough to enable exploration of alternative reasoning paths, low enough to avoid degenerate outputs. The tool-augmented agent follows the ReAct paradigm (Yao et al., 2023), interleaving reasoning reports with tool calls in a multi-round process following the WebResearcher (Qiao et al., 2025) architecture.

Evaluation judge. Correctness is evaluated using o3-mini (OpenAI, 2025b) as the LLM judge, guided by the official strict evaluation prompt from HLE (Phan et al., 2025). The prompt (Appendix D.1) requires the judge to extract the final answer from the model's response, compare it against the ground truth, provide reasoning, output a binary correct/incorrect verdict, and include a confidence score. The use of o3-mini (a stronger model than GPT-4o, used for internal judgment during data synthesis) reflects the high difficulty of the evaluation tasks—models like HLE and ZPD Exam require a judge sophisticated enough to handle subtle equivalence cases in graduate-level mathematics, physics, and other technical domains.

Why o3-mini for evaluation but GPT-4o for data filtering? The data synthesis pipeline uses GPT-4o for the internal IsCorrect and IsSolvableBy checks during Stages II and III. The evaluation uses o3-mini. This asymmetry reflects cost-benefit tradeoffs: the pipeline makes millions of judgment calls (every refinement step, every ZPD filter check), making the cheaper GPT-4o practical; the evaluation makes far fewer calls (one per test question per model), justifying the more accurate but more expensive o3-mini. The paper does not discuss whether this judge mismatch could introduce systematic bias (if o3-mini considers answers correct that GPT-4o would reject, or vice versa), which is a potential concern for the validity of the ZPD filtering that the paper does not address.

4. Key Insights and Innovations

Innovation 1: ZPD as an Operational Data Selection Criterion, Not Just a Pedagogical Metaphor

The paper's most distinctive conceptual contribution is transforming Vygotsky's Zone of Proximal Development from a qualitative educational metaphor into a precise, automated, binary test for whether a training example is at the optimal learning frontier. This is a fundamentally different use of ZPD than what appears in any prior ML literature.

Before this work, the ZPD was occasionally invoked in curriculum learning research as a loose inspiration—train on progressively harder examples, like a teacher scaffolding a student's learning. But these invocations were metaphorical: "harder" was defined heuristically (e.g., longer sequences, more reasoning steps, higher perplexity), and the frontier was approximate at best. The field had no way to ask, for a specific model and a specific task, "Is this precisely at the boundary of what this model can learn?" and get an operational yes/no answer.

AgentFrontier provides exactly that. The LKP–MKO adversarial calibration (Section 2.3) defines the ZPD extensionally rather than descriptively: a QA pair is in the ZPD iff the base model cannot answer it (IsSolvableBy(LKP) = 0) AND a stronger tool-augmented agent can (IsSolvableBy(MKO) = 1). This transforms ZPD from a fuzzy concept into a computable predicate that can be evaluated automatically for every candidate training example at scale.

Why this matters beyond the mechanism: it solves the expressive ceiling problem that the paper identifies as the fundamental limitation of self-play data generation (Section 1). When a model generates its own training data, it can only reliably produce correct answers for problems it can already solve, meaning the generated data never exceeds the model's own competence. The ZPD filter breaks this circularity by using a stronger agent (the MKO) to generate correct solutions for problems the weaker agent (the LKP) cannot solve. The LKP defines the frontier; the MKO provides the scaffolding. Neither agent alone could produce the training data—only the adversarial pairing can.

This is a fundamental conceptual advance, not an incremental refinement. Prior difficulty calibration approaches—constraint stacking (Patel et al., 2025), probing for recitation vs. reasoning (Yan et al., 2025), perplexity-based difficulty scoring—all operate within a single model's competence horizon. They can make questions harder within that horizon, but they cannot guarantee the questions cross the boundary into genuinely new capability territory. The LKP–MKO framework provides that guarantee by construction.

The evidence that this matters is not just the final benchmark numbers but the diagnostic power of the framework itself. The ZPD Exam's three-zone stratification (Section 3.2, Figure 1b)—Intrinsic Competence (< 20), Reasoning Bottleneck (20-60), Emergent Mastery (> 60)—would be impossible without a principled difficulty calibration mechanism. The fact that models without tools cluster in the < 20 zone, while tool-augmented models span the full range, validates that the benchmark genuinely measures the gap between what models know and what they can discover. This diagnostic capability is a direct consequence of the ZPD operationalization and represents a qualitatively new kind of evaluation.

Innovation 2: Knowledge Fusion as a Distinct Capability Axis, Not Just Multi-Document Retrieval

The paper draws a sharp, previously underappreciated distinction between multi-document retrieval (find relevant facts across multiple sources) and knowledge fusion (synthesize information across sources to derive insights not present in any single source). While prior work on retrieval-augmented generation and multi-hop QA implicitly touched on this distinction, the paper is the first to make it the central organizing principle of a data synthesis framework and to design a pipeline that systematically produces training data demanding fusion rather than retrieval.

The dominant paradigm in agent training data—exemplified by the baselines the paper compares against (TaskCraft, MegaScience, MiroVerse)—treats difficulty primarily as a function of how many documents must be consulted or how obscure the facts are. TaskCraft generates tasks requiring multiple tools but doesn't enforce that the tools' outputs must be integrated; MegaScience grounds questions in scientific textbooks but tests localized comprehension; MiroVerse covers diverse tasks but is code-centric, training models to write programs rather than synthesize knowledge. None of these datasets systematically requires the model to connect concepts across documents, resolve contradictions, or derive new conclusions from partial information.

The paper's triplet-based seeding strategy (Stage I) is not merely an engineering choice—it embodies a principled claim about what makes a question require fusion. By requiring three thematically coherent but distinct chunks to generate each seed question, and by setting the similarity threshold τ_theme = 0.8 (high enough for coherence, low enough to avoid redundancy), the engine produces questions whose answers by construction cannot be found in any single source. The triplet structure ensures that each source provides necessary but insufficient information—the model must integrate.

This is a conceptual reframing with significant implications. If knowledge fusion is a distinct capability from retrieval, then scaling up retrieval-based training data (more documents, more facts, more retrieval steps) will hit a capability ceiling—models will become better retrievers but not better synthesizers. The paper's results provide indirect evidence for this: the baseline datasets, which all provide some form of multi-document or multi-step tasks, consistently underperform AgentFrontier on benchmarks requiring deep synthesis (HLE, ZPD Exam) despite being trained on the same number of rounds (25,600) and using the same base model. The gap is not about data quantity or tool diversity but about the kind of reasoning the data demands.

The subject-level dominance on HLE (Table 2) further supports this interpretation. AgentFrontier-trained models win in six to eight out of eight subjects across backbones, with particularly large margins in disciplines requiring cross-domain synthesis (e.g., Humanities at 31.61% vs. next-best 24.87% on the 30B backbone). A retrieval-centric dataset would be expected to perform well on fact-heavy subjects (Biology, Chemistry) and poorly on synthesis-heavy ones (Humanities, interdisciplinary questions). The consistent advantage suggests AgentFrontier is teaching a transferable synthesis skill, not just domain-specific knowledge.

Innovation 3: The Reasoning Bottleneck as a Diagnostic Concept for Agent Evaluation

The paper introduces a new evaluative construct—the reasoning bottleneck—that fills a critical gap in how the field thinks about agent capabilities. Prior benchmarks (HLE, GPQA, MMLU, R-Bench) measure whether a model gets the right answer, but they don't distinguish between why models fail. Does the model lack knowledge? Does it have the knowledge but fail to retrieve it? Does it retrieve relevant information but fail to synthesize it correctly? These are qualitatively different failure modes with different implications for how to improve the model, and existing benchmarks don't separate them.

The ZPD Exam's three-zone framework (Section 3.2) does separate them. Zone 1 (Intrinsic Competence, < 20) isolates the knowledge ceiling—what the model can do from parametric memory alone. Zone 2 (Reasoning Bottleneck, 20–60) isolates the gap between having access to information (via tools) and being able to orchestrate that access effectively. Zone 3 (Emergent Mastery, > 60) identifies models that have crossed the bottleneck and can function as autonomous research agents.

What makes this a genuine intellectual contribution rather than just a binning of scores is the specific causal interpretation it enables. The paper argues, with evidence from Figure 1b, that many models with tool access (GPT-4o+tools at 51.3%, WebShaper-72B at 54.4%) score substantially above their tool-free counterparts (GPT-4o at 4.8%) but far below the mastery threshold. This gap—the difference between what tools enable and what the model can achieve with them—is precisely the reasoning bottleneck. It's not that these models can't use tools; they clearly can. It's that they struggle with the meta-cognitive demands of multi-step research: knowing what to search for, when to read deeply vs. broadly, how to reconcile contradictory findings, and when to adjust their approach.

This is a diagnostic advance that changes how we should think about improving agents. If the bottleneck were primarily about tool access or tool quality, the fix would be engineering—better APIs, faster retrieval, more comprehensive databases. But the paper's evidence suggests the bottleneck is primarily about reasoning architecture—the ability to plan, synthesize, and adapt across multiple tool calls. This implies that the path to better agents lies not in better tools but in better training data that teaches orchestration skills. The fact that AgentFrontier's training data (which demonstrates exactly these orchestration skills through the MKO's trajectories) pushes models into Zone 3 validates this interpretation: the bottleneck is trainable, not architectural.

The "bottleneck" framing also explains why prior work reached contradictory conclusions about tool-augmented agents. Some studies found dramatic improvements from tool access (because they tested problems near the tool-free ceiling), while others found minimal gains (because they tested problems in Zone 1 where tools aren't needed or in Zone 3 where tools alone are insufficient without orchestration). The ZPD Exam's diagnostic framework provides the vocabulary to reconcile these findings: tool access helps, but only to the extent that the model's orchestration capabilities allow, and the gap between tool access and tool mastery is the specific capability that needs to be trained.

Innovation 4: The Pass@1 to Pass@8 Gap as Evidence for a Rich Policy Distribution and RL Readiness

The paper's Best-of-N analysis (Section 5.1, Figure 7) reveals a 19.0-point gap between pass@1 (21.7%) and pass@8 (40.7%) on the AgentFrontier validation set. The paper interprets this gap not as a failure—"the model only gets 21.7% right on first try"—but as positive evidence that the training data contains a diverse distribution of valid solution strategies, making it suitable as a foundation for reinforcement learning.

This is a counterintuitive reframing of what would typically be seen as a limitation. In standard supervised fine-tuning evaluation, a low pass@1 is a problem to be solved—the model hasn't learned the task well enough. But the paper argues that for RL readiness, what matters is not pass@1 but the gap between pass@1 and pass@N. If pass@1 is low but pass@N is high, the model's policy distribution assigns significant probability mass to regions of solution space that contain correct answers—it just needs exploration to find them. This is the ideal precondition for RL: the policy has a good prior (high-quality trajectories exist in its distribution) but hasn't yet concentrated its mass on them (so RL has a clear gradient to follow).

The contrast with prior work on RL for language models is instructive. RLHF and related methods typically initialize from SFT models that already have high pass@1 on the training distribution—the RL step fine-tunes quality rather than discovering new capabilities. The paper's frame suggests a different paradigm: use ZPD-calibrated data to train a model that has latent capability (correct trajectories exist in its distribution but aren't reliably sampled), then use RL to surface that capability into reliable performance.

This is a methodological insight rather than an architectural one, but it has significant practical implications. It suggests that the evaluation of training datasets for agents should include not just final accuracy but also the pass@1-to-pass@N gap as a measure of learning potential—how much headroom exists for improvement beyond supervised learning. Datasets that produce high pass@1 (the model has memorized the training strategies) may actually be worse for subsequent RL than datasets that produce moderate pass@1 with high pass@N (the model has learned diverse strategies but hasn't converged to the best ones).

The paper does not actually perform RL—this insight is a promissory note for future work, acknowledged in the Limitations (Section 7). The 19.0-point gap serves as empirical motivation for that direction but remains unvalidated as a predictor of RL success. This is the most speculative of the paper's innovations, but it reframes a metric that the field typically treats as a weakness into evidence of a strength, which is intellectually generative even if not yet proven.

5. Experimental Analysis

Evaluation Methodology

Dataset. The primary evaluations use four benchmarks: Humanity's Last Exam (HLE; Phan et al., 2025), specifically the 2,154 text-only questions; ZPD Exam-v1, the paper's newly introduced benchmark with 1,024 multidisciplinary questions spanning nine disciplines (Figure 5); R-Bench-T (Guo et al., 2025), a graduate-level multidisciplinary benchmark with 1,093 English text-only multiple-choice questions (one question excluded for potential ambiguity); and xBench-ScienceQA (Xbench-Team, 2025), a curated set of 100 Chinese QA items evaluating foundational scientific knowledge. The ZPD Exam-v1 is constructed from a corpus of 30,000 scientific papers published 2023–2025 that is strictly disjoint from the training data corpus, ensuring no contamination.
Base model(s). The paper trains on the Qwen3 family (Yang et al., 2025), including two dense variants (Qwen3-8B, Qwen3-32B) and one mixture-of-experts variant (Qwen3-30B-A3B-Thinking-2507). The 30B-A3B backbone receives both continued pre-training and rejection-sampling fine-tuning; the 8B and 32B backbones receive only RFT (due to the computational cost of CPT, which "is conducted only on Qwen3-30B-A3B-Thinking-2507" per Section 5.3). The base models—without tools and without fine-tuning—provide the "Direct Inference" baselines reported in Table 4: Qwen3-30B-A3B achieves 9.2% on HLE (text-only) and 4.9% on ZPD Exam-v1 without tools, rising to 10.2% and 47.2% respectively with tool access.
Metrics. The primary metric across all benchmarks is accuracy (%)—the fraction of test questions for which the model's final answer matches the ground truth, as judged by an automated evaluator. The paper uses o3-mini (OpenAI, 2025b) as the judge, guided by the official strict evaluation prompt from HLE (Phan et al., 2025; reproduced in Appendix D.1). The prompt requires the judge to extract a final answer from the model's response, provide reasoning for the correctness determination, output a binary correct/incorrect verdict, and include a confidence score. For tool-use analysis (Tables 3 and 7), the paper additionally reports conditional tool accuracy, defined as the success rate on tasks that use a particular tool, and average tool usage per round.
Baselines. The paper compares against three public fine-tuning datasets for agent training, each normalized to the same training volume (25,600 rounds) and trained on the same base models with identical hyperparameters: TaskCraft (Shi et al., 2025), which programmatically generates agentic tasks with multiple tools and verifiable trajectories; MegaScience (Fan et al., 2025), constructed by integrating high-quality subsets from multiple open-source scientific datasets, primarily sourced from university textbooks; and MiroVerse (MiroMind-Data-Team, 2025), an open-source large-scale dataset covering multi-hop QA, web navigation, and scientific reasoning, using the SFT data from its v0.1 release. For the holistic model (CPT+RFT), the paper additionally compares against leading proprietary LLMs (GPT-4o, Claude 4 Sonnet, Gemini 2.5 Flash, DeepSeek V3.1-671B) both with and without tool access, proprietary deep-research agents (OpenAI DeepResearch, Gemini DeepResearch, Kimi-Researcher), and prominent open-source agents (WebDancer-QwQ-32B, WebSailor-72B, WebShaper-72B), as shown in Table 4.
Generation budget / compute accounting. For fair comparison across datasets, the paper normalizes training data volume to 25,600 rounds for each dataset, with each round capped at 40,960 tokens, trained for 3 epochs (Section 4.1). The 12,000 trajectories from AgentFrontier are selected to fill exactly this round budget—each trajectory averages approximately 2.13 rounds. At inference time, all models use nucleus sampling with temperature = 0.6 and top-p = 0.95. Tool-augmented agents follow the ReAct paradigm with a maximum of 40 rounds per question, though the paper reports that 95% of problems are solved within 15 rounds (Figure 8). The paper does not report wall-clock inference time or FLOP counts; all compute comparisons are in terms of training data volume (rounds) and inference rounds.
Cross-validation / statistical protocol. The paper does not employ cross-validation for model evaluation—all results are reported on the standard test splits of the respective benchmarks. For the Best-of-N analysis in Section 5.1, the paper uses a held-out validation set of 300 samples from AgentFrontier and reports 95% confidence intervals (Figure 7). The paper does not report confidence intervals or statistical significance tests for the main benchmark results; all numbers are point estimates from single evaluation runs. The ZPD Exam-v1 is split into 1,024 public questions and an undisclosed private set; only public-set results are reported in Figure 1b and Figure 6.

Main Quantitative Results

Overall Fine-Tuning Dataset Comparison Across Benchmarks

The central result of the paper's controlled comparison appears in Figure 6: when fine-tuning the Qwen3-30B-A3B backbone on four datasets normalized to identical training volume (25,600 rounds), AgentFrontier outperforms all baselines on every benchmark. The specific numbers:

HLE (text-only): AgentFrontier achieves 25.7% vs. TaskCraft (19.9%), MegaScience (20.2%), MiroVerse (19.6%). This represents a +5.8 absolute point advantage over the next-best baseline (MegaScience at 20.2%) and a +16.5 point improvement over the base model without tools (9.2%). The base model with tools but no fine-tuning scores 10.2%, meaning the RFT alone accounts for +15.5 points of improvement.
ZPD Exam-v1: AgentFrontier achieves 91.4% vs. TaskCraft (90.1%), MegaScience (90.0%), MiroVerse (86.7%). The margin here is smaller (+1.3 over TaskCraft) because all RFT-trained models score above 86%, suggesting the ZPD Exam's difficulty is somewhat saturated for fine-tuned models. Note that the base model with tools already scores 47.2%, so the RFT improvement (+44.2 points) dwarfs the inter-dataset differences.
RBench-T: AgentFrontier achieves 74.4% vs. TaskCraft (72.3%), MegaScience (73.1%), MiroVerse (70.6%). The +1.3 point advantage over MegaScience is modest but consistent with the pattern.
xBench-ScienceQA: AgentFrontier achieves 54.0% vs. TaskCraft (44.0%), MegaScience (48.0%), MiroVerse (49.0%). This is the largest relative advantage among the benchmarks (+5.0 points over MiroVerse), suggesting ZPD-calibrated data is particularly effective for scientific knowledge tasks.

Cross-backbone consistency. The same pattern holds for other backbones (Figure 6): on Qwen3-32B, AgentFrontier achieves 23.8% HLE (vs. 19.9% MiroVerse, +3.9 points), 90.9% ZPD Exam (vs. 91.1% TaskCraft, a rare second-place finish, though the gap is only 0.2 points), 70.3% RBench-T (vs. 68.4% MegaScience), and 51.0% xBench-ScienceQA (vs. 43.0% MiroVerse, +8.0 points). On Qwen3-8B, AgentFrontier achieves 18.8% HLE (vs. 15.0% MiroVerse, +3.8 points), 86.8% ZPD Exam (vs. 87.5% TaskCraft, -0.7 points), 67.2% RBench-T (vs. 64.3% TaskCraft), and 40.0% xBench-ScienceQA (vs. 36.0% MegaScience). The paper notes that "the performance of competing datasets such as TaskCraft, MegaScience, and MiroVerse is inconsistent; while each may show strength on a particular benchmark, none demonstrates the robust, cross-domain superiority imparted by AgentFrontier."

Subject-level dominance on HLE. Table 2 breaks down HLE accuracy across eight academic disciplines for all three backbones. For the Qwen3-30B-A3B backbone, AgentFrontier achieves the highest accuracy in every single subject: Math (29.85% vs. next-best 24.62% TaskCraft), CS/AI (16.81% vs. 14.60% MegaScience), Biology/Medicine (21.27% vs. 20.81% tie between MegaScience and MiroVerse), Physics (17.82% vs. 10.40% MiroVerse), Humanities (31.61% vs. 34.72% MiroVerse—this is an error in the paper's claim; MiroVerse actually scores higher on Humanities), Chemistry (22.00% vs. 19.00% TaskCraft), Engineering (14.52% vs. 12.90% TaskCraft), and Other (28.00% vs. 22.86% MiroVerse). For the 32B backbone, AgentFrontier wins in six of eight subjects; for the 8B backbone, it wins in seven of eight. The overall averages show AgentFrontier at 25.67% (30B), 23.82% (32B), and 18.80% (8B), with gaps of +5.03, +3.90, and +3.80 points over the next-best dataset respectively.

Analysis of Why AgentFrontier Excels: Deconstructing Reasoning and Tool-Use Gains

Round-interval analysis (Figure 8). The paper examines accuracy as a function of the number of reasoning rounds for the Qwen3-30B-A3B model on HLE. AgentFrontier consistently outperforms all baselines across round intervals 1–5, 6–10, 11–15, 16–20, and 21–25. The cumulative distribution of rounds shows that 95% of problems are solved within 15 rounds—a window in which AgentFrontier's advantage is most pronounced. The paper interprets this as evidence that AgentFrontier teaches the model to solve problems efficiently through knowledge fusion rather than extended, shallow retrieval chains.

Tool usage and conditional accuracy (Table 3). On the HLE text-only set, the Qwen3-30B-A3B agent fine-tuned on AgentFrontier achieves an overall conditional accuracy of 26.3%, compared to 21.0% (TaskCraft), 20.6% (MegaScience), and 20.5% (MiroVerse). This +5.3 to +5.8 point advantage is decomposed by tool:

Search: 24.9% conditional accuracy (vs. 19.6–20.4% for baselines), with comparable usage (0.73 calls/round vs. 0.67–0.73).
Scholar: 25.4% (vs. 20.3–21.0%), usage 0.89 vs. 0.78–0.98.
Browser: 29.8% (vs. 22.7–25.2%), usage 1.32 vs. 1.24–1.47.
Code: 24.9% (vs. 18.1–18.6%), usage 0.63 vs. 0.52–0.67.

The key pattern: AgentFrontier achieves substantially higher accuracy per tool call while using a comparable or slightly lower number of calls (overall 4.57 rounds vs. 4.21–4.74 for baselines). As the paper states, "agent capability stems not from the volume of tool calls, but their efficacy." The balanced tool distribution in the training data (Table 1: 0.32 search, 0.66 scholar, 0.82 browser, 0.52 code per trajectory) forces the model to develop inter-tool orchestration rather than over-specializing in a single tool.

Extended tool analysis across benchmarks (Table 7). The supplementary results in Table 7 extend the tool-usage analysis to ZPD Exam-v1, RBench-T, and xBench-ScienceQA. On ZPD Exam-v1, AgentFrontier achieves 87.6% overall conditional accuracy vs. 78.9–87.4% for baselines, with particularly strong performance on Scholar (91.7%) and Browser (91.8%). On RBench-T, AgentFrontier achieves 63.7% vs. 57.2–62.5%. On xBench-ScienceQA, the pattern partially inverts: MiroVerse achieves 52.0% vs. AgentFrontier's 50.7%, the only case where AgentFrontier does not lead on conditional accuracy. The paper does not comment on this anomaly.

Holistic Training Results (CPT + RFT)

Main results (Table 4). The fully trained AgentFrontier-30B-A3B (CPT + RFT) model is evaluated against a broad set of competitors:

HLE (text-only): 28.6%, surpassing OpenAI DeepResearch (26.6%), Gemini DeepResearch (26.9%), and Kimi-Researcher (26.9%), all of which are proprietary deep-research agents. This also exceeds DeepSeek V3.1-671B with tools (29.8%—but note this number is marked with † indicating it is from official reports, not the paper's own evaluation, so the comparison may not be apples-to-apples). The ablation shows RFT-only achieves 25.7%, with CPT adding +2.9 points.
ZPD Exam-v1: 93.4%, exceeding all listed agents including DeepSeek V3.1-671B with tools (93.1%—again †) and Claude 4 Sonnet with tools (86.6%). The CPT gain is +2.0 points over RFT-only (91.4%). The paper notes this gain is particularly notable because "the RFT-only model's performance was already near-saturation."
RBench-T: 77.1%, exceeding DeepSeek V3.1-671B without tools (76.3%) and Gemini 2.5 Flash with tools (75.8%). CPT adds +2.7 points over RFT-only (74.4%).
xBench-ScienceQA: 61.0%, the largest CPT gain at +7.0 points over RFT-only (54.0%). This suggests that CPT's knowledge infusion is especially impactful for foundational science questions where parametric knowledge matters more than research orchestration.

The paper frames the CPT contribution as evidence that "strengthening a model's foundational knowledge via CPT directly enhances its capacity for complex agentic tasks." However, no ablation is provided on the composition of the CPT corpus (1M text chunks + 20M QA pairs)—we cannot determine whether the QA pairs, the text chunks, or both contribute to the gains.

Direct inference baselines without fine-tuning. The upper panel of Table 4 shows that base models without tools perform poorly on HLE (GPT-4o: 2.3%, Claude 4 Sonnet: 5.4%, Gemini 2.5 Flash: 10.4%, DeepSeek V3.1: 18.5%) and ZPD Exam-v1 (4.8%, 6.0%, 6.3%, 8.2% respectively). Tool access improves performance substantially: GPT-4o rises from 2.3% to 4.8% on HLE but jumps from 4.8% to 51.3% on ZPD Exam-v1, consistent with the benchmark's design as measuring tool-requiring research capability. The paper uses these numbers to validate the ZPD Exam's construction: base models without tools cluster in Zone 1 (< 20%), confirming the benchmark's calibration.

Best-of-N Analysis: Validating Difficulty Richness

On a held-out validation set of 300 samples from AgentFrontier, the RFT Qwen3-30B-A3B model achieves a pass@1 of 21.7% and a pass@8 of 40.7%, for a total gain of +19.0 points (Figure 7). The 95% confidence intervals are shown in the figure. The paper interprets this 19.0-point gap as evidence that the dataset "presents a challenging frontier where initial attempts may fail, but success is achievable through exploration"—in other words, the training data contains problems where the model's policy distribution assigns non-trivial probability to multiple valid solution strategies, but the model hasn't yet concentrated its probability mass on the best ones. The paper explicitly positions this as a precondition for effective reinforcement learning: "the large gap between pass@1 and pass@8 confirms that for problems the model fails to solve on the first attempt, its policy distribution contains diverse and successful alternative trajectories."

Ablation Studies and Robustness Checks

Effect of continued pre-training (CPT): Table 4 (final row) isolates the CPT contribution by comparing RFT-only vs. CPT+RFT on the same Qwen3-30B-A3B backbone. CPT adds +2.9 points on HLE (25.7% → 28.6%), +2.0 on ZPD Exam-v1 (91.4% → 93.4%), +2.7 on RBench-T (74.4% → 77.1%), and +7.0 on xBench-ScienceQA (54.0% → 61.0%). The gains are consistent but modest on benchmarks where RFT already achieves high scores (ZPD Exam), and larger on knowledge-intensive benchmarks (xBench-ScienceQA). The paper does not ablate CPT data composition (e.g., text chunks only vs. QA pairs only vs. both), so the relative contributions of the two CPT data sources are unknown.

Model scale ablation: Figure 6 shows results across three model scales (8B, 32B, 30B-A3B). The absolute gains from AgentFrontier over baselines generally increase with model scale: the HLE advantage over next-best is +3.8 points at 8B, +3.9 at 32B, and +5.0 at 30B-A3B. This supports the paper's claim that "as model capacity increases, the rich, multi-step reasoning trajectories within AgentFrontier become increasingly effective." However, the MoE architecture (30B-A3B) and dense architectures (8B, 32B) are not directly comparable in scale, so the trend should be interpreted cautiously.

Training data ablation (implicit across Figures 6, 8, Tables 2–3, 7): By comparing four datasets normalized to identical training volume (25,600 rounds, 3 epochs), the paper implicitly ablates data quality while holding quantity constant. The consistent underperformance of TaskCraft, MegaScience, and MiroVerse—despite each having strengths (TaskCraft: programmatic verification; MegaScience: textbook grounding; MiroVerse: task diversity)—isolates the ZPD calibration mechanism as the distinguishing factor. However, this is a between-dataset comparison, not a controlled ablation of the ZPD filter within the AgentFrontier pipeline itself. The paper does not compare AgentFrontier data with the ZPD filter against AgentFrontier data without the ZPD filter (e.g., using all refined QA pairs regardless of LKP/MKO solvability), which would be a more direct ablation.

Tool distribution ablation (Tables 1, 3, 7): The paper's training data (Table 1) exhibits a balanced tool distribution compared to the baselines' skewed distributions (TaskCraft: browser-heavy at 1.19 calls/trajectory; MiroVerse: code-heavy at 0.93). The evaluation results (Tables 3, 7) show that AgentFrontier-trained models achieve higher conditional accuracy across all tools, not just the tools that were heavily represented in training. This suggests that balanced tool training teaches transferable orchestration skills rather than tool-specific proficiency. However, the paper does not ablate tool distribution within its own pipeline—it does not, for example, train models on AgentFrontier data with deliberately skewed tool distributions to test whether balance is causal or merely correlated with quality.

Difficulty calibration ablation (implicit in ZPD Exam design): The ZPD Exam's dual constraint (fail 3/3 unaided, succeed 3/3 with tools) is stricter than the training data's ZPD filter (fail once unaided, succeed ≥ 1/3 with tools). The results in Figure 1b show that base models without tools score uniformly below 20% on ZPD Exam-v1 (GPT-5: 9.9%, Gemini-2.5-Pro: 9.6%, DeepSeek-V3.1: 8.2%), while models with tools span a wide range (47.2%–93.4%). This validates that the stricter filter successfully isolates tool-dependent questions. However, the paper does not compare the two filtering approaches directly—we cannot determine whether the stricter filter produces a meaningfully different benchmark than the looser filter.

Negative result on the reasoning bottleneck: Figure 1b and the accompanying analysis (Section 3.2) reveal that many tool-augmented models remain in Zone 2 (20–60%), despite having access to the same tools as Zone 3 models. GPT-4o+tools (51.3%), WebShaper-72B (54.4%), and WebSailor-72B (62.1%) all fall short of mastery despite substantial tool access. This represents a negative result for the hypothesis that tool access alone suffices for deep research—it demonstrates that the bottleneck is reasoning orchestration, not tool availability. The paper does not explore why these specific models stall in Zone 2, which would require controlled experiments varying only the training data while holding tools constant.

Unablated components: Several important components of the pipeline are never ablated. These include the triplet size (3 chunks vs. pairs vs. quadruplets), the thematic coherence threshold τ_theme = 0.8 (what happens at 0.7 or 0.9?), the choice of 4 escalation dimensions (are all necessary? does adding a 5th help?), the k_nn = 10 neighborhood size for triplet search, the N = 3 Best-of-N verification size, the redundancy threshold ε = 0.7, and the choice of GPT-4o vs. alternatives for the automated judge. Some of these (especially the ZPD filter thresholds) are plausibly critical to the pipeline's behavior, and their sensitivity is unknown.

Critical Assessment

Claim 1: "ZPD-guided data synthesis enables state-of-the-art performance on challenging benchmarks, surpassing proprietary deep-research agents."

This claim is supported by the results in Table 4, but with important caveats. The 28.6% HLE score does exceed the reported scores for OpenAI DeepResearch (26.6%), Gemini DeepResearch (26.9%), and Kimi-Researcher (26.9%)—all proprietary agents that the paper did not evaluate itself (these numbers are cited from official reports, marked with † or assumed to be publicly reported). The comparison is not controlled: the proprietary agents may have been evaluated under different conditions (different HLE subsets, different grading protocols, different tool environments). Moreover, DeepSeek V3.1-671B with tools scores 29.8% (marked †), placing it above AgentFrontier-30B-A3B, which the paper acknowledges but then effectively dismisses by not including it in the "Proprietary Research Agents" section. The claim of "surpassing" is thus narrowly true for the three named proprietary research agents, but not for all listed competitors.

The more robust claim is the controlled comparison against other fine-tuning datasets (TaskCraft, MegaScience, MiroVerse) on identical base models with identical training volume. Here the evidence is strong—AgentFrontier outperforms on 11 of 12 benchmark-backbone combinations in Figure 6 (the only exception being ZPD Exam on 8B, where TaskCraft leads 87.5% to 86.8%, a 0.7-point gap). The subject-level dominance on HLE (Table 2) provides additional granularity: AgentFrontier wins in 19 of 24 subject-backbone combinations (6/8 on 8B, 6/8 on 32B, 8/8 on 30B-A3B), with the losses concentrated in Humanities and Engineering on the smaller backbones.

Claim 2: "The ZPD Exam provides a self-evolving benchmark that diagnoses the reasoning bottleneck in agentic capabilities."

The diagnostic framework (three zones) is validated by the distribution of scores in Figure 1b: models without tools cluster in Zone 1 (< 20), tool-augmented models span Zones 2 and 3, and the highest-scoring models (AgentFrontier, DeepSeek-V3.1 with tools) reach Zone 3 (> 60 for the boundary defined in Section 3.2, though at 93+% they far exceed the minimum threshold). The benchmark's construction from 2023–2025 papers provides face validity for the claim that it tests frontier knowledge rather than memorization.

However, the "self-evolving" claim is aspirational, not demonstrated. The paper presents ZPD Exam-v1 as a single static release; future versions are hypothesized but not produced. The flywheel mechanism (regenerate with updated papers and stronger baselines) is described conceptually but never executed, so we have no evidence that the benchmark can be regenerated with comparable quality, that successive versions would maintain calibration, or that the difficulty would track model improvements. The claim is a design property of the framework, not an empirically demonstrated capability.

Additionally, the benchmark's construction uses the same AgentFrontier Engine that produces the training data, creating a potential conflict of interest—the engine's design choices (triplet size, refinement dimensions, LKP/MKO selection) simultaneously shape both the training distribution and the evaluation distribution. Even though the paper guarantees disjoint corpora, if the engine systematically produces questions with certain structural properties (e.g., favoring certain types of knowledge fusion), models trained on engine-produced data may have an inherent advantage on engine-produced benchmarks that does not generalize to independently constructed evaluations. The baseline comparisons in Figure 6 partially address this (AgentFrontier also wins on independently constructed benchmarks like HLE and RBench-T), but the ZPD Exam results should be interpreted as within-framework validation, not independent assessment.

Claim 3: "The 19.0-point pass@1-to-pass@8 gap demonstrates rich policy diversity suitable for subsequent RL."

This is the most speculative claim in the paper, and it is supported by a single experiment (Figure 7) on a 300-sample validation set from the AgentFrontier dataset itself—not from an independent benchmark. The gap is real (21.7% to 40.7%), but the interpretation that this gap "highlights the significant potential for subsequent reinforcement learning" is an extrapolation, not a demonstrated result. The paper does not run RL, so we have no evidence that the pass@1-to-pass@N gap actually predicts RL gains. It is possible that the alternative trajectories that boost pass@8 are variations that an RL policy would not discover (e.g., they rely on lucky tool-call sequences that a policy gradient method would not reinforce), or that the gap reflects noise rather than genuine latent capability.

The validation set of 300 samples is also small—a gap of this magnitude could be driven by a small number of problems where the model happens to have diverse strategies. Without reporting per-problem statistics (how many of the 300 problems contribute to the gap, and by how much), we cannot assess whether the diversity is distributed across the dataset or concentrated in a few outlier problems. The paper's claim that this demonstrates "rich learning signal beyond superficial pattern matching" overstates what the experiment shows.

What experiments would have strengthened the paper:

Ablation of the ZPD filter: The paper never compares training on AgentFrontier data with the ZPD filter against training on the same data without the filter (e.g., using all Stage II refined QA pairs regardless of LKP solvability, or using a random difficulty sampling). This is the most critical missing experiment—without it, we cannot attribute the performance gains to the ZPD calibration specifically rather than to other properties of the pipeline (the triplet seeding, the four-dimensional refinement, the tool diversity). The comparison against TaskCraft/MegaScience/MiroVerse shows AgentFrontier is better than those specific datasets, but does not isolate which component of AgentFrontier drives the improvement.
CPT data composition ablation: The 50B-token CPT corpus combines 1M text chunks with 20M QA pairs. We don't know whether the +2.0 to +7.0 CPT gains come from the text chunks (which would suggest broad knowledge infusion is the mechanism), the QA pairs (which would suggest task-specific knowledge matters more), or their combination. Training with each component separately would distinguish these hypotheses.
Dependence on the MKO model: The ZPD filter's definition depends on the MKO (Qwen3-235B-A22B with tools). If a weaker MKO were used, fewer problems would pass the filter; if a stronger MKO were used, more would pass. The paper does not explore sensitivity to MKO strength, which matters for reproducibility—another research group attempting to replicate the pipeline with different base models would need to calibrate their MKO appropriately, and the paper provides no guidance on how MKO strength affects data quality.
Dependence on the automated judge: Both the ZPD filter and the evaluation use LLM-as-a-Judge (GPT-4o for filtering, o3-mini for evaluation) to determine correctness. The paper does not report judge agreement rates with human evaluators, judge calibration, or the sensitivity of ZPD filtering to judge errors. If GPT-4o incorrectly marks a correct answer as wrong during filtering, a genuinely solvable problem is misclassified as "unsolvable by LKP" and may enter D_ZPD or D_human erroneously.
Generalization beyond Qwen3: All experiments use Qwen3 family models. The ZPD framework is presented as model-agnostic, but we have no evidence that it transfers to other model families (e.g., Llama, DeepSeek, Gemma) or that the ZPD threshold calibrated for Qwen3-30B-A3B is meaningful for differently architected models.
Statistical significance: The paper reports point estimates without confidence intervals except in the BoN analysis. On the 2,154-question HLE set, a +5 percentage point gap between methods represents roughly 108 questions; on the 1,024-question ZPD Exam, the gaps are smaller in absolute terms (e.g., +1.3 points over TaskCraft, ~13 questions). Without confidence intervals, we cannot assess whether these gaps are statistically reliable or could arise from sampling variability.
Latency analysis: The paper reports tool usage statistics (Tables 3, 7) but never discusses inference latency. The Browser tool averages 1.32 calls per round on HLE—each call involves fetching a webpage, reading up to 10,000 tokens, and synthesizing an answer. The wall-clock time per question is unknown but likely substantial. For the proprietary research agents listed as baselines, latency is similarly unreported, making the comparison purely accuracy-based.

6. Limitations and Trade-offs

The ZPD Filter Depends on an Expensive, Uncalibrated MKO That Is Not Characterized for Sensitivity

The assumption or constraint. The entire ZPD framework is defined relative to two personas: the LKP (the base model without tools) and the MKO (Qwen3-235B-A22B with tools, search, scholar, browser, and code). The MKO serves as the oracle for what is "learnable"—a QA pair is classified as within the ZPD if the MKO can solve it in at least 1 of 3 attempts (Section 2.3). The paper treats the MKO as a fixed, reliable reference point and never ablates or characterizes its behavior.

The paper acknowledges the computational cost of the MKO in Appendix A.3— $0.18 per candidate for verification, amortized to$ 0.54 per accepted pair—but does not acknowledge a deeper assumption: that the MKO's success or failure is a reliable signal of problem learnability rather than a noisy function of the MKO's specific architecture, training data, prompt format, and tool quality.

The consequence. The ZPD dataset D_ZPD is exactly the set of problems the MKO can solve but the LKP cannot. This inherits all of the blind spots, biases, and failure modes of the MKO. If the MKO systematically fails on a class of problems—not because they are fundamentally unsolvable with tools, but because the MKO's particular tool suite, reasoning style, or base knowledge is insufficient—those problems are routed to D_human (for expert review) and excluded from training. The resulting training data teaches the LKP to solve only the subset of frontier problems that the MKO happens to handle well. The model is being trained toward the MKO's capability profile, not toward a more general notion of agentic competence.

This is particularly concerning because the paper never characterizes the MKO's failure modes. What types of problems does the MKO consistently fail at (even with 3 attempts)? Are they concentrated in specific disciplines, specific difficulty levels, or specific reasoning patterns? Without this characterization, we cannot know whether D_ZPD systematically underrepresents certain categories of frontier reasoning—and therefore whether the trained model has systematic capability gaps inherited from the MKO rather than from the LKP.

The choice of MKO model also creates a reproducibility and calibration problem for other research groups. A team using a different base model (e.g., Llama, DeepSeek) as their LKP would need to select an MKO that is "strong enough" to solve frontier problems but not so different from the LKP that the ZPD gap is unbridgeable. The paper provides no guidance on how to select or calibrate the MKO—is a 235B model necessary? Would a 70B model suffice? Does the MKO need to share architecture with the LKP? These questions are unanswered, making the framework difficult to apply in new settings without extensive trial-and-error.

What evidence exists in the paper. The paper reports only aggregate statistics about the MKO's behavior: it has a 33% success rate on Stage III candidates (Appendix A.3.2), and it uses an average of 3.32 API calls with specific tool distributions. There is no analysis of MKO failure patterns, no breakdown of MKO success rates by discipline or difficulty, and no comparison of MKO behavior to alternative strong agents (e.g., GPT-4o with tools, Claude with tools). The paper implicitly assumes the MKO is "strong enough" because it uses 235B parameters and tool augmentation, but parameter count and tool access are not guarantees of comprehensive frontier competence.

Mitigation status. The paper does not acknowledge this as a limitation and does not attempt to mitigate it. The MKO is treated as a fixed component of the pipeline rather than a variable whose properties shape the training data. Section 7 (Limitations and Future Work) does not mention MKO sensitivity or calibration. The ZPD Exam's dual constraint (fail 3/3 unaided, succeed 3/3 with tools) partially addresses this for evaluation by requiring consistent MKO success, but the training data uses a weaker threshold (≥1/3 correct), meaning the training set includes problems that the MKO can only solve unreliably—which may be poor training examples.

The CPT and RFT Training Stages Are Never Ablated against Simpler Data Selection Baselines

The assumption or constraint. The paper's central claim is that ZPD-guided data synthesis—the adversarial LKP–MKO filtering in Stage III—is what makes AgentFrontier training data superior to alternatives. The evidence for this claim comes from comparing AgentFrontier-trained models against models trained on three other public datasets (TaskCraft, MegaScience, MiroVerse). All datasets are normalized to 25,600 rounds of training data (Section 4.1). This comparison demonstrates that AgentFrontier data as a whole outperforms these specific baselines.

However, the AgentFrontier pipeline has many components beyond the ZPD filter: the triplet seeding (Stage I), the four-dimensional agentic refinement (Stage II), the balanced tool distribution, the specific Qwen3-235B-A22B models used for generation and refinement, the 12,000 trajectory selection, and the 50B-token CPT corpus. The paper never isolates the ZPD filter as the causal factor by comparing AgentFrontier data with and without the ZPD filter, or by comparing ZPD-filtered data against data filtered by a simpler criterion (e.g., random difficulty sampling, length-based filtering, perplexity-based filtering). Additionally, the CPT stage composition (1M text chunks + 20M QA pairs) is never ablated—we do not know whether the CPT gains come from the text chunks (suggesting broad knowledge infusion matters), the QA pairs (suggesting task-specific knowledge matters), or their combination.

The consequence. We cannot determine whether the ZPD filter specifically contributes to model performance, or whether the gains come from other aspects of the pipeline—the triplet structure that forces cross-document reasoning, the balanced tool distribution that teaches inter-tool synergy, the higher quality of Qwen3-235B-A22B-generated refinements compared to the baselines' data generation processes, or simply the scale and diversity of the underlying corpus. The baseline datasets differ from AgentFrontier along many dimensions simultaneously:

TaskCraft uses programmatic generation, not LLM-based refinement; its tool distribution is browser-heavy (1.19 calls/trajectory); it does not enforce cross-document knowledge fusion.
MegaScience sources from textbooks, not web documents; its questions primarily test single-document comprehension; its tool distribution is different.
MiroVerse is code-centric (0.93 code calls/trajectory); it covers diverse tasks but does not calibrate difficulty.

A dataset could outperform these baselines for reasons entirely unrelated to the ZPD principle—for example, because it forces multi-document synthesis (a property of the triplet seeding, not the ZPD filter) or because it uses a more balanced tool distribution (a property of the refinement agent's design, not the ZPD filter). Without an ablation that varies only the ZPD filter while holding the rest of the pipeline constant, the paper's central claim—that ZPD calibration is the key innovation—remains correlational rather than causal.

The CPT composition ablation gap is similarly consequential. The paper reports CPT gains of +2.0 to +7.0 points across benchmarks (Table 4) and interprets them as evidence that "strengthening a model's foundational knowledge via CPT directly enhances its capacity for complex agentic tasks." But if the gains come primarily from the 20M QA pairs (which are themselves ZPD-filtered to be solvable by the LKP), then CPT is effectively providing additional task-specific fine-tuning rather than broad knowledge infusion. This would change the interpretation of why the two-stage pipeline works and how practitioners should allocate resources between CPT and RFT.

What evidence exists in the paper. The paper provides extensive comparisons against external baselines (Figures 6, 8; Tables 2, 3, 4, 7) but no internal ablation of its own pipeline. There is no experiment that:

Trains on AgentFrontier Stage II refined data without the Stage III ZPD filter.
Trains on AgentFrontier data filtered by a non-ZPD criterion (e.g., random sampling, length threshold).
Trains on CPT with text chunks only vs. QA pairs only vs. both.
Varies the ZPD filter threshold (e.g., requiring MKO ≥2/3 correct vs. ≥1/3).
Uses a different LKP or MKO to test sensitivity of the ZPD boundary.

The comparisons against TaskCraft, MegaScience, and MiroVerse are valuable for establishing that AgentFrontier produces effective training data, but they do not isolate which part of AgentFrontier's pipeline is responsible.

Mitigation status. The paper does not acknowledge this as a limitation. The ablation gap is significant because it means the paper's central conceptual contribution—that ZPD is the right principle for data calibration—is not directly tested. The paper argues for ZPD by analogy to educational theory and by showing that AgentFrontier (which implements ZPD among other things) works well, but this is a package deal: we observe that the whole pipeline succeeds, not that the ZPD component specifically is necessary or sufficient. Future work that ablates the ZPD filter while holding the rest of the pipeline constant would be required to validate the paper's core claim.

The Full Computational Cost of the Pipeline Is Not Included in Any Efficiency Claim, and the Headline $4× Efficiency Analogy from Prior Work Does Not Apply Here

The assumption or constraint. The paper reports the cost of producing a single frontier QA pair as approximately $0.78—$ 0.24 for Stage II refinement plus $0.54 amortized for Stage III verification (Appendix A.3). This cost accounting is unusually detailed and transparent. However, it excludes the cost of difficulty estimation that is embedded in the refinement process: the pipeline must periodically test each QA pair against the LKP during Stage II to determine when the stopping criterion is met (Section 2.2: "the refinement loop terminates when the generated question q_k becomes unsolvable by the Less Knowledgeable Peer"). Each LKP test requires a full inference call—generating an answer and having GPT-4o judge it—and with an average of 7.81 refinement iterations per candidate, this could involve up to 7–8 LKP evaluations per data point. The paper does not include these LKP evaluation costs in its per-sample budget calculations.

Separately, the paper frames its contribution in terms of data efficiency—achieving better performance with the same number of training rounds (25,600)—rather than compute efficiency. Unlike the scaling laws literature or the compute-optimal test-time scaling work (Hoffmann et al., 2022; Jones, 2021; Sardana and Frankle, 2023), the paper does not perform a FLOPs-matched comparison between its data synthesis cost and the cost of alternative approaches. It does not compare, for example, whether spending the synthesis budget ( $0.78 per trajectory × 12,000 trajectories = ~$ 9,360 in API costs, plus the unaccounted LKP evaluation costs) on generating more data from a simpler pipeline would produce comparable or better results.

The consequence. A practitioner reading this paper cannot answer the central deployment question: is the ZPD pipeline worth the cost compared to simpler, cheaper alternatives? The 25,600-round normalization ensures that the training compute is equal across datasets, but the data synthesis compute is wildly different. TaskCraft uses programmatic generation (essentially zero LLM cost per sample). MegaScience and MiroVerse use document-grounded QA generation but without the expensive iterative refinement and adversarial MKO verification. The AgentFrontier pipeline costs ~$0.78 per training example (plus unaccounted LKP costs), while the baseline datasets may cost orders of magnitude less to produce.

If the goal is to maximize model performance for a given data synthesis budget (rather than a given training compute budget), the comparison might reverse: spending $10,000 on MiroVerse or MegaScience data generation might produce far more than 12,000 trajectories, and training on a larger volume of simpler data might match or exceed the performance of training on a smaller volume of ZPD-calibrated data. The paper provides no evidence to resolve this question because it normalizes training volume, not total cost.

The exclusion of LKP evaluation costs from the pipeline accounting is also practically significant. If each of the 7.81 average refinement iterations requires an LKP check, and each check requires a full model inference plus GPT-4o judgment (~ $0.01–0.02 per judgment at GPT-4o pricing), the per-sample cost could be ~$ 0.10–0.15 higher than reported—a 13–19% increase over the stated $0.78. This is not a trivial omission for anyone budgeting a large-scale data synthesis operation.

What evidence exists in the paper. Appendix A.3 provides detailed cost breakdowns for Stage II LLM calls and Stage III MKO verification. The paper is transparent about these costs. However, Section 3.2's description of the stopping criterion ("the refinement loop terminates when the generated question q_k becomes unsolvable by the Less Knowledgeable Peer") implies LKP evaluations that are not itemized in the cost analysis. The paper also does not report the total pipeline cost for producing the full 12,000-trajectory training set, the total cost of the CPT corpus (1M text chunks + 20M QA pairs, each requiring generation), or any FLOPs-based comparison against alternative approaches.

The paper's Figure 6 normalizes training to 25,600 rounds across datasets, which equalizes training FLOPs but ignores data synthesis FLOPs. The paper does not discuss this asymmetry.

Mitigation status. The paper partially acknowledges the cost issue by framing the $0.78 figure as a "quality-over-quantity" investment (Appendix A.3.2): "While this represents a non-trivial investment per sample, it aligns with our 'quality-over-quantity' approach." This is a fair framing but does not address the missing LKP evaluation costs, the absence of a FLOPs-matched comparison, or the need for practitioners to evaluate whether the synthesis cost is justified relative to simpler approaches. The Limitation section does not discuss computational cost of data synthesis as a barrier to adoption.

Performance on the Hardest Problems Remains Near-Zero, and the Pipeline Cannot Generate Training Data for Problems the MKO Cannot Solve

The assumption or constraint. The ZPD framework defines the frontier as problems that are unsolvable by the LKP but solvable by the MKO (Section 2.3). This definition has an inherent ceiling: the MKO's capability defines the upper bound of what the training data can teach. Any problem that is genuinely beyond the MKO's reach—too novel, too complex, requiring knowledge or reasoning that even the best tool-augmented agent cannot reliably access—is routed to D_human and excluded from training. The model can never learn to solve problems that are harder than what the MKO can demonstrate.

The paper reports that approximately 67% of Stage III candidates fail the ZPD filter (only 33% are accepted into D_ZPD; Appendix A.3.2). Some of these failures are due to flawed questions, but some are problems that the MKO genuinely cannot solve. The paper does not characterize these MKO-unsolvable problems—how many are in each difficulty bin, which disciplines they cluster in, or what makes them beyond the MKO's capability. The paper also acknowledges, in the difficulty analysis for HLE and ZPD Exam, that performance on the most difficult subsets is poor—for example, Table 2 shows that even the fully trained AgentFrontier-30B-A3B model scores only 14.52% on Engineering and 17.82% on Physics on HLE, despite these being disciplines represented in the training corpus.

The consequence. The ZPD pipeline creates a capability ceiling at the MKO's level. The trained model can approach but not exceed the MKO's competence at frontier reasoning, because the training data contains no examples of problems that the MKO cannot solve. This is a fundamental limitation for any self-improvement or iterative training paradigm that hopes to bootstrap past the teacher's capabilities. The paper's framework is designed to efficiently transfer the MKO's capabilities to the LKP, not to discover capabilities that neither possesses.

This limitation is particularly acute for the hardest problems in scientific and mathematical reasoning. On HLE, the base Qwen3-30B-A3B without tools scores 13.03% on Math and 3.47% on Physics (Table 2). With CPT+RFT training on ZPD-calibrated data, these rise to 29.85% and 17.82%—substantial improvements, but still below 30% on Math and below 20% on Physics. The model fails on 70–82% of frontier math and physics problems despite being trained on data explicitly calibrated to its ZPD. This suggests that either (a) the MKO itself cannot reliably solve these problems, meaning the training data for the hardest subdomains is thin or absent, or (b) the gap between the MKO's demonstrated solutions and the LKP's ability to learn from them is too large for the current training regime to bridge.

In either case, the ZPD framework provides no mechanism for improving performance on problems where the MKO cannot provide reliable supervision. This contrasts with approaches like reinforcement learning from environment feedback or self-play (e.g., AlphaGo-style methods), where the model can discover novel strategies beyond the teacher's demonstrations by exploring and receiving outcome-based rewards. The paper's pass@1-to-pass@8 analysis (Figure 7) hints at this possibility—there exist correct trajectories in the model's policy distribution that are not captured by the single reference trajectory used in RFT—but the paper does not implement RL and does not demonstrate that exploration can push past the MKO ceiling.

What evidence exists in the paper. The difficulty-stratified results in Table 2 show that AgentFrontier-30B-A3B's accuracy varies dramatically by discipline, with the hardest subjects (Physics, Engineering, Math) remaining well below 30% accuracy. The BoN analysis (Figure 7) shows a 19-point gap between pass@1 and pass@8, indicating that even for the problems the model attempts, first-try success is low. The paper does not break down the ZPD Exam results by discipline or difficulty, so we cannot assess whether similar patterns hold there. The 33% MKO acceptance rate (Appendix A.3.2) implies that ~67% of refined candidates are either too hard or flawed, but no further characterization is provided.

Mitigation status. The paper partially acknowledges this limitation in Section 7 (Limitations and Future Work), point 2: "From Imitation to Exploration: Our reliance on imitation learning (IL), specifically Rejection-Sampling Fine-Tuning, constrains the agent to mode-seeking behavior... This presents a prime opportunity for Reinforcement Learning (RL)." The paper frames RL as the path to "break beyond the performance ceiling of the demonstration data." However, even RL would be constrained by the availability of reward signals—if the MKO cannot solve a problem, what reward function would guide the RL agent to discover a solution? The paper suggests "repurposing the ZPD-guided data as a principled reward signal" but does not explain how this would work for problems where no correct trajectory exists in the training data.

The paper also routes MKO-unsolvable problems to D_human for expert review, suggesting that human experts could provide the missing supervision. But this is a fallback, not a solution—relying on human experts to manually solve the hardest problems reintroduces the scalability bottleneck that the automated pipeline was designed to avoid.

The assumption or constraint. The ZPD Exam-v1 is constructed using the same AgentFrontier Engine that produces the training data (Section 3.1). The engine applies the same triplet seeding (from thematically coherent document groups), the same four-dimensional refinement process, and the same LKP–MKO filtering logic—only with a disjoint corpus (30,000 scientific papers 2023–2025 vs. the 1M general web documents for training data) and a stricter filtering criterion (3/3 unaided failures AND 3/3 tool-augmented successes vs. 1 failure AND ≥1/3 successes). The paper emphasizes the disjoint corpus to guarantee no data contamination, but it does not address the deeper issue: the engine itself embeds design choices—triplet size, thematic coherence threshold τ_theme = 0.8, the four escalation dimensions, the specific MKO model and tool suite, the GPT-4o judge—that shape the distribution of both training and evaluation questions.

The consequence. A model trained on engine-produced data may have a structural advantage on engine-produced benchmarks that does not reflect genuine generalization to independently constructed evaluations. This is not about memorizing specific questions or answers (which the disjoint corpus prevents). It is about the model learning to excel at the kind of reasoning the engine tends to produce—the specific patterns of knowledge fusion, the types of multi-step trajectories, the tool orchestration strategies, and the question formats that emerge from the engine's design choices. If these patterns differ systematically from those in human-crafted benchmarks or real-world research tasks, the ZPD Exam scores will overstate the model's true agentic capability.

For example, the triplet seeding strategy (Section 2.1) creates questions that require integrating information from exactly three related sources. The refinement process (Section 2.2) escalates complexity along four specific dimensions (knowledge expansion, conceptual abstraction, factual grounding, computational formulation). The resulting questions may have a characteristic "fingerprint"—they tend to ask for synthesis of three complementary perspectives, often require computational verification, frequently demand academic literature grounding, and follow a predictable structure of progressive refinement. A model trained extensively on such questions may become highly proficient at this specific pattern while struggling with questions that require different forms of synthesis (e.g., integrating five sources, resolving contradictory evidence without computation, or reasoning about qualitative trends without academic citations).

The paper partially addresses this concern by evaluating on externally constructed benchmarks: HLE, RBench-T, and xBench-ScienceQA. AgentFrontier outperforms baselines on all of these, suggesting that the training data does transfer to independently constructed tasks. However, the size of the advantage varies substantially: the gap between AgentFrontier and the next-best baseline is largest on xBench-ScienceQA (+5.0 points on 30B) and HLE (+5.8 points on 30B) but much smaller on RBench-T (+1.3 points) and ZPD Exam-v1 (+1.3 points, and even slightly negative on 8B). This variation could reflect different degrees of structural alignment between the engine's question patterns and each benchmark's question patterns. HLE and xBench-ScienceQA may share more structural properties with engine-produced questions than RBench-T does, inflating the apparent advantage.

What evidence exists in the paper. The paper acknowledges the disjoint corpus but not the shared pipeline as a potential confound. The evidence for and against structural bias is mixed:

Evidence against severe bias: AgentFrontier wins on HLE (+5.03 points over next-best on 30B), an independently constructed benchmark, suggesting genuine transfer. The subject-level dominance in Table 2 spans eight disciplines, which is unlikely to result from narrow structural overfitting.
Evidence consistent with some bias: The ZPD Exam-v1 advantage is modest (+1.3 points, and actually negative on 8B where TaskCraft leads 87.5% to 86.8%), suggesting the benchmark may not strongly differentiate AgentFrontier from other RFT datasets despite being constructed by the same engine. This could indicate that the ZPD Exam's structure is not uniquely favorable to AgentFrontier-trained models, or it could indicate that the benchmark is saturated (all models >86%) and ceiling effects mask the advantage.
Missing evidence: The paper does not compare the distributional properties of ZPD Exam questions vs. HLE questions vs. RBench-T questions. Are ZPD Exam questions more similar to the training data in terms of required reasoning steps, tool invocation patterns, or question length? Without this analysis, we cannot assess the degree of structural alignment.

Mitigation status. The paper does not acknowledge this as a limitation. The disjoint corpus is described as "ensuring a fair and uncontaminated evaluation" (Section 3.1), which addresses data contamination but not pipeline-induced structural bias. The paper's Limitation section (Section 7) does not discuss the relationship between the training data generation pipeline and the benchmark generation pipeline. The use of externally constructed benchmarks provides partial mitigation, but the paper does not discuss why the ZPD Exam advantage is smaller than the HLE advantage or whether this pattern is expected under the hypothesis of no structural bias.

Addressing this limitation would require either (a) comparing the distributional properties of engine-produced questions against human-written questions on multiple dimensions (reasoning steps, knowledge sources, question format, answer type) to quantify structural similarity, or (b) constructing an independent benchmark using a completely different generation methodology (e.g., human experts, a different LLM pipeline with different design choices) and verifying that the advantage persists.

The Generalization of ZPD-Calibrated Data to Other Model Families, Tasks, and Domains Is Completely Uncharacterized

The assumption or constraint. All experiments in the paper use the Qwen3 model family (Yang et al., 2025): Qwen3-8B, Qwen3-32B, and Qwen3-30B-A3B-Thinking-2507 for the base models; Qwen3-235B-A22B for the chunking function, seed QA generator, and refinement agent; and the same Qwen3-235B-A22B (with tools) as the MKO. The training data is generated for and evaluated on Qwen3 models, and the ZPD boundary is defined relative to a Qwen3-30B-A3B LKP and a Qwen3-235B-A22B MKO. The paper presents the ZPD framework as a general principle—"a scalable and effective path toward building more capable LLM agents" (Abstract)—but provides zero evidence that the framework transfers to other model families, architectures, or training paradigms.

This is not just about model scale or architecture. The ZPD boundary depends on the relative capabilities of the LKP and MKO. If a different base model family has different strengths and weaknesses—for example, stronger on math but weaker on biology, or better at tool orchestration but worse at factual recall—the ZPD boundary will fall at different points in the task space. The triplet seeding, the four-dimensional refinement, and the tool distribution all assume that the ZPD for a Qwen3 base model is representative of the ZPD for any base model, which is an untested assumption.

The consequence. A practitioner using Llama, DeepSeek, Gemma, or any non-Qwen3 model cannot assume that the ZPD framework will produce comparably effective training data. They would need to recalibrate the entire pipeline for their model family—selecting an appropriate MKO (which may need to be from the same family for distributional compatibility), re-running the ZPD filter with their specific LKP, and potentially adjusting hyperparameters (τ_theme, k_nn, escalation dimensions, BoN size) that were tuned for Qwen3 behavior. The paper provides no guidance for this recalibration, no sensitivity analysis showing which components are model-dependent vs. model-agnostic, and no evidence that the gains observed for Qwen3 would replicate for other architectures.

The paper also restricts evaluation to four specific benchmarks (HLE, ZPD Exam-v1, RBench-T, xBench-ScienceQA) that all test multidisciplinary academic reasoning—primarily answering graduate-level science and humanities questions. The datasets use English text (with xBench-ScienceQA as a Chinese exception) and require tool-augmented web research. There is no evidence that ZPD-calibrated data improves performance on qualitatively different agentic tasks: code generation, multi-turn dialogue, embodied task planning, long-horizon decision-making, or creative problem-solving. The paper's claim to train "LLM agents" broadly is supported only for a narrow slice of agentic behavior—tool-augmented academic research QA.

Finally, the paper does not investigate whether the ZPD data synthesis pipeline works for modalities beyond text. The tool suite includes code execution, but the questions and answers are text-based. Extending to multimodal tasks (image understanding, video reasoning, audio processing), to tasks requiring real-time interaction, or to tasks with open-ended or subjective evaluation criteria would require fundamentally different tool suites, verifier architectures, and difficulty calibration mechanisms that the paper does not address.

What evidence exists in the paper. All models in all experiments are Qwen3 variants. All benchmarks are text-based multidisciplinary QA. The paper does not report experiments with non-Qwen3 models, does not test on non-QA agent tasks, and does not discuss multimodal extensions. The paper's cross-backbone scaling in Figure 6 (8B → 32B → 30B-A3B) shows that the ZPD advantage generally increases with model scale, which is within-family evidence but does not demonstrate cross-family transfer.

The paper does not acknowledge this as a limitation. The term "LLM agents" is used throughout without qualification, implying generality that is not empirically supported.

Mitigation status. The paper does not address generalizability in its Limitations section. The three limitations discussed in Section 7 (graduated scaffolding, imitation-to-exploration transition, dynamic tool creation) are all about extending the ZPD framework in new directions, not about validating it in new settings. The paper's positioning as a general framework for agent training data synthesis is aspirational; the experimental support is confined to a single model family, a single task type, and a single language (with one Chinese benchmark exception).

Validating generalizability would require demonstrating that the ZPD pipeline produces effective training data for at least one non-Qwen3 model family (e.g., Llama-3, DeepSeek-V2), at least one non-QA agent task (e.g., web navigation, tool-use planning, interactive coding), and ideally at least one non-English setting (beyond the Chinese xBench-ScienceQA). Until such validation is provided, claims about the framework's generality remain hypotheses.

7. Implications and Future Directions

How This Work Changes the Landscape

This paper introduces a principled operationalization of the Zone of Proximal Development as a data selection criterion, transforming Vygotsky's qualitative educational metaphor into a computable predicate—IsSolvableBy(LKP) = 0 AND IsSolvableBy(MKO, N=3) ≥ 1—that can be evaluated automatically at scale for every candidate training example. This is not a new model architecture, a new training algorithm, or even a new dataset; it is a meta-method for generating training data whose difficulty is calibrated to the precise frontier of a specific model's capabilities. The magnitude of this contribution is best understood as a methodological reframing rather than a paradigm shift: it changes how we think about what makes training data valuable for agentic reasoning, even if the individual components (LLM-based data generation, tool-augmented refinement, rejection sampling) are individually familiar.

Concretely, the paper resolves a tension that has silently structured the agent training literature: the contradiction between the need for difficult training examples (to push capability frontiers) and the need for correct supervision signals (to avoid reinforcing errors). Prior approaches handle this tension heuristically—programmatic generation ensures correctness but limits difficulty to what can be procedurally verified (TaskCraft, Shi et al., 2025); document-grounding increases factual richness but struggles to escape single-document comprehension paradigms (MegaScience, MiroVerse); self-play methods can generate harder questions but hit the expressive ceiling where the model cannot reliably produce correct answers for problems it cannot yet solve. The ZPD framework resolves this by decoupling difficulty generation (the LKP defines what is hard) from supervision generation (the MKO provides correct trajectories for what is learnable). Neither agent alone could produce the training data; only the adversarial pairing can.

This reframing has several cascading effects on the research landscape:

It redirects attention from data volume to data calibration. The paper's central empirical result—that 12,000 ZPD-calibrated trajectories (25,600 rounds normalized) outperform comparable volumes of alternative data across four benchmarks and three model scales (Figure 6, Table 2)—suggests that data quality, specifically difficulty targeting, dominates data quantity for teaching complex reasoning. This undercuts the implicit assumption driving much of the synthetic data literature: that scaling up generation pipelines will naturally produce better training data. If difficulty calibration matters more than volume, the research priority shifts from "how do we generate more data?" to "how do we identify which data is at the frontier?"—a fundamentally different optimization problem.

It provides a unified explanation for why different agent training datasets produce inconsistent results. The paper shows that TaskCraft, MegaScience, and MiroVerse each have strengths on specific benchmarks (TaskCraft leads on ZPD Exam for the 8B backbone at 87.5% vs. AgentFrontier's 86.8%; MiroVerse leads on xBench-ScienceQA conditional accuracy at 52.0% vs. AgentFrontier's 50.7% in Table 7) but none demonstrates consistent cross-domain superiority. The ZPD framework explains this: each baseline dataset implicitly targets a different, uncalibrated difficulty distribution—TaskCraft's programmatic generation may oversample easy tool-use patterns, MegaScience's textbook grounding may produce questions within the model's parametric reach, MiroVerse's code-centric tasks may teach a narrow skill set. Without a principled difficulty calibration mechanism, dataset quality varies unpredictably across benchmarks. The ZPD framework provides the calibration mechanism and, as a result, produces the only dataset that consistently wins across benchmarks.

It redefines what "good" training data looks like for agentic capabilities. The paper's analysis of why AgentFrontier excels (Section 5.2, Figures 8, Tables 3 and 7) reveals that the critical factor is not the volume of tool calls or the diversity of tools used, but the efficacy per tool call—the ability to orchestrate tools strategically rather than invoke them indiscriminately. AgentFrontier-trained models achieve higher conditional accuracy across all tools (Search: 24.9% vs. 19.6–20.4% for baselines; Browser: 29.8% vs. 22.7–25.2%; Table 3) while using comparable or slightly fewer calls (4.57 rounds vs. 4.21–4.74). This reframes the agent training problem: the goal is not to teach models to use tools (they can already do that) but to teach them when and how to use tools effectively—a meta-cognitive skill that ZPD-calibrated data cultivates by demonstrating successful orchestration trajectories at the frontier where the base model would otherwise fail.

It introduces a new diagnostic capability for evaluating agents—the reasoning bottleneck. The ZPD Exam's three-zone framework (Section 3.2) provides vocabulary and measurement for a distinction that prior benchmarks conflated: the gap between what tools enable and what a model can achieve with them. Zone 2 (Score 20–60) is not just a score range; it is a diagnostic category for agents that can access information but cannot orchestrate its acquisition and synthesis. This changes how we interpret benchmark results: a model scoring 50% on a tool-requiring benchmark is not "50% capable"—it is bottlenecked at a qualitatively different developmental stage than a model scoring 90%, and the appropriate intervention (better training data for orchestration, not better tools or more parameters) follows from the diagnosis.

It makes the case that the path to better agents is through better data, not necessarily better architectures or larger models. The paper shows that AgentFrontier-30B-A3B—a 30B-parameter MoE model with 3B active parameters—surpasses proprietary deep-research agents (OpenAI DeepResearch at 26.6%, Gemini DeepResearch at 26.9%, Kimi-Researcher at 26.9% on HLE; Table 4) that are almost certainly larger and trained on more data. The differentiating factor is the ZPD calibration of the training data, not model scale. This is a data-centric success story that strengthens the argument for investing in data quality over model scale for agentic capabilities, particularly in regimes where the base model already has sufficient knowledge but lacks the meta-cognitive skills to deploy it effectively.

Research directions that become more attractive. The ZPD framework makes difficulty calibration a first-class research problem: how do we estimate the capability frontier accurately, cheaply, and continuously? This opens up work on lightweight difficulty estimators (Section 7, Future Work #1 in the paper's limitations), dynamic ZPD tracking (recalibrating the frontier as the model learns, rather than using a fixed LKP), and graduated scaffolding (the paper's Future Work #1). The framework also makes RL from ZPD data more promising: if the pass@1-to-pass@8 gap (19.0 points, Figure 7) genuinely reflects latent capability that RL can surface (Section 5.1), then ZPD-calibrated data provides an ideal prior for RL initialization—diverse enough to support exploration but structured enough to provide a good starting policy.

Research directions that become less attractive. The paper implicitly argues against naïve data scaling without difficulty calibration. Generating 100,000 trajectories from a simpler pipeline may be less effective than generating 12,000 ZPD-calibrated trajectories, even if the former costs less per trajectory. This weakens the case for "more data is better" approaches to agent training unless they incorporate explicit difficulty targeting. Similarly, the paper's balanced tool distribution (Table 1) and the poor performance of code-centric (MiroVerse) and browser-centric (TaskCraft) baselines on synthesis-heavy benchmarks suggest that narrowly tool-focused agent training is less promising than holistic orchestration training.

Follow-Up Research This Work Enables

Ablating the ZPD filter to establish causality. The paper's central claim—that the ZPD filter is what makes AgentFrontier data superior—is supported only by comparisons against external baselines (TaskCraft, MegaScience, MiroVerse) that differ from AgentFrontier along multiple dimensions simultaneously (triplet seeding, refinement process, tool distribution, corpus composition). A causal ablation would train models on AgentFrontier Stage II refined data with and without the Stage III ZPD filter—for example, using all refined QA pairs regardless of LKP solvability, or using random difficulty subsampling matched for volume. If the ZPD-filtered data significantly outperforms the unfiltered data on HLE and ZPD Exam, the ZPD principle is directly validated. If performance is comparable, the gains come from other pipeline components (triplet structure, four-dimensional refinement, balanced tools), and the ZPD framing is correlational rather than causal. A strong follow-up would also ablate the MKO strength by using a weaker MKO (e.g., Qwen3-72B instead of 235B) and measuring how the ZPD dataset quality degrades, establishing a sensitivity curve for MKO capability.

Graduated scaffolding with tiered MKO support. The paper's Future Work #1 (Section 7) proposes replacing the binary MKO scaffold (complete solution trajectory or nothing) with graduated assistance—high-level strategic hints for easier problems within the ZPD, specific sub-goals for harder problems, and full trajectories only when necessary. A concrete experiment: generate ZPD data at three scaffolding levels (strategic hints only, sub-goal decomposition, full trajectory), train separate models on each level, and measure whether tiered scaffolding produces models that learn how to seek help—a meta-cognitive skill the binary approach cannot teach. The key metric would be performance on novel problems where the model must decide when and what kind of assistance to request, evaluated against a baseline trained only on full trajectories. The paper's existing infrastructure (refinement agent that can produce intermediate representations, tool suite for verification) makes this experiment immediately tractable.

RL from ZPD-calibrated policy priors. The 19.0-point pass@1-to-pass@8 gap on the AgentFrontier validation set (Figure 7) is the paper's strongest argument for RL readiness, but it remains an untested promissory note. A direct follow-up would initialize a PPO or GRPO agent from the RFT model (AgentFrontier-30B-A3B RFT-only, achieving 25.7% HLE), use the ZPD-calibrated training questions as the environment (with the MKO's verified answers providing correctness-based rewards), and measure whether RL closes the pass@1-to-pass@8 gap—i.e., whether pass@1 after RL approaches the pre-RL pass@8 of 40.7%. A critical control: compare RL from the ZPD-trained RFT model against RL from a baseline RFT model (e.g., trained on MegaScience data) to test whether the gap specifically reflects ZPD-induced policy diversity rather than general properties of RFT. If RL from the ZPD prior substantially outperforms RL from the baseline prior, the paper's claim about "rich policy distribution" is validated.

Cross-family transfer: testing ZPD calibration on non-Qwen3 models. Every experiment in the paper uses Qwen3 models. To establish that the ZPD framework generalizes, a replication study should apply the identical pipeline to a different model family—for example, Llama-3.1-70B as the base model, with a strong Llama-family MKO (or a cross-family MKO like Qwen3-235B to test distributional robustness). The key question is whether the ZPD boundary defined for Qwen3 transfers: do questions classified as within-Qwen3-ZPD also lie within Llama-ZPD, or does each model family require its own calibration? If ZPD is model-specific, practitioners must recalibrate for each new base model—a significant adoption cost. If ZPD is relatively model-agnostic (e.g., the triplet structure and refinement process produce questions that are frontier-level across model families), the framework is more broadly applicable. The experiment would measure correlation between Qwen3-ZPD classifications and Llama-ZPD classifications on a shared set of candidate questions.

Continuous ZPD tracking during training. The paper uses a static LKP (the pre-trained base model) to define the ZPD boundary once, before training begins. But as the model trains on ZPD data, its capability frontier moves—questions that were initially in the ZPD become solvable by the LKP and are no longer at the frontier. A dynamic ZPD tracker would periodically re-evaluate the training model against the ZPD filter (checking whether it can now solve questions that were previously unsolvable) and adjust the training data distribution accordingly—retiring questions that have fallen below the frontier and introducing new, harder questions. The experiment would compare static ZPD training (all 12,000 trajectories trained for 3 epochs, as in the paper) against dynamic ZPD training (curriculum of increasing difficulty, with frontier recalibration every N steps) on the same total training budget. The hypothesis is that dynamic tracking prevents wasted training on questions the model has already mastered, potentially improving sample efficiency.

Characterizing the MKO ceiling: what problems does the pipeline systematically exclude? The paper reports a 33% MKO acceptance rate in Stage III (Appendix A.3.2) but never characterizes the 67% of candidates that fail—are they concentrated in specific disciplines, difficulty levels, or reasoning patterns? A diagnostic study would take the rejected candidates from D_human, attempt to solve them with alternative strong agents (GPT-4o with tools, Claude with tools, human experts on a subset), and categorize failure modes: genuinely unsolvable (no current agent can solve), MKO-specific failures (other agents can solve), flawed questions (ambiguous, contradictory, or unanswerable), or tool-gated (soluble with different tools). This would reveal whether the MKO's blind spots create systematic gaps in the training data—for example, if the MKO consistently fails on physics problems requiring multi-step mathematical derivation, the ZPD dataset will underrepresent that reasoning pattern, and the trained model will inherit the weakness.

Practical Applications and Downstream Use Cases

Cost-efficient training data generation for specialized research agents. An organization building a domain-specific research agent—for example, a legal research assistant that synthesizes case law across jurisdictions, or a biomedical literature review agent that integrates findings across clinical trials—can deploy the AgentFrontier Engine on their proprietary document corpus. The pipeline's cost (~ $0.78 per frontier QA pair, Appendix A.3) is orders of magnitude cheaper than hiring domain experts to manually create equivalent training problems. For a corpus of 10,000 domain-specific documents, running the full pipeline to produce ~1,000-5,000 ZPD-calibrated trajectories (depending on corpus richness and 33% yield) would cost ~$ 800-$3,900—a fraction of the cost of expert annotation. The resulting agent, fine-tuned on domain-specific ZPD data, would be trained to perform the exact knowledge fusion and multi-source synthesis that domain research requires, rather than generic web search patterns. The paper's results on subject-level HLE dominance (Table 2) suggest this approach would be particularly effective in disciplines requiring cross-document integration (Humanities: 31.61% for AgentFrontier vs. 24.87% next-best).

Self-improving benchmark suites for model evaluation organizations. Evaluation organizations (e.g., frontier model safety institutes, benchmarking consortia) face the saturation problem the paper identifies: static benchmarks become obsolete as models improve, requiring continuous, expensive expert re-curation. The ZPD Exam framework provides an automated alternative: periodically regenerate the benchmark from recent publications (papers from the last 12-18 months), recalibrate the difficulty filter using the current state-of-the-art model as the baseline, and release the new version. The dual-constraint filter (fail 3/3 unaided, succeed 3/3 with tools, Section 3.1) ensures the benchmark remains at the frontier—questions that become solvable without tools are retired, and new questions from more recent literature maintain the difficulty. The cost to regenerate a 1,024-question benchmark following Appendix A.3's accounting would be on the order of $1,000-$ 2,000 in API costs (assuming similar yield rates), making quarterly or even monthly regeneration economically feasible. This directly addresses the sustainability crisis in LLM evaluation, where the cost of expert-crafted benchmarks like HLE (Phan et al., 2025) limits refresh frequency.

Curriculum design for staged AI training programs. Organizations training LLMs in stages—from base pretraining to continued pretraining to instruction tuning to agentic fine-tuning—can use the ZPD framework to define the transition point between stages. The paper's two-stage pipeline (50B-token CPT on D_pretrain, followed by RFT on D_ZPD) provides a template: the model graduates from knowledge-intensive training to agentic training when the ZPD filter determines that the current LKP (the model after CPT) fails on a substantial fraction of frontier questions, indicating readiness for orchestration training. The specific numbers from the paper—+2.0 to +7.0 point CPT gains on RFT-trained models (Table 4)—suggest that CPT before RFT is beneficial but not transformative; the bulk of agentic capability comes from RFT. A practical deployment would calibrate the CPT-to-RFT transition based on monitoring the LKP's pass rate on a held-out frontier set, switching to RFT when CPT gains plateau—a data-driven curriculum decision that replaces heuristic stage boundaries.

When to Prefer This Method

The paper does not explicitly articulate a decision rule for when practitioners should prefer ZPD-guided data synthesis over alternative data generation approaches, nor does it provide a FLOPs-matched comparison that would enable a direct cost-benefit analysis. The comparison against TaskCraft, MegaScience, and MiroVerse is presented as validation of the pipeline's effectiveness rather than as a structured tradeoff against named alternatives. The paper frames ZPD-guided synthesis as a general principle for generating training data—not as a method that should be preferred in specific circumstances and avoided in others.

However, the paper's results imply several contextual factors that would favor adopting the ZPD approach, which can be stated as conditional guidance rather than a formal tradeoff matrix:

Prefer ZPD-guided synthesis when the target capability is cross-document knowledge fusion rather than single-source retrieval or factual recall. The triplet seeding strategy (Stage I) and the four-dimensional refinement (Stage II) are specifically designed to produce tasks requiring synthesis across multiple sources. If the application primarily requires retrieving facts from individual documents, simpler document-centric methods (MegaScience-style) may be equally effective at lower synthesis cost.
Prefer ZPD-guided synthesis when the base model already has substantial parametric knowledge but lacks orchestration skills. The ZPD filter specifically targets the gap between what the model knows and what it can discover with tools. If the base model lacks fundamental domain knowledge (e.g., cannot understand the terminology or basic concepts in the target domain), CPT or broader pretraining should precede ZPD data synthesis—the ZPD may be empty or nearly empty, as the model cannot benefit from orchestration training if it cannot comprehend the underlying content.
Prefer ZPD-guided synthesis when training data quality (difficulty calibration) matters more than data quantity, and the synthesis budget supports the per-sample cost. The pipeline costs ~$0.78 per frontier QA pair. For organizations with limited training compute but budget for data synthesis, spending on high-quality, calibrated data may yield better returns than generating larger volumes of uncalibrated data. The paper's results—12,000 ZPD trajectories outperforming comparable volumes of alternative data—support this tradeoff, but the absence of a FLOPs-matched or cost-matched comparison means the optimal budget allocation between synthesis cost and training volume remains an open empirical question.