Paper deep dive
What Makes Good Agentic Data? An ACE Lens on Data Generation for LLM Agents
Xingshan Zeng, Zishan Xu, Boju Zhang, Yuzhou Wu, Lingzhi Wang, Jianghao Lin, Liangyou Li, Yasheng Wang, Lifeng Shang, Xin Jiang, Weinan Zhang, Yong Yu, Qun Liu, Weiwen Liu
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 91%
Last extracted: 8/28/2026, 4:57:08 AM
Summary
This paper introduces the ACE (Accuracy-Complexity-divErsity) framework for evaluating and generating agentic data for Large Language Model (LLM) agents. It proposes a factorized data object d=(E,q,τ,v) comprising Environment specification, Task signal, Interaction realization, and Verifier. The framework argues that effective data generation must ensure Accuracy (grounded consistency), Complexity (learner-relative challenge), and Diversity (non-redundant coverage), shifting the focus from mere data abundance to high-quality, informative experience allocation.
Entities (9)
Relation Signals (12)
Agentic Data Object → comprises → Task Signal
confidence 95% · comprising an environment specification, task signal, interaction realization, and optional verifier.
Agentic Data Object → comprises → Interaction Realization
confidence 95% · comprising an environment specification, task signal, interaction realization, and optional verifier.
Agentic Data Object → comprises → Verifier
confidence 95% · comprising an environment specification, task signal, interaction realization, and optional verifier.
Agentic Data Object → comprises → Environment Specification
confidence 95% · comprising an environment specification, task signal, interaction realization, and optional verifier.
ACE Framework → defines → Accuracy
confidence 95% · Accuracy establishes the feasible support of grounded and internally consistent data.
ACE Framework → defines → Complexity
confidence 95% · Complexity places learning mass relative to the capability of a declared learner and execution configuration
ACE Framework → defines → Diversity
confidence 95% · divErsity controls coverage and redundancy of data.
Diversity → controls → redundancy
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:LLM agents increasingly rely on generated interaction data to learn how to interact with external environments. Agentic data generation must maintain consistency among environments, tasks, interactions, and success signals while producing experience that is useful rather than merely abundant. Existing work spans many agent domains, but domain-centered organization and heterogeneous evaluation often obscure common generation mechanisms and conflate candidate construction with verification and selection. This work develops a two-level framework for the field. First, we represent agentic data as a common factorized object $(E,q,\tau,v)$, comprising an environment specification, task signal, interaction realization, and optional verifier. We organize generation paradigms by their primary anchor and dependency structure. Second, we formulate generation as constrained distribution design through the Accuracy-Complexity-divErsity (ACE) lens. Accuracy establishes the feasible support of grounded and internally consistent data. Within this support, Complexity places learning mass relative to the capability of a declared learner and execution configuration, while divErsity controls coverage and redundancy of data. Using this framework, we explore how prior work verifies generated experience, constructs and calibrates difficulty, and expands behavioral coverage. The literature reveals a shift toward execution-grounded accuracy, learner-relative complexity, and diversity beyond surface variation or dataset size. We further discuss broader directions and emerging trends in agentic data generation through the ACE lens, including their implications for scaling, data sources, training regimes and adaptive learning. Overall, the central challenge is not simply to generate more data, but to continually allocate valid, informative, and non-redundant experience as agents and environments evolve.
Tags
Links
- Source: https://arxiv.org/abs/2608.27260v1
- Canonical: https://arxiv.org/abs/2608.27260v1
Trouble viewing inline? Open PDF directly →
Full Text
183,436 characters extracted from source content.
Expand or collapse full text
What Makes Good Agentic Data? An ACE Lens on Data Generation for LLM Agents Xingshan Zeng 1 , Zishan Xu 2 , Boju Zhang 2 , Yuzhou Wu 3 , Lingzhi Wang 4 , Jianghao Lin 2 , Liangyou Li 5 , Yasheng Wang, Lifeng Shang 1 , Xin Jiang 1 , Weinan Zhang 2 , Yong Yu 2 , Qun Liu 1 , Weiwen Liu 2,† 1 Huawei Technologies Co., Ltd, 2 Shanghai Jiao Tong University, 3 Northwestern University, Chicago, IL, 4 Harbin Institute of Technology, Shenzhen, 5 Shenzhen Loop Area Institute † Corresponding author Large language model agents increasingly rely on generated interaction data to learn how to interact with external environments. Unlike conventional instruction synthesis, agentic data generation must maintain consistency among environments, tasks, interactions, and success signals while producing experience that is useful rather than merely abundant. Existing work spans many agent domains, but domain-centered organization and heterogeneous evaluation often obscure common generation mechanisms and conflate candidate construction with verification and selection. This work develops a two-level framework for the field. First, we represent agentic data as a common factorized object (E,q,τ,v), comprising an environment specification, task signal, interaction realization, and optional verifier. We organize generation paradigms by their primary anchor and dependency structure, covering general forward and reverse pipelines. Second, we formulate generation as constrained distribution design through theAccuracy– Complexity– divErsity (ACE) lens. Accuracy establishes the feasible support of grounded and internally consistent data. Within this support, Complexity places learning mass relative to the capability of a declared learner and execution configuration, while divErsity controls coverage and redundancy across environments, tasks, and interaction behaviors. Using this framework, we explore how prior work verifies generated experience, constructs and calibrates difficulty, and expands behavioral coverage. The literature reveals a shift toward execution-grounded accuracy, learner- relative complexity, and diversity beyond surface variation or dataset size. We further discuss broader directions and emerging trends in agentic data generation through the ACE lens, including their implications for scaling, data sources, training regimes and adaptive learning. Overall, the central challenge is not simply to generate more data, but to continually allocate valid, informative, and non-redundant experience as agents and environments evolve. Q Correspondence: zeng.xingshan@huawei.com, wwliu@sjtu.edu.cn Date: August 28, 2026 1 arXiv:2608.27260v1 [cs.AI] 27 Aug 2026 Contents 1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 2 Formulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 2.1 Agentic Multi-turn Interaction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 2.2 Environment Parameterization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 2.3 From Interaction to Agentic Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 2.4 A Common Data Object . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 3 Generation Paradigms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 3.1 A Factorized View . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 3.2 Forward Generation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 3.3 Reverse Generation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 3.4 ACE as Constrained Distribution Design . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 4 Accuracy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 4.1 Accuracy under the ACE Objective . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 4.2 Factor-Level Accuracy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 4.3 Accuracy Assurance throughout Data Generation . . . . . . . . . . . . . . . . . . . . . . . . . 13 4.3.1 Layered Rule-, Model-, and Human-Based Checking . . . . . . . . . . . . . . . . . . . 13 4.3.2 Constraint-Grounded Construction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14 4.3.3 Execution- and State-Based Verification . . . . . . . . . . . . . . . . . . . . . . . . . . 15 4.3.4 Feedback-Based Repair and Selective Admission . . . . . . . . . . . . . . . . . . . . . 15 4.4 Accuracy Costs, Tradeoffs, and Limitations . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 5 Complexity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 5.1 Complexity under the ACE Objective . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 5.2 Factor-Level Complexity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 5.3 Constructing and Calibrating Agentic Complexity . . . . . . . . . . . . . . . . . . . . . . . . 18 5.3.1 Structural Specification and Composition . . . . . . . . . . . . . . . . . . . . . . . . . 18 5.3.2 Task and Information Control . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 5.3.3 Environment and Interaction Design . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 5.3.4 Completion and Feedback Design . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 5.3.5 Evolution and Progressive Transformation . . . . . . . . . . . . . . . . . . . . . . . . . 19 5.3.6 Failure-Driven and Model-Aware Calibration . . . . . . . . . . . . . . . . . . . . . . . 20 5.3.7 Bidirectional Calibration and Scaffolding . . . . . . . . . . . . . . . . . . . . . . . . . 20 5.4 Estimating and Reporting Complexity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 5.5 Complexity Tradeoffs and Limitations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 6 Diversity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 6.1 Diversity under the ACE Objective . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 6.2 Factor-Level Diversity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 6.3 Expanding Agentic Diversity: Mechanisms and Domain Evidence . . . . . . . . . . . . . . . . 23 6.3.1 Source and Support Expansion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 6.3.2 Compositional Recombination . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 6.3.3 Exploration and Experience-First Discovery . . . . . . . . . . . . . . . . . . . . . . . . 24 6.3.4 Perturbation and Counterfactual Variation . . . . . . . . . . . . . . . . . . . . . . . . 24 6.3.5 Coverage-Guided Balancing and Adaptation . . . . . . . . . . . . . . . . . . . . . . . . 24 6.3.6 Domain-Specific Instantiations and Evidence . . . . . . . . . . . . . . . . . . . . . . . 25 6.4 Measuring Diversity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 6.5 Diversity Tradeoffs and Limitations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 7 Discussion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 7.1 Scaling Law under ACE Objective . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 7.2 Real and Synthetic Data under ACE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 7.3 Data Generation for Agentic Pre-training and Mid-training . . . . . . . . . . . . . . . . . . . 31 7.4 Data Generation for Self-Evolving Agents . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31 8 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 2 1 Introduction Large language model (LLM) agents are increasingly expected to act rather than only respond: they invoke tools, operate systems, search information, modify files, and interact with simulated or physical worlds [Qin et al., 2024, Xie et al., 2024, Pan et al., 2025, Zheng et al., 2025, Wang et al., 2024c]. Learning these behaviors requires experience that connects decisions to observations and state changes, often over multiple turns [Prabhakar et al., 2025, Dong et al., 2026]. Such interaction data are expensive to collect manually, and difficult to verify and expand. Agentic data generation has therefore become a central means of scaling both agent training and evaluation [Mitra et al., 2024, Liu et al., 2024, Song et al., 2026]. The central challenge, however, is not merely to generate more data, but to ensure that generated experience is accurate, appropriately complex for the learner, and sufficiently diverse. Agentic data generation is not simply instruction generation followed by response sampling. A useful sample must connect an actionable environment, a grounded task, and an interaction in which actions produce valid observations and state changes. Recent pipelines consequently generate not only instructions and demonstrations, but also tool ecosystems, executable environments, stateful tasks, rollout feedback, and verification procedures [Liu et al., 2024, 2025, Xu et al., 2025c, Song et al., 2026, Xu et al., 2026a]. We use Accuracy–Complexity–divErsity (ACE) to name the three corresponding requirements: whether generated experience is grounded and valid, whether it presents a useful challenge for a particular learner, and whether a collection covers distinct rather than repetitive situations and behaviors. The resulting literature remains fragmented and difficult to compare. Studies commonly describe data in domain-specific forms, such as API calls [Qin et al., 2024, Liu et al., 2024], repository tasks [Pan et al., 2025, Jain et al., 2025], GUI demonstrations [Sun et al., 2025, Qin et al., 2025], simulator rollouts [Wang et al., 2024c,b], or scientific discovery experience [Xu et al., 2026b, Li et al., 2025d], and organize methods by application domain, training stage, or environment type. This organization creates two structural difficulties. First, it conflates mechanism with application: related mechanisms may be discussed separately across diverse scenarios. Second, descriptions of a pipeline often mix how candidates are constructed with how they are verified, selected, or allocated to a learner. As a result, similar mechanisms appear under different terminology, while data produced through substantially different processes are frequently reported under heterogeneous and difficult-to-align criteria. The agentic data generation field therefore needs a common account of both what components a pipeline constructs and how the resulting distribution is shaped under ACE. To make ACE comparable across domains, we introduce a compact but sufficiently expressive factorization of agentic data as d = (E,q,τ,v). Here, E describes the actionable world, including its state, dynamics, poli- cies, and action–observation interfaces; q specifies the task-conditioned objective and constraints; τ records a realized interaction; and the optional v supplies outcome- or process-level supervision, including executable checks, model judgments, or rewards. This abstraction accommodates diverse agentic settings without re- quiring every dataset to serialize the four factors in the same way. More importantly, it makes the targets of ACE explicit: accuracy concerns local validity and consistency among the factors, complexity concerns the burden induced by their configuration, and diversity concerns their non-redundant coverage. As shown in Figure 1, we formalize ACE as a constrained distribution-design objective. Accuracy defines the feasible support by requiring local validity and relational consistency among E, q, τ, and v. Within that support, complexity shapes where probability mass is placed relative to the capability of a declared learner and execution configuration, while diversity determines how broadly it covers distinct, non-redundant environments, tasks, and interaction behaviors. This asymmetry is essential: difficulty or variation cannot compensate for invalidity as a generation objective, whereas uniformly valid but trivial or repetitive data may provide little additional learning value. It is worth noting that ACE is not intended as an exhaustive checklist for dataset governance. Cost, efficiency, safety, etc., remain important constraints. Rather, ACE captures three generation-time properties that most directly determine whether the agentic experience is useful for learning. It consequently serves as an analytical lens over diverse generation mechanisms. The factorization also supports a mechanism-oriented taxonomy of generation paradigms. We organize pipelines by the factor that serves as the primary anchor and by the dependency structure through which the remaining factors are instantiated. Forward pipelines ground tasks and interactions in an existing environ- 3 Agentic Data Generation through the ACELens: Agentic Data C COMPLEXITY S A ACCURACY Relational consistency across E DIVERSITY Low Redundancy (Minimize Overlap) Embodied Coding Web Tool-use Environment E Tasks q Interactions Verifier v ACE Objective ACE Feasible prerequisite Learning in the right band Maximum coverage， minimal redundancy High-Value Agent Experience Accuracy Gate Admits valid data into B A 1 E internally consistent 2 3 4 휏 Causally valid under E and q V aligned with intended outcome grounded executable aligned qgrounded& feasible under E feasible Leaner-Relative Challenge Non-Redundant Coverage Figure 1 The ACE lens views agentic data generation as constrained distribution design: Accuracy defines valid support, while learner-relative Complexity and Diversity shape useful, non-redundant experience over (E,q,τ,v). ment; task-first and trajectory-first pipelines construct the remaining factors around a target capability or observed experience; and structure-first pipelines use an intermediate graph, plan, or blueprint to coordinate them. This view accommodates joint, iterative, and self-improving systems in which verification failures or learner feedback revise previously generated factors. It therefore describes how data are constructed, while ACE specifies which generated data should be admitted or emphasized. Viewed through this lens, the literature reveals a coherent shift from plausibility judgments toward execution- grounded accuracy, from static difficulty heuristics toward model- and configuration-relative complexity, and from surface variation toward behavioral coverage [Liu et al., 2024, Xu et al., 2026a, Guo et al., 2025, Chen et al., 2025d, 2026a]. Meanwhile, agentic data are expanding beyond fixed post-training trajectories toward pre- and mid-training supervision and closed-loop experience that changes with the learner [Zeng et al., 2026a, Zuo et al., 2026, Zhai et al., 2025]. These developments make it increasingly important to separate the architecture of data generation from the objectives used to evaluate and allocate its outputs. Our main contributions are as follows: Main Contributions 1. An ACE-centered synthesis of agentic data generation. We organize prior work around how generation pipelines ensure Accuracy, construct and calibrate learner-relative Complexity, and expand effective Diversity, together with domain-specific evidence, measurement choices, costs, and limitations. 2. A cross-domain formulation of agentic data. We define a common factorized data object (E,q,τ,v) that makes the generated components and their consistency relations explicit across tool use, software engineering, GUI, embodied, social, and scientific agents. 3. A mechanism-oriented taxonomy of generation paradigms. We organize pipelines by their primary anchor and dependency structure rather than by domain labels, while separating how data are constructed from how generated candidates are assessed and selected. 4 The remainder of this paper is organized as follows. Section 2 defines agentic interaction and the common data object. Section 3 introduces factorized generation paradigms and the ACE objective. Sections 4–6 synthesize existing methods and findings along the three ACE dimensions. Section 7 then discuss scaling under ACE objective, data provenance, earlier training stages, and continual self-evolution beyond the task-level setting. 2 Formulation 2.1 Agentic Multi-turn Interaction Following prior work that models tool-augmented interaction as a partially observable Markov decision process (POMDP) [Prabhakar et al., 2025, Zeng et al., 2026c, Dong et al., 2026], we write M = (U,S,A,O,P,R),(1) where U is the task or user-intent space, S is the latent state space, A denotes action space which contains language responses and environment-facing actions, O is the observation space, P specifies state transitions, andR is an optional reward or evaluation function. At turn t, an agent chooses an action from the observable history, and the environment returns a new observation while possibly changing its latent state. More concretely, the policy acts on the observable history rather than the latent state, and the selected action induces the next state and observation: h t = (o 0 ,a 1 ,o 1 ,...,a t−1 ,o t−1 ), a t ∼ π θ (·| h t ),(s t+1 ,o t+1 )∼P(·| s t ,a t ).(2) This distinction is central to agentic data: the trajectory records what the policy observes and does, whereas an executable environment may additionally maintain latent state for transition and reward computation. This abstraction covers nearly all agent domains. In tool use, actions are structured API calls and observations are tool returns. In web and GUI agents, they are interface operations and visual or structured page states. In coding agents, the environment includes a repository, shell, dependencies, and tests, while in embodied settings, it may be a simulator or physical world. User turns are included in observations: they progressively reveal constraints, answer clarification questions, or revise an earlier request. Consequently, the task should not always be identified with the first utterance; it can be a latent intent expressed over the interaction. A realized interaction is denoted by τ = (o 0 ,a 1 ,o 1 ,...,a T ,o T ),(3) where a i are actions including text responses and tool calls, observations o j can be user messages or environ- ment feedback. This representation accommodates both simple function-calling examples and long, stateful, multi-turn trajectories. 2.2 Environment Parameterization For data generation, a concrete environment can be parameterized as e = (D,F,P rule , Ω,v),(4) whereD is an optional state carrier such as a database, repository, application, or simulator;F is the available tool or action set; P rule contains policies, permissions, and domain constraints; Ω determines which parts of the latent state are exposed as observations; and v is an optional success interface. A serialized environment specification E describes some or all of these components. In simple function calling, E may contain only tool schemas and usage rules; in RL-oriented data, E must additionally support outcome evaluation. 2.3 From Interaction to Agentic Data Agentic data instantiates the interaction process through three core factors. 5 Environment Specification (E). The environment describes the actionable world. It may contain tool schemas, a database or simulator state, transition rules, policies, permissions, observation interfaces, and ter- mination conditions. Some datasets serialize only textual tool descriptions, whereas executable environments expose state transitions and can support new rollouts. Thus, E ranges from a static interface specification to a complete interaction substrate. Task Signal (q). The task specifies what should be achieved and under which constraints. It may be an explicit instruction, a target state, a hidden user intent, or a signal progressively expressed across several turns. A task is grounded only relative to an environment: its entities must exist, required actions must be available, and its completion condition must be meaningful under the environment rules. Interaction Realization (τ). The realization specifies how the task is attempted or solved in the environ- ment. For supervised fine-tuning, it is commonly a demonstrated trajectory. For reinforcement learning, it may instead be sampled online from an executable environment. A pipeline can also retain multiple successful, failed, exploratory, or recovery trajectories for the same environment–task pair. These factors give the central decomposition used in this survey: Agentic Data Decomposition Agentic Data = Environment Specification + Task Signal + Interaction Realization.(5) The decomposition is conceptual rather than a serialization requirement. For example, the initial state may be stored inside an executable environment, and a progressively revealed task may be represented through the user turns in τ. 2.4 A Common Data Object Common Data Object For the remainder of the survey, we use the common data object d = (E,q,τ,v),(6) where v is an optional verifier or reward interface. The first three factors define the interactive problem and its realization; v records how their consistency or outcome is evaluated. It may be a schema checker, executable test, terminal-state predicate, policy rule, proof assistant, LLM judge, or a hybrid of these mechanisms. Treating v as an interface avoids conflating the object being generated with one particular training paradigm. For SFT, d usually stores E and a fixed τ, with q expressed explicitly or through its user turns; v is optional and may only be used during curation. For RL and environment-based evaluation, E must support new interactions, while q and v define the rollout objective and success condition. The same notation therefore allows us to compare trajectory synthesis, executable environment construction, and online task generation without claiming that their released artifacts are identical. Figure 2 illustrates how the same factors are instantiated across representative agent domains. Their concrete forms differ, but each domain requires an actionable world, a grounded objective, a realized or sampled interaction, and some basis for assessing validity or success. This factorization also clarifies the scope of agentic data generation. It is not simply instruction genera- tion followed by response sampling. The pipeline must establish compatible relations among an actionable environment, a grounded task, an interaction process, and, when needed, a trustworthy success signal. 6 231 564 General Tool UseSoftware EngineeringWeb & GUI E q t v APls, schemas, services， shared state, and policies A user request grounded in current state Language turns, tool calls， observations, recovery Schema/argument checks， results, or state predicates E q t v Repositories, dependencies， build system, and shell An issue, bug report, or feature reques Code search, shell commands， edits, builds, test run Compilation, tests, and patch-level checks E q t v Websites or applications with visual, DOM, stat A navigation, info-seeking， or transaction goa Clicks, typing, scrolling， page transitions, obs DOM/state checks amd task-completion predicates Embodied AgentsSocial & Multi-AgentScientific & Formal E q t v Simulators or physical world with objects, sensors, etc. A goal involving navigation or manipulation Control actions, sensory observations, state trans Simulator predicates, success detectors, or human assessment E q t v Other agents, private info， roles, norms, incentives A collaborative, competitive， or negotiation objective Dialogue, commitments， joint actions, responses Outcome criteria, policy checks, or model/human judgments E q t v Experimental tools， simulators, formal systems A discovery, design， reasoning,or proof goal Experiments, computation， evidence, proof steps Executable tests, outcomes， formal checkers, proof assistants Figure 2 Cross-domain instantiations of the common agentic data object d = (E,q,τ,v). The factors retain the same conceptual roles even though their concrete representations and verification signals differ across domains. 3 Generation Paradigms Section 2 identifies the factors contained in agentic data. We next organize existing generation pipelines by the order in which they construct and ground these factors. 3.1 A Factorized View Agentic data generation can be viewed as designing a joint distribution over environments, tasks, and inter- action realizations. The dominant factorization is p(E,q,τ ) = p(E)p(q | E)p(τ | E,q),(7) but this order is not mandatory. Task-first pipelines begin from q and construct a compatible E; trajectory- first pipelines recover q from an executable or observed τ. The ordering determines which factors are directly controlled and where consistency must be recovered. This view separates two questions that are often conflated. A generation paradigm specifies how the factors are produced. A data objective specifies which generated instances should be accepted or emphasized. The former is discussed below, which can be categoried into twofolds, forward generation and reverse generation (see Figure 3); the ACE objective is introduced at the end of this section serving as principles during generation. 3.2 Forward Generation Forward generation constructs an environment, generates grounded tasks based on the environments, and then obtains trajectories. It mirrors the natural dependency of interaction: available actions and states determine which tasks are feasible, and both determine which trajectories are meaningful. Constructing Environments. Existing work obtains E from three overlapping sources. First, real spec- ifications are crawled or curated from existing APIs, MCP services, repositories, websites, and applications. A substantial body of prior work grounds data generation in real-world tool ecosystems [Qin et al., 2024, Patil et al., 2024, Liu et al., 2024, Shim et al., 2025, Li et al., 2025f, Xu et al., 2025c], and similarly, software-engineering pipelines instantiate execution environments from repositories collected from real-world projects [Pan et al., 2025, Jain et al., 2025, Yang et al., 2025b, Badertdinov et al., 2025]. While these sources offer high realism, they also inherit uneven documentation, unstable dependencies, and constraints related to execution, access, and licensing. Second, LLM synthesis expands tools, rules, and domain descriptions beyond collected resources. ToolACE [Liu et al., 2025] evolves an API pool before generating tasks and trajectories, while ToolAlpaca [Tang et al., 2023], Seal-Tools [Wu et al., 2024], SynthTools [Castellani et al., 2025], and ToolWeave [Khandelwal et al., 2026] use 7 Forward Generation One natural chain Reverse Generation Change the starting anchor 23 Create Tasks Realize Interactions 1 Build Environment • Real tools & apps • Synthetic tools • Programmed simulators • Grounded in the environment • Plans or tool graphs • Can evolve from failure • Teacher or role-play agents • Execution-guided rollout • Exploration or search · Verification runs throughout • environment• task •transitions•outcome BCA Task-First Trajectory -First Structure- First • Start from a goal • Build environment to support it • Then realize interaction · • Start from observed experience • Derive the task from a valid path • Build around what works • Start from a scaffold • Use plans, graphs， or blueprints • Then realize the full data Figure 3 Generation Paradigms: Forward Generation vs Reverse Generation. related forms of tool or tool-graph synthesis. This route is scalable and controllable, but generated interfaces can be underspecified or detached from plausible workflows. Third, programmatic construction explicitly implements databases, transition dynamics, simulators, and validators. This line of work marks a shift from static textual tool descriptions toward stateful, resettable, and verifiable environments [Song et al., 2026, Wang et al., 2026c, Dong et al., 2026, Xu et al., 2026a, Tu et al., 2026, Tian et al., 2026, Zhou et al., 2026b]. The same paradigm has also been extended to executable tool-use arenas, scientific-discovery environments, and simulation-ready 3D worlds [Du et al., 2026, Xu et al., 2026b, Wang et al., 2026a, Zhou et al., 2026c]. Programmatic construction offers stronger support for stateful interaction, controlled reset, and reliable verification. However, this flexibility comes at a higher engineering cost. Environments must be implemented, tested, and maintained, while the breadth and fidelity of the resulting domains depend heavily on the quality of the underlying code generation or environment design. Generating Grounded Tasks. The simplest approach prompts a model to write instructions from tool descriptions [Qin et al., 2024, Liu et al., 2024]. More recent work introduces intermediate grounding structures. Tool-graph-guided (or skill graph) methods sample compatible tools or dependency paths before writing the request [Wang et al., 2025b, Shim et al., 2025, Yin et al., 2025, Yang et al., 2025a, Xu et al., 2026a, Fan et al., 2026]. Blueprint- and plan-first methods specify intended actions or subgoals before dialogue realization [Prabhakar et al., 2025, Wang et al., 2025b, Erdogan et al., 2025]. Stateful systems jointly construct the initial state, task, and verifier so that feasibility is established in a particular environment instance [Cai et al., 2025, Song et al., 2026, Tu et al., 2026, Dong et al., 2026]. Other pipelines evolve existing tasks or derive new ones from exploration and failure traces, making generation more targeted to current capability gaps [Hu et al., 2025, Zhai et al., 2025, Hao et al., 2026, Fu et al., 2026, Xiao et al., 2026]. Realizing Interactions. Trajectories can be produced by a teacher model, role-playing agents, execution- guided rollout, or combinations of them. Earlier function-calling datasets often realize short interactions from an explicit task [Qin et al., 2024, Patil et al., 2024, Liu et al., 2024]. Multi-turn pipelines simulate user, assistant, and sometimes tool roles to expose constraints progressively and collect clarification or recovery behavior [Tang et al., 2023, Liu et al., 2025, Wang et al., 2025b, Prabhakar et al., 2025, Li et al., 2025f, Gu et al., 2026]. Executable environments instead return observations from explicit state transitions and can reject invalid actions during rollout [Song et al., 2026, Xu et al., 2026a, Tian et al., 2026, Du et al., 2026]. Exploration-driven web and mobile pipelines further collect multimodal trajectories and recovery behavior from interaction rather than relying entirely on scripted demonstrations [Pahuja et al., 2025, Cheng et al., 2026, Qin et al., 2025]. Search and deep-research agents collect another form of interaction realization in which retrieval, evidence integration, and repeated query reformulation unfold under online or real-world 8 Table 1 Representative works in forward agentic data generation. All methods follow the dependency E→ q→ τ. Methods are grouped according to the dominant source of environment construction: real or curated environments, LLM-synthesized environments, and programmatic or executable environments. Resource links to public GitHub repositories or Hugging Face websites when available. MethodE Constructionq Generationτ RealizationResource Real / Curated Environments ToolLLM [Qin et al., 2024] Real API collectionTool-description prompting Teacher-guided tool rollout GitHub Gorilla [Patil et al., 2024]Real API collectionAPI-grounded instructions Single-turn API invocation GitHub APIGen [Liu et al., 2024]Executable API poolVerified task synthesisExecutable function-call rollout GitHub ToolDial [Shim et al., 2025] Real API graphGraph-guided task synthesis Multi-turn role-playing GitHub InfTool [Li et al., 2025f]Connected executable APIs Tool-conditioned synthesis Multi-turn role-playing– TOUCAN [Xu et al., 2025c] Real MCP environments MCP-grounded task synthesis Real tool execution rollout GitHub LLM-Synthesized Environments ToolAlpaca [Tang et al., 2023] LLM-synthesized tools Tool-conditioned instructions Multi-agent simulation GitHub ToolACE [Liu et al., 2025] Self-evolved API poolTool-grounded task synthesis Multi-agent dialogue rollout Hugging Face Seal-Tools [Wu et al., 2024] Synthetic tool generation Self-instruct task synthesis Simulated tool-use rollout GitHub SynthTools [Castellani et al., 2025] Hierarchical environment synthesis Verifiable task synthesis Simulator-grounded rollout GitHub ToolWeave [Khandelwal et al., 2026] Synthetic tool graphsGraph-guided goal synthesis Plan-guided dialogue synthesis GitHub Programmatic / Executable Environments AutoForge [Cai et al., 2025] Programmatic environment synthesis State-conditioned task synthesis Executable environment rollout – EnvScaler [Song et al., 2026] Programmatic tool environments State-conditioned scenarios Executable agent rollout GitHub Agent-World [Dong et al., 2026] Executable world construction State-grounded task synthesis Online agent rollout– EnvFactory [Xu et al., 2026a] Executable environment factory Graph- and state-grounded tasks Executable multi-turn rollout GitHub ScaleEnv [Tu et al., 2026]Programmatic environment scaling State-conditioned task synthesis Executable RL rollout– feedback [Zheng et al., 2025, Li et al., 2025a, Jin et al., 2025, Song et al., 2025]. Structural scaffolds such as plans and tool graphs improve long-range coherence before local utterances are generated. When environment implementation is the bottleneck, LLM-based simulators can generate stateful responses from API specifications and interaction history [Li et al., 2025e, Lee et al., 2026], and even serve as rehearsal environments during learning [Xu et al., 2026d]. Table 1 summarizes the representative works. This kind of paradigm offers strong grounding because later factors are conditioned on an existing environment. Its main risk is cascading dependence: narrow or unre- liable environments constrain every task and trajectory built on top of them. Verification is therefore not merely a final step. Recent pipelines increasingly test environment components, task feasibility, intermediate transitions, and terminal outcomes throughout generation. Section 4 further surveys these mechanisms. 3.3 Reverse Generation We use reverse generation for pipelines that do not follow the direct environment–task–trajectory order (see representative works in Table 2). They alter which artifact anchors the others and therefore offer different 9 Table 2 Representative works in reverse agentic data generation. Methods are grouped into task-first, trajectory-first, and structure-first generation, followed by adaptive and self-evolving approaches as a cross-cutting extension. Domain indicates the primary application setting, while Resource links to public repositories when available. MethodDomainKey MechanismResource Task-First Generation AgentInstruct [Mitra et al., 2024]GeneralCapability-targeted environment synthesis– Agentic Proposing [Jiao et al., 2026]GeneralProblem-first downstream synthesis GitHub BUTTON [Chen et al., 2025b]ToolCompositional multi-turn task synthesis GitHub ToolBridge [Jin et al., 2024]ToolExisting-task tool integration GitHub ToRA [Gou et al., 2024]MathTool-integrated mathematical reasoning GitHub MathCoder [Wang et al., 2024a]MathCode-assisted mathematical reasoning GitHub MARIO [Liao et al., 2024]MathCode-interpreter augmented reasoning GitHub AgentMath [Luo et al., 2025]MathTool-augmented mathematical reasoning– ReTool [Feng et al., 2026]MathStrategic tool-use reasoning GitHub ToRL [Li et al., 2025c]MathTool-integrated reinforcement learning GitHub AutoSDT [Li et al., 2025d]ScienceScientific discovery task transformation GitHub Agentic-Ideation [Zhao et al., 2026]ScienceScientific reasoning-path reconstruction– Trajectory-First Generation Learn-by-interact [Su et al., 2025]ToolInteraction-derived task generation– Trajectory2Task [Wang et al., 2026e]ToolExecutable trajectory-to-task conversion– Unlocking Implicit Experience [Xu et al., 2026c] ToolImplicit workflow mining from text– OS-Genesis [Sun et al., 2025]GUIGUI trajectory-to-task reversal GitHub Explorer [Pahuja et al., 2025]WebExploration-driven web task synthesis GitHub OpenMobile [Cheng et al., 2026]MobileMobile interaction task synthesis GitHub Structure-First Generation ToolACE-MT [Zeng et al., 2026c]ToolCoarse-to-fine interaction refinement– Magnet [Yin et al., 2025]ToolStructured tool-graph realization– ToolFlow [Wang et al., 2025b]ToolTool-graph guided task planning– APIGen-MT [Prabhakar et al., 2025]ToolVerified blueprint trajectory realization Hugging Face Execution-First [Ouajdi et al., 2026]ToolExecution-validated task synthesis– Adaptive and Self-Evolving Generation AFlow [Zhang et al., 2025]GeneralSearch-based agentic workflow optimization GitHub Chain-of-Agents [Li et al., 2025b]GeneralMulti-agent distillation and agentic RL GitHub AgentEvolver [Zhai et al., 2025]ToolSelf-questioning and experience-guided evolution GitHub WebEvolver [Fang et al., 2025]WebWorld-model-guided web self-improvement GitHub SESA [Fu et al., 2026]SearchSelf-play task posing and skill evolution GitHub Socratic-SWE [Xiao et al., 2026]SWETrace-derived skills for adaptive task generation – forms of control. Task-First Generation. Task-first pipelines specify a target capability, instruction pattern, or composed goal and then construct the tools, environment, and interaction needed to realize it. AgentInstruct [Mitra et al., 2024] and Agentic Proposing [Jiao et al., 2026] use generated capability targets or problems to drive later synthesis. BUTTON composes atomic tasks into complex multi-turn requests before synthesizing cor- responding functions and trajectories [Chen et al., 2025b]. One line of methods similarly transform existing mathematical, coding, or discovery tasks into tool-integrated interactions [Jin et al., 2024, Gou et al., 2024, Wang et al., 2024a, Liao et al., 2024, Luo et al., 2025, Feng et al., 2026, Li et al., 2025c,d]. Agentic-Ideation reconstructs tool-augmented reasoning paths from reference ideas, showing that the same order applies be- yond digital navigation [Zhao et al., 2026]. This order provides direct control over task content and difficulty, but requires strong checks that the constructed environment actually supports the requested behavior. 10 Trajectory-First Generation. Trajectory-first methods explore an environment or mine a workflow be- fore writing the user-facing task. Learn-by-interact [Su et al., 2025] and Trajectory2Task [Wang et al., 2026e] derive tasks from observed valid behavior, while tutorial-mining methods [Xu et al., 2026c] extract implicit procedures before formulating explicit instructions. OS-Genesis [Sun et al., 2025] reverses GUI trajectories into tasks; other similar agents use interaction to expand web or mobile trajectories [Pahuja et al., 2025, Cheng et al., 2026]. Grounding the task in an existing path improves executability and supports reverse construction of ambiguous, changing, or recovery-oriented intents. The resulting distribution, however, is bounded by what the exploration policy discovers. Structure-First Generation. Another line of methods first generate an intermediate object such as a tool graph, function path, dialogue skeleton, or task blueprint. ToolACE-MT [Zeng et al., 2026c] refines a coarse interaction non-autoregressively, Magnet [Yin et al., 2025] realizes structured tool-call graphs as multi-turn data, and Execution-First [Ouajdi et al., 2026] generates template graphs and then tool-use traces before task realization. More works likewise use plans or verified blueprints to stabilize dependencies across turns [Wang et al., 2025b, Prabhakar et al., 2025]. We do not view the scaffold as a fourth data factor. It is rather a construction device that controls relations among E, q, and τ. More broadly, agentic data generation is shifting from static, one-shot synthesis toward adaptive and self- evolving processes [Zhang et al., 2025, Li et al., 2025b, Zhai et al., 2025, Fang et al., 2025, Fu et al., 2026, Xiao et al., 2026]. Rather than producing independent samples with a fixed generator, these systems use accumulated experience, verification outcomes, model behavior, and observed coverage gaps to continually revise generation strategies, construct new tasks and workflows, and target the learner’s evolving needs. Data generation thus becomes a closed-loop process that co-evolves with the agent and its environment. 3.4 ACE as Constrained Distribution Design The paradigms above explain how a pipeline constructs candidates. The ACE lens explains how it should shape the accepted distribution. Let p φ denote a generation pipeline and B A the subset of a generated batch that passes checks on environment consistency, task feasibility, trajectory validity, etc. Accuracy is therefore an admission condition rather than a benefit that can be compensated for by other properties. Within this valid subset, complexity should be calibrated rather than blindly maximized. We use C z (d) for the difficulty of an instance under a declared learner and execution configuration z, including the model, available scaffold and tools, verifier, and inference budget. A utility g z (C z (d)) can favor hard cases or, more commonly for training, a learnable band near the current model frontier. Diversity is a batch-level property D(B A ) that rewards coverage and non-redundancy over environments, tasks, and interaction realizations. ACE Objective A compact statement of the ACE objective is max φ E B∼p φ " λ C 1 |B A | X d∈B A g z (C z (d)) + λ D D(B A ) # s.t.Pr d∼p φ [A(d) = 1]≥ α,(8) where A(d) is the validity decision and α is a required acceptance level. If no candidate passes the accu- racy gate, the utility is defined as zero. This formulation expresses the intended asymmetry: accuracy establishes the feasible set, while complexity and diversity shape which valid data are most useful. ACE therefore is an analytical lens over existing pipelines, not a partition of the literature into three disjoint method families. A verified blueprint can improve accuracy, induce a longer dependency structure, and enable controlled recombination at the same time. Conversely, a failure-driven generator may target model-relative complexity while narrowing domain coverage. The following three sections therefore decompose prior work at the mechanism level: how generation pipelines ensure accuracy, calibrate complexity, and expand diversity, including the interactions and costs among these goals. 11 4 Accuracy Accuracy is the prerequisite of the ACE objective. In agentic data, supervision extends beyond a final answer to a coupled environment, task, interaction, and success signal. A sample can be fluent yet inaccurate because its task is infeasible, a tool is implemented inconsistently, an observation does not follow from the preceding action, or the verifier rewards the wrong outcome. Existing work addresses these failures at different points in the generation pipeline rather than through one universal accuracy method. 4.1 Accuracy under the ACE Objective Section 3.4 treats accuracy as an admission condition. For d = (E,q,τ,v), A(d) requires the environment to be internally consistent, the task to be feasible and grounded, the interaction to respect actions and state transitions, and the verifier to match the intended outcome. Complexity and diversity are evaluated only after this gate because invalid examples cannot become useful merely by being difficult or different. We summarize these requirements through a conjunctive validity decision and its batch-level acceptance rate: Accuracy under the ACE Objective A(d) = V E (E)∧ V q (q | E)∧ V τ (τ | E,q)∧ V v (v | E,q,τ ), Acc(B) = 1 |B| X d∈B I[A(d) = 1]. (9) The conjunction is intentional: a correct-looking trajectory does not compensate for an infeasible task, and a correct terminal state does not compensate for a verifier that accepts policy-violating shortcuts. This definition combines local validity and relational consistency. Local checks concern individual components, such as a well-formed schema or executable call. Relational checks ask whether the components describe the same problem: q must refer to objects and operations in E, observations in τ must result from executed actions, and v must accept the intended terminal condition. Independently plausible components can drift apart when generated in separate stages [Ivanov and Rana, 2026]. Accuracy has one conceptual standard but domain-specific evidence. Tool-use data can check schemas and API execution; coding data can compile and run tests; formal reasoning can invoke a proof assistant; web, GUI, and embodied data can inspect application or simulator state. Where no complete oracle exists, pipelines combine partial rules with semantic review. The survey question is therefore what a work verifies, when it verifies it, and which failures remain outside its verifier. 4.2 Factor-Level Accuracy Environment Accuracy. An accurate E implements its declared tools, states, policies, and transitions consistently. Local checks test schemas, argument types, returns, and reset behavior, while global checks test coherent state changes and policy enforcement. When environments are directly instantiated from real-world systems, this consistency is often inherited to some extent. Therefore, the main challenge on this axis lies in simulated or synthetically constructed environments. Executable environments are especially valuable because they enable component-level validation before rollout and are increasingly becoming a central design choice for constructing accurate agentic environments [Song et al., 2026, Tu et al., 2026, Wang et al., 2026c, Xu et al., 2026a]. Task Accuracy. A valid q must be interpretable and feasible under the relevant state, tools, and policies. In multi-turn settings, the task is often implicit and progressively revealed through interaction rather than fully specified upfront. The evolving intent should remain semantically coherent over time, unless it reflects an intentional change that is itself recognized and handled by the verifier. Accordingly, task validity can be enforced both before interaction, for example through task blueprints or plans [Prabhakar et al., 2025, Wang 12 Agentic Accuracy EnvironmentAccuracy (E) Tools, schemas, and states are correct Transitions follow declared dynamics Policies and permissions are enforced 1 Task Accuracy (q) Goals are interpretable and feasible Constraints stay coherent over turns Intent matches context and environment 2 Interaction Accuracy(휏) Actions follow schemas and preconditions Observations are Causally grounded Behavior stays Consistent with task and policy 3 Verifier & Outcome Accuracy（v） Success is detected correctly Meaningful failures are rejected No unintended incentives or reward loopholes 4 √ Figure 4 Four complementary factors of accuracy: environment, task, interaction, and verifier/outcome accuracy. et al., 2025b], and during interaction, through semantic consistency checks that ensure the progressively revealed intent remains coherent with the preceding context [Wang et al., 2026e]. Interaction Accuracy. An accurate τ should contain schema-compliant actions, causally grounded obser- vations, and behavior that remains consistent with the task and applicable policies. Unlike environment and task accuracy, which primarily affect learning through the conditions they impose, the interaction trajectory directly provides the behavioral supervision from which the agent learns. Trajectory accuracy is therefore particularly critical, as errors in τ can be directly imitated by the trained model. Consequently, a sub- stantial portion of agentic data validation focuses on trajectory-level checks, typically implemented through filtering procedures that remove structurally invalid, semantically inconsistent, or execution-inconsistent in- teractions [Liu et al., 2024, 2025, Ouajdi et al., 2026]. Verifier and Outcome Accuracy. The verifier v must correctly recognize successful outcomes, reject meaningful failures, and avoid introducing unintended incentives. Database-backed systems compare states, software-engineering environments use repository setup, compilation, and tests, and formal-reasoning agents use proof-assistant acceptance [Wang et al., 2026c, Pan et al., 2025, Jain et al., 2025, Yang et al., 2025b, Badertdinov et al., 2025, Xin et al., 2024]. Verifier accuracy is especially critical for RL, where v directly shapes the reward signal and therefore largely determines whether optimization reinforces genuinely successful behavior or exploits flaws in the reward design. 4.3 Accuracy Assurance throughout Data Generation The four components above are not mutually exclusive: a single pipeline may incorporate validity constraints during construction, execute intermediate components, and employ multiple critics or verifiers. In this subsection, we examine how existing work ensures accuracy throughout the data generation pipeline and summarize the recurring mechanisms into several high-level directions, which can be observed in Figure 5. 4.3.1 Layered Rule-, Model-, and Human-Based Checking Verification and filtering are central safeguards for data accuracy, yet no single verifier can detect all structural, behavioral, and semantic failures. Existing pipelines therefore compose checks along two dimensions: cost, 13 Prevent invalid Ground in Repair and admit Detect the best execution obvious errors construction 3 4 Feedback-Based Execution-and 1 Constraint- Repair and Layered Rule-, State-Based Selective Admission Model-, and Grounded Verification Human-Based Checking Construction • revise and retry • verify by real execution • failure-driven regeneration • validate before generation • state transitions and • selective admission and •post-hoc filtering • blueprints, graphs, and outcomes recursive improvement • rules, model judges, and human escalation constraints • tests, proofs, and • states, rules, and success conditions executable objectives • turn-and trajectory- level review 1 2 3 4 Figure 5 Four major research directions and emerging trends in accuracy assurance for agentic data generation. from inexpensive deterministic tests to model and human review, and granularity, from individual actions and turns to complete trajectories. APIGen [Liu et al., 2024], for example, applies format validation before function execution and semantic review, while ToolACE [Liu et al., 2025] and TOUCAN [Xu et al., 2025c] combine rule-based checks for schemas and arguments with model-based judgments of semantic coherence. Such ordering removes obvious errors early and reserves more expensive checks for candidates that pass objective constraints. For long-horizon interactions, checking only the final trajectory can conceal local errors that propagate through later observations. ToolMind [Yang et al., 2025a] and WebSTAR [He et al., 2025] therefore per- form fine-grained turn- or step-level filtering, complementing trajectory-level assessment with localized qual- ity signals. Other pipelines strengthen model-based verification through deliberation and cross-checking: ToolMVR [Ma et al., 2025] introduces meta-verification and reflection over initial judgments, whereas APIGen- MT [Prabhakar et al., 2025] uses a committee of reviewers and iterative feedback to validate task blueprints before realizing full dialogues. These mechanisms reduce dependence on a single judgment, although reviewers derived from similar models may still share systematic biases. The resulting evidence favors a layered verification stack with explicit and partially independent responsibili- ties. Rules establish necessary structural properties; execution and state signals test operational consistency; step- and trajectory-level critics examine causal and semantic coherence. Human review is prohibitively ex- pensive [Ramrakhya et al., 2025, Xu et al., 2025b], therefore better used as a selective escalation mechanism for ambiguous goals, disagreement among automated judges, safety-sensitive outcomes, and calibration audits, particularly practical for benchmark construction [Chen et al., 2025a, He et al., 2026]. Importantly, passing one layer should not be treated as evidence for properties that it cannot observe. Reliable filtering therefore depends not only on adding more judges, but on matching each check to a specified failure class, preserving disagreement and provenance, and escalating uncertain or high-risk samples to stronger verification. 4.3.2 Constraint-Grounded Construction The second direction restricts what can be generated. APIGen-MT [Prabhakar et al., 2025] verifies a struc- tured blueprint before multi-turn simulation, preventing an invalid plan from contaminating later turns. Tool graphs and workflow structures constrain candidate actions and dependencies before surface realiza- tion [Wang et al., 2025b, Yin et al., 2025, Tian et al., 2026]. Stateful environment generators construct tasks together with initial states, rules, and success conditions [Zeng et al., 2026d, Song et al., 2026, Tu et al., 2026]. Trajectory-first methods instead write tasks from paths already observed to execute [Wang et al., 2026e, Su et al., 2025, Ouajdi et al., 2026, Sun et al., 2025]. The shared mechanism is a structural anchor across E, q, τ, and v. In broader domains, coding pipelines generally start from repository state and a testable change [Pan et al., 2025, Jain et al., 2025, Yang et al., 2025b]; web and GUI pipelines parameterize application states and success predicates [Trivedi et al., 2024, Rawles et al., 2025, Xie et al., 2024]; formal pipelines generate within 14 a grammar or proof environment [Xin et al., 2024, Trinh et al., 2025]. 4.3.3 Execution- and State-Based Verification A growing trend is to ground verification in actual execution rather than judge whether generated data merely appear plausible. Generated actions and trajectories are executed against tools or environments, and their effects are checked through tool responses, state transitions, tests, or formal objectives. This prevents generators from fabricating observations and produces reproducible failure signals. In tool-use and stateful environments, verification relies on real function execution, database states, and transition or terminal-state checks [Liu et al., 2024, Song et al., 2026, Tu et al., 2026, Xu et al., 2026a, Wang et al., 2026c, Dong et al., 2026]. Software-engineering pipelines validate generated tasks and trajectories through repository setup, compilation, and tests [Jain et al., 2025, Yang et al., 2025b, Badertdinov et al., 2025, Du et al., 2025, Wang et al., 2025a]. Formal and scientific domains similarly use proof-assistant acceptance or executable discovery environments [Xin et al., 2024, Xu et al., 2026b, Li et al., 2025d]. Execution provides a stronger accuracy anchor than plausibility judgments alone, but it remains incomplete. A trajectory may satisfy a terminal condition while exploiting verifier loopholes, causing unintended state changes, or violating implicit constraints. Execution-based signals should therefore be combined with process checks and semantic review. 4.3.4 Feedback-Based Repair and Selective Admission Verification increasingly controls subsequent generation rather than only filtering final samples. Environment builders localize failed tests and regenerate broken tools [Xu et al., 2026a]; blueprint systems revise plans before realization [Prabhakar et al., 2025]; rollout systems retry from the last verified state. For example, EnvFactory [Xu et al., 2026a] and EnvScaler [Song et al., 2026] exemplify iterative construction and testing. UI-TARS [Qin et al., 2025] uses iterative trace collection and reflection, while self-evolving coding and search agents feed observed errors or outcomes back into later experience generation [Xiao et al., 2026, Fu et al., 2026]. Rejecting or repairing a candidate at the earliest failed stage is especially valuable for long trajectories, where one invalid transition can corrupt every later observation. Repeated repair against a fixed verifier may narrow the accepted data toward verifier-friendly patterns. Pipelines should therefore preserve alternative valid paths and use recorded failure types to guide targeted regeneration rather than merely discard failed samples [Qin et al., 2024, Hao et al., 2026]. Recursive synthesis makes this feedback loop explicit: it extends a verified seed, realigns the instruction and verifier to the longer workflow, and admits successful tasks as seeds for later rounds [Li et al., 2026c]. 4.4 Accuracy Costs, Tradeoffs, and Limitations Verification Strength versus Cost. Rule-based checks are inexpensive, whereas execution, repository setup, simulator rollout, multi-model review, and human inspection are progressively more costly. In general, pipelines apply cheap checks early [Liu et al., 2024, 2025], while coding pipelines automate environment setup and testing whenever possible [Jain et al., 2025, Yang et al., 2025b, Badertdinov et al., 2025]. EnvFactory suggests that a smaller set of robustly verified environments can compete with simply scaling the number of environments [Xu et al., 2026a]. These findings motivate a tiered verification strategy that applies lightweight checks broadly and allocates more costly verification to samples with greater uncertainty or potential impact. Verifier Coverage versus Verifier Bias. A verifier can only assess the properties represented in its rules or judging criteria. Deterministic checks are reliable for observable conditions but may overlook semantic errors or unintended side effects, whereas model-based judges cover less structured properties but can be inconsistent and may inherit assumptions from the generator. Meta-verification and cross-checking can reduce, but not eliminate, these errors [Ma et al., 2025]. Moreover, when tasks, environments, trajectories, and verifiers are generated separately, they may remain individually plausible while becoming mutually inconsistent [Ivanov and Rana, 2026]. Repeated optimization against a fixed verifier can further encourage 15 solutions that satisfy the check without fulfilling the intended task. Studies should therefore distinguish verifier acceptance from independently audited correctness. Coupling with Complexity and Diversity. As tasks span longer horizons, richer dependencies, and broader domains, verification must cover more possible sources of inconsistency. A sample should not be treated as difficult or novel until its feasibility and correctness have been established; otherwise, generation errors may be mistaken for useful complexity. Conversely, overly narrow verifiers may reject valid alternative strategies simply because they differ from an expected trajectory or outcome representation [Prabhakar et al., 2025, Ivanov and Rana, 2026]. Accuracy assurance must therefore expand with the complexity and diversity, while preserving consistent validity requirements across different task types and solution paths. Residual Semantic Uncertainty. Some aspects of accuracy cannot be fully captured by executable checks or a single success condition. This uncertainty is particularly important when observations come from an LLM simulator rather than an executable environment: responses may remain locally coherent while encoding incorrect state dynamics [Li et al., 2025e, Lee et al., 2026]. A trajectory may complete the stated task while remaining inefficient, unsafe, inconsistent with user intent, or harmful in its longer-term effects. Hybrid checks can reduce this uncertainty, but cannot eliminate it. Accuracy should therefore be reported across data factors, domains, and failure categories, rather than summarized by a single aggregate pass rate. 5 Complexity Complexity determines whether accurate data provides an informative learning or evaluation signal. Agentic complexity is not synonymous with length, tool count, or linguistic obscurity. It is the difficulty induced by a grounded task, environment, and interaction protocol for a particular model configuration. Existing generation work manipulates structural features to create harder candidates, but increasingly relies on model behavior to decide whether those candidates are actually useful. 5.1 Complexity under the ACE Objective Complexity under the ACE Objective For an accurate instance d, let z denote the complete execution configuration: the target model and policy scaffold, available tools, environment protocol, verifier, sampling settings, and inference budget. We use verified failure probability as a simple model-relative definition, C z (d) = 1− Pr[v(d,τ ) = 1| d,z].(10) The same instance can therefore have different complexity for different models, tool access, or budgets. Structural attributes such as horizon, dependency depth, branching, partial observability, and memory demand are explanatory variables and generation controls, not universal difficulty scores. A broken environment or impossible task is excluded by the accuracy gate; its failure rate is not evidence of useful complexity. The ACE objective uses a utility over C z (d) rather than maximizing it unconditionally. Easy examples may be redundant, while examples that every available solver fails can provide no successful trajectory and may lie beyond the current learnable region. Useful data often occupies a moving band near the learner’s capability frontier (see Figure 6). This makes complexity control bidirectional: generation can add burdens when candidates are too easy and simplify or scaffold them when they are too hard. For comparisons between a base configuration z 0 and an agent-assisted configuration z A , a particularly informative band contains tasks that are not reliably solved by the base model but become solvable with agentic assistance: p z 0 (d) < ρ≤ p z A (d), p z (d) = Pr[v(d,τ ) = 1| d,z].(11) 16 Too Easy Learnable Band Too Difficult redundant most useful beyond frontier Learning Utility Complexity Band Moves with the Learner useful band shifts Complexity is model-aware and learner-relative. Too easy→add burdenToo hard →simplify / scaffold weak stronger Figure 6 Learner-relative task complexity. Learning utility is maximized within a learnable band between tasks that are too easy and too difficult. This band can also shift with learner capability. This paired criterion separates useful agent-requiring tasks from both the base-solvable tail and the beyond- frontier tail. The threshold ρ is protocol-dependent rather than universal. 5.2 Factor-Level Complexity Environment Complexity. Environment complexity is the burden induced by the actionable world in which the task is solved. It is determined by the structure of the state and action spaces, dependencies among tools or objects, transition dynamics, observation protocol, applicable policies, and the behavior of other actors [Tu et al., 2026, Lu et al., 2025b, Barres et al., 2025]. Large environments are not necessarily complex: additional tools, records, or states matter only when they create task-relevant alternatives, prerequisites, uncertainty, or consequences. Conversely, a small action space can remain complex when actions have delayed effects, observations reveal only partial state, or repeated decisions interact through persistent state. Task-signal Complexity. Task-signal complexity concerns what the agent must infer and what obligations a valid solution must satisfy. It can arise from compositional goals, interacting constraints, implicit or progressively revealed intent, cross-source evidence, and dependencies among subgoals [Prabhakar et al., 2025, Shim et al., 2025, Zhang et al., 2026]. This factor is distinct from linguistic obscurity. Missing information creates meaningful complexity only when it can be recovered from the user, environment, or available tools; otherwise, it makes the task ambiguous or infeasible. Likewise, additional conditions matter only when they jointly constrain successful behavior rather than add irrelevant detail. Interaction-realization Complexity. Interaction complexity concerns about the minimum consequential interaction structure required to solve a valid task in its environment. Relevant properties include unavoidable serial dependencies, branching choices, parallel subgoals, joins, loops, clarification, and recovery from task- induced contingencies [Shen et al., 2024, Chen et al., 2025b, Xie et al., 2026b]. This definition separates task-required interaction from policy-dependent inefficiency: a trajectory can be long because the problem requires many dependent steps, or because one solver repeats actions and makes mistakes. Horizon and tool-call count are therefore incomplete proxies unless they reflect the shortest valid solution structure under the stated configuration. Verifier-conditioned Completion Complexity. The verifier influences complexity by defining what counts as completion and what evidence must be produced. A task may require any feasible terminal state, satisfaction of multiple constraints, an optimal outcome, avoidance of forbidden actions, diagnosis of infeasibility, or correctness at intermediate steps [Xu et al., 2025a, Wu et al., 2026b, Xia et al., 2026]. Stricter completion semantics can increase the decision burden, but only when they remain consistent with the task 17 Agentic Complexity EnvironmentComplexity (E) Rich state and actionstructure Dependencies, dynamics, and policies Partial observations and persistent state 1 Task-signal Diversity(q) Compositional goals and interacting constraints Implicit or evolving intent Cross-source evidence and subgoal dependence 2 Interaction-realization Diversity(휏) Serial dependencies and branching choices Loops, clarification, and recovery Shortest valid solution structure matters 3 Verifier-conditioned Completion Complexity（v） Completion rules define what counts Evidence or intermediate checks may be required Optimality, safety, or infeasibility can raise burden 4 Figure 7 Factor-level complexity in agentic data across environments, tasks, interactions, and completion criteria. and observable to the verifier. Adding obligations that the verifier cannot check creates label uncertainty rather than legitimate complexity. These factors should be interpreted jointly. The environment determines the available decision process, the task selects a goal-conditioned region of that process, the required interaction describes the dependencies that must be traversed, and the verifier specifies the accepted completion set. The same surface prompt can therefore vary in complexity through changes to any one of these components. 5.3 Constructing and Calibrating Agentic Complexity Existing work intervenes on the factors above through several recurring mechanisms. Some methods specify dependencies before generation, while others regulate information access, alter the environment or completion conditions, transform valid seeds, or select candidates according to model behavior. These mechanisms often appear together within a broader pipeline. 5.3.1 Structural Specification and Composition The most direct approach is to specify a dependency structure before realizing a task in natural language. Generators construct subgoal graphs, tool-dependency paths, scenario-skill paths, coupled constraints, or initial-to-goal plans, and then instantiate tasks that require the selected structure [Shi et al., 2025, Chen et al., 2025b, Shen et al., 2024, Wang et al., 2026d, Fan et al., 2026, Zhou et al., 2026b]. Related methods compose verified subtasks or action sequences so that an earlier result becomes a prerequisite for a later decision [Ye et al., 2025, Xie et al., 2026b, Yin et al., 2025, Dong et al., 2026]. These structures control different burdens. Depth creates unavoidable serial dependence, width introduces parallel subgoals, joins require intermediate results to be integrated, and conditional edges make later actions depend on the current state. Similar structures appear in long-horizon navigation and branched scientific reasoning [Cheng et al., 2026, Pahuja et al., 2025, Zhao et al., 2026]. However, more nodes or edges do not automatically make a task harder: an explicit chain can reveal the solution, and an added condition can prune the search space. Structural controls therefore need executable relevance and behavioral calibration. 18 5.3.2 Task and Information Control Task-side methods adjust either what must be achieved or what information is initially available. Information can be omitted from the initial request, disclosed through later user turns, distributed across observations, or made discoverable only through tools. This creates clarification, retrieval, and state-tracking burdens in multi-turn interaction [Shim et al., 2025, Zeng et al., 2026c, Wang et al., 2026e, Gu et al., 2026]. Other methods progressively remove procedural cues or reverse-generate requests from known action sequences, producing less explicit but still grounded tasks [Pandit et al., 2025, Crouse et al., 2026, Hao et al., 2026]. Goal-side controls instead add compositional objectives, interacting constraints, intent changes, or evidence that must be integrated across sources. Verified blueprints and reasoning graphs make these obligations explicit before dialogue realization [Prabhakar et al., 2025, Zhang et al., 2026, Yang et al., 2026b]. Search and multimodal generators similarly vary serial or parallel decomposition and the number of evidence sources that must be reconciled [Zhao et al., 2025, Chen et al., 2025e, Huang et al., 2026]. The key condition is resolvability. Withheld information must have an intended source and recovery action, while additional constraints must affect the accepted solution. Otherwise, the generator produces ambiguity or decorative detail rather than meaningful complexity. 5.3.3 Environment and Interaction Design Environment-side methods change the decision process in which a task is solved. Typed tool dependencies, shared state, persistent databases, policy boundaries, and restricted observation protocols create prerequisites and consequences that span multiple actions [Tu et al., 2026, Song et al., 2026, Wang et al., 2026c, Xu et al., 2026a]. Initial-state selection and controlled information access can further increase the amount of state that must be inferred without changing the visible goal [Zeng et al., 2026d, Lu et al., 2025b]. The implementation is domain-dependent. Coding and scientific environments derive complexity from repos- itory or program dependencies, executable feedback, and multi-step experimentation [Du et al., 2026, Xu et al., 2026b]. Embodied environments add geometry, physics, sensing, and longer action horizons [Wang et al., 2026a, Zhou et al., 2026c]. Social environments introduce private information, competing incentives, communication, and strategic responses from other policies [Zhou et al., 2024, Leibo et al., 2021, Barres et al., 2025, Yashwanth YS et al., 2026]. Across these settings, additional environment detail is useful only when it changes the transitions, observations, or choices relevant to the task. 5.3.4 Completion and Feedback Design Complexity can also be controlled through the definition of success. Generated tasks may require a target state, satisfaction of coupled constraints, completion of several rubric items, avoidance of forbidden actions, or diagnosis that no feasible solution exists. State targets, constraint programs, rubric trees, and subgoal evaluators make these requirements machine-checkable [Cai et al., 2025, Ivanov and Rana, 2026, Xie et al., 2026a, Xu et al., 2025a]. Programmatic benchmark generators likewise vary completion semantics across tools and environments [Lyu et al., 2026, Wu et al., 2026b]. Feedback need not be limited to a terminal pass or fail. Path-centric rewards and step-level checks assign credit to intermediate evidence gathering, action choice, or progress toward a goal [Xia et al., 2026, He et al., 2025]. Such feedback can make long-horizon tasks learnable without reducing their underlying dependency structure. The task and verifier must nevertheless evolve together: adding obligations that are absent from the success check creates label error, while adding checks unrelated to the stated goal changes the benchmark rather than its complexity. 5.3.5 Evolution and Progressive Transformation Instead of generating hard instances from scratch, many pipelines transform already valid seeds. Some pro- gressively remove procedural cues or make intents less explicit [Pandit et al., 2025, Kang et al., 2026], while others strengthen goal conditions and interacting obligations [Hu et al., 2025]. Long-horizon complexity can also be increased by extending verified follow-up subtasks [Xie et al., 2026b], composing workflow-relevant 19 skills [Fan et al., 2026], or producing progressively longer workflows [Li et al., 2026c]. Progressive transfor- mation preserves a grounded core and makes the intended source of additional burden easier to identify. Adaptive variants use execution outcomes or accumulated experience to choose subsequent transformations. They can target unresolved capabilities, derive new tasks from failures, or turn successful traces into reusable skills [Zhai et al., 2025, Fang et al., 2025, Fu et al., 2026, Xiao et al., 2026]. Because each edit can introduce infeasibility or irrelevant detail, progressive generation still requires an accuracy gate and a record of the factor being changed. 5.3.6 Failure-Driven and Model-Aware Calibration The decreasing solver pass rate across verified recursive-synthesis rounds illustrates how structural growth can be checked against observed model difficulty [Li et al., 2026c]. Structural controls describe why a candidate may be hard, but solver behavior determines whether it is informative for a particular learner. Model-aware pipelines estimate verified success under a stated model, scaffold, and rollout budget, then retain candidates near a target success band or capability frontier [Florensa et al., 2018, Guo et al., 2025, Acikgoz et al., 2026, Wolf et al., 2026, Zeng et al., 2026b]. Capability profiles and observed failures can further direct generation toward specific weaknesses rather than increasing every structural feature uniformly [Hao et al., 2026, Kang et al., 2026, Chen et al., 2025d, Huang et al., 2026]. Failure is informative only after validity has been established. Otherwise, frontier tasks are mixed with broken environments, impossible requests, and incomplete verifiers. Repeated verified rollouts and stratification by domain or skill are therefore needed before a candidate is prioritized, simplified, or deferred. 5.3.7 Bidirectional Calibration and Scaffolding Complexity control is bidirectional. Saturated candidates can be strengthened by adding a dependency, reducing information exposure, or tightening completion requirements. Candidates beyond the useful band can be simplified by reversing those changes or by supplying intermediate goals, procedural prerequisites, action hints, and opportunities for clarification [Hu et al., 2025, Liu et al., 2025, Xu et al., 2025b, Shim et al., 2025]. Corrective feedback and reference actions can also turn otherwise inaccessible tasks into usable supervision [Yin et al., 2025, Hao et al., 2026]. Additional scaffolding may divide planning, routing, specialization, and critique among auxiliary agents, while selective human assistance can resolve ambiguity or domain-specific blockers [Li et al., 2025b, Yao et al., 2026, Jiao et al., 2026, Trinh et al., 2026]. Because scaffolding changes the execution configuration z, comparisons should keep the underlying instance fixed and state whether the objective is to generate harder tasks, obtain learnable supervision, or measure the value added by assistance. 5.4 Estimating and Reporting Complexity Complexity evaluation should combine structural description with behavioral calibration. Structural reports should cover the manipulated factors: goal constraints, information exposure, required dependency topology, state and observation design, horizon, branching, recovery, and verifier semantics. These descriptors explain why a candidate may be hard and support controlled ablations, but they should not be collapsed into an unvalidated universal score. Behavioral reports should state the target model, scaffold, tools, inference budget, sampling protocol, and number of rollouts. Success rates should be stratified by domain, skill, and structural band, with uncertainty where stochasticity is material. Paired evaluation is especially informative: compare matched instances before and after one intervention, or compare a base model and agent-assisted configuration on the same accepted data. Studies of code-agent trajectory curation and software-engineering data scaling further motivate report- ing trajectory selection and data budget rather than treating all verified rollouts as equally informative [Han, 2026, Zeng et al., 2025]. The reported complexity distribution should move as the learner improves rather than remain tied to a fixed teacher judgment [Ge et al., 2026, Guo et al., 2025, Chen et al., 2025d]. 20 The two views answer different questions. Structural descriptors support diagnosis and controllable gen- eration, whereas behavioral estimates determine whether the resulting burden is meaningful for a learner. A convincing complexity claim therefore reports their relationship: whether deeper dependencies, reduced information, richer state, or stricter completion semantics actually lower verified success, and whether that effect persists across models rather than reflecting one solver artifact. 5.5 Complexity Tradeoffs and Limitations Complexity versus Accuracy. Additional dependencies, state transitions, and completion requirements enlarge both the space of possible failures and the burden of verification. Long trajectories are especially fragile because an invalid early step can corrupt subsequent states. Difficulty should therefore be assessed only after schema, execution, semantic, and verifier checks; otherwise, broken environments and infeasible tasks are easily mistaken for hard cases. Strong validity constraints may reduce candidate yield, but relaxing them does not create useful complexity [Jiao et al., 2026, Yang et al., 2025a, Badertdinov et al., 2026]. Complexity versus Diversity. Model-aware generation often concentrates on a narrow set of current failures. This can improve short-term learning efficiency while reducing coverage of other domains, skills, solution paths, or easier examples needed for retention. Conversely, a broad mixture may contain little useful signal if most samples are already saturated. Complexity-aware selection should therefore operate within explicit coverage constraints rather than replace diversity with frontier difficulty. Fixed-budget studies showing gains from varied trajectory structures support balancing these objectives instead of optimizing either in isolation [Chen et al., 2026b,a]. Complexity versus Reality. Reality and complexity are related but distinct. Reality concerns whether an environment, task, and interaction plausibly reflect situations that arise in deployment, whereas complexity concerns the reasoning, information, and action burden required for completion. Realistic scenarios are often complex because they involve implicit constraints, persistent state, and noisy observations, but many real workflows remain routine; conversely, a synthetic task may be difficult yet implausible or irrelevant. Recreated environments should therefore preserve task-relevant action semantics, state transitions, and constraints rather than maximize environmental detail or difficulty for its own sake [Li et al., 2026a, Chae et al., 2026]. Complexity claims should accordingly specify the relevant task family and deployment setting. Proxy Fidelity and Calibration Cost. Structural proxies such as horizon, tool count, graph depth, or constraint count are inexpensive and controllable, but they do not reliably predict behavioral difficulty. Added steps may be parallelizable, extra conditions may narrow the search, and an explicit decomposition may make a longer task easier. Behavioral calibration is more informative but requires repeated executable rollouts and remains sensitive to model, scaffold, inference budget, and stochasticity [Ge et al., 2026, Guo et al., 2025, Wolf et al., 2026]. Practical pipelines must balance cheap structural screening against costly model-based estimates, especially near selection boundaries. Difficulty versus Learnability. Maximizing failure rate can push generation beyond the region from which a learner receives useful supervision. All-failure candidates may provide no successful trajectory, stable reward, or evidence that the task is solvable under the available tools and budget. Frontier-oriented methods instead seek mixed outcomes or a measurable advantage from stronger scaffolds, and simplify or defer candidates that remain inaccessible [Acikgoz et al., 2026, Wolf et al., 2026, Chen et al., 2025d]. The appropriate target also depends on use: training data should usually provide an attainable learning signal, whereas evaluation may deliberately include a harder tail to measure future progress. Curriculum Drift and Closed-loop Bias. The useful complexity band moves as the learner improves [Zeng et al., 2026b]. Static generators eventually saturate, while continuously adaptive generators can overfit to the current model’s idiosyncratic failures, a fixed verifier, or one simulator’s dynamics. Co-evolution and difficulty-aware generation address saturation, but they also make the data distribution non-stationary [Guo 21 et al., 2025, Kang et al., 2026, Chen et al., 2025d]. Held-out domains, fixed anchor sets, and periodic recal- ibration are needed to distinguish genuine capability growth from a generator and learner adapting to the same narrow feedback loop. 6 Diversity Diversity concerns the breadth of accurate and appropriately complex agentic data. It is not determined by the number of samples, prompts, tools, or domain labels, but by whether the data cover distinctions that change what an agent can observe, decide, and do. Existing pipelines pursue such coverage by expanding data sources and executable support, recombining compatible components, exploring reachable experience, constructing controlled variants, and adapting generation to remaining coverage gaps. The relevant unit is therefore a valid and behaviorally distinct environment–task–interaction relation. 6.1 Diversity under the ACE Objective Section 3.4 treats diversity as a batch-level utility over the accuracy-filtered set B A . Effective diversity is validity-conditioned: inconsistent environments and unsupported trajectories enlarge the error space rather than the useful support. It is structural: renamed tools or paraphrased requests may still induce the same behavior. It is also learner-aware: a distinction that is novel to one model or corpus may already be redundant for another, while unrestricted novelty may move outside the learnable region. Diversity under the ACE Objective Let Z E , Z Q , and Z I represent the environment-, task-, and interaction-level factors introduced above. We define D(B) as the effective diversity of a generated batchB: the breadth of its valid and appropriately complex factor coverage after discounting behaviorally redundant samples. A useful abstraction is D(B) = X k∈E,Q,I w k H(Z k | d∈B A , C z (d)∈I z )− λ Red(B A ),(12) where B A is the subset that passes the accuracy gate, and I z denotes the useful complexity range for learner configuration z. For each factor level k, H(·) measures the entropy of its empirical factor distribution within this filtered subset: a larger value indicates broader and more balanced coverage. The weight w k specifies the relative importance of environment, task, and interaction diversity, while Red(B A ) measures behavioral redundancy and λ controls its penalty. Thus, the objective rewards balanced factor- level coverage among valid, learnable samples rather than surface variation or raw dataset size. This formulation is a design principle rather than a universal score. Its factor representation, entropy esti- mator, redundancy measure, weights, learner configuration, and target complexity range should be specified for each domain. 6.2 Factor-Level Diversity Environment-specification Diversity. This factor describes variation in the actionable world: tool and action schemas, initial states, transition dynamics, observation interfaces, policies, modalities, verifiers, and other actors. Its useful subdimensions include state, action-space, observation, dynamics, rule, and reward diversity. Environment names or tool counts are weak proxies when the resulting systems expose the same preconditions, effects, information paths, and success conditions. Stateful tool and application environments illustrate why changing a permission, policy, or hidden state may create more consequential variation than adding another nominal API [Lu et al., 2025b, Trivedi et al., 2024, Barres et al., 2025]. Task-signal Diversity. Task diversity concerns what the agent is asked or expected to achieve. It spans goals and capabilities, interacting constraints, user profiles, intent revelation, feasibility regimes, temporal 22 Environment-specification Diversity(E) Task-signal Diversity(q) Vary tools, states, Cover different goals, observations, and policies users, and constraints Include different dynamics, Vary intent revelation rewards,and actors and feasibility regimes Meaningful variation Spread across capability matters more than extra APIs and difficulty bands Agentic Diversity 1 2 Generator & Provenance Diversity (G) Mix prompts,models, critics,and simulators Use varied scaffolds and decoding policies Record provenance and assess induced coverage 4 Interaction-realization Diversity(휏) Include alternative plans and action orders Cover clarification, recovery, and assistance patterns Keep different valid outcomes,not rollout noise 3 Figure 8 Four complementary factors of diversity: environment, task, interaction, and generator/provenance. conditions, and difficulty bands. Surface requests are meaningfully different only when they alter the ev- idence, decision, or acceptable outcome. In particular, clarification, refusal, partial completion, recovery, and successful completion should be treated as distinct task regimes rather than collapsed into generic hard cases [Shim et al., 2025, Wang et al., 2026e]. Difficulty is one task factor, but a broad difficulty distribution can still be narrow in goals, users, or required capabilities. Interaction-realization Diversity. For a fixed environment and task, several valid interaction processes may exist. This factor covers horizon and turn structure, alternative plans and action orders, tool substitu- tions, action representations, clarification and recovery patterns, assistance, and outcomes. The distinction is behavioral: alternative paths that reach valid states reveal strategy coverage, whereas repeated hesitation or accidental detours are rollout noise. Failure traces contribute only when the failure is grounded and the correction or outcome is verified [Hao et al., 2026, Gao et al., 2026]. Generator and provenance Diversity. Generated data also inherit the priors of source corpora, teacher models, prompts, simulators, critics, decoding policies, and agent scaffolds. Mixing these sources can reduce a single generator’s blind spots, but source heterogeneity is an intervention rather than an outcome: different model names may still reproduce the same task and trajectory templates. Provenance should therefore be recorded and its value assessed through the induced factor coverage and learner utility [Mitra et al., 2024, Xu et al., 2025c, Yang et al., 2026a]. 6.3 Expanding Agentic Diversity: Mechanisms and Domain Evidence Prior work rarely optimizes diversity as an isolated objective. Instead, broader generation pipelines use several recurring mechanisms to enlarge or rebalance one or more of the factors above. 6.3.1 Source and Support Expansion The most direct mechanism adds environments, tools, repositories, scenes, users, modalities, task sources, or verification regimes. Tool-oriented work scales real and synthetic API ecosystems, software-agent pipelines broaden executable repositories and languages, and embodied or scientific systems construct simulation-ready worlds and discovery spaces [Qin et al., 2024, Xu et al., 2025c, Badertdinov et al., 2026, Du et al., 2026, Wang 23 et al., 2026a, Xu et al., 2026b]. Heterogeneous documents and real traces offer authentic long-tail support but inherit source imbalance; model generation is more controllable but can repeat teacher priors; programmatic construction supports execution and reset but may reproduce a small set of templates. Nominal scale is therefore an incomplete measure. Broader environment distributions can improve trans- fer [Tu et al., 2026, Dong et al., 2026], yet a smaller collection of robustly verified environments can be more useful than a larger but unreliable one [Xu et al., 2026a]. What matters is the marginal addition of a valid capability, relation, state transition, or feedback structure. 6.3.2 Compositional Recombination Composition creates new relations among existing components: multi-tool dependencies, cross-application workflows, interacting user constraints, cross-file edits, or multi-object tasks. Graph- and blueprint-based pipelines sample compatible components before realizing a task or trajectory, reducing contradictions that arise from independent combination [Wang et al., 2025b, Yin et al., 2025, Prabhakar et al., 2025]. Re- lated methods recombine task graphs, capabilities, and subgoals across tool use, computer use, coding, and robotics [Chen et al., 2025b, Xie et al., 2026b, He et al., 2026, Nasiriany et al., 2024]. Composition adds diversity only when the components interact and change the required behavior; concatenating independent subtasks mainly increases length. 6.3.3 Exploration and Experience-First Discovery Rather than writing a task first, experience-first methods traverse an environment, simulator, repository, proof system, or hypothesis space and derive tasks or training signals from reachable behavior. This pattern supports tool and GUI interaction, robotics, program discovery, and scientific search [Ramrakhya et al., 2025, Su et al., 2025, Wang et al., 2024c, Romera-Paredes et al., 2024, Zhao et al., 2026]. Reverse generation from executed tool combinations further grounds tasks in observed evidence [Chen et al., 2026a], while exploration- driven GUI pipelines broaden states, applications, and recovery paths [Pahuja et al., 2025, Sun et al., 2025, Cheng et al., 2026]. Reachability does not guarantee broad support: a narrow explorer repeatedly visits familiar states and strategies, and reward-driven search can ignore useful but hard-to-score behavior. Multiple policies, external seeds, resets, novelty signals, and state-coverage estimates help separate what an environment supports from what the current explorer happened to discover. 6.3.4 Perturbation and Counterfactual Variation Controlled variation changes selected factors while holding others fixed, including initial state, policy, user constraint, observation format, tool semantics, layout, or physical parameters. Such perturbations are used to expose specific query, action, observation, and domain shifts [Lv et al., 2026]; domain randomization similarly broadens visual and physical conditions for embodied transfer [Tobin et al., 2017, Mehta et al., 2020, Chen et al., 2025c]. Matched counterfactuals are especially informative because they reveal whether a change in state or policy causes the intended change in action. Variants that alter only surface form add apparent entropy, while implausible perturbations leave the deployment distribution; both require validity and behavioral checks. 6.3.5 Coverage-Guided Balancing and Adaptation Coverage-guided pipelines target under-represented factor combinations, remove redundancy, or allocate gen- eration toward named transfer gaps. Model-adaptive pipelines instead use failures, uncertainty, or a solve-rate band to produce experience near the learner’s current frontier [Hao et al., 2026, Chen et al., 2025d, Guo et al., 2025, Kang et al., 2026, Wolf et al., 2026]. Self-evolving systems feed observed behavior, accumulated experi- ence, or world-model errors back into task and experience generation [Zhai et al., 2025, Fang et al., 2025, Fu et al., 2026, Xiao et al., 2026], while trajectory-aware allocation explicitly targets under-covered reasoning and interaction structures [Chen et al., 2026b]. 24 Tool-use & Digital Agents •tool dependencies •state effects •multi turn flow •policies & errors •action forms Web, GUI & Computer-use Agents •app & layouts •OS / modalities • initial & persistent state •cross-app workflows •recovery traces appearance ≠behavior •languages & repos •dependencies / build / tests •issue types •edit & recovery paths Coding & Software-engineering Agents Embodied & Social Agents • tool dependencies •state effects •multi turn flow Embodied Social • partner policies •private info • communication / institutions Scientific & Formal Agents •materials / proteins •hypothesis / experiments •programs / proofs •verification / simulation Candidate diversity ≠validdiscoverydiversity Figure 9 Domain-specific instantiations of diversity across diverse kinds of agents. Meaningful diversity should be characterized by domain-specific behavioral units rather than surface-level variation alone. Adaptation improves marginal efficiency but can overfit generation to transient model failures. Coverage constraints, stratified replay, and periodic broad exploration are needed to preserve skills, domains, and easier anchor cases while the frontier moves. 6.3.6 Domain-Specific Instantiations and Evidence The mechanisms are shared, but meaningful factors and evidence differ by domain. Within-domain diversity covers states, workflows, users, strategies, and outcomes inside one deployment family; cross-domain diversity covers qualitatively different semantics, interfaces, dynamics, and verification regimes. Figure 9 summarizes the domain-specific instantiations of diversity across diverse kinds of agents and Table 3 lists the representative works. Below explores the details. Tool-use and Digital Agents. Coverage initially centered on API and capability pools, but later pipelines diversify executable state effects, coherent tool dependencies, multi-turn information flow, policies, errors, and action representations [Qin et al., 2024, Liu et al., 2024, 2025, Wang et al., 2025b, Yao et al., 2026]. Search agents add variation in sources, retrieval engines, decomposition, evidence paths, and query revision even when the nominal search interface is unchanged [Zheng et al., 2025, Li et al., 2025a, Jin et al., 2025, Zhao et al., 2025]. Tool identity thus substantially undercounts behavioral support. Controlled tool-use studies further show that tool-pool and per-task toolset coverage can improve out-of-distribution performance more efficiently than repeated sampling from the same support [Chen et al., 2026a]. Web, GUI, and Computer-use Agents. Relevant variation spans applications, layouts, operating sys- tems, modalities, initial states, persistent effects, and cross-application workflows. Existing work combines real or recreated interfaces with procedural task generation, reverse synthesis, environment exploration, mul- timodal actions, and recovery traces [Xie et al., 2024, Rawles et al., 2025, Xu et al., 2025a, Ramrakhya et al., 2025, Sun et al., 2025, Cheng et al., 2026]. This domain separates visual from behavioral diversity particu- larly clearly: very different screenshots may share one interaction topology, while a small permission or state change on the same screen may reverse the correct action. Transfer to unseen real interfaces is therefore stronger evidence than generated page count. Coding and Software-engineering Agents. Environment coverage includes languages, repository struc- tures, dependencies, build systems, tests, and project histories; task and trajectory coverage include issue types, localization paths, edit scopes, test feedback, and recovery. Recent pipelines scale executable reposi- tories and multilingual trajectories, generate feature-level tasks and tests, and allocate fixed budgets across distinct trajectory structures [Badertdinov et al., 2026, Ahmad et al., 2026, Du et al., 2025, Wang et al., 25 Table 3 Representative works on domain-specific diversity in agentic data generation. Methods are grouped by their primary application domain. Key Mechanism summarizes the domain-specific source of meaningful behavioral diversity, while Resource links to public GitHub repositories or Hugging Face websites when available. MethodDomainKey MechanismResource Tool-use and Digital Agents ToolLLM [Qin et al., 2024]Tool UseLarge-scale coverage of real-world APIs and tool capabilities GitHub APIGen [Liu et al., 2024]Tool UseVerifiable function-calling generation across diverse APIs, tasks, and executions GitHub ToolACE [Liu et al., 2025]Tool UseDiversification of tool pools, function-calling tasks, and action representations Hugging Face ToolFlow [Wang et al., 2025b] Tool UseCoherent tool dependencies and multi-turn information flow through structured synthesis – ACE-Router [Yao et al., 2026] Tool / MCP History-aware routing across heterogeneous MCP tools and interaction histories GitHub DeepResearcher [Zheng et al., 2025] SearchDiverse real-world research trajectories, retrieval behavior, and evidence integration GitHub WebSailor-V2 [Li et al., 2025a] SearchSynthetic deep-search experience with diverse retrieval and evidence paths GitHub Search-R1 [Jin et al., 2025]SearchReinforcement learning over interleaved reasoning and search-engine interaction GitHub ParallelSearch [Zhao et al., 2025] SearchQuery decomposition and parallelized sub-query search trajectories – DIVE [Chen et al., 2026a]Tool UseExpansion of tool-pool and per-task toolset coverage for OOD generalization GitHub Web, GUI, and Computer-use Agents OSWorld [Xie et al., 2024]Computer Use Coverage of real computer environments, applications, states, and open-ended workflows GitHub AndroidWorld [Rawles et al., 2025] Mobile / GUI Dynamic Android applications with state-dependent task instantiation GitHub CRAB [Xu et al., 2025a]GUICross-environment multimodal tasks spanning heterogeneous applications and interfaces GitHub Scaling Synthetic Task Generation [Ramrakhya et al., 2025] Computer Use Exploration-driven synthesis that expands reachable states, tasks, and interaction paths – OS-Genesis [Sun et al., 2025] GUIReverse task synthesis from GUI trajectories and executable interaction paths GitHub OpenMobile [Cheng et al., 2026] MobileTask and trajectory generation across applications and interaction states GitHub Coding and Software-engineering Agents SWE-rebench V2 [Badertdinov et al., 2026] Software Eng. Language-agnostic scaling of executable software-engineering tasks and repositories GitHub Open-SWE-Traces [Ahmad et al., 2026] Software Eng. Multilingual software-engineering trajectories with diverse solution and feedback paths – SWE-Dev [Du et al., 2025]Software Eng. Feature-level software-development tasks coupled with executable tests GitHub SWE-dev [Wang et al., 2025a] Software Eng. Training trajectories spanning repositories, task types, edit scopes, and execution feedback GitHub Beyond Quantity [Chen et al., 2026b] CodingFixed-budget allocation across distinct trajectory structures rather than repeated samples – 2025a, Chen et al., 2026b]. The meaningful unit is a verified problem–repository–feedback relation, not an issue description or repository count. Embodied and Social Agents. Embodied diversity spans scenes, objects, affordances, physics, sensors, embodiments, and action effects. Procedural world generation becomes behaviorally useful when scene varia- tion is coupled with activities, physical constraints, task graphs, or policy changes [Deitke et al., 2022, Yang et al., 2024, Nasiriany et al., 2024, He et al., 2026, Wang et al., 2026a]. Social environments add partner policies, incentives, private information, communication channels, and institutions; persona variation alone 26 Table 3 Representative works on domain-specific diversity in agentic data generation (continued). MethodDomainKey MechanismResource Embodied and Social Agents ProcTHOR [Deitke et al., 2022] EmbodiedProcedural generation of diverse scenes, objects, layouts, and embodied environments GitHub Holodeck [Yang et al., 2024] EmbodiedLanguage-guided generation of interactive 3D environments and scene configurations GitHub RoboCasa [Nasiriany et al., 2024] EmbodiedLarge-scale simulation of everyday scenes, objects, affordances, and manipulation tasks GitHub Automatic Cognitive Task Generation [He et al., 2026] EmbodiedGeneration of activities and task structures under physical and environmental constraints – EmbodiedGen V2 [Wang et al., 2026a] EmbodiedSimulation-ready 3D world generation with diverse scenes and physical interaction conditions GitHub SOTOPIA [Zhou et al., 2024] SocialOpen-ended social interactions with diverse roles, goals, and partner behavior GitHub Melting Pot [Leibo et al., 2021] Multi-AgentDiverse partner policies, incentives, social situations, and interaction structures GitHub Concordia [Vezhnevets et al., 2023] SocialGenerative agent-based simulation grounded in physical, social, or digital contexts GitHub SOTOPIA-ToM [Yashwanth YS et al., 2026] SocialDiverse private-information settings and information-management demands in multi-agent interaction – SynthAgent [Aghaee et al., 2026] Social / Simulation Persona-conditioned longitudinal behavior and outcomes grounded in heterogeneous evidence – Scientific and Formal Agents Scaling Deep Learning for Materials Discovery [Merchant et al., 2023] MaterialsLarge-scale exploration of candidate materials under learned property prediction GitHub RFdiffusion [Watson et al., 2023] Protein Design Generative exploration of diverse protein structures and functions GitHub SciDisco [Xu et al., 2026b]ScientificDiverse scientific-discovery processes in executable environments with process-level verification – AutoSDT [Li et al., 2025d]ScientificGeneration of executable data-driven scientific discovery tasks across heterogeneous datasets GitHub FunSearch [Romera-Paredes et al., 2024] Formal / Math Exploration of executable programs under automated evaluation and iterative program search GitHub DeepSeek-Prover [Xin et al., 2024] FormalLarge-scale synthetic theorem generation with proof-assistant-based formal verification GitHub is weak unless these factors change transitions or rewards [Zhou et al., 2024, Leibo et al., 2021, Vezhnevets et al., 2023, Yashwanth YS et al., 2026]. Domain-specific simulations can further couple personas with lon- gitudinal behavior and outcomes, as in virtual patients grounded in clinical, behavioral, and psychosocial sources [Aghaee et al., 2026]. Scientific and Formal Agents. Here, candidate breadth is tightly constrained by feasibility and verifica- tion. Generative systems explore materials, proteins, hypotheses, experiments, programs, and proofs under property predictors, execution, simulation, or formal checking [Merchant et al., 2023, Watson et al., 2023, Xu et al., 2026b, Li et al., 2025d, Romera-Paredes et al., 2024, Xin et al., 2024]. These domains make the distinction between candidate diversity and valid discovery diversity explicit: verifier coverage must expand with the candidate space, or the apparently broader support cannot be trusted. 6.4 Measuring Diversity Agentic diversity cannot be summarized reliably by a single number. Its measurement should proceed in stages: first determine which environment, task, and interaction factors are covered; then check whether the resulting samples require genuinely different behavior, remain valid and appropriately difficult, transfer to held-out settings, and provide additional value to the learner. Each study should therefore state explicitly which differences it regards as meaningful. 27 Factor Coverage and Balance. The most direct measurement is to divide each factor level into a set of categories. For example, task diversity may be partitioned into information seeking, transaction, clarification, refusal, recovery, and so on, while environment diversity may be partitioned by tool family, state regime, or policy type. Factor Coverage and Balance LetS k denote the declared categories for factor level k ∈E,Q,I, let n b be the number of valid samples in category b, and let bp b be its empirical proportion. Coverage and normalized entropy then provide two simple summaries: Cov k = |b∈S k : n b > 0| |S k | , e H k =− 1 log|S k | X b∈S k bp b logbp b .(13) Here, Cov k is the fraction of declared categories represented by at least one sample. The normalized entropy e H k measures how evenly samples are distributed across those categories: it reaches one when the distribution is uniform and decreases as the data concentrate in a few categories. The two statistics are complementary. Coverage can be high even when nearly all samples belong to one dominant category, whereas entropy alone does not show which important categories are absent. Marginal statistics should also be supplemented with a small number of meaningful joint distributions, such as tool family × task capability or state regime × required outcome. Otherwise, each factor may appear diverse on its own while occurring only in fixed combinations. This “template locking” creates nominal coverage without broadening the relations that agents must learn. Full Cartesian coverage is rarely practical, so studies should select combinations that correspond to expected deployment shifts or known dependencies. Behavioral Non-redundancy. Category coverage still overestimates diversity when differently worded samples require essentially the same behavior. Text similarity can detect paraphrases, but agentic data should also be compared through tool-call or action graphs, state transitions, dependency paths, clarification and recovery patterns, and final-state changes. These representations help distinguish alternative strate- gies from renamed tools, rewritten requests, or inconsequential rollout variation. Graph fingerprints and kernel-based effective-number measures can summarize behavioral non-redundancy, provided that the chosen representation and similarity function are reported [Friedman and Dieng, 2023]. ACE-conditioned Coverage. Coverage should be measured after the accuracy gate and within declared complexity ranges. Otherwise, invalid samples may make a dataset appear broader, or most of its valid coverage may be concentrated among trivial tasks. Aggregate statistics can also hide low validity in rare domains or long trajectories. Reports should therefore pair diversity statistics with validity rates, failure types, and model-relative difficulty for each important factor slice. Transfer Coverage. Internal coverage does not by itself show that the data support generalization. Stronger evidence comes from controlled evaluation under named held-out factors, such as unseen tools, schemas, states, policies, interfaces, user behaviors, dynamics, or horizons. Studies should report both per- formance on the held-out factor and its gap from a matched in-domain setting [Lv et al., 2026, Wang et al., 2026d, Wu et al., 2026b, Li et al., 2026b]. Marginal Learner Utility. The final question is whether a newly covered region improves the learner more than adding the same amount of data from existing regions. A sample may be new to the corpus but already easy for the model, or novel to the model but too difficult or irrelevant to produce useful learning. Model-aware generators approximate this distinction with capability profiles or success-rate bands [Guo et al., 2025, Kang et al., 2026, Chen et al., 2025d, Wolf et al., 2026]. Evaluation should therefore distinguish corpus novelty, model-relative novelty, and downstream transfer benefit. 28 6.5 Diversity Tradeoffs and Limitations Diversity versus Quantity. Structural coverage can provide greater marginal value than repeated sam- pling from saturated modes [Chen et al., 2026a,b]. This does not make quantity irrelevant: additional samples improve estimation and robustness in genuinely under-sampled regions. The limitation is that raw counts cannot distinguish support expansion from denser repetition, so scaling claims require coverage-controlled comparisons. Diversity versus Accuracy. Broader recombination increases the chance of incompatible tools, unreach- able goals, inconsistent states, and misaligned verifiers. Execution, procedural tests, constraints, and state- based checks must therefore accompany expansion [Liu et al., 2024, Song et al., 2026, Tian et al., 2026, Ivanov and Rana, 2026]. Yet verifier support can be narrower than the valid solution space: optimizing admission against one fixed checker may discard legitimate strategies and make the accepted set appear less diverse. Diversity should expand only after validity is established, while verifier coverage and independent audits expand with it. Diversity versus Model-aware Complexity. A broad dataset can still be poorly allocated for a par- ticular learner. Easy regions may be diverse but provide little new signal, whereas frontier-only generation can discard foundational capabilities and repeatedly chase transient failures. Because the useful complexity region moves during training, generation needs both frontier-focused allocation and broad replay coverage. Diversity should thus be reported within difficulty bands, and adaptation should be evaluated for collapse across skills and domains. Realism, Controllability, and Scale. Environment-free trajectory generation sharpens this tradeoff by scaling from API specifications alone while shifting accuracy assurance to simulator consistency and model- based filtering [Li et al., 2025e, Lee et al., 2026]. Real systems expose authentic dynamics and long-tail behavior but are costly, unsafe, difficult to reset, and prone to temporal drift. Learned simulators scale cheaply but may invent transitions; programmatic and recreated environments offer control and deterministic checking but omit unmodeled behavior. Hybrid designs combine real specifications or traces with executable replicas and learned components [Wang et al., 2026c, Chae et al., 2026, Zuo et al., 2026]. Their diversity claims remain conditional on simulator fidelity and should be tested on held-out real environments. Mixture Interference and Open-world Drift. Combining domains and generators introduces incom- patible formats, action conventions, reward scales, and sampling frequencies. Standardization and balancing can reduce this interference [Chen et al., 2024, Zhang et al., 2024, Cai et al., 2025], but aggressive normal- ization may erase domain-specific semantics. Moreover, any finite mixture is a snapshot: tools, interfaces, policies, and user behavior continue to change. Sustainable diversity therefore requires provenance tracking, shift detection, and periodic support repair rather than one-time maximization [Lv et al., 2026, Dong et al., 2026, Gao et al., 2026]. 7 Discussion The preceding sections use ACE to analyze the construction and selection of agentic data. Several impor- tant questions, however, concern choices around agentic data generation rather than another mechanism for improving Accuracy, Complexity, or Diversity. This section discusses such extensions. 7.1 Scaling Law under ACE Objective Data scaling primarily asks whether performance improves as more training examples are added. Under the ACE objective, however, raw quantity becomes a weaker proxy for useful scale because additional samples contribute unevenly. Accuracy determines how much of the generated pool is actually admissible; Complexity determines whether valid samples remain informative for the current learner rather than being already sat- urated or completely beyond reach; and Diversity determines whether new data expand behavioral support or merely densify modes that are already well covered. Recent results in agentic settings already suggest 29 this distinction: diversity-oriented scaling can outperform simple quantity scaling under comparable or even smaller data budgets, while environment-scaling studies show that a smaller set of robust, behaviorally dis- tinct environments can be more effective than a much larger but redundant or weakly verified collection [Chen et al., 2026a,b, Xu et al., 2026a, Tu et al., 2026]. This perspective suggests that the relevant scaling variable for agentic data is closer to effective support than raw dataset size. Scaling can occur by producing more valid experience, moving probability mass toward the learner’s useful complexity frontier, or expanding coverage over environments, states, tasks, policies, and interaction structures. These directions are coupled rather than independent [Guo et al., 2025, Chen et al., 2025d, Wolf et al., 2026, Hao et al., 2026]. The strongest scaling strategy may not maximize any single ACE dimension, but maintain a growing region that is simultaneously valid, learnable, and behaviorally non-redundant. A further implication is that agentic data scaling is likely to become increasingly dynamic. As the learner improves, previously useful tasks become saturated, the complexity frontier moves, and previously diverse regions can become redundant; at the same time, expanding into new domains introduces new accuracy requirements and verifier gaps. Static quantity scaling therefore has diminishing value unless generation and allocation adapt with the learner. Self-evolving and difficulty-aware systems already move in this direction by using failures, success rates, and coverage gaps to decide what experience to generate next [Zhai et al., 2025, Kang et al., 2026, Guo et al., 2025, Chen et al., 2025d]. From the ACE perspective, a future scaling law for agentic data may therefore be less about how performance grows with the number of trajectories, and more about how efficiently additional generation expands the accurate, appropriately challenging, and behaviorally distinct experience available to the agent. 7.2 Real and Synthetic Data under ACE We distinguish real and synthetic data by the origin of their agentic content. Real data are collected from naturally occurring or deployed environments, such as human working with AIs. Their environments, tasks, or behaviors originate from actual use rather than being created specifically by the generation pipeline. Synthetic data are constructed by models, programs, simulators, or controlled transformations to instantiate new environments, tasks, interactions, or supervision signals. They provide different kinds of evidence, and neither is uniformly better under ACE. For Accuracy, real data offer direct evidence of authentic interfaces, behavior, and user needs, but they are not automatically correct. Logs can contain failed or inefficient behavior, hidden context, stale interfaces, privacy-sensitive content, and outcomes that cannot be reconstructed or verified. Synthetic generation can attach explicit states, constraints, and verifiers and can regenerate failed cases, but its correctness is limited by the fidelity of the generator and environment. Model-generated tasks may be plausible yet infeasible, or overly machine-like. Real sources are therefore strongest for grounding and external auditing; synthetic sources are strongest when controlled execution and explicit supervision are required [Liu et al., 2024, Trivedi et al., 2024, Xu et al., 2026a, Chae et al., 2026]. For Complexity, real workflows naturally contain coupled constraints, long-tail states, delayed effects, and organizational rules, but their difficulty is difficult to control and may fall outside a learner’s useful range. Synthetic pipelines can vary dependencies, information access, horizon, and assistance to target a model- relative frontier, although nominally longer or more elaborate samples may still be artificial or irrelevant. For Diversity, real ecosystems expose authentic variation across users, tools, repositories, and temporal conditions, yet observed data are often highly skewed toward frequent workflows. Synthetic generation can deliberately fill missing combinations and counterfactual cases at scale, but shared prompts, teachers, and templates can create data with narrow behavioral support [Liu et al., 2025, Guo et al., 2025, Chen et al., 2026a,b]. These tradeoffs favor hybrid allocation rather than a fixed real-to-synthetic ratio. Real data can define deployment-relevant factors, seed environment semantics, and provide held-out audits; synthetic data can expand, balance, and calibrate the support around those anchors. The appropriate mixture depends on which ACE deficiency is limiting: additional real evidence is valuable when fidelity is uncertain, whereas controlled synthesis is valuable when verified coverage or model-aware difficulty is missing. 30 7.3 Data Generation for Agentic Pre-training and Mid-training Most agentic data generation currently serves post-training: SFT teaches an interaction format and RL optimizes behavior from environment feedback. This places a large burden on a relatively late and data- limited stage, because a general foundation model must acquire basic interaction priors while also learning how to solve particular tasks. Agentic pre-training and mid-training instead expose models earlier to state transitions, action–observation dependencies, tool composition, persistent policies, and long-horizon informa- tion seeking [Zeng et al., 2026a, Lu et al., 2025c, Tongyi DeepResearch Team, 2025, Zuo et al., 2026]. The goal is not to replace post-training, but to provide reusable concepts on which later alignment and policy optimization can build. This shift changes both scale and data form. Complete expert rollouts in real environments are too expensive to supply pre-training-scale corpora, motivating executable or learned environments and the conversion of repositories, videos, documents, and relational structures into interaction-relevant supervision [Chen et al., 2026c, Lu et al., 2025a, Xiong et al., 2026, Zhou et al., 2026a]. Moreover, a training unit need not be a complete (E,q,τ,v) record anymore. Local state transitions, inverse-dynamics examples, dependency completions, reachability objectives, and distilled policy or causal knowledge can teach components from which agentic behavior is later composed [Liu et al., 2026, Lei et al., 2026, Wang et al., 2026b, Wu et al., 2026a]. ACE consequently changes emphasis. Accuracy remains a floor, but often concerns local transition correctness, source fidelity, and distribution-level noise rather than verified task completion. Complexity concerns the information and dependency burden of fragments, not only end-to-end task difficulty. Once scalable quality control is available, diversity becomes especially important because pre-/mid-training should establish broad priors before downstream tasks are known. Promising directions include using post-training feedback to select or weight earlier-stage data, combining strongly verified anchors with much larger weakly supervised corpora, and determining which interaction knowledge should be internalized rather than kept explicit and updateable. 7.4 Data Generation for Self-Evolving Agents Self-evolving agents change data generation from an offline preparation step into part of a continual learning loop. Instead of constructing a fixed dataset before training, the system observes the agent’s behavior, identifies capability gaps, generates or discovers relevant experience, and uses verified outcomes to guide the next update. Recent systems instantiate parts of this loop by generating tasks from model failures or curiosity, coevolving environments and world models, and extracting reusable skills from accumulated traces [Zhai et al., 2025, Fang et al., 2025, Fu et al., 2026, Xiao et al., 2026]. Data generation therefore becomes a mechanism for deciding what the agent should experience next, rather than merely producing more samples. Its role also expands beyond synthesizing complete tasks and successful trajectories. A self-evolving pipeline may create targeted tasks around a failure, modify their difficulty, explore an environment for new reachable states, repair an invalid rollout, extract a skill from a successful one, or replay earlier experience to preserve existing capabilities. Model-aware generators already use rollout success to move tasks toward the learner’s current frontier [Guo et al., 2025, Chen et al., 2025d], while self-evolving systems improve sample use through experience reuse, attribution, and trace-derived skill discovery [Zhai et al., 2025, Xiao et al., 2026]. The central problem consequently shifts from generating each sample independently to selecting, transforming, and allocating experience according to its expected value for the current agent. ACE becomes dynamic in this setting. Accuracy prevents erroneous feedback from being repeatedly reinforced; Complexity determines whether new experience should be made harder, simplified, or supported as the capability frontier moves; and Diversity prevents the loop from concentrating only on recent failures or verifier-friendly strategies. These objectives cannot be estimated solely from the evolving agent, because a generator, learner, and verifier that adapt together may confirm the same mistaken assumptions. Stable self-evolution therefore requires fixed or independently updated anchors, such as held-out tasks, external execution, or periodic evaluation in real environments. The open challenge is not simply autonomous data generation, but a feedback loop that continues to expand capability without amplifying errors, narrowing coverage, or forgetting previously learned behavior. 31 8 Conclusion Agentic data generation is the joint construction of an actionable environment, a grounded task, an interaction process, and, when needed, a trustworthy success signal. This paper combines a factorized account of how these components are generated with the ACE account of how the resulting distribution should be shaped. The former connects forward, task-first, trajectory-first, and structure-first pipelines; the latter explains why producing plausible individual samples is insufficient for building useful agent data. The literature supports an asymmetric interpretation of ACE. Accuracy establishes the feasible set through consistency among environments, tasks, interactions, and verifiers. Complexity should then be calibrated relative to the learner and execution configuration rather than maximized through superficial length or struc- ture, while Diversity should measure valid behavioral coverage rather than sample count or surface variation. Together, these dimensions suggest evaluating generation pipelines by the reliable and non-redundant learning value they add, while making verification coverage, model dependence, and generation costs explicit. The field is now moving from fixed post-training trajectories toward generated environments, broader pre- and mid-training supervision, and feedback-driven experience that evolves with the agent. In this setting, data generation becomes less a one-time production step and more a continual process of discovering capability gaps, constructing and verifying relevant experience, and allocating it as the learner changes. The central challenge is therefore not autonomous generation alone, but maintaining a grounded learning loop that expands capability without amplifying errors, narrowing coverage, or losing contact with real environments. References Emre Can Acikgoz, Cheng Qian, Jonas Hübotter, Heng Ji, Dilek Hakkani-Tür, and Gokhan Tur. Tool-R0: Self- Evolving LLM Agents for Tool-Learning from Zero Data, 2026. URL https://arxiv.org/abs/2602.21320. Arman Aghaee, Sepehr Asgarian, and Jouhyun Jeon. SynthAgent: A Multi-Agent LLM Framework for Realistic Patient Simulation – A Case Study in Obesity with Mental Health Comorbidities, 2026. URL https://arxiv.org/ abs/2602.08254. Wasi Uddin Ahmad, Nikolai Ludwig, Somshubra Majumdar, and Boris Ginsburg. Open-SWE-Traces: Advancing Dual- Mode Multilingual Distillation for Software Engineering Agents, 2026. URL https://arxiv.org/abs/2606.16038. Ibragim Badertdinov, Alexander Golubev, Maksim Nekrashevich, Anton Shevtsov, Simon Karasik, Andrei An- driushchenko, Maria Trofimova, Daria Litvintseva, and Boris Yangel. Swe-rebench: An automated pipeline for task collection and decontaminated evaluation of software engineering agents. In Danielle Belgrave, Cheng Zhang, Laura N. Montoya, Hsuan-Tien Lin, Razvan Pascanu, Piotr Koniusz, Marzyeh Ghassemi, Nancy Chen, Iván Vladimir Meza Ruíz, and Arturo Loaiza-Bonilla, editors, Advances in Neural Information Processing Systems 38: Annual Conference on Neural Information Processing Systems 2025, NeurIPS 2025, San Diego, CA, USA, Decem- ber 2-7, 2025 / Mexico City, Mexico, November 30 - December 5, 2025, 2025. URL http://papers.nips.c/paper_ files/paper/2025/hash/21bec6ace947b1b58967b945c8ac0f10-Abstract-Datasets_and_Benchmarks_Track.html. Ibragim Badertdinov, Maksim Nekrashevich, Anton Shevtsov, and Alexander Golubev. SWE-rebench V2: Language- Agnostic SWE Task Collection at Scale, 2026. URL https://arxiv.org/abs/2602.23866. Victor Barres, Honghua Dong, Soham Ray, Xujie Si, and Karthik Narasimhan. τ 2 -Bench: Evaluating Conversational Agents in a Dual-Control Environment, 2025. URL https://arxiv.org/abs/2506.07982. Shihao Cai, Runnan Fang, Jialong Wu, Baixuan Li, Xinyu Wang, Yong Jiang, Liangcai Su, Liwen Zhang, Wenbiao Yin, Zhen Zhang, Fuli Feng, Pengjun Xie, and Xiaobin Wang. AutoForge: Automated Environment Synthesis for Agentic Reinforcement Learning, 2025. URL https://arxiv.org/abs/2512.22857. Tommaso Castellani, Naimeng Ye, Daksh Mittal, Thomson Yen, Emmanouil Koukoumidis, William Zeng, and Hongseok Namkoong. Synthtools: A framework for scaling synthetic tools for agent development, 2025. URL https://arxiv.org/abs/2511.09572. Hyungjoo Chae, Jungsoo Park, and Alan Ritter. Safe and Scalable Web Agent Learning via Recreated Websites, 2026. URL https://arxiv.org/abs/2603.10505. 32 Aili Chen, Chi Zhang, Junteng Liu, Jiangjie Chen, Chengyu Du, Yunji Li, Ming Zhong, Qin Wang, Zhengmao Zhu, Jiayuan Song, Ke Ji, Junxian He, Pengyu Zhao, and Yanghua Xiao. DIVE: Scaling Diversity in Agentic Task Synthesis for Generalizable Tool Use, 2026a. URL https://arxiv.org/abs/2603.11076. Chen Chen, Xinlong Hao, Weiwen Liu, Xu Huang, Xingshan Zeng, Shuai Yu, Dexun Li, Yuefeng Huang, Xiangcheng Liu, Wang Xinzhi, and Wu Liu. ACEBench: A comprehensive evaluation of LLM tool usage. In Christos Christodoulopoulos, Tanmoy Chakraborty, Carolyn Rose, and Violet Peng, editors, Findings of the Association for Computational Linguistics: EMNLP 2025, pages 12970–12998, Suzhou, China, November 2025a. Associa- tion for Computational Linguistics. ISBN 979-8-89176-335-7. doi: 10.18653/v1/2025.findings-emnlp.697. URL https://aclanthology.org/2025.findings-emnlp.697/. Guhong Chen, Chenghao Sun, Cheng Fu, Qiyao Wang, Zhihong Huang, ChaoPeng Wei, Guangxu Chen, Feiteng Fang, Ahmadreza Argha, Bing Zhao, Xander Xu, Qi Han, Hamid Alinejad-Rokny, Qiang Qu, Binhua Li, Shiwen Ni, Min Yang, HU Wei, and Yongbin Li. Beyond quantity: Trajectory diversity scaling for code agents. In Maria Liakata, Viviane P. Moreira, Jiajun Zhang, and David Jurgens, editors, Findings of the Association for Computational Linguistics: ACL 2026, pages 15676–15691, San Diego, California, United States, 2026b. Association for Computational Linguistics. ISBN 979-8-89176-395-1. doi: 10.18653/v1/2026.findings-acl.768. URL https: //aclanthology.org/2026.findings-acl.768/. Mingyang Chen, Haoze Sun, Tianpeng Li, Fan Yang, Hao Liang, Keer Lu, Bin Cui, Wentao Zhang, Zenan Zhou, and Weipeng Chen. Facilitating multi-turn function calling for llms via compositional instruction tuning. In The Thirteenth International Conference on Learning Representations, ICLR 2025, Singapore, April 24-28, 2025. OpenReview.net, 2025b. URL https://openreview.net/forum?id=owP2mymrTD. Mouxiang Chen, Lei Zhang, Yunlong Feng, Xuwu Wang, Wenting Zhao, Ruisheng Cao, Jiaxi Yang, Jiawei Chen, Mingze Li, Zeyao Ma, Hao Ge, Zongmeng Zhang, Zeyu Cui, Dayiheng Liu, Jingren Zhou, Jianling Sun, Junyang Lin, and Binyuan Hui. SWE-Universe: Scale Real-World Verifiable Environments to Millions, 2026c. URL https: //arxiv.org/abs/2602.02361. Tianxing Chen, Zanxin Chen, Baijun Chen, Zijian Cai, Yibin Liu, Zixuan Li, Qiwei Liang, Xianliang Lin, Yiheng Ge, Zhenyu Gu, Weiliang Deng, Yubin Guo, Tian Nian, Xuanbing Xie, Qiangyu Chen, Kailun Su, Tianling Xu, Guodong Liu, Mengkang Hu, Huan ang Gao, Kaixuan Wang, Zhixuan Liang, Yusen Qin, Xiaokang Yang, Ping Luo, and Yao Mu. RoboTwin 2.0: A Scalable Data Generator and Benchmark with Strong Domain Randomization for Robust Bimanual Robotic Manipulation, 2025c. URL https://arxiv.org/abs/2506.18088. Xuanzhong Chen, Zile Qiao, Guoxin Chen, Liangcai Su, Zhen Zhang, Xinyu Wang, Pengjun Xie, Fei Huang, Jingren Zhou, and Yong Jiang. AgentFrontier: Expanding the Capability Frontier of LLM Agents with ZPD-Guided Data Synthesis, 2025d. URL https://arxiv.org/abs/2510.24695. Yurun Chen, Xavier Hu, Yuhan Liu, Ziqi Wang, Zeyi Liao, Lin Chen, Feng Wei, Yuxi Qian, Bo Zheng, Keting Yin, and Shengyu Zhang. Graph2Eval: Automatic Multimodal Task Generation for Agents via Knowledge Graphs, 2025e. URL https://arxiv.org/abs/2510.00507. Zehui Chen, Kuikun Liu, Qiuchen Wang, Wenwei Zhang, Jiangning Liu, Dahua Lin, Kai Chen, and Feng Zhao. Agent-FLAN: Designing data and methods of effective agent tuning for large language models. In Lun-Wei Ku, Andre Martins, and Vivek Srikumar, editors, Findings of the Association for Computational Linguistics: ACL 2024, pages 9354–9366, Bangkok, Thailand, 2024. Association for Computational Linguistics. doi: 10.18653/v1/ 2024.findings-acl.557. URL https://aclanthology.org/2024.findings-acl.557/. Kanzhi Cheng, Zehao Li, Zheng Ma, Nuo Chen, Jialin Cao, Qiushi Sun, Zichen Ding, Fangzhi Xu, Hang Yan, Jiajun Chen, Anh Tuan Luu, Jianbing Zhang, Lewei Lu, and Dahua Lin. OpenMobile: Building Open Mobile Agents with Task and Trajectory Synthesis, 2026. URL https://arxiv.org/abs/2604.15093. Maxwell Crouse, Ibrahim Abdelaziz, Kshitij Fadnis, Siva Sankalp Patel, Kinjal Basu, Chulaka Gunasekara, Sadhana Kumaravel, Asim Munawar, and Pavan Kapanipathi. Simulating Complex Multi-Turn Tool Calling Interactions in Stateless Execution Environments, 2026. URL https://arxiv.org/abs/2601.19914. Matt Deitke, Winson Han, Alvaro Herrasti, Aniruddha Kembhavi, Eric Kolve, Roozbeh Mottaghi, Jordi Salvador, Eli VanderBilt, and Luca Weihs. ProcTHOR: Large-Scale Embodied AI Using Procedural Generation. In Advances in Neural Information Processing Systems, volume 35, 2022. URL https://proceedings.neurips.c/paper_files/ paper/2022/hash/27c546ab1e4f1d7d638e6a8dfbad9a07-Abstract-Conference.html. Guanting Dong, Junting Lu, Junjie Huang, Wanjun Zhong, Longxiang Liu, Shijue Huang, Zhenyu Li, Yang Zhao, Xiaoshuai Song, Xiaoxi Li, Jiajie Jin, Yutao Zhu, Hanbin Wang, Fangyu Lei, Qinyu Luo, Mingyang Chen, Zehui 33 Chen, Jiazhan Feng, Ji-Rong Wen, and Zhicheng Dou. Agent-World: Scaling Real-World Environment Synthesis for Evolving General Agent Intelligence, 2026. URL https://arxiv.org/abs/2604.18292. Weihua Du, Hailei Gong, Zhan Ling, Kang Liu, Lingfeng Shen, Xuesong Yao, Yufei Xu, Dingyuan Shi, Yiming Yang, and Jiecao Chen. Generalizable End-to-End Tool-Use RL with Synthetic CodeGym. In The Fourteenth International Conference on Learning Representations, 2026. doi: 10.48550/arXiv.2509.17325. URL https://proceedings.iclr. c/paper_files/paper/2026/hash/1e4322fddd833f83c855660ac65e428d-Abstract-Conference.html. Yaxin Du, Yuzhu Cai, Yifan Zhou, Cheng Wang, Yu Qian, Xianghe Pang, Qian Liu, Yue Hu, and Siheng Chen. SWE- Dev: Evaluating and Training Autonomous Feature-Driven Software Development, 2025. URL https://arxiv.org/ abs/2505.16975. Lutfi Eren Erdogan, Nicholas Lee, Sehoon Kim, Suhong Moon, Hiroki Furuta, Gopala Anumanchipalli, Kurt Keutzer, and Amir Gholami. Plan-and-act: Improving planning of agents for long-horizon tasks. In Aarti Singh, Maryam Fazel, Daniel Hsu, Simon Lacoste-Julien, Felix Berkenkamp, Tegan Maharaj, Kiri Wagstaff, and Jerry Zhu, editors, Forty-second International Conference on Machine Learning, ICML 2025, Vancouver, BC, Canada, July 13-19, 2025, volume 267 of Proceedings of Machine Learning Research. PMLR / OpenReview.net, 2025. URL https: //proceedings.mlr.press/v267/erdogan25a.html. Zhiyuan Fan, Tinghao Yu, Yuanjun Cai, Jiangtao Guan, Yun Yang, Dingxin Hu, Jiang Zhou, Xing Wu, Zhuo Han, Feng Zhang, and Lilin Wang. Toward Scalable Terminal Task Synthesis via Skill Graphs, 2026. URL https://arxiv.org/abs/2604.25727. Tianqing Fang, Hongming Zhang, Zhisong Zhang, Kaixin Ma, Wenhao Yu, Haitao Mi, and Dong Yu. WebEvolver: Enhancing web agent self-improvement with co-evolving world model. In Christos Christodoulopoulos, Tanmoy Chakraborty, Carolyn Rose, and Violet Peng, editors, Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing, pages 8959–8975, Suzhou, China, 2025. Association for Computational Linguis- tics. ISBN 979-8-89176-332-6. doi: 10.18653/v1/2025.emnlp-main.454. URL https://aclanthology.org/2025. emnlp-main.454/. Jiazhan Feng, Shijue Huang, Xingwei Qu, Ge Zhang, Yujia Qin, Baoquan Zhong, Chengquan Jiang, Jinxin Chi, and Wanjun Zhong. ReTool: Reinforcement Learning for Strategic Tool Use in LLMs. In The Fourteenth International Conference on Learning Representations, 2026. doi: 10.48550/arXiv.2504.11536. URL https://proceedings.iclr. c/paper_files/paper/2026/hash/4038c9208dfc22644c60ad39c24e5c53-Abstract-Conference.html. Carlos Florensa, David Held, Xinyang Geng, and Pieter Abbeel. Automatic goal generation for reinforcement learning agents. In Jennifer G. Dy and Andreas Krause, editors, Proceedings of the 35th International Conference on Ma- chine Learning, ICML 2018, Stockholmsmässan, Stockholm, Sweden, July 10-15, 2018, volume 80 of Proceedings of Machine Learning Research, pages 1514–1523. PMLR, 2018. URL http://proceedings.mlr.press/v80/florensa18a. html. Dan Friedman and Adji Bousso Dieng. The vendi score: A diversity evaluation metric for machine learning. Trans. Mach. Learn. Res., 2023, 2023. URL https://openreview.net/forum?id=g97OHbQyk1. Zenghuang Fu, Zhaoyang Li, Qiuyuan Ai, Haoyu Wu, Minghui Wu, Chenxu Zhao, Ante Wang, Guannan He, and Changwei Wang. Self-Play Meets Skill Evolution: Self-Evolving Search Agents that Pose, Solve, and Remember, 2026. URL https://arxiv.org/abs/2607.29468. Jiaxuan Gao, Jiaao Chen, Chuyi He, Wei-Chen Wang, Shusheng Xu, Hanrui Wang, Di Jin, and Yi Wu. From Self- Evolving Synthetic Data to Verifiable-Reward RL: Post-Training Multi-turn Interactive Tool-Using Agents, 2026. URL https://arxiv.org/abs/2601.22607. Chris Ge, Daria Kryvosheieva, Daniel Fried, Uzay Girit, and Kaivalya Hariharan. Agent Psychometrics: Task-Level Performance Prediction in Agentic Coding Benchmarks, 2026. URL https://arxiv.org/abs/2604.00594. Zhibin Gou, Zhihong Shao, Yeyun Gong, Yelong Shen, Yujiu Yang, Minlie Huang, Nan Duan, and Weizhu Chen. Tora: A tool-integrated reasoning agent for mathematical problem solving. In The Twelfth International Conference on Learning Representations, ICLR 2024, Vienna, Austria, May 7-11, 2024. OpenReview.net, 2024. URL https: //openreview.net/forum?id=Ep0TtjVoap. Hengrui Gu, Xiaotian Han, and Kaixiong Zhou. WRIT: Write-Read Intensive Trajectory Synthesis for Multi-Turn User-Facing Agents, 2026. URL https://arxiv.org/abs/2606.02908. 34 Jiacheng Guo, Ling Yang, Peter Chen, Qixin Xiao, Yinjie Wang, Xinzhe Juan, Jiahao Qiu, Ke Shen, and Mengdi Wang. GenEnv: Difficulty-Aligned Co-Evolution Between LLM Agents and Environment Simulators, 2025. URL https://arxiv.org/abs/2512.19682. Yunze Han. A Systematic Evaluation of Trajectory Data Curation for LoRA Fine-Tuning of Code Agents, 2026. URL https://arxiv.org/abs/2607.17205. Bingguang Hao, Zengzhuang Xu, Yuntao Wen, Xinyi Xu, Yang Liu, Tong Zhao, Maolin Wang, Long Chen, Dong Wang, Yicheng Chen, Cunyin Peng, Xiangyu Zhao, Chenyi Zhuang, and Ji Zhang. From Failure to Mastery: Generating Hard Samples for Tool-use Agents, 2026. URL https://arxiv.org/abs/2601.01498. Xinyi He, Ying Yang, Chuanjian Fu, Sihan Guo, Songchun Zhu, Lifeng Fan, Zhenliang Zhang, and Yujia Peng. Automatic Cognitive Task Generation for In-Situ Evaluation of Embodied Agents, 2026. URL https://arxiv.org/ abs/2602.05249. Yifei He, Pranit Chawla, Yaser Souri, Subhojit Som, and Xia Song. Scalable Data Synthesis for Computer Use Agents with Step-Level Filtering, 2025. URL https://arxiv.org/abs/2512.10962. Mengkang Hu, Pu Zhao, Can Xu, Qingfeng Sun, Jian-Guang Lou, Qingwei Lin, Ping Luo, and Saravan Rajmohan. Agentgen: Enhancing planning abilities for large language model based agent via environment and task generation. In Yizhou Sun, Flavio Chierichetti, Hady W. Lauw, Claudia Perlich, Wee Hyong Tok, and Andrew Tomkins, editors, Proceedings of the 31st ACM SIGKDD Conference on Knowledge Discovery and Data Mining, V.1, KDD 2025, Toronto, ON, Canada, August 3-7, 2025, pages 496–507. ACM, 2025. doi: 10.1145/3690624.3709321. URL https://doi.org/10.1145/3690624.3709321. Shijue Huang, Hangyu Guo, Chenxin Li, Junting Lu, Xinyu Geng, Zhaochen Su, Zhenyu Li, Shuang Chen, Hongru Wang, and Yi R. Fung. Towards On-Policy Data Evolution for Visual-Native Multimodal Deep Search Agents, 2026. URL https://arxiv.org/abs/2605.10832. Maksim Ivanov and Abhijay Rana. Anchor: Mitigating Artifact Drift in Agent Benchmark Generation, 2026. URL https://arxiv.org/abs/2605.26321. Naman Jain, Jaskirat Singh, Manish Shetty, Liang Zheng, Koushik Sen, and Ion Stoica. R2e-gym: Procedural environments and hybrid verifiers for scaling open-weights swe agents. In Conference on Language Modeling, 2025. URL https://github.com/R2E-Gym/R2E-Gym. Zhengbo Jiao, Shaobo Wang, Zifan Zhang, Xuan Ren, Wei Wang, Bing Zhao, Hu Wei, and Linfeng Zhang. Agentic Proposing: Enhancing Large Language Model Reasoning via Compositional Skill Synthesis, 2026. URL https: //arxiv.org/abs/2602.03279. Bowen Jin, Hansi Zeng, Zhenrui Yue, Dong Wang, Hamed Zamani, and Jiawei Han. Search-R1: Training LLMs to Reason and Leverage Search Engines with Reinforcement Learning, 2025. URL https://arxiv.org/abs/2503.09516. Zhenchao Jin, Mengchen Liu, Dongdong Chen, Lingting Zhu, Yunsheng Li, and Lequan Yu. Toolbridge: An open- source dataset to equip llms with external tool capabilities, 2024. URL https://arxiv.org/abs/2410.10872. Linjia Kang, Zhimin Wang, Yongkang Zhang, Duo Wu, Jinghe Wang, Ming Ma, Haopeng Yan, and Zhi Wang. Learning with Challenges: Adaptive Difficulty-Aware Data Generation for Mobile GUI Agent Training, 2026. URL https://arxiv.org/abs/2601.22781. Dinesh Khandelwal, Gnana Prakash Punnavajhala, GPS Bhargav, Gaurav Pandey, Sachin Joshi, Hima Karanam, and Dinesh Raghu. ToolWeave: Structured Synthesis of Complex Multi-Turn Tool-Calling Dialogues, 2026. URL https://arxiv.org/abs/2605.12521. Seanie Lee, Sanjoy Chowdhury, Chao Jiang, Cheng-Yu Hsieh, Ting-Yao Hu, Alexander Toshev, Oncel Tuzel, and Raviteja Vemulapalli. Environment-free Synthetic Data Generation for API-Calling Agents, 2026. URL https: //arxiv.org/abs/2607.16900. Xuanyu Lei, Yiqi Zhu, Chenliang Li, Kaiming Liu, Peng Li, Ming Yan, Jieping Ye, Ya-Qin Zhang, and Yang Liu. State2State: Environment-Derived Mid-Training for LLM Agents, 2026. URL https://arxiv.org/abs/2608.04934. Joel Z. Leibo, Edgar A. Duéñez-Guzmán, Alexander Vezhnevets, John P. Agapiou, Peter Sunehag, Raphael Koster, Jayd Matyas, Charlie Beattie, Igor Mordatch, and Thore Graepel. Scalable evaluation of multi-agent reinforcement learning with melting pot. In Marina Meila and Tong Zhang, editors, Proceedings of the 38th International Con- ference on Machine Learning, ICML 2021, 18-24 July 2021, Virtual Event, volume 139 of Proceedings of Machine Learning Research, pages 6187–6199. PMLR, 2021. URL http://proceedings.mlr.press/v139/leibo21a.html. 35 Jiachun Li, Zhuoran Jin, Tianyi Men, Yupu Hao, Kejian Zhu, Lingshuai Wang, Dongqi Huang, Longxiang Wang, Shengjia Hua, Lu Wang, Jinshan Gao, Hongbang Yuan, Ruilin Xu, Kang Liu, and Jun Zhao. Agentic Environ- ment Engineering for Large Language Models: A Survey of Environment Modeling, Synthesis, Evaluation, and Application, 2026a. URL https://arxiv.org/abs/2606.12191. Kuan Li, Zhongwang Zhang, Huifeng Yin, Rui Ye, Yida Zhao, Liwen Zhang, Litu Ou, Dingchu Zhang, Xixi Wu, Jialong Wu, Xinyu Wang, Zile Qiao, Zhen Zhang, Yong Jiang, Pengjun Xie, Fei Huang, and Jingren Zhou. WebSailor-V2: Bridging the Chasm to Proprietary Agents via Synthetic Data and Scalable Reinforcement Learning, 2025a. URL https://arxiv.org/abs/2509.13305. Weizhen Li, Jianbo Lin, Zhuosong Jiang, Jingyi Cao, Xinpeng Liu, Jiayu Zhang, Zhenqiang Huang, Qianben Chen, Weichen Sun, Qiexiang Wang, Hongxuan Lu, Tianrui Qin, Chenghao Zhu, Yi Yao, Shuying Fan, Xiaowan Li, Tiannan Wang, Pai Liu, King Zhu, He Zhu, Dingfeng Shi, Piaohong Wang, Yeyi Guan, Xiangru Tang, Minghao Liu, Yuchen Eleanor Jiang, Jian Yang, Jiaheng Liu, Ge Zhang, and Wangchunshu Zhou. Chain-of-Agents: End-to- End Agent Foundation Models via Multi-Agent Distillation and Agentic RL, 2025b. URL https://arxiv.org/abs/ 2508.13167. Xuefeng Li, Haoyang Zou, and Pengfei Liu. ToRL: Scaling Tool-Integrated RL, 2025c. URL https://arxiv.org/abs/ 2503.23383. Yifei Li, Hanane Nour Moussa, Ziru Chen, Shijie Chen, Botao Yu, Mingyi Xue, Benjamin Burns, Tzu-Yao Chiu, Vishal Dey, Zitong Lu, Chen Wei, Qianheng Zhang, Tianyu Zhang, Song Gao, Xuhui Huang, Xia Ning, Nesreen K. Ahmed, Ali Payani, and Huan Sun. AutoSDT: Scaling data-driven discovery tasks toward open co-scientists. In Christos Christodoulopoulos, Tanmoy Chakraborty, Carolyn Rose, and Violet Peng, editors, Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing, pages 30396–30418, Suzhou, China, 2025d. Association for Computational Linguistics. ISBN 979-8-89176-332-6. doi: 10.18653/v1/2025.emnlp-main.1546. URL https://aclanthology.org/2025.emnlp-main.1546/. Yuanyang Li, Xue Yang, Longyue Wang, Weihua Luo, and Hongyang Chen. ComplexMCP: Evaluation of LLM Agents in Dynamic, Interdependent, and Large-Scale Tool Sandbox, 2026b. URL https://arxiv.org/abs/2605.10787. Yuetai Li, Huseyin A. Inan, Xiang Yue, Wei-Ning Chen, Lukas Wutschitz, Janardhan Kulkarni, Radha Poovendran, Robert Sim, and Saravan Rajmohan. Simulating Environments with Reasoning Models for Agent Training, 2025e. URL https://arxiv.org/abs/2511.01824. Yuwen Li, Wei Zhang, Zelong Huang, Mason Yang, Jiajun Wu, Shawn Guo, Huahao Hu, Lingyi Sun, Jian Yang, Mingjie Tang, and Byran Dai. Close the Loop: Synthesizing Infinite Tool-Use Data via Multi-Agent Role-Playing, 2025f. URL https://arxiv.org/abs/2512.23611. Zhongzhi Li, Yucheng Shi, Zongxia Li, Ruhan Wang, Anhao Li, Zixun Huang, Junyao Yang, Lei Ke, Ninghao Liu, Haitao Mi, and Leowei Liang. Recursive Synthesis for Long-Horizon Terminal Tasks, 2026c. URL https://arxiv. org/abs/2608.05466. Minpeng Liao, Chengxi Li, Wei Luo, Wu Jing, and Kai Fan. MARIO: MAth reasoning with code interpreter output - a reproducible pipeline. In Lun-Wei Ku, Andre Martins, and Vivek Srikumar, editors, Findings of the Association for Computational Linguistics: ACL 2024, pages 905–924, Bangkok, Thailand, August 2024. Association for Computa- tional Linguistics. doi: 10.18653/v1/2024.findings-acl.53. URL https://aclanthology.org/2024.findings-acl.53/. Weiwen Liu, Xu Huang, Xingshan Zeng, Xinlong Hao, Shuai Yu, Dexun Li, Shuai Wang, Weinan Gan, Zhengying Liu, Yuanqing Yu, Zezhong Wang, Yuxian Wang, Wu Ning, Yutai Hou, Bin Wang, Chuhan Wu, Xinzhi Wang, Yong Liu, Yasheng Wang, Duyu Tang, Dandan Tu, Lifeng Shang, Xin Jiang, Ruiming Tang, Defu Lian, Qun Liu, and Enhong Chen. Toolace: Winning the points of LLM function calling. In The Thirteenth International Conference on Learning Representations, ICLR 2025, Singapore, April 24-28, 2025. OpenReview.net, 2025. URL https://openreview.net/forum?id=8EB8k6DdCU. Xiangyan Liu, Kaixin Li, Haonan Wang, Biao Wu, Meng Fang, Longxu Dou, Chao Du, Michael Qizhe Shieh, and Tianyu Pang. Scaling GUI Agents with Visual State Transitions, 2026. URL https://arxiv.org/abs/2607.24112. Zuxin Liu, Thai Hoang, Jianguo Zhang, Ming Zhu, Tian Lan, Shirley Kokane, Juntao Tan, Weiran Yao, Zhi- wei Liu, Yihao Feng, Rithesh R. N., Liangwei Yang, Silvio Savarese, Juan Carlos Niebles, Huan Wang, Shelby Heinecke, and Caiming Xiong. Apigen: Automated pipeline for generating verifiable and diverse function-calling datasets. In Amir Globersons, Lester Mackey, Danielle Belgrave, Angela Fan, Ulrich Pa- quet, Jakub M. Tomczak, and Cheng Zhang, editors, Advances in Neural Information Processing Sys- tems 37: Annual Conference on Neural Information Processing Systems 2024, NeurIPS 2024, Vancouver, 36 BC, Canada, December 10 - 15, 2024, 2024. URL http://papers.nips.c/paper_files/paper/2024/hash/ 61cce86d180b1184949e58939c4f983d-Abstract-Datasets_and_Benchmarks_Track.html. Dunjie Lu, Yiheng Xu, Junli Wang, Haoyuan Wu, Xinyuan Wang, Zekun Wang, Junlin Yang, Hongjin Su, Jixuan Chen, Junda Chen, Yuchen Mao, Jingren Zhou, Junyang Lin, Binyuan Hui, and Tao Yu. VideoAgentTrek: Computer Use Pretraining from Unlabeled Videos, 2025a. URL https://arxiv.org/abs/2510.19488. Jiarui Lu, Thomas Holleis, Yizhe Zhang, Bernhard Aumayer, Feng Nan, Haoping Bai, Shuang Ma, Shen Ma, Mengyu Li, Guoli Yin, Zirui Wang, and Ruoming Pang. ToolSandbox: A stateful, conversational, interactive evaluation benchmark for LLM tool use capabilities. In Luis Chiruzzo, Alan Ritter, and Lu Wang, editors, Findings of the Association for Computational Linguistics: NAACL 2025, pages 1160–1183, Albuquerque, New Mexico, 2025b. Association for Computational Linguistics. ISBN 979-8-89176-195-7. doi: 10.18653/v1/2025.findings-naacl.65. URL https://aclanthology.org/2025.findings-naacl.65/. Junru Lu, Jiarui Qin, Lingfeng Qiao, Yinghui Li, Xinyi Dai, Bo Ke, Jianfeng He, Ruizhi Qiao, Di Yin, Xing Sun, Yunsheng Wu, Yinsong Liu, Shuangyin Liu, Mingkong Tang, Haodong Lin, Jiayi Kuang, Fanxu Meng, Xiaojuan Tang, Yunjia Xi, Junjie Huang, Haotong Yang, Zhenyi Shen, Yangning Li, Qianwen Zhang, Yifei Yu, Siyu An, Junnan Dong, Qiufeng Wang, Jie Wang, Keyu Chen, Wei Wen, Taian Guo, Zhifeng Shen, Daohai Yu, Jiahao Li, Ke Li, Zongyi Li, and Xiaoyu Tan. Youtu-LLM: Unlocking the Native Agentic Potential for Lightweight Large Language Models, 2025c. URL https://arxiv.org/abs/2512.24618. Haipeng Luo, Huawen Feng, Qingfeng Sun, Can Xu, Kai Zheng, Yufei Wang, Tao Yang, Han Hu, Yansong Tang, and Di Wang. AgentMath: Empowering Mathematical Reasoning for Large Language Models via Tool-Augmented Agent, 2025. URL https://arxiv.org/abs/2512.20745. Song-Lin Lv, Weiming Wu, Rui Zhu, Zi-Jian Cheng, and Lan-Zhe Guo. Can Agents Generalize to the Open World? Unveiling the Fragility of Static Training in Tool Use, 2026. URL https://arxiv.org/abs/2607.01084. Yuanjie Lyu, Chengyu Wang, Lei Shen, Jun Huang, and Tong Xu. Mock worlds, real skills: Building small agentic lan- guage models with synthetic tasks, simulated environments, and rubric-based rewards. In Maria Liakata, Viviane P. Moreira, Jiajun Zhang, and David Jurgens, editors, Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 12529–12545, San Diego, California, United States, 2026. Association for Computational Linguistics. ISBN 979-8-89176-390-6. doi: 10.18653/v1/2026.acl-long.570. URL https://aclanthology.org/2026.acl-long.570/. Zhiyuan Ma, Jiayu Liu, Xianzhen Luo, Zhenya Huang, Qingfu Zhu, and Wanxiang Che. Advancing tool-augmented large language models via meta-verification and reflection learning. In Luiza Antonie, Jian Pei, Xiaohui Yu, Flavio Chierichetti, Hady W. Lauw, Yizhou Sun, and Srinivasan Parthasarathy, editors, Proceedings of the 31st ACM SIGKDD Conference on Knowledge Discovery and Data Mining, V.2, KDD 2025, Toronto ON, Canada, August 3-7, 2025, pages 2078–2089. ACM, 2025. doi: 10.1145/3711896.3736835. URL https://doi.org/10.1145/3711896. 3736835. Bhairav Mehta, Manfred Diaz, Florian Golemo, Christopher J. Pal, and Liam Paull. Active Domain Randomization. In Proceedings of the Conference on Robot Learning, volume 100 of Proceedings of Machine Learning Research, pages 1162–1176. PMLR, 2020. URL https://proceedings.mlr.press/v100/mehta20a.html. Amil Merchant, Simon Batzner, Samuel S. Schoenholz, Muratahan Aykol, Gowoon Cheon, and Ekin Dogus Cubuk. Scaling Deep Learning for Materials Discovery. Nature, 2023. doi: 10.1038/s41586-023-06735-9. URL https: //doi.org/10.1038/s41586-023-06735-9. Arindam Mitra, Luciano Del Corro, Guoqing Zheng, Shweti Mahajan, Dany Rouhana, Andres Codas, Yadong Lu, Wei-ge Chen, Olga Vrousgos, Corby Rosset, Fillipe Silva, Hamed Khanpour, Yash Lara, and Ahmed Awadallah. AgentInstruct: Toward Generative Teaching with Agentic Flows, 2024. URL https://arxiv.org/abs/2407.03502. Soroush Nasiriany et al. RoboCasa: Large-Scale Simulation of Everyday Tasks for Generalist Robots. In Robotics: Sci- ence and Systems, 2024. URL https://rpl.cs.utexas.edu/publications/2024/07/15/nasiriany-rss24-robocasa/. Hafsa Ouajdi, Francesco Giannuzzo, Alaa Boukhary, Paolo Papotti, Gerard Conangla, and Adam Elwood. Execution- First Synthetic Tool-Use Trace Generation for LLM Agents, 2026. URL https://arxiv.org/abs/2607.29175. Vardaan Pahuja, Yadong Lu, Corby Rosset, Boyu Gou, Arindam Mitra, Spencer Whitehead, Yu Su, and Ahmed Has- san Awadallah. Explorer: Scaling exploration-driven web trajectory synthesis for multimodal web agents. In Wanxiang Che, Joyce Nabende, Ekaterina Shutova, and Mohammad Taher Pilehvar, editors, Findings of the Association for Computational Linguistics: ACL 2025, pages 6300–6323, Vienna, Austria, 2025. Association 37 for Computational Linguistics. ISBN 979-8-89176-256-5. doi: 10.18653/v1/2025.findings-acl.326. URL https: //aclanthology.org/2025.findings-acl.326/. Jiayi Pan, Xingyao Wang, Graham Neubig, Navdeep Jaitly, Heng Ji, Alane Suhr, and Yizhe Zhang. Training software engineering agents and verifiers with swe-gym. In Aarti Singh, Maryam Fazel, Daniel Hsu, Simon Lacoste-Julien, Felix Berkenkamp, Tegan Maharaj, Kiri Wagstaff, and Jerry Zhu, editors, Forty-second International Conference on Machine Learning, ICML 2025, Vancouver, BC, Canada, July 13-19, 2025, volume 267 of Proceedings of Machine Learning Research. PMLR / OpenReview.net, 2025. URL https://proceedings.mlr.press/v267/pan25g.html. Shrey Pandit, Xuan-Phi Nguyen, Yifei Ming, Austin Xu, Jiayu Wang, Caiming Xiong, and Shafiq Joty. Synthesizing Agentic Data for Web Agents with Progressive Difficulty Enhancement Mechanisms, 2025. URL https://arxiv. org/abs/2510.13913. Shishir G. Patil, Tianjun Zhang, Xin Wang, and Joseph E. Gonzalez. Gorilla: Large language model con- nected with massive apis. In Amir Globersons, Lester Mackey, Danielle Belgrave, Angela Fan, Ulrich Paquet, Jakub M. Tomczak, and Cheng Zhang, editors, Advances in Neural Information Processing Sys- tems 37: Annual Conference on Neural Information Processing Systems 2024, NeurIPS 2024, Vancouver, BC, Canada, December 10 - 15, 2024, 2024. URL http://papers.nips.c/paper_files/paper/2024/hash/ e4c61f578f07830f5c37378d3ecb0d-Abstract-Conference.html. Akshara Prabhakar, Zuxin Liu, Ming Zhu, Jianguo Zhang, Tulika Manoj Awalgaonkar, Shiyu Wang, Zhi- wei Liu, Haolin Chen, Thai Hoang, Juan Carlos Niebles, Shelby Heinecke, Weiran Yao, Huan Wang, Sil- vio Savarese, and Caiming Xiong. Apigen-mt: Agentic pipeline for multi-turn data generation via simu- lated agent-human interplay. In Danielle Belgrave, Cheng Zhang, Laura N. Montoya, Hsuan-Tien Lin, Raz- van Pascanu, Piotr Koniusz, Marzyeh Ghassemi, Nancy Chen, Iván Vladimir Meza Ruíz, and Arturo Loaiza- Bonilla, editors, Advances in Neural Information Processing Systems 38: Annual Conference on Neural Infor- mation Processing Systems 2025, NeurIPS 2025, San Diego, CA, USA, December 2-7, 2025 / Mexico City, Mexico, November 30 - December 5, 2025, 2025. URL http://papers.nips.c/paper_files/paper/2025/hash/ 5e3661f7fe4c8ac5652d62eb3d3c96ea-Abstract-Datasets_and_Benchmarks_Track.html. Yujia Qin, Shihao Liang, Yining Ye, Kunlun Zhu, Lan Yan, Yaxi Lu, Yankai Lin, Xin Cong, Xiangru Tang, Bill Qian, Sihan Zhao, Lauren Hong, Runchu Tian, Ruobing Xie, Jie Zhou, Mark Gerstein, Dahai Li, Zhiyuan Liu, and Maosong Sun. Toolllm: Facilitating large language models to master 16000+ real-world apis. In The Twelfth Inter- national Conference on Learning Representations, ICLR 2024, Vienna, Austria, May 7-11, 2024. OpenReview.net, 2024. URL https://openreview.net/forum?id=dHng2O0Jjr. Yujia Qin, Yining Ye, Junjie Fang, Haoming Wang, Shihao Liang, Shizuo Tian, Junda Zhang, Jiahao Li, Yunxin Li, Shijue Huang, Wanjun Zhong, Kuanye Li, Jiale Yang, Yu Miao, Woyu Lin, Longxiang Liu, Xu Jiang, Qianli Ma, Jingyu Li, Xiaojun Xiao, Kai Cai, Chuang Li, Yaowei Zheng, Chaolin Jin, Chen Li, Xiao Zhou, Minchao Wang, Haoli Chen, Zhaojian Li, Haihua Yang, Haifeng Liu, Feng Lin, Tao Peng, Xin Liu, and Guang Shi. UI-TARS: Pioneering Automated GUI Interaction with Native Agents, 2025. URL https://arxiv.org/abs/2501.12326. Ram Ramrakhya, Andrew Szot, Omar Attia, Yuhao Yang, Anh Nguyen, Bogdan Mazoure, Zhe Gan, Harsh Agrawal, and Alexander Toshev. Scaling Synthetic Task Generation for Agents via Exploration, 2025. URL https://arxiv. org/abs/2509.25047. Christopher Rawles, Sarah Clinckemaillie, Yifan Chang, Jonathan Waltz, Gabrielle Lau, Marybeth Fair, Alice Li, William E. Bishop, Wei Li, Folawiyo Campbell-Ajala, Daniel Kenji Toyama, Robert James Berry, Divya Tyam- agundlu, Timothy P. Lillicrap, and Oriana Riva. Androidworld: A dynamic benchmarking environment for au- tonomous agents. In The Thirteenth International Conference on Learning Representations, ICLR 2025, Singapore, April 24-28, 2025. OpenReview.net, 2025. URL https://openreview.net/forum?id=il5yUQsrjC. Bernardino Romera-Paredes, Mohammadamin Barekatain, Alexander Novikov, Matej Balog, M. Pawan Kumar, Em- ilien Dupont, Francisco J. R. Ruiz, Jordan S. Ellenberg, Pengming Wang, Omar Fawzi, Pushmeet Kohli, and Alhussein Fawzi. Mathematical Discoveries from Program Search with Large Language Models. Nature, 2024. doi: 10.1038/s41586-023-06924-6. URL https://doi.org/10.1038/s41586-023-06924-6. Yongliang Shen, Kaitao Song, Xu Tan, Wenqi Zhang, Kan Ren, Siyu Yuan, Weiming Lu, Dongsheng Li, and Yueting Zhuang. Taskbench: Benchmarking large language models for task automation. In Amir Globersons, Lester Mackey, Danielle Belgrave, Angela Fan, Ulrich Paquet, Jakub M. Tomczak, and Cheng Zhang, editors, Advances in Neural Information Processing Systems 37: Annual Conference on Neural Information Processing Systems 2024, NeurIPS 2024, Vancouver, BC, Canada, December 10 - 15, 2024, 2024. URL http://papers.nips.c/paper_files/paper/ 2024/hash/085185ea97db31ae6dcac7497616fd3e-Abstract-Datasets_and_Benchmarks_Track.html. 38 Dingfeng Shi, Jingyi Cao, Qianben Chen, Weichen Sun, Weizhen Li, Hongxuan Lu, Fangchen Dong, Tianrui Qin, King Zhu, Minghao Liu, Jian Yang, Ge Zhang, Jiaheng Liu, Changwang Zhang, Jun Wang, Yuchen Eleanor Jiang, and Wangchunshu Zhou. TaskCraft: Automated Generation of Agentic Tasks, 2025. URL https://arxiv.org/abs/ 2506.10055. Jeonghoon Shim, Gyuhyeon Seo, Cheongsu Lim, and Yohan Jo. Tooldial: Multi-turn dialogue generation method for tool-augmented language models. In The Thirteenth International Conference on Learning Representations, ICLR 2025, Singapore, April 24-28, 2025. OpenReview.net, 2025. URL https://openreview.net/forum?id=J1J5eGJsKZ. Huatong Song, Jinhao Jiang, Yingqian Min, Jie Chen, Zhipeng Chen, Wayne Xin Zhao, Lei Fang, and Ji-Rong Wen. R1-Searcher: Incentivizing the Search Capability in LLMs via Reinforcement Learning, 2025. URL https: //arxiv.org/abs/2503.05592. Xiaoshuai Song, Haofei Chang, Guanting Dong, Yutao Zhu, Ji-Rong Wen, and Zhicheng Dou. EnvScaler: Scaling tool-interactive environments for LLM agent via programmatic synthesis. In Maria Liakata, Viviane P. Moreira, Jiajun Zhang, and David Jurgens, editors, Findings of the Association for Computational Linguistics: ACL 2026, pages 8326–8357, San Diego, California, United States, 2026. Association for Computational Linguistics. ISBN 979- 8-89176-395-1. doi: 10.18653/v1/2026.findings-acl.407. URL https://aclanthology.org/2026.findings-acl.407/. Hongjin Su, Ruoxi Sun, Jinsung Yoon, Pengcheng Yin, Tao Yu, and Sercan Ö. Arik. Learn-by-interact: A data- centric framework for self-adaptive agents in realistic environments. In The Thirteenth International Conference on Learning Representations, ICLR 2025, Singapore, April 24-28, 2025. OpenReview.net, 2025. URL https:// openreview.net/forum?id=3UKOzGWCVY. Qiushi Sun, Kanzhi Cheng, Zichen Ding, Chuanyang Jin, Yian Wang, Fangzhi Xu, Zhenyu Wu, Chengyou Jia, Liheng Chen, Zhoumianze Liu, Ben Kao, Guohao Li, Junxian He, Yu Qiao, and Zhiyong Wu. OS-genesis: Automating GUI agent trajectory construction via reverse task synthesis. In Wanxiang Che, Joyce Nabende, Ekaterina Shutova, and Mohammad Taher Pilehvar, editors, Proceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 5555–5579, Vienna, Austria, 2025. Association for Computational Linguistics. ISBN 979-8-89176-251-0. doi: 10.18653/v1/2025.acl-long.277. URL https://aclanthology.org/2025. acl-long.277/. Qiaoyu Tang, Ziliang Deng, Hongyu Lin, Xianpei Han, Qiao Liang, Boxi Cao, and Le Sun. ToolAlpaca: Generalized Tool Learning for Language Models with 3000 Simulated Cases, 2023. URL https://arxiv.org/abs/2306.05301. Xiaoyu Tian, Haotian Wang, Shuaiting Chen, Hao Zhou, Kaichi Yu, Yudian Zhang, Jade Ouyang, Junxi Yin, Jiong Chen, Baoyan Guo, Lei Zhang, Junjie Tao, Yuansheng Song, Ming Cui, and Chengwei Liu. ASTRA: Automated Synthesis of Agentic Trajectories and Reinforcement Arenas, 2026. URL https://arxiv.org/abs/2601.21558. Josh Tobin, Rachel Fong, Alex Ray, Jonas Schneider, Wojciech Zaremba, and Pieter Abbeel. Domain Randomization for Transferring Deep Neural Networks from Simulation to the Real World. In IEEE/RSJ International Confer- ence on Intelligent Robots and Systems, 2017. URL https://dblp.org/search?q=Domain%20Randomization%20for% 20Transferring%20Deep%20Neural%20Networks%20from%20Simulation%20to%20the%20Real%20World. Tongyi DeepResearch Team. Tongyi DeepResearch Technical Report, 2025. URL https://arxiv.org/abs/2510.24701. Trieu H. Trinh et al. Gold-medalist Performance in Solving Olympiad Geometry with AlphaGeometry2, 2025. URL https://arxiv.org/abs/2502.03544. Tu Trinh, Mohamed Elfeki, Guangze Luo, Kelvin Luu, Nathan Hunt, Ernesto Hernandez, Nandan Marwaha, Yan- nis Yiming He, Charles Wang, Fernando Carabedo, Alessa Castillo, and Bing Liu. HiL-Bench (Human-in-Loop Benchmark): Do Agents Know When to Ask for Help?, 2026. URL https://arxiv.org/abs/2604.09408. Harsh Trivedi, Tushar Khot, Mareike Hartmann, Ruskin Manku, Vinty Dong, Edward Li, Shashank Gupta, Ashish Sabharwal, and Niranjan Balasubramanian. AppWorld: A controllable world of apps and people for benchmarking interactive coding agents. In Lun-Wei Ku, Andre Martins, and Vivek Srikumar, editors, Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 16022–16076, Bangkok, Thailand, 2024. Association for Computational Linguistics. doi: 10.18653/v1/2024.acl-long.850. URL https://aclanthology.org/2024.acl-long.850/. Dunwei Tu, Hongyan Hao, Hansi Yang, Yihao Chen, Yi-Kai Zhang, Zhikang Xia, Yu Yang, Yueqing Sun, Xingchen Liu, Furao Shen, Qi Gu, Hui Su, and Xunliang Cai. ScaleEnv: Scaling Environment Synthesis from Scratch for Generalist Interactive Tool-Use Agent Training, 2026. URL https://arxiv.org/abs/2602.06820. 39 Alexander Sasha Vezhnevets, John P. Agapiou, Avia Aharon, Ron Ziv, Jayd Matyas, Edgar A. Dueñez-Guzmán, William A. Cunningham, Simon Osindero, Danny Karmon, and Joel Z. Leibo. Generative Agent-Based Modeling with Actions Grounded in Physical, Social, or Digital Space Using Concordia, 2023. URL https://arxiv.org/abs/ 2312.03664. Haoran Wang, Zhenyu Hou, Yao Wei, Jie Tang, and Yuxiao Dong. SWE-dev: Building software engineering agents with training and inference scaling. In Wanxiang Che, Joyce Nabende, Ekaterina Shutova, and Mo- hammad Taher Pilehvar, editors, Findings of the Association for Computational Linguistics: ACL 2025, pages 3742–3761, Vienna, Austria, 2025a. Association for Computational Linguistics. ISBN 979-8-89176-256-5. doi: 10.18653/v1/2025.findings-acl.193. URL https://aclanthology.org/2025.findings-acl.193/. Ke Wang, Houxing Ren, Aojun Zhou, Zimu Lu, Sichun Luo, Weikang Shi, Renrui Zhang, Linqi Song, Mingjie Zhan, and Hongsheng Li. Mathcoder: Seamless code integration in llms for enhanced mathematical reasoning. In The Twelfth International Conference on Learning Representations, ICLR 2024, Vienna, Austria, May 7-11, 2024. OpenReview.net, 2024a. URL https://openreview.net/forum?id=z8TW0ttBPp. Lirui Wang, Yiyang Ling, Zhecheng Yuan, Mohit Shridhar, Chen Bao, Yuzhe Qin, Bailin Wang, Huazhe Xu, and Xiaolong Wang. Gensim: Generating robotic simulation tasks via large language models. In The Twelfth Inter- national Conference on Learning Representations, ICLR 2024, Vienna, Austria, May 7-11, 2024. OpenReview.net, 2024b. URL https://openreview.net/forum?id=OI3RoHoWAN. Xinjie Wang, Liu Liu, Taojun Ding, Andrew Choi, Chaodong Huang, Mengao Zhao, Ziang Li, Jackson Jiang, Chunlei Yu, Shengxiang Liu, Wei Xu, and Zhizhong Su. EmbodiedGen V2: An Agentic, Simulation-Ready 3D World Engine for Embodied AI, 2026a. URL https://arxiv.org/abs/2607.07459. Yubo Wang, Jiarong Liang, Yuxuan Zhang, Xuye Liu, Cong Wei, Yuyu Zhang, Ping Nie, and Wenhu Chen. Function- Aware Fill-in-the-Middle as Mid-Training for Coding Agent Foundation Models, 2026b. URL https://arxiv.org/ abs/2607.12463. Yufei Wang, Zhou Xian, Feng Chen, Tsun-Hsuan Wang, Yian Wang, Katerina Fragkiadaki, Zackory Erickson, David Held, and Chuang Gan. Robogen: Towards unleashing infinite data for automated robot learning via generative simulation. In Forty-first International Conference on Machine Learning, ICML 2024, Vienna, Austria, July 21-27, 2024. OpenReview.net, 2024c. URL https://openreview.net/forum?id=SQIDlJd3hN. Zezhong Wang, Xingshan Zeng, Weiwen Liu, Liangyou Li, Yasheng Wang, Lifeng Shang, Xin Jiang, Qun Liu, and Kam-Fai Wong. ToolFlow: Boosting LLM tool-calling through natural and coherent dialogue synthesis. In Luis Chiruzzo, Alan Ritter, and Lu Wang, editors, Proceedings of the 2025 Conference of the Nations of the Americas Chapter of the Association for Computational Linguistics: Human Language Technologies (Volume 1: Long Papers), pages 4246–4263, Albuquerque, New Mexico, 2025b. Association for Computational Linguistics. ISBN 979-8-89176- 189-6. doi: 10.18653/v1/2025.naacl-long.214. URL https://aclanthology.org/2025.naacl-long.214/. Zhaoyang Wang, Canwen Xu, Boyi Liu, Yite Wang, Siwei Han, Zhewei Yao, Huaxiu Yao, and Yuxiong He. Agent World Model: Infinity Synthetic Environments for Agentic Reinforcement Learning, 2026c. URL https://arxiv. org/abs/2602.10090. Zhenting Wang, Qi Chang, Hemani Patel, Shashank Biju, Cheng-En Wu, Quan Liu, Aolin Ding, Alireza Rezazadeh, Ankit Parag Shah, Yujia Bao, and Eugene Siow. MCP-Bench: Benchmarking Tool-Using LLM Agents with Complex Real-World Tasks via MCP Servers. In The Fourteenth International Conference on Learning Representations, 2026d. URL https://arxiv.org/abs/2508.20453. Ziyi Wang, Yuxuan Lu, Yimeng Zhang, Pei Chen, Ziwei Dong, Jing Huang, Jiri Gesi, Xianfeng Tang, Chen Luo, Qun Liu, Yisi Sang, Hanqing Lu, Manling Li, Jin Lai, and Dakuo Wang. Trajectory2Task: Training robust tool-calling agents with synthesized yet verifiable data for complex user intents. In Maria Liakata, Viviane P. Moreira, Jiajun Zhang, and David Jurgens, editors, Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 44021–44044, San Diego, California, United States, 2026e. Association for Computational Linguistics. ISBN 979-8-89176-390-6. doi: 10.18653/v1/2026.acl-long.2037. URL https://aclanthology.org/2026.acl-long.2037/. Joseph L. Watson, David Juergens, Nathaniel R. Bennett, Brian L. Trippe, Jason Yim, Helen E. Eisenach, Woody Ahern, Andrew J. Borst, Robert J. Ragotte, Lukas F. Milles, Basile I. M. Wicky, Nikita Hanikel, Samuel J. Pellock, Alexis Courbet, William Sheffler, Jue Wang, Preetham Venkatesh, Isaac Sappington, Susana Vázquez Torres, Anna Lauko, Valentin De Bortoli, Emile Mathieu, Regina Barzilay, Tommi S. Jaakkola, Frank DiMaio, Minkyung 40 Baek, and David Baker. De novo Design of Protein Structure and Function with RFdiffusion. Nature, 2023. doi: 10.1038/s41586-023-06415-8. URL https://doi.org/10.1038/s41586-023-06415-8. Lorenz Wolf, Connor Watts, Roger Creus Castanyer, Geoffrey Bradway, Maxwill Lin, Augustine N. Mavor-Parker, and Matthew Daborn-Sargent. Breaking the Solver Bottleneck: Training Task Generators at the Learnable Frontier, 2026. URL https://arxiv.org/abs/2606.18284. Mengsong Wu, Tong Zhu, Han Han, Chuanyuan Tan, Xiang Zhang, and Wenliang Chen. Seal-Tools: Self-Instruct Tool Learning Dataset for Agent Tuning and Detailed Benchmark. In Natural Language Processing and Chinese Computing. arXiv, 2024. doi: 10.48550/arXiv.2405.08355. URL https://dblp.org/rec/conf/nlpcc/WuZHTZC24.html. Zheng Wu, Chengcheng Han, Zhengxi Lu, Tianjie Ju, Yanyu Chen, Qi Gu, Xunliang Cai, and Zhuosheng Zhang. GUI-CIDER: Mid-training GUI Agents via Causal Internalization and Density-aware Exemplar Reselection, 2026a. URL https://arxiv.org/abs/2605.28534. Zijian Wu, Xiangyan Liu, Xinyuan Zhang, Lingjun Chen, Fanqing Meng, Lingxiao Du, Yiran Zhao, Fanshi Zhang, Yaoqi Ye, Jiawei Wang, Zirui Wang, Jinjie Ni, Yufan Yang, Arvin Xu, and Michael Qizhe Shieh. MCPMark: A Benchmark for Stress-Testing Realistic and Comprehensive MCP Use. In The Fourteenth International Conference on Learning Representations, 2026b. URL https://arxiv.org/abs/2509.24002. Tianle Xia, Ming Xu, Lingxiang Hu, Yiding Sun, Wenwei Li, Linfang Shang, Liqun Liu, Peng Shu, Huan Yu, and Jie Jiang. Search-p1: Path-centric reward shaping for stable and efficient agentic RAG training. In Yunyao Li, Georg Rehm, and Mei Tu, editors, Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 6: Industry Track), pages 517–534, San Diego, California, USA, 2026. Association for Computational Linguistics. ISBN 979-8-89176-394-4. doi: 10.18653/v1/2026.acl-industry.36. URL https://aclanthology.org/ 2026.acl-industry.36/. Chuan Xiao, Zhengbo Jiao, Shaobo Wang, Wei Wang, Bing Zhao, Hu Wei, Linfeng Zhang, and Lin Qu. Socratic-SWE: Self-Evolving Coding Agents via Trace-Derived Agent Skills, 2026. URL https://arxiv.org/abs/2606.07412. Jian Xie, Tianhe Lin, Zilu Wang, Yuting Ning, Yuekun Yao, Tianci Xue, Zhehao Zhang, Zhongyang Li, Kai Zhang, Yufan Wu, Shijie Chen, Boyu Gou, Mingzhe Han, Yifei Wang, Vint Lee, Xinpeng Wei, Xiangjun Wang, Yu Su, and Huan Sun. QUEST: Training Frontier Deep Research Agents with Fully Synthetic Tasks, 2026a. URL https: //arxiv.org/abs/2605.24218. Jingxu Xie, Dylan Xu, Xuandong Zhao, and Dawn Song. AgentSynth: Scalable Task Generation for Generalist Computer-Use Agents, 2026b. URL https://arxiv.org/abs/2506.14205. Tianbao Xie, Danyang Zhang, Jixuan Chen, Xiaochuan Li, Siheng Zhao, Ruisheng Cao, Toh Jing Hua, Zhou- jun Cheng, Dongchan Shin, Fangyu Lei, Yitao Liu, Yiheng Xu, Shuyan Zhou, Silvio Savarese, Caiming Xiong, Victor Zhong, and Tao Yu. Osworld: Benchmarking multimodal agents for open-ended tasks in real computer environments. In Amir Globersons, Lester Mackey, Danielle Belgrave, Angela Fan, Ulrich Paquet, Jakub M. Tomczak, and Cheng Zhang, editors, Advances in Neural Information Processing Sys- tems 37: Annual Conference on Neural Information Processing Systems 2024, NeurIPS 2024, Vancouver, BC, Canada, December 10 - 15, 2024, 2024. URL http://papers.nips.c/paper_files/paper/2024/hash/ 5d413e48f84dc61244b6be550f1cd8f5-Abstract-Datasets_and_Benchmarks_Track.html. Huajian Xin et al. DeepSeek-Prover: Advancing Theorem Proving in LLMs through Large-Scale Synthetic Data, 2024. URL https://arxiv.org/abs/2405.14333. Weimin Xiong, Shuhao Gu, Bowen Ye, Zihao Yue, Lei Li, Feifan Song, Sujian Li, and Hao Tian. Video2GUI: Synthesizing Large-Scale Interaction Trajectories for Generalized GUI Agent Pretraining, 2026. URL https:// arxiv.org/abs/2605.14747. Minrui Xu, Zilin Wang, Mengyi DENG, Zhiwei Li, Zhicheng Yang, Xiao Zhu, Yinhong Liu, Boyu Zhu, Baiyu Huang, Chao Chen, Heyuan Deng, Fei Mi, Lifeng Shang, Xingshan Zeng, and Zhijiang Guo. EnvFactory: Scaling Tool-Use Agents via Executable Environments Synthesis and Robust RL, 2026a. URL https://arxiv.org/abs/2605.18703. Tianqi Xu, Linyao Chen, Dai-Jie Wu, Yanjun Chen, Zecheng Zhang, Xiang Yao, Zhiqiang Xie, Yongchao Chen, Shilong Liu, Bochen Qian, Anjie Yang, Zhaoxuan Jin, Jianbo Deng, Philip Torr, Bernard Ghanem, and Guohao Li. CRAB: Cross-environment agent benchmark for multimodal language model agents. In Wanxiang Che, Joyce Nabende, Eka- terina Shutova, and Mohammad Taher Pilehvar, editors, Findings of the Association for Computational Linguistics: ACL 2025, pages 21607–21647, Vienna, Austria, 2025a. Association for Computational Linguistics. ISBN 979-8- 89176-256-5. doi: 10.18653/v1/2025.findings-acl.1113. URL https://aclanthology.org/2025.findings-acl.1113/. 41 Yiheng Xu, Dunjie Lu, Zhennan Shen, Junli Wang, Zekun Wang, Yuchen Mao, Caiming Xiong, and Tao Yu. Agenttrek: Agent trajectory synthesis via guiding replay with web tutorials. In The Thirteenth International Conference on Learning Representations, ICLR 2025, Singapore, April 24-28, 2025. OpenReview.net, 2025b. URL https: //openreview.net/forum?id=EEgYUccwsV. Yucheng Xu, Keyi Zhang, Yuyang Yu, Min Zhang, Shiyuan Meng, Pei Chu, and Zhongying Tu. Scaling Scientific Discovery Environments for Turn-Level Agentic RL, 2026b. URL https://arxiv.org/abs/2607.28990. Zhangchen Xu, Adriana Meza Soria, Shawn Tan, Anurag Roy, Ashish Sunil Agrawal, Radha Poovendran, and Rameswar Panda. TOUCAN: Synthesizing 1.5M Tool-Agentic Data from Real-World MCP Environments, 2025c. URL https://arxiv.org/abs/2510.01179. Zhihao Xu, Rumei Li, Jiahuan Li, Rongxiang Weng, Jingang Wang, Xunliang Cai, and Xiting Wang. Unlock- ing implicit experience: Synthesizing tool-use trajectories from text. In Maria Liakata, Viviane P. Moreira, Ji- ajun Zhang, and David Jurgens, editors, Proceedings of the 64th Annual Meeting of the Association for Com- putational Linguistics (Volume 1: Long Papers), pages 9961–9980, San Diego, California, United States, 2026c. Association for Computational Linguistics. ISBN 979-8-89176-390-6. doi: 10.18653/v1/2026.acl-long.452. URL https://aclanthology.org/2026.acl-long.452/. Zishan Xu, Zhiyuan Yao, Yuxin Chen, Yifu Guo, Zhengxi Lu, Yuquan Lu, Jinyang Huang, Yan Xu, Yasheng Wang, Weinan Zhang, Xingshan Zeng, and Weiwen Liu. EnvACE: Internalizing Environment Dynamics via World Re- hearsal for Agentic Reinforcement Learning, 2026d. URL https://arxiv.org/abs/2608.06197. Chen Yang, Ran Le, Yun Xing, Zhenwei An, Zongchao Chen, Wayne Xin Zhao, Yang Song, and Tao Zhang. ToolMind Technical Report: A Large-Scale, Reasoning-Enhanced Tool-Use Dataset, 2025a. URL https://arxiv.org/abs/ 2511.15718. John Yang, Kilian Lieret, Carlos E. Jimenez, Alexander Wettig, Kabir Khandpur, Yanzhe Zhang, Binyuan Hui, Ofir Press, Ludwig Schmidt, and Diyi Yang. Swe-smith: Scaling data for software engineering agents. In Danielle Belgrave, Cheng Zhang, Laura N. Montoya, Hsuan-Tien Lin, Razvan Pascanu, Pi- otr Koniusz, Marzyeh Ghassemi, Nancy Chen, Iván Vladimir Meza Ruíz, and Arturo Loaiza-Bonilla, ed- itors, Advances in Neural Information Processing Systems 38: Annual Conference on Neural Information Processing Systems 2025, NeurIPS 2025, San Diego, CA, USA, December 2-7, 2025 / Mexico City, Mex- ico, November 30 - December 5, 2025, 2025b. URL http://papers.nips.c/paper_files/paper/2025/hash/ 8b86cf5ace600c48fd188efbb8dedec8-Abstract-Datasets_and_Benchmarks_Track.html. Yingxuan Yang, Chengrui Qu, Muning Wen, Laixi Shi, Ying Wen, Weinan Zhang, Adam Wierman, and Shangding Gu. Understanding Agent Scaling in LLM-Based Multi-Agent Systems via Diversity, 2026a. URL https://arxiv. org/abs/2602.03794. Yuancheng Yang, Lin Yang, Xu Wang, Chao Tong, and Haihua Yang. ImpRIF: Stronger implicit reasoning leads to better complex instruction following. In Maria Liakata, Viviane P. Moreira, Jiajun Zhang, and David Jurgens, editors, Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 38771–38796, San Diego, California, United States, 2026b. Association for Computational Linguistics. ISBN 979-8-89176-390-6. doi: 10.18653/v1/2026.acl-long.1796. URL https://aclanthology.org/2026.acl-long. 1796/. Yue Yang, Fan-Yun Sun, Luca Weihs, Eli VanderBilt, Alvaro Herrasti, Winson Han, Jiajun Wu, Nick Haber, Ranjay Krishna, Lingjie Liu, Chris Callison-Burch, Mark Yatskar, Aniruddha Kembhavi, and Christopher Clark. Holodeck: Language guided generation of 3d embodied AI environments. In IEEE/CVF Conference on Computer Vision and Pattern Recognition, CVPR 2024, Seattle, WA, USA, June 16-22, 2024, pages 16277–16287. IEEE, 2024. doi: 10.1109/CVPR52733.2024.01536. URL https://doi.org/10.1109/CVPR52733.2024.01536. Zhiyuan Yao, Zishan Xu, Yifu Guo, Zhiguang Han, Cheng Yang, Shuo Zhang, Weinan Zhang, Xingshan Zeng, and Weiwen Liu. ACE-router: Generalizing history-aware routing from MCP tools to the agent web. In Maria Liakata, Viviane P. Moreira, Jiajun Zhang, and David Jurgens, editors, Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 6224–6240, San Diego, California, United States, July 2026. Association for Computational Linguistics. ISBN 979-8-89176-390-6. doi: 10.18653/v1/2026. acl-long.281. URL https://aclanthology.org/2026.acl-long.281/. Yashwanth YS, Ruichen Wang, Shihua Zeng, Xuhui Zhou, Koichi Onoue, Vasudha Varadarajan, and Maarten Sap. SOTOPIA-ToM: Evaluating Information Management in Multi-Agent Interaction with Theory of Mind, 2026. URL https://arxiv.org/abs/2605.02307. 42 Junjie Ye, Zhengyin Du, Xuesong Yao, Weijian Lin, Yufei Xu, Zehui Chen, Zaiyuan Wang, Sining Zhu, Zhiheng Xi, Siyu Yuan, Tao Gui, Qi Zhang, Xuanjing Huang, and Jiecao Chen. ToolHop: A query-driven benchmark for evaluating large language models in multi-hop tool use. In Wanxiang Che, Joyce Nabende, Ekaterina Shutova, and Mohammad Taher Pilehvar, editors, Proceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 2995–3021, Vienna, Austria, 2025. Association for Computational Linguistics. ISBN 979-8-89176-251-0. doi: 10.18653/v1/2025.acl-long.150. URL https://aclanthology.org/2025. acl-long.150/. Fan Yin, Zifeng Wang, I-Hung Hsu, Jun Yan, Ke Jiang, Yanfei Chen, Jindong Gu, Long Le, Kai-Wei Chang, Chen-Yu Lee, Hamid Palangi, and Tomas Pfister. Magnet: Multi-turn tool-use data synthesis and distillation via graph translation. In Wanxiang Che, Joyce Nabende, Ekaterina Shutova, and Mohammad Taher Pilehvar, editors, Pro- ceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 32600–32616, Vienna, Austria, 2025. Association for Computational Linguistics. ISBN 979-8-89176-251-0. doi: 10.18653/v1/2025.acl-long.1566. URL https://aclanthology.org/2025.acl-long.1566/. Ji Zeng, Dayuan Fu, Tiantian Mi, Yumin Zhuang, Yaxing Huang, Xuefeng Li, Lyumanshan Ye, Muhang Xie, Qishuo Hua, Zhen Huang, Mohan Jiang, Hanning Wang, Jifan Lin, Yang Xiao, Jie Sun, Yunze Wu, and Pengfei Liu. daVinci- Dev: Agent-native Mid-training for Software Engineering, 2026a. URL https://arxiv.org/abs/2601.18418. Liang Zeng, Yongcong Li, Yuzhen Xiao, Changshi Li, Chris Yuhao Liu, Rui Yan, Tianwen Wei, Jujie He, Xuchen Song, Yang Liu, and Yahui Zhou. Skywork-SWE: Unveiling Data Scaling Laws for Software Engineering in LLMs, 2025. URL https://arxiv.org/abs/2506.19290. Xingshan Zeng, Weiwen Liu, Xu Huang, Zezhong Wang, Lingzhi Wang, Liangyou Li, Yasheng Wang, Lifeng Shang, Xin Jiang, Ruiming Tang, and Qun Liu. Toolace-r: Model-aware iterative training and adaptive refinement for tool learning. In Sven Koenig, Chad Jenkins, and Matthew E. Taylor, editors, Fortieth AAAI Conference on Artificial Intelligence, Thirty-Eighth Conference on Innovative Applications of Artificial Intelligence, Sixteenth Symposium on Educational Advances in Artificial Intelligence, AAAI 2026, Singapore, January 20-27, 2026, pages 34593–34601. AAAI Press, 2026b. doi: 10.1609/AAAI.V40I41.40759. URL https://doi.org/10.1609/aaai.v40i41.40759. Xingshan Zeng, Weiwen Liu, Lingzhi Wang, Liangyou Li, Fei Mi, Yasheng Wang, Lifeng Shang, Xin Jiang, and Qun Liu. ToolACE-MT: Non-autoregressive generation for agentic multi-turn interaction. In The Fourteenth International Conference on Learning Representations, ICLR 2026, 2026c. URL https://openreview.net/forum?id=KznJt9Fhjc. Yucheng Zeng, Weipeng Lu, Linyun Liu, Shupeng Li, Zitian Qu, Chenghao Zhu, Shaofei Li, Zhengdong Tan, Mengyue Liu, Haotian Zhao, Zhe Zhou, and Jianmin Wu. LOGIGEN: Logic-Driven Generation of Verifiable Agentic Tasks, 2026d. URL https://arxiv.org/abs/2603.00540. Yunpeng Zhai, Shuchang Tao, Cheng Chen, Anni Zou, Ziqian Chen, Qingxu Fu, Shinji Mai, Li Yu, Jiaji Deng, Zouying Cao, Zhaoyang Liu, Bolin Ding, and Jingren Zhou. AgentEvolver: Towards Efficient Self-Evolving Agent System, 2025. URL https://arxiv.org/abs/2511.10395. Jianguo Zhang, Tian Lan, Rithesh Murthy, Zhiwei Liu, Weiran Yao, Ming Zhu, Juntao Tan, Thai Hoang, Zuxin Liu, Liangwei Yang, Yihao Feng, Shirley Kokane, Tulika Awalgaonkar, Juan Carlos Niebles, Silvio Savarese, Shelby Heinecke, Huan Wang, and Caiming Xiong. AgentOhana: Design Unified Data and Training Pipeline for Effective Agent Learning, 2024. URL https://arxiv.org/abs/2402.15506. Jiayi Zhang, Jinyu Xiang, Zhaoyang Yu, Fengwei Teng, Xionghui Chen, Jiaqi Chen, Mingchen Zhuge, Xin Cheng, Sirui Hong, Jinlin Wang, Bingnan Zheng, Bang Liu, Yuyu Luo, and Chenglin Wu. Aflow: Automating agentic workflow generation. In The Thirteenth International Conference on Learning Representations, ICLR 2025, Singapore, April 24-28, 2025. OpenReview.net, 2025. URL https://openreview.net/forum?id=z5uVAKwmjf. Yinger Zhang, Shutong Jiang, Renhao Li, Jianhong Tu, Yang Su, Lianghao Deng, Xudong Guo, ChenXu Lv, and Junyang Lin. DeepPlanning: Benchmarking long-horizon agentic planning with verifiable constraints. In Maria Liakata, Viviane P. Moreira, Jiajun Zhang, and David Jurgens, editors, Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 7377–7407, San Diego, California, United States, 2026. Association for Computational Linguistics. ISBN 979-8-89176-390-6. doi: 10.18653/v1/2026. acl-long.335. URL https://aclanthology.org/2026.acl-long.335/. Keyu Zhao, Lingyan Kong, Fengli Xu, and Yong Li. Agentic-Ideation: Sample Efficient Agentic Trajectories Synthesis for Scientific Ideation Agents, 2026. URL https://arxiv.org/abs/2606.31229. Shu Zhao, Tan Yu, Anbang Xu, Japinder Singh, Aaditya Shukla, and Rama Akkiraju. ParallelSearch: Train your 43 LLMs to Decompose Query and Search Sub-queries in Parallel with Reinforcement Learning, 2025. URL https: //arxiv.org/abs/2508.09303. Yuxiang Zheng, Dayuan Fu, Xiangkun Hu, Xiaojie Cai, Lyumanshan Ye, Pengrui Lu, and Pengfei Liu. DeepRe- searcher: Scaling deep research via reinforcement learning in real-world environments. In Christos Christodoulopou- los, Tanmoy Chakraborty, Carolyn Rose, and Violet Peng, editors, Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing, pages 414–431, Suzhou, China, 2025. Association for Computational Lin- guistics. ISBN 979-8-89176-332-6. doi: 10.18653/v1/2025.emnlp-main.22. URL https://aclanthology.org/2025. emnlp-main.22/. Jiang Zhou, Zhiyuan Fan, Xing Wu, Tinghao Yu, Feng Zhang, and Lilin Wang. Deep Research Pretraining via Predictive Navigation, 2026a. URL https://arxiv.org/abs/2608.00432. Shuaiyu Zhou, Fengpeng Yue, Zengjie Hu, Yuanzhe Shen, Chenyang Zhang, Feng Hong, Cao Liu, and Ke Zeng. ToolVerse: Unlocking Massive Environments and Long-Horizon Tasks for Agentic Reinforcement Learning, 2026b. URL https://arxiv.org/abs/2607.15660. Xueyang Zhou, Yihan Sun, Xijie Gong, Guiyao Tie, Pan Zhou, Lichao Sun, and Yongchao Chen. EmbodiedClaw: Conversational Workflow Execution for Embodied AI Development, 2026c. URL https://arxiv.org/abs/2604. 13800. Xuhui Zhou, Hao Zhu, Leena Mathur, Ruohong Zhang, Haofei Yu, Zhengyang Qi, Louis-Philippe Morency, Yonatan Bisk, Daniel Fried, Graham Neubig, and Maarten Sap. SOTOPIA: interactive evaluation for social intelligence in language agents. In The Twelfth International Conference on Learning Representations, ICLR 2024, Vienna, Austria, May 7-11, 2024. OpenReview.net, 2024. URL https://openreview.net/forum?id=mM7VurbA4r. Yuxin Zuo, Zikai Xiao, Li Sheng, Fei Huang, Jianhong Tu, Yuxuan Liu, Tianyi Tang, Xiaomeng Hu, Yang Su, Qingfeng Lan, Yantao Liu, Qin Zhu, Yinger Zhang, Bowen Yu, Haiquan Zhao, Haiyang Xu, Jianxin Yang, Jiayang Cheng, Junyang Wang, Lianghao Deng, Mingfeng Xue, Tianyi Bai, Yang Fan, Yubo Ma, Yucheng Li, Zeyu Cui, Zhihai Wang, Zhihui Xie, Zhuorui Ye, An Yang, Dayiheng Liu, Jingren Zhou, and Ning Ding. Qwen-AgentWorld: Language World Models for General Agents, 2026. URL https://arxiv.org/abs/2606.24597. 44