betaFeedback

WorksComputer Science

CrossEnv: Synthesizing Verifiable Cross-Environment Tasks for Long-Horizon Agent Training

Abstract

Executable synthetic environments provide scalable training tasks and verifiable feedback for long-horizon agents. Existing environment synthesis methods primarily generate tasks within individual environments. However, these tasks do not adequately capture real-world interactions across services, where actions in one service depend on information obtained from another. Synthesizing such tasks is challenging because data generated across environments must remain consistent to support executable and verifiable interactions. To address this challenge, we introduce CrossEnv, a framework that uses an entity-tool graph to identify connections between environments and aligns task-specific data to synthesize executable, verifiable cross-environment tasks. We further propose CrossEnv-Curriculum, which progresses from single-environment tool use to coordination across more environments and business domains, before introducing user interaction. Across four external benchmarks, combining cross-environment training data with this curriculum achieves competitive performance with fewer training examples. Further analyses support the benefits of cross-environment data and curriculum training, and provide evidence of transfer to new environment combinations, external tasks less similar to the training data, and longer workflows.

Introduction

Large language models (LLMs) are increasingly used as agents that invoke tools (Schick et al., 2023) and adapt their actions based on environmental feedback (Yao et al., 2023; Liu et al., 2025; Shinn et al., 2023). Training these agents requires diverse executable environments and verifiable tasks that

provide reliable feedback (Xi et al., 2025). However, restricted access and high interaction costs limit training in real-world applications [6]. Programmatic environment synthesis offers a scalable alternative by generating executable tools, stateful environments, and verifiable training tasks (Song et al., 2026; Tu et al., 2026).

Real-world long-horizon workflows often span multiple services, where actions in one service depend on information obtained from another (Trivedi et al., 2024; Li et al., 2026; Xie et al., 2024). Figure 1(b) illustrates a travel-planning example: after booking flights and accommodation, an agent selects and reserves a restaurant based on the flight arrival time, hotel location, and personal preferences. Training agents for such workflows requires tasks that capture these information dependencies and the coordinated actions needed to achieve a shared goal.

Figure 1. Independent tasks and a cross-environment task. (a) Flight, hotel, and dining tasks are completed and verified independently. (b) A travel-planning task uses flight arrival time, hotel location, and personal preferences to guide restaurant reservation, with joint verification of cross-environment requirements.

However, existing programmatic environment synthesis methods primarily generate single-environment tasks, with limited support for combining independently constructed environments into joint tasks (Song et al., 2026; Wang et al., 2026). Cross-application benchmarks capture some cross-environment dependencies, but task and evaluator design is often manual or semi-automated (Trivedi et al., 2024; Li et al., 2026; Xu et al., 2025a; Zhou et al., 2024), limiting their scalability for training. This leaves a gap in automatically synthesizing cross-environment training tasks at scale.

A key difficulty is maintaining data consistency across environments. Data constructed independently for different environments may be valid in isolation but inconsistent with one another. For example, the same hotel may be recorded with different addresses in the booking and navigation environments. Synthesizing cross-environment tasks therefore requires aligning relevant data across environments to support executable, verifiable tasks.

To address this challenge, we introduce CrossEnv, a framework for automatically synthesizing executable, verifiable cross-environment tasks. CrossEnv uses an entity–tool graph to connect environments through shared entity types and guide the construction of task workflows. It then aligns task-specific data across environments to support execution and generates verification rules from task objectives and reference execution.

CrossEnv generates tasks with varying coordination complexity by controlling the number of participating environments and their business-domain scope. We introduce CrossEnv-Curriculum to establish basic tool-use skills before progressively training agents to coordinate operations across environments. Training begins with supervised fine-tuning on single-environment reference trajectories, followed by stagewise reinforcement learning that expands to multiple environments within a business domain, then across domains, and finally introduces user interaction.

Experiments on four external benchmarks show

that combining cross-environment training data with this curriculum achieves competitive performance with fewer training examples than comparable environment-trained baselines. Further analyses support the benefits of cross-environment data and curriculum training, and provide evidence of transfer to new environment combinations, external environments, and longer workflows.

Our main contributions are as follows:

  1. We introduce CrossEnv, which combines entity–tool graph-guided workflows with cross-environment data alignment to synthesize executable, verifiable training tasks.

  1. We propose CrossEnv-Curriculum, which organizes training from single-environment tool use to increasingly complex coordination across environments and business domains, and finally to tasks requiring user interaction.

  1. We analyze stagewise capability development and retention, comparing curriculum versus mixed training and single- versus cross-environment tasks to assess the roles of training strategy and task composition.

Related Work

Environment Synthesis

Table 1 compares approaches based on real-world access (Xu et al., 2025b), LLM simulation [6] (Xu et al. 2026c), and programmatic construction. For general synthesis, real services and executable programs support action execution, while programmatic approaches provide task-outcome checks (Song et al., 2026; Yang et al., 2025c; Xu et al., 2026b). ScaleEnv (Tu et al., 2026), Agent-World [8], and Skill2Env (Xu et al., 2026a) explicitly control task complexity. Graph-guided synthesis supports long-horizon tool tasks in ToolVerse (Zhou et al., 2026), terminal skill composition in SkillSync [9], and controllable subtask complexity in OmniBench [5]. Across environments, ToolLLM (Qin et al., 2023) and Toucan (Xu et al., 2025c) support multi-service tasks and new-service integration; Simia (Li et al., 2025) simulates multi-environment workflows, while AWM (Wang et al., 2026) provides limited support within bundled service suites. ARE (Froger et al., 2025) addresses cross-app data coherence through dependency-aware generation. CrossEnv composes independently constructed environments through shared entity types and aligns task-specific records for jointly verifiable workflows.

MethodExec.Verif.Ctrl.CrossConsist.Ext.
Real-world environments
ToolLLM (2023)✓✗✓✓✗✓
Toucan (2025c)✓✗✓✓✗✓
AgentTr ek (2025b)✓✗✗✗✗✗
LLM-simulated environments
Simia (2025)✗✗△✓✗✗
DreamGym (2025)✗✗△✗✗✗
EnvACE (2026c)✗✗✗✗✗✗
Programmatic environments
EnvScaler (2026)✓✓✗✗✗✗
AWM (2026)✓✓✗△✗✗
ScaleEnv (2026)✓✓✓✗✗✗
Agent-World (2026)✓✓✓✗✗✗
Skill2Env (2026a)✓✓✓✗✗✗
CrossEnv✓✓✓✓✓✓

Table 1. Environment and task synthesis capabilities. Exec.: real-service or code execution; Verif.: programmatic outcome checks; Ctrl.: adjustable complexity; Cross: multi-environment tasks; Consist.: cross-environment data alignment; Ext.: new-environment integration into joint tasks. ✓: supported; △: limited; ✗: not explicitly provided.

Curriculum Learning

Curriculum learning organizes training examples by difficulty or learning progress to support progressive skill acquisition [4, 10] (Kumar et al. 2010; Graves et al. 2017; Florensa et al. 2017). For LLM agents, AgentGym-RL (Xi et al., 2025) gradually increases interaction budgets, while WebRL (Qi et al., 2025) generates tasks from failures and filters them by difficulty. AgentGen (Hu et al., 2025) constructs planning tasks at varying difficulty levels through bidirectional evolution. More recently, GenEnv (Guo et al., 2025) and Tool-R0 [1] use co-evolution to generate tasks adapted to the agent’s current capabilities. CrossEnv-Curriculum organizes training around the coordination structure of cross-environment workflows, providing an explicit progression from foundational execution skills to joint task completion.

CrossEnv

CrossEnv automatically synthesizes executable, verifiable cross-environment tasks. Figure 2 presents an overview of its five-phase pipeline.

Figure 2. Overview of the CrossEnv task synthesis framework. Entity–tool graph composition forms task skeletons, while tool synthesis, data alignment, and reference execution produce executable tasks with verifiable outcomes. Tasks are validated through reference replay and independent agent attempts.

A cross-environment task involves tool use in at least two environments. Task completion requires using information from one environment to guide actions in another or meeting constraints on their combined results. Each task is represented as

τ=(ES,I,s0,τ,A∗,Cτ),(1)\tau= (\mathcal{E}_S, I, s_{0,\tau}, A^{*}, C_{\tau}), \tag*{(1)}

where ES\mathcal{E}_S is the set of environments used in the task, II is the instruction, s0,τs_{0,\tau} is their joint initial state, A∗A^{*} is a reference execution sequence, and CτC_{\tau} contains executable verification rules. Task completion requires all rules to pass, evaluated from tool outputs and final environment states.

Single-Environment Research

Environment research. We collect environment seeds from MCP services and public skill documents, retaining 801 MCP seeds and 682 skill seeds after filtering. A research agent retrieves documentation and data, while a data construction agent builds initial databases and requests further retrieval when needed. These materials support entity extraction and tool implementation.

Environment taxonomy. We classify the seeds into 10 business domains and 84 capability categories, drawing on the Agent-World taxonomy [8] and seed functionality. This taxonomy supports within-domain and cross-domain task composition; the complete classification is provided in Appendix § 11.

Local Dependency Graphs

For each environment EiE_i, we extract entity types and attributes from its initial database and tool descriptions. We then construct a local entity–tool graph Gi=(Vi,Ri)G_i = (V_i, R_i), where nodes represent entity types and directed edges represent relations supported by tools. In Figure 2, for example, reserve_room supports a booking relation from Person to Hotel, while search_hotels supports a search relation from City to Hotel.

Cross-Environment Graph Composition

Graph composition. Different environments may support different operations involving the same entity types. We merge their local graphs through these shared types, retaining each relation’s source environment and supporting tools. In Figure 2, shared Person and City nodes connect the flight, hotel, and dining graphs, bringing their operations into a cross-environment entity–tool graph.

Task skeleton sampling. From the composed graph, we sample connected subgraphs spanning at least two environments. We assess whether the selected operations involve related entities, complement one another, and form a coherent business workflow. For each selected combination, we define a task objective specifying how the operations work together, including which actions use results from other environments and what constraints their combined outcomes must satisfy. This produces a task skeleton SS and its required tools. We control task composition through environment count, business-domain scope, and whether user interaction is required.

Tool Synthesis and Testing

Given a task skeleton, we reuse tested tool implementations and have a coding agent implement missing tools using their descriptions, research findings, and initial databases. We test required tools for correct outputs, intended state changes, and error handling, repairing and retesting failures. The tested implementations provide executable operations for the participating environments and support subsequent task instantiation.

Task Instantiation and Verification

Data alignment. Given a task skeleton and its objective, we select concrete entities and records, supplement missing data, and resolve conflicting information across environments. We plan initial data and reference actions jointly: required records must exist initially or be produced by earlier actions, while records the agent must create are not inserted in advance. This produces the aligned initial state s0,τs_{0,\tau}.

Reference execution. We execute the planned actions from s0,τs_{0,\tau}, recording outputs and state changes. Actions use results from other environments as required by the objective. Execution failures trigger revisions to the data and action plan. Successful execution provides the reference sequence A∗A^{*}, from which we generate the task instruction II together with the task scenario.

Verification rule generation. We derive executable rules CτC_{\tau} from the task objective and constraints, using reference execution results to specify expected outcomes. The rules check tool outputs, required state changes, and cross-environment consistency. Negative cases, such as omitted operations and incorrect values, test whether the rules reject incomplete or incorrect outcomes.

Task validation. We reset the environments and replay A∗A^{*}, requiring reproducible outcomes that pass all verification rules. We then run five independent agent attempts from the same initial state, using the task instruction and available interaction interfaces.

We retain tasks with successful reference replay and at least two successful agent attempts.

CrossEnv-Curriculum

Curriculum organization. We organize CrossEnv tasks into five levels according to environment count, business-domain scope, and user interaction. L1 contains single-environment tasks that establish basic tool-use skills. L2 introduces coordination between two environments within one business domain, and L3 expands to three or more environments within the same domain. L4 extends coordination across multiple business domains while retaining three or more environments. L5 retains L4’s environment-count and domain-scope requirements and introduces user interaction. The curriculum progressively expands environment count and business-domain scope, then introduces user interaction under L4’s structural requirements.

Training procedure. We first perform supervised fine-tuning on L1 reference trajectories to teach tool selection, argument specification, and the use of tool outputs. We then conduct reinforcement learning sequentially on L2–L5, initializing each stage from the preceding checkpoint. During RL, the agent acts on the task instruction and interaction history, receiving rewards from executable checks of tool outputs and final environment states.

Experiments

We present the experimental setup (§ 5.1) and overall performance (§ 5.2), then analyze curriculum learning (§ 5.3), generalization (§ 5.4), the value of cross-environment tasks (§ 5.5), and synthesis quality and construction cost (§ 5.6).

Experimental Setup

Benchmarks. Our main evaluation uses four benchmarks covering complementary capabilities: interactive tool use, assessed by τ2\tau^2-bench ([3]) through multi-step execution and user coordination; long-horizon task completion, assessed by DeepPlanning-Shopping ((Zhang et al., 2026)) through constrained planning and VitaBench ((He et al., 2025)) through coordinated service interactions; and general assistant tasks, assessed by Claw-Eval ((Ye et al., 2026)) through service orchestration and professional dialogue. Benchmark subsets and evaluation settings are detailed in Appendix § 14.

Models. We use Qwen3 backbones ((Yang et al., 2025a)) with 1.7B, 4B, and 8B parameters and compare against the corresponding base models to assess training gains. Environment-trained baselines include Toucan ((Xu et al., 2025c)), EnvACE ((Xu et al., 2026c)), EnvScaler ((Song et al., 2026)), Arctic-AWM ((Wang et al., 2026)), and Agent-World ([8]). We use in-house reproductions of EnvScaler-4B and Agent-World-4B/8B; the Agent-World implementation was not publicly available at the time of our experiments. We also include frontier closed-source models ((OpenAI, n.d.; Anthropic, 2025; Google DeepMind, 2026; Qwen Team, n.d.)) and open-weight general-purpose models ([7] (Z.ai, n.d.; Kimi Team et al. 2026)) as reference points. Model versions and sources are documented in Appendix § 13.

Training. We train on CrossEnv-generated data following the curriculum in § 4. We first perform full-parameter SFT on 800 L1 reference trajectories, followed by stagewise trajectory-level outcome GRPO on 2,154 tasks across L2–L5, for a total of 2,954 training records. Table 2 reports training and validation counts and average reference lengths by level. All CrossEnv models in the main results table complete L1–L5 training. Capability tracking extends through L5; the Mixed comparison and longer-workflow tests use checkpoints through L4.

LevelStageTrainVal.Avg. Turns
L1SFT800404.73
L2RL579404.84
L3RL620508.70
L4RL6005012.66
L5RL + User3554013.76

Table 2. CrossEnv training and validation data by curriculum level. Turns count tool calls and, for L5, one required clarification question.

Overall Performance

Table 3 reports results on the four external benchmarks. We highlight three findings.

MethodTrain dataSourceτ2\tau^2-bench Ret.Air.Tel.Bnk.Avg.DeepPlanning L1L2L3Avg.VitaBench Del.Ins.OTACr.Avg.Claw-Eval Gen.MTAvg.
Frontier Closed-Source Models
GPT-5.6-Luna—☁21.944.09.66.217.140.040.020.036.732.040.08.012.023.078.357.974.4
Claude-Haiku-4.5—☁36.058.01.83.120.036.024.015.027.540.032.024.08.026.049.036.846.7
Gemini-3.8-Flash—☁9.624.09.62.19.634.034.025.032.50.00.048.00.012.068.884.271.8
Qwen3.8-Max—☁30.750.07.94.119.572.066.075.070.064.052.036.036.047.078.376.377.9
Open-Weight General-Purpose Models
DeepSeek-V4-Pro—☁43.962.07.04.124.862.038.050.050.044.048.036.028.039.075.281.676.4
GLM-5.3—☁16.736.04.43.112.062.042.030.048.364.064.060.040.057.077.171.175.9
Kimi-K3—☁20.242.03.54.113.942.024.025.031.760.048.044.032.046.080.978.980.5
Qwen3-1.7B—⇩5.314.04.43.15.64.00.00.01.70.00.00.00.00.08.92.67.7
Qwen3-4B—⇩9.628.05.32.18.82.00.00.00.80.04.00.00.01.015.30.012.3
Qwen3-8B—⇩14.926.07.05.211.54.00.00.01.716.012.00.00.07.017.22.614.4
Environment-Trained Baselines
Toucan-7B119,300⇩9.68.00.03.14.86.02.00.03.30.00.00.00.00.026.12.621.5
EnvACE-1.7B8,129⇩4.418.00.92.14.52.00.00.00.80.00.00.00.00.06.40.05.1
EnvACE-8B8,129⇩12.330.03.53.19.64.02.00.02.58.00.00.00.02.016.67.914.9
EnvScaler-1.7B11,572⇩7.910.00.91.04.36.04.00.04.28.00.00.00.02.011.52.69.7
EnvScaler-4B11,572⚙11.426.010.55.211.58.04.010.06.724.00.00.00.06.013.40.010.8
EnvScaler-8B11,572⇩21.922.07.04.112.812.06.05.08.324.04.04.04.09.024.87.921.5
Arctic-AWM-4B3,315⇩3.516.06.13.15.90.00.00.00.08.00.00.00.02.08.30.06.7
Arctic-AWM-8B3,315⇩12.326.010.54.111.52.02.00.01.78.012.00.00.05.015.97.914.4
Agent-World-4B3,000⚙12.326.07.01.09.612.04.00.06.724.04.00.00.07.021.70.017.4
Agent-World-8B3,000⚙14.018.07.02.19.314.06.05.09.236.08.012.00.014.024.25.320.5
Our Models
CrossEnv-1.7B2,954⚙5.312.07.93.16.412.04.00.06.74.04.00.00.02.08.92.67.7
CrossEnv-4B2,954⚙11.422.010.52.110.112.010.00.09.28.08.08.04.07.022.35.319.0
CrossEnv-8B2,954⚙14.928.09.74.112.314.010.05.010.824.016.08.08.014.027.47.923.6

Table 3. Performance on four external benchmarks. Source: ☁ hosted API; ⇩ public checkpoint deployed locally; ⚙ trained in this work. Avg. is weighted by subset size. Bold and underlined scores indicate the best and second-best among the displayed 1.7B–8B models.

(1) Consistent gains over base models. Across all three model sizes, CrossEnv improves or matches the corresponding Qwen3 backbone on each benchmark. At 8B, scores increase from 1.7 to 10.8 on DeepPlanning, 7.0 to 14.0 on VitaBench, and 14.4 to 23.6 on Claw-Eval, showing gains across constrained planning, coordinated service interactions, and general assistant tasks.

(2) Competitive performance with fewer training records. Among the evaluated 1.7B–8B models, CrossEnv-8B achieves the highest aggregate scores on DeepPlanning and Claw-Eval and ties with Agent-World-8B on VitaBench. With 2,954 training records, approximately one quarter of EnvScaler’s reported dataset, it outperforms EnvScaler-8B on three of the four benchmarks.

(3) Gains vary across capabilities and model scales. CrossEnv improves planning and service coordination across all three model sizes, with larger models also showing stronger gains on general assistant tasks. Improvements on interactive tool use are more modest. These results indicate benefits across multiple capabilities, with the extent of improvement varying by task type and model scale.

Curriculum Learning Analysis

Capability development and retention. We track Qwen3-8B from Base through L5 on fixed evaluation sets (Figure 3). L1 SFT improves basic tool use, while subsequent stages improve the model’s ability to act across required environments and execute later workflow steps. These gains do not always translate immediately into correct outcomes: the model executes more required tools at L3 but passes fewer final-state checks. More final-state checks pass at L4 and L5, with user interaction also improving at L5. Although some execution scores decrease slightly at later stages, most earlier gains are retained. Overall, the model learns to coordinate more complex workflows while largely preserving previously acquired tool-use skills.

Figure 3. Qwen3-8B capability scores from Base to L5. Shading highlights the corresponding training stages. Panel (e) reports a composite interaction score, not a success rate (Appendix § 15.§ 2).

Comparison with mixed training. We compare curriculum and mixed training from the same L1 SFT checkpoint using the same L2–L4 task pools. At checkpoints with similar cumulative RL GPU-hours, curriculum training achieves higher success at every task level (Figure 4(a)). Starting with shorter two-environment tasks before introducing longer, more complex workflows may reduce the interaction cost per sample early in training. Curriculum training also accumulates more rollouts within a comparable compute budget (Figure 4(b)). These results support the value of the progressive curriculum for both training effectiveness and efficient use of compute under the current configurations.

Curriculum vs. Mixed (8B)

Figure 4. Curriculum vs. Mixed (8B): (a) strict success at similar GPU-hours; (b) cumulative rollouts.

Generalization Analysis

We examine whether learned skills transfer to new environment combinations, longer workflows, and external tasks less similar to training data.

Generalization to unseen environment combinations. We evaluate combinations of familiar environments that were never used together in a training task. Table 4 compares gains over Base on seen and unseen combinations, with task success requiring all task requirements to be met. CrossEnv improves task success on both groups at all three model sizes, showing transfer to new combinations of familiar environments.

ModelPairSuccessObs.StateAnswer
1.7BSeen+6.7+40.7+37.5+22.2
1.7BUnseen+5.3+38.90.0+11.1
4BSeen+30.0+43.7+48.5+32.2
4BUnseen+24.0+33.7+26.9+22.5
8BSeen+28.0+44.3+30.4+26.4
8BUnseen+16.0+34.3+14.6+13.0

Table 4. CrossEnv gains over Base on seen and unseen environment combinations (percentage points). Obs.: observation.

Generalization to longer workflows. We evaluate curriculum checkpoints on two sets of tasks with reference workflows of 16–18 and 24–28 tool calls, both exceeding the training maximum of 14 calls. Figure 5 shows the average proportion of task checks passed. From L1 to L4, both 4B and 8B improve on both sets, while 1.7B shows a late-stage decline on longer tasks. These results suggest that training on shorter workflows can improve performance on longer tasks, although gains vary by model size.

Generalization to longer workflows

Figure 5. Generalization to longer workflows. Scores show the average proportion of task checks passed (%).

Transfer across task similarity. We examine whether CrossEnv learns transferable skills beyond its training tasks. Inspired by EnvScaler (Song et al., 2026), we use instruction-level semantic similarity as a proxy for task similarity. In Figure 6, both model sizes improve over Base on average in the lowest-similarity group of each benchmark, while higher similarity does not consistently yield larger gains. These results support generalization to tasks less similar to the training data.

Task similarity and CrossEnv gains over Base at 4B and 8B

Figure 6. Task similarity and CrossEnv gains over Base at 4B (left) and 8B (right). Lines show mean gains in four similarity groups with 95% confidence intervals.

The Value of Cross-Environment Tasks

Performance comparison. We compare single-and cross-environment RL using the same SFT cold-start initialization (Table 5). CrossEnv outperforms Base, SFT, and SingleEnv on DeepPlanning and Claw-Eval; on τ2\tau^2-bench, it exceeds SFT and SingleEnv and matches Base.

MetricBaseSFTSingleEnvCrossEnv
Benchmark performance
τ2\tau^2-bench11.58.58.811.5
DeepPlanning1.73.36.77.5
Claw-Eval14.416.915.420.0
Execution capabilities
Output reuse6.78.31.711.7
Later-step success23.318.328.333.3
Joint success5.01.70.08.3

Table 5. Qwen3-8B comparison (%). Bold: row best.

Execution analysis. To understand why cross-environment training yields larger gains than single-environment training, we systematically analyze evaluation trajectories across the four evaluation benchmarks. The differences center on three aspects: (1) output reuse, correctly using prior tool outputs in subsequent operations; (2) later-step success, continuing execution to complete required later operations; and (3) joint success, satisfying all service goals and task constraints together (Appendix § 17). CrossEnv outperforms SingleEnv on all three metrics (Table 5), suggesting that cross-environment training helps models coordinate multiple operations toward a shared goal.

Synthesis Quality and Construction Cost

Execution and verification quality. We randomly sample 100 tasks, stratified by domain, with 50 each from MCP and Skill environments. All reference workflows run successfully and pass all checks. Further tests on subsets confirm that: (1) resetting the environments and rerunning the workflows yields the same results; (2) skipping a required operation prevents full credit; and (3) reordering queries without changing their results still earns full credit (Appendix § 18).

Scalability and construction cost. As the environment pool grows, CrossEnv combines new environments with existing ones, enabling more task combinations and accelerating growth in candidate task yield (Figure 7(a)). These combinations reuse environment data, tools, and entity relations without repeating environment construction, so the average construction cost per candidate generally decreases as output grows (Figure 7(b)). Although supporting long cross-environment workflows requires a higher initial investment, this reuse eventually reduces CrossEnv’s average construction cost to approximately 4.0k tokens per candidate, below our reproduced AgentWorld result and the EnvScaler estimate based on reported figures.

Output yield and average environment-build cost

Figure 7. Output yield and average environment-build cost. *: estimates.

Conclusion

We presented CrossEnv, a framework for synthesizing executable and verifiable cross-environment tasks with consistent data, and CrossEnv-Curriculum, a progressive training scheme for learning from these tasks. Across four external benchmarks, combining cross-environment data with curriculum training achieves competitive performance with fewer training examples. Our analyses suggest that cross-environment tasks improve workflow coordination, while progressive training achieves higher success and collects more rollouts at comparable compute. Further evaluations provide evidence of transfer to new environment combinations, external environments, and workflows longer than those seen during training.

Limitations

Programmatically synthesized environments may simplify real-world service behavior, including changing interfaces, noisy responses, and complex business constraints. Although CrossEnv aligns task-specific data to support coherent workflows, transfer to real services with dynamically changing data and operational conditions requires further evaluation.

Our generalization evidence is bounded by the evaluated environments and workflow lengths. The combination experiments test new combinations of familiar environments, while the longer-workflow experiments extend to 24–28 reference tool calls and measure the proportion of task checks passed. These results do not establish reliable end-to-end completion in entirely new services or substantially longer workflows.

Some training comparisons do not fully isolate the factors contributing to performance gains. In particular, curriculum and mixed training use similar cumulative GPU-hours but differ in batch configuration, parallelism, and reference-model settings, limiting attribution of the gains solely to curriculum order. Likewise, comparisons of training-record counts across methods do not establish equivalent advantages in training compute.

Ethical Considerations

CrossEnv aims to reduce the effort required to construct cross-environment tasks for agent training. By synthesizing executable and verifiable workflows, it supports research on tool use and service coordination. This capability has potential dual-use implications: tasks designed for beneficial automation could also be adapted to train agents for harmful purposes. We encourage responsible use of the framework and synthesized tasks, and careful evaluation of trained agents before deployment in sensitive applications.

AI Use Statement

We used generative AI tools to assist with manuscript drafting and language editing. The authors reviewed the resulting content and take full responsibility for the final manuscript.

Detailed CrossEnv Method

Building on the task definition in Equation (1), this appendix supplements Section 3 with formal interaction and graph definitions, seed sources and taxonomy statistics, tool testing procedures, and detailed data alignment and verification. It also specifies the reference replay and independent-agent filtering criteria used to retain tasks.

Agentic Interaction across Environments

We consider an agent that completes tasks by invoking tools across multiple environments and interacting with a user when required. Each environment Ei=(Si,Ti,Oi,Fi)E_i = (S_i, T_i, O_i, F_i) consists of a state space SiS_i, a tool set TiT_i, an observation space OiO_i, and an execution function FiF_i. The state represents the current application data. Let E={E1,…,En}\mathcal{E} = \{E_1, \ldots, E_n\} denote the available environments. For a task τ\tau, only its participating environments ES⊆E\mathcal{E}_S \subseteq\mathcal{E} enter the joint state st=(st(i))Ei∈ESs_t = (s_t^{(i)})_{E_i \in\mathcal{E}_S}, with s0=s0,τs_0 = s_{0,\tau}. We suppress the task index on subsequent states for readability. At each step, the agent selects an action using the task instruction II and interaction history hth_t. For a tool call, at=(it,ft,xt)a_t = (i_t, f_t, x_t), where Eit∈ESE_{i_t} \in\mathcal{E}_S, ft∈Titf_t \in T_{i_t}, and xtx_t denotes the tool arguments. The selected environment executes the call and returns an observation:

(st+1(it),ot)=Fit(st(it),(ft,xt)),\left(s_{t+1}^{(i_t)}, o_t\right) = F_{i_t}\left(s_t^{(i_t)}, (f_t, x_t)\right),
st+1(j)=st(j)(Ej∈ES, j≠it).(2)s_{t+1}^{(j)} = s_t^{(j)} \quad(E_j \in\mathcal{E}_S,\ j \ne i_t). \tag*{(2)}

For tasks requiring user interaction, ata_t may instead be a user-directed message. The task’s user interaction interface supplies a reply observation oto_t and determines any associated application-state changes. User exchanges are recorded in hth_t alongside tool calls and their outputs. Equation (2) describes tool execution only.

The agent selects actions from the task instruction and interaction feedback, using earlier tool outputs to coordinate subsequent operations (Yao et al., 2023; Wang et al., 2024). Let A=(a0,…,aT−1)A = (a_0, \ldots, a_{T-1}) denote the action sequence, including tool calls and user-directed interactions where applicable, and let T=∣A∣T = |A|. The resulting observations OA=(o0,…,oT−1)O_A = (o_0, \ldots, o_{T-1}) include tool outputs and any user replies. The same convention applies to the reference sequence A∗A^*. Task completion is evaluated using these observations and the final joint state sTs_T of the participating environments (Trivedi et al., 2024; Yao et al., 2024; Wu et al., 2025). Each executable rule c∈Cτc \in C_\tau returns a binary result; task completion requires

c(OA,sT)=1,∀c∈Cτ.(3)c(O_A, s_T) = 1,\qquad\forall c \in C_\tau. \tag*{(3)}

Phase 1: Single-Environment Research

Environment theme collection. Diverse environment themes provide concrete application scenarios and operational context for environment synthesis. We collect environment seeds from MCP services and publicly available agent skill documents. MCP services provide functionality descriptions and tool interfaces, while skill documents describe task-specific procedures and workflows. After filtering the seeds and organizing their capabilities, we obtain 801 MCP seeds and 682 skill seeds, covering 14,657 tool capability descriptions. These serve as the starting points for environment research and construction.2

Environment taxonomy construction. To support coherent cross-environment task composition, we organize environment seeds using a two-level taxonomy of 10 business domains and 84 capability categories, drawing on the Agent-World taxonomy [8] and the business characteristics and capabilities of our seeds. Each seed is assigned one primary domain and capability category, while a capability may be associated with multiple domains.

Environment research and data construction. Given an environment seed, a research agent retrieves relevant documentation and available data using the environment description and tool functionality descriptions. A data construction agent then organizes the environment data from these findings. When information is missing, it sends a request to the research agent for further retrieval. Once sufficient information is available, this process produces the initial database, which represents the initial state s0(i)s_0^{(i)} of environment EiE_i.

Phase 2: Local Dependency Graphs

Entity extraction. Using the initial database and tool descriptions, we abstract the application objects queried or manipulated by tools into entity types and organize their descriptive information as attributes. All environments share an entity type set CC, where each type is defined as

c=(nc,Ac)∈C,Ac=⋃i:c∈ViAc(i),(4)c = (n_c, \mathcal{A}_c) \in C,\qquad\mathcal{A}_c = \bigcup_{i:c\in V_i}\mathcal{A}_c^{(i)}, \tag*{(4)}

where ncn_c is the entity type name, Ac(i)\mathcal{A}_c^{(i)} is its attribute set in environment EiE_i, and Ac\mathcal{A}_c is the union of these attributes across environments. The entity types extracted from EiE_i form the node set Vi⊆CV_i \subseteq C of its local dependency graph. This representation connects corresponding entity types across environments without selecting or equating concrete database records; task-specific records are aligned in Phase 5.

Relation extraction. We then represent tool functionality as relations between entity types and associate each relation with the tools that implement it. In Figure 2, for example, reserve_room supports a booking relation from Person to Hotel, while search_hotels supports a search relation from City to Hotel. The figure labels these relations with their supporting tool names. This yields a local dependency graph

Gi=(Vi,Ri),r=(u,ρ,v,Tr)∈Ri,(5)G_i = (V_i, R_i),\qquad r = (u,\rho,v,T_r) \in R_i, \tag*{(5)}

where ViV_i is the entity type set and RiR_i is the set of directed relations. Each relation rr contains a source entity type u∈Viu \in V_i, a relation label ρ\rho describing its semantics, a target entity type v∈Viv \in V_i, and a set of supporting tools Tr⊆TiT_r \subseteq T_i.

Phase 3: Cross-Environment Graph Composition

Connecting environments through shared entity types. Tools in different environments may provide different operations on the same entity type. We merge the local graphs through shared entity types while retaining the environment associated with each relation and its tools. The resulting cross-environment dependency graph is

G×=(V×,R×),G^\times= (V^\times, R^\times),
V×=⋃iVi,V^\times= \bigcup_i V_i,
R×=⋃i{(i,r)∣r∈Ri}.(6)R^\times= \bigcup_i \{(i,r) \mid r \in R_i\}. \tag*{(6)}

Each shared entity type corresponds to a single node in the composed graph. Its attributes aggregate information from different environments, while its incident edges retain the operations supported by each environment. To incorporate a new environment, we extract its entities and relations and connect its local graph to the existing graph through shared entity types. We can then sample task combinations that include the new environment.

Task skeleton sampling. We select connected relations and their associated tools from the cross-environment graph to form task skeletons. Candidate combinations are assessed along three dimensions: entity relationships, which indicate whether operations in different environments can involve common objects; complementary operations, which indicate whether create, read, update, and delete (CRUD) operations can form a coherent workflow; and business relevance, which indicates whether the capabilities naturally belong in the same task. Filtering candidates along these dimensions yields a task skeleton

S=(VS,RS),VS⊆V×,RS⊆R×,(7)S = (V_S,R_S),\qquad V_S \subseteq V^\times,\qquad R_S \subseteq R^\times, \tag*{(7)}

where (VS,RS)(V_S,R_S) is a connected subgraph specifying the entity types, relations, and supporting tools. Its participating environments are ES={Ei∣(i,r)∈RS}\mathcal{E}_S = \{E_i \mid(i,r) \in R_S\}, and TST_S denotes their selected supporting tools. The index ii in each relation identifies its source environment. We then assign a task objective to the selected combination, specifying what the operations should accomplish together. This determines which operations must use earlier results and which cross-environment constraints the final outcomes must satisfy. The subgraph specifies the skeleton’s structure, while the objective and constraints supply its task semantics. If the workflow requires additional operations, we record the corresponding tool requirements.

Structural difficulty control. We control task skeleton complexity along two dimensions: the number of environments and their semantic scope. Restricting the number of environments controls the scale of coordination required by a task. Restricting their business domains controls its semantic scope, from coordination within a single domain to coordination across domains.

User interaction. We additionally specify whether a task requires interaction with the user. In CrossEnv-Curriculum, L5 introduces user interaction while retaining L4’s environment-count and business-domain-scope requirements, as described in § 4.

Phase 4: Tool Synthesis and Testing

Tool synthesis. Given a task skeleton, we group the required tools by environment, reuse existing implementations that have passed testing, and use a coding agent to implement missing tools. The coding agent uses tool descriptions, research findings, and the initial database to generate executable code that reads or modifies data and returns results. This turns the tool capabilities associated with graph relations into executable operations. For environment EiE_i, the tested implementations define the execution function FiF_i introduced in Section A.1.

Tool testing. We invoke the generated tools and check whether their outputs and data changes match the expected behavior. For read operations, we check that the returned information is correct and the data remains unchanged. For create, update, and delete operations, we check that the intended changes occur and confirm them through subsequent queries. We also test invalid inputs and conflicting operations to assess error handling. Failures are returned to the coding agent for correction, followed by another round of testing. The executable environments are considered complete only when all tools required by the skeleton pass these tests.

Phase 5: Task Instantiation and Verification

Task instantiation. Given a task skeleton SS, its objective, and its constraints, we select concrete entities and data for the task. Because the initial states s0(i)s_0^{(i)} are constructed independently, records for the same object may be missing or contain conflicting information across relevant environments. We supplement required records and resolve conflicts so that the selected objects and cross-environment constraints are consistent. Initial data and reference actions are planned jointly: records needed by read, update, and delete operations must either exist initially or be created by earlier actions; records that the task requires the agent to create are not inserted in advance. This produces a task-specific initial state s0,τ(i)s_{0,\tau}^{(i)} for each environment and the joint initial state

s0,τ=(s0,τ(i))Ei∈ES.(8)s_{0,\tau} = \left(s_{0,\tau}^{(i)}\right)_{E_i\in\mathcal{E}_S}. \tag*{(8)}

Reference execution and task generation. Starting from s0,τs_{0,\tau}, we execute the planned actions, including user interaction where required, and record their observations and data changes. Later actions can use results produced by earlier operations. If execution diverges from expectations, we revise the task data and action plan based on the feedback and execute the plan again. Once execution succeeds, we retain the reference action sequence A∗A^* and generate the task instruction II from the scenario and execution results.

Verification rule generation. We derive executable verification rules CτC_\tau from the task objective and constraints, using the tool outputs and data changes observed during reference execution to specify expected outcomes. These rules check whether the required records have been created, updated, or deleted; whether returned results satisfy the specified conditions; and whether related information is consistent across environments. We then construct negative cases, such as omitted operations and incorrect values, to check whether the rules reject incomplete or incorrect task outcomes.

Task verification. For an action sequence AA, let T(A)=∣A∣T(A)=|A| and define its binary verification outcome as

Pass⁡τ(A)=∏c∈Cτc(OA,sT(A)),(9)\operatorname{Pass}_{\tau}(A)=\prod_{c\in C_\tau}c(O_A,s_{T(A)}), \tag*{(9)}

where execution starts from s0,τs_{0,\tau} and sT(A)s_{T(A)} contains the final states of ES\mathcal{E}_S. This is one exactly when every verification rule passes. We use two levels of verification: reference action replay and independent agent attempts. First, we reset all participating environments to s0,τs_{0,\tau}, replay A∗A^*, and require reproducible results with Pass⁡τ(A∗)=1\operatorname{Pass}_{\tau}(A^*)=1. We then run five independent agent attempts using the task instruction, available tools, and user interaction where required, with every attempt starting from the same initial state. Let A(k)A^{(k)} denote the action sequence from attempt kk. Following successful reference replay, we retain the task if ∑k=151[Pass⁡τ(A(k))]≥2\sum_{k=1}^{5}\mathbf{1}[\operatorname{Pass}_{\tau}(A^{(k)})]\ge2. These two checks assess the reproducibility of the reference solution and whether an agent can find a valid solution from the task instruction and interfaces, respectively.

The retained task follows Equation (1), with aligned initial states s0,τs_{0,\tau}, a successful reference sequence A∗A^*, and executable verification rules CτC_\tau.

Environment Taxonomy

Table 6 lists 10 business domains (C1C_1) and 84 capability categories (C2C_2). Categories may span domains; each seed has one primary domain and category, assigned by its main purpose.

Business domain (C1C_1)Capability categories (C2C_2)
TravelFlight booking; Accommodation booking; Food and dining; Transit and navigation; Earth science and environmental monitoring; Maps and location services; Weather and forecasting; Itinerary planning; Currency exchange; Messaging and notification; Task and project management; Local search; Calendar and scheduling.
Work & OfficeDecision support; Messaging and notification; Task and project management; Calendar and scheduling; Email management; Document processing; Presentation and design; Knowledge management; Web search; Customer support.
Life ServicesFood and dining; Transit and navigation; Earth science and environmental monitoring; Maps and location services; Weather and forecasting; Messaging and notification; Calendar and scheduling; Shopping; Home services; Local news; Medical appointment booking; Billing and payments; Arts, culture, and museums; Events and entertainment; Gaming and interactive experiences; Real estate services.
Finance & InvestmentCurrency exchange; Billing and payments; Crypto market data; Market intelligence; Stock and equity investment; Blockchain infrastructure and wallets; DeFi and DEX protocols; Accounting; Risk management and compliance.
Health & WellnessMedical appointment booking; Biomedical research; Medical information lookup; Fitness tracking; Nutrition and diet; Mental wellness.
Academic ResearchEarth science and environmental monitoring; Knowledge management; Biomedical research; Literature search; Citation analysis; Data collection and processing; Arithmetic and general calculation; Scientific and symbolic computing; Statistical analysis; Academic writing and collaboration; Data visualization; Experiment design.
Data AnalyticsEarth science and environmental monitoring; Trend analysis and analytics; NoSQL and document stores; Relational databases; Arithmetic and general calculation; Scientific and symbolic computing; Statistical analysis; Data visualization; Agent orchestration and multi-agent workflows; Model hubs and LLM APIs; Machine learning; Data pipelines; Knowledge graphs and vector retrieval; Web scraping; Report generation.
Content CreationTrend analysis and analytics; Video and audio production; Image generation and editing; Social network integration; Video and content platforms; Writing and copywriting; Graphic design; Content scheduling; Agent orchestration and multi-agent workflows; Model hubs and LLM APIs.
Software EngineeringCode development; Package and dependency management; Cloud services and deployment; CI/CD and DevOps; Browser control and interaction; Software testing and quality assurance; NoSQL and document stores; Relational databases; API integration and testing; Shell and infrastructure; Frameworks and libraries; Technical documentation.
CybersecurityCompliance and audit; Log analysis; Security assessment; Threat intelligence; Network monitoring and response; Identity and access management; Security training.

Table 6. Complete environment taxonomy. The table covers all 10 business domains and all 84 unique capability categories. Categories shared across domains are repeated with identical names; the number of domain–capability associations therefore exceeds 84.

Curriculum and Training Details

This appendix specifies task partitions, checkpoint initialization, and training objectives for § 4. Appendix § 15 documents curriculum evaluation, and Appendix § 16 documents generalization tests.

Curriculum Organization

Task levels. Tasks are grouped into L1–L5 according to environment count, business-domain scope, and user interaction. L1 contains single-environment tasks, which use the representation in Equation (1) with ∣ES∣=1|\mathcal{E}_S| = 1. Within a single business domain, L2 introduces tasks involving two environments, and L3 extends coordination to three or more environments. L4 requires coordination across multiple business domains and three or more environments. L5 retains L4’s environment-count and domain-scope requirements and introduces user interaction. Let D\mathcal{D} denote the synthesized training tasks. The task set at each level is

Dk={τ∈D∣level⁡(τ)=Lk},k=1,…,5.(10)\mathcal{D}_k = \{\tau\in\mathcal{D} \mid\operatorname{level}(\tau) = L_k\}, \qquad k = 1,\ldots,5. \tag*{(10)}

Single-Environment Supervised Fine-Tuning

We perform SFT on reference execution trajectories from D1\mathcal{D}_1 to teach tool selection, argument specification, and the use of tool outputs to guide subsequent actions (Qin et al., 2023; Yang et al., 2025b; Xu et al., 2025b). For task τ\tau, let A∗=(a0∗,…,aTτ−1∗)A^* = (a^*_0,\ldots,a^*_{\mathcal{T}_\tau-1}) denote the reference action sequence, with length Tτ=∣A∗∣T_{\tau}=|A^{*}|. Here, II denotes the task instruction and hth_t contains the preceding interactions. The policy πθ\pi_{\theta} predicts actions conditioned on II and hth_t. The training objective is

LSFT(θ)=−Eτ∼D1∑t=0Tτ−1log⁡πθ(at∗∣I,ht).(11)\mathcal{L}_{\mathrm{SFT}}(\theta)=-\mathbb{E}_{\tau\sim D_1}\sum_{t=0}^{T_{\tau}-1}\log\pi_{\theta}(a_t^{*}\mid I,h_t). \tag*{(11)}

The resulting checkpoint θ1\theta_1 initializes subsequent cross-environment RL.

Stagewise Reinforcement Learning on Cross-Environment Tasks

Stagewise training. Starting from the L1 SFT checkpoint, we train sequentially on L2–L5. For k=2,…,5k=2,\ldots,5, stage kk uses DkD_k and is initialized with θkinit=θk−1\theta_k^{\mathrm{init}}=\theta_{k-1}. We denote the checkpoint obtained after this stage by θk\theta_k.

Execution feedback. For a sampled task τ\tau, the agent starts from the joint initial state s0,τs_{0,\tau} and selects tool calls based on the instruction II and interaction history hth_t. At L5, execution also includes interaction with a user. Let AA denote the agent’s action sequence, including tool calls and user-directed interactions where applicable. The verification rules CτC_{\tau} evaluate its outputs and final states, producing the execution reward rτ(A)r_{\tau}(A). The training objective at level kk is

Jk(θ)=Eτ∼DkEA∼πθ(⋅∣τ)[rτ(A)],k=2,…,5.(12)J_k(\theta)=\mathbb{E}_{\tau\sim D_k}\mathbb{E}_{A\sim\pi_{\theta}(\cdot\mid\tau)}[r_{\tau}(A)], \qquad k=2,\ldots,5. \tag*{(12)}

Here, πθ(⋅∣τ)\pi_{\theta}(\cdot\mid\tau) denotes the rollout distribution induced by the policy interacting with task τ\tau; the policy observes only the instruction and interaction history, not the underlying environment states or verification rules.

Training Configuration

The mainline uses Qwen3 backbones at 1.7B, 4B, and 8B. Table 2 gives the stagewise data counts. The settings below document L1 SFT and L2–L5 RL: single-environment supervision is followed by two-environment tasks within one domain, three-environment tasks within one domain, three-environment tasks across domains, and tasks requiring user interaction. At each transition, we load the selected policy weights from the preceding stage and reinitialize the optimizer and task sampler. The paper’s L4 corresponds to L5 in the historical experiment directories; this naming is distinct from the paper’s subsequent user-interaction stage.

ParameterL1 SFTL2–L5 RL
Learning rate5×10−75\times10^{-7} (peak)5×10−75\times10^{-7} (constant)
LR schedule≈10%\approx10\% warmup, cosine decayConstant
Global batch8 assistant responses16 task slots
Samples per taskReference supervision8 trajectories
PPO epochs—1
KL coefficient—0.001 in the loss
Temperature—Train: 1.0 Validation: 0

Table 7. Training configuration for L1 SFT and L2–L5 RL. Each RL batch contains 128 sampled trajectories.

L5 user interaction. L5 retains the L4 optimization settings and reward formulation, including the interaction-turn budgets. Qwen3.8-Flash generates user replies during interaction. The agent initially receives only the public task instruction, with user-specific facts withheld. It can request this information by calling ask_user with a question argument. The reply is appended to the context as a tool-role message, after which the agent continues execution. Each task allows at most three questions. These calls consume assistant turns, context, and wall-clock time, but do not count toward the environment’s business-action budget.

Supervised loss. SFT supervises only the current assistant response. Preceding dialogue and tool feedback are masked from the loss, so the global batch size counts assistant-response samples rather than complete trajectories.

GRPO advantages. RL uses trajectory-level outcome GRPO. For the eight trajectories sampled for a task, let RiR_i be trajectory ii’s terminal reward, and let μR\mu_R and σR\sigma_R be the within-group reward mean and standard deviation. The normalized advantage is

A^i=Ri−μRσR+10−6.(13)\hat{A}_i=\frac{R_i-\mu_R}{\sigma_R+10^{-6}}. \tag*{(13)}

This advantage is assigned to all assistant-generated tokens in that trajectory. The KL term is added to the optimization loss with coefficient 0.001.

Terminal Reward

For L2–L5, the terminal reward combines progress on task checks, constraint violations, invalid actions, and completion bonuses:

R=0.85(PT−P0)−0.20(VT−V0)−0.01ninvalid+0.10IF+0.05IFIDe.(14)R = 0.85(P_T - P_0) - 0.20(V_T - V_0) - 0.01n_{\mathrm{invalid}} + 0.10I_F + 0.05I_F I_D e. \tag*{(14)}

Here, PP is the weighted fraction of task checks passed, and VV is the weighted fraction of invariant constraints violated; subscripts 0 and TT denote the initial and terminal values. The count ninvalidn_{\mathrm{invalid}} records invalid actions. The indicator IFI_F requires all execution checks to pass and a valid final answer, while IDI_D indicates satisfaction of the tool-discovery protocol. The efficiency term is

e=clip⁡(Tmax⁡−TTmax⁡−Tref,0,1),(15)e = \operatorname{clip}\left(\frac{T_{\max} - T}{T_{\max} - T_{\mathrm{ref}}}, 0, 1\right), \tag*{(15)}

where TT is the number of interaction turns. The budget parameters (Tmax⁡,Tref)(T_{\max}, T_{\mathrm{ref}}) are (32,18)(32, 18) for L2 and (40,30)(40, 30) for L3–L5. Thus, the reward gives partial credit for progress and is not a binary task-success signal.

Evaluation Model Versions

Table 8 lists all models in Table 3, their sources, and available evaluation identifiers. The GPT-5.6-Luna and Gemini-3.8-Flash API IDs are recorded in the evaluation configurations and request code. IDs marked Claw-Eval are recorded for that benchmark; their use on other benchmarks remains to be verified. API IDs record requested model names; backend snapshots remain unverified. Hugging Face repositories identify public releases, but their evaluation revisions remain to be verified against the run configurations. Agent-World entries include the frozen checkpoint identifiers recorded for our in-house reproductions. For EnvScaler-4B and CrossEnv, we report the Qwen3 backbone; CrossEnv entries also specify the final curriculum stage. The Qwen3.8 link describes a related open-weight release and does not establish equivalence to the Max API.

ModelVersion / source
Frontier closed-source models
GPT-5.6-LunaOpenAI model documentation API ID: gpt-5.6-luna
Claude-Haiku-4.5Anthropic model announcement Claw-Eval API ID: bedrock/claude-haiku-4_5
Gemini-3.8-FlashGoogle DeepMind model card API ID: gemini-3.8-flash
Qwen3.8-MaxClaw-Eval API ID: qwen3.8-max-0902 Qwen/Qwen3.8-2.4T-A95B (related model card)
Open-weight general-purpose models
DeepSeek-V4-Prodeepseek-ai/DeepSeek-V4-Pro-0813 Recorded ID: deepseek-v4-pro-0813
GLM-5.3zai-org/GLM-5.3 Claw-Eval API ID: glm-5.3
Kimi-K3moonshotai/Kimi-K3 Claw-Eval API ID: kimi-k3
Qwen3-1.7BQwen/Qwen3-1.7B
Qwen3-4BQwen/Qwen3-4B
Qwen3-8BQwen/Qwen3-8B
Environment scaling methods
EnvScaler-1.7BXXHStudyHard/EnvScaler-Qwen3-1.7B
EnvScaler-4BOur reproduction; Qwen3-4B backbone
EnvScaler-8BXXHStudyHard/EnvScaler-Qwen3-8B
Arctic-AWM-4BSnowflake/Arctic-AWM-4B
Arctic-AWM-8BSnowflake/Arctic-AWM-8B
Toucan-7BAgent-Ark/Toucan-Qwen2.5-7B-Instruct-v0.1
EnvACE-1.7BTeam-ACE/EnvACE-Qwen3-1.7B
EnvACE-8BTeam-ACE/EnvACE-Qwen3-8B
Agent-World-4BOur reproduction; Qwen3-4B RL step50 AgentWorld-Qwen3-4B-dlcxnsnwrsoefb16-step50
Agent-World-8BOur reproduction; Qwen3-8B RL step50 AgentWorld-Qwen3-8B-dlc13s4sujlwtirs-step50
CrossEnv
CrossEnv-1.7BTrained in this work (Qwen3-1.7B); final L5 checkpoint
CrossEnv-4BTrained in this work (Qwen3-4B); final L5 checkpoint
CrossEnv-8BTrained in this work (Qwen3-8B); final L5 checkpoint

Table 8. Model versions and sources.

Evaluation Protocol Notes

Benchmark Subsets and Metrics

τ2\tau^2-bench. We evaluate Retail (114 tasks), Airline (50), Telecom (114), and the Banking Knowledge extension (97) (Shi et al., 2026), for a total of 375 tasks. These domains assess conversational task completion under domain-specific rules; Telecom additionally requires coordination with a user who can act in the environment. We report pass@1.

DeepPlanning-Shopping. We evaluate the L1, L2, and L3 difficulty subsets, containing 50, 50, and 20 tasks, respectively. These 120 tasks assess information gathering and planning under local and global constraints. We report the average case score. These benchmark difficulty labels are separate from the CrossEnv curriculum levels.

VitaBench. We evaluate 25 tasks from each of Delivery, In-store, OTA, and the cross-scenario subset, for a total of 100 tasks. They assess service execution, information integration, and adaptation to user requests, with the cross-scenario subset requiring coordination across services. We report pass@1.

Claw-Eval. We evaluate the adapted text subset of 157 General and 38 Multi-Turn tasks, excluding tasks involving multimodal content. General covers service orchestration, while Multi-Turn covers professional dialogue. We report pass@1; the task-score threshold and protocol adaptations are specified below.

The four benchmarks comprise 790 tasks per model: 375 from τ2\tau^2-bench, 120 from DeepPlanning, 100 from VitaBench, and 195 from Claw-Eval. Within each benchmark, Avg. is weighted by subset size. Capability groups describe the main evaluation emphasis rather than mutually exclusive abilities: VitaBench and Claw-Eval Multi-Turn also involve user interaction.

Evaluation Settings

Checkpoints and decoding. We evaluate CrossEnv models after L1–L5 training. Capability tracking extends through L5. The Mixed comparison and longer-workflow tests use checkpoints through L4. Agent-World-4B and Agent-World-8B use our reproduced Qwen3 RL step50 checkpoints. The recorded October baseline campaigns use temperature 0, thinking enabled, and no replay of historical reasoning; Toucan uses its native Qwen2.5 non-thinking template. GPT-5.6-Luna and Claude-Haiku-4.5 use temperature 1 on τ2\tau^2-bench, DeepPlanning, and VitaBench. Claw-Eval settings are specified separately below.

τ2\tau^2-bench. The four API reference models Qwen3.8-Max, DeepSeek-V4-Pro, GLM-5.3, and Kimi-K3 use a 128K context budget. Qwen3 Base, EnvScaler, Arctic-AWM, and Toucan use 64K. Local runs use the Hermes tool-call adapter with exexplicit model-format handling. Fixed-budget failures receive zero credit and remain in the task denominator.

VitaBench. October runs use a 4,096-token judge output budget. The EnvACE-1.7B and Arctic-AWM-4B runs use a 16,384-token judge budget and a YaRN original-position baseline of 40,960. Tool outputs and user interactions are scored using the benchmark’s task rubrics.

Claw-Eval scoring. We perform one trial per task on the 157 General and 38 Multi-Turn tasks specified above. A native task score of at least 0.75 counts as success. All 195 tasks remain in the denominator, including model errors and fixed-budget failures.

The native score is

q=safety(0.8 completion+0.2 robustness),(16)q = \text{safety}\left(0.8\ \text{completion} + 0.2\ \text{robustness}\right), \tag*{(16)}
task_score=round⁡(q,4).\text{task\_score} = \operatorname{round}(q, 4).

Gen. and MT report subset success rates, and the table’s average is

Avg.⁡=157sGen.+38sMT195.(17)\operatorname{Avg.} = \frac{157s_{\mathrm{Gen.}} + 38s_{\mathrm{MT}}}{195}. \tag*{(17)}

The mean native task score is a separate metric from this success rate.

Claw-Eval local models. Qwen3 and EnvScaler use temperature 0, thinking enabled, no replay of historical reasoning, a 131,072-token context, and an 8,192-token Agent output budget. Toucan-7B, EnvACE-1.7B/8B, and Arctic-AWM-4B/8B use the same context and Agent output budgets; Toucan uses its native non-thinking template. Native per-task turn and time limits are retained. The judge and user simulator use Qwen3.8-Max with output budgets of 8,192 and 65,536 tokens, respectively. Toucan-7B, EnvACE-8B, and Arctic-AWM-8B use eight task workers; Arctic-AWM-4B uses two TP1 replicas with four workers each.

Claw-Eval API models. The recorded identifiers for Qwen3.8-Max, DeepSeek-V4-Pro, GLM-5.3, and Kimi-K3 are qwen3.8-max-0902, deepseek-v4-pro-0813, glm-5.3, and kimi-k3. These models use temperature 0, thinking enabled, and no replay of historical reasoning. Agent output limits follow upstream defaults, with a 131,072-token input-plus-output budget per response; judge and user output budgets are 8,192 and 65,536 tokens. Full evaluations use eight workers per model. GPT-5.6-Luna uses temperature 1 and Responses medium reasoning. Gemini-3.8-Flash uses temperature 0 with native signature handling. Claude-Haiku-4.5 uses the bedrock/claude-haiku-4_5 Chat-compatible API at temperature 0 with thinking requested. These three models have no explicit Agent output cap and use the same 131,072-token input-plus-output budget, with at most eight task workers per model.

Claw-Eval tool interfaces. Tasks run in separate gVisor environments. IQS replaces Google via Novada search. OCR and long-document text are retained in files and exposed through previews and segmented reads; the Read preview limit is 16,000 characters. Adapter configurations include model-specific tool-call parsing, web-fetch transport handling, PDF rendering, and non-UTF-8 output handling. The revised web-fetch configuration uses a cancellable total deadline of at most 30 seconds and a 35-second outer RPC wait.

Curriculum Learning Analysis

We define the metrics used in § 5.3. Each metric uses a fixed evaluation set across checkpoints. For a set of evaluated requirements UU, let bm(u)∈{0,1}b_m(u) \in\{0,1\} indicate whether model mm satisfies requirement uu, and define

rm(U)=100∣U∣∑u∈Ubm(u).(18)r_m(U) = \frac{100}{\lvert U\rvert}\sum_{u \in U} b_m(u). \tag*{(18)}

Stagewise Capability Metrics

Tool execution coverage. This measures whether the agent executes the tools required by reference workflows, capturing basic tool-use coverage. For the evaluated reference tool requirements UtoolU_{\mathrm{tool}},

Stool(m)=rm(Utool).(19)S_{\mathrm{tool}}(m) = r_m(U_{\mathrm{tool}}). \tag*{(19)}

Coverage does not by itself establish correct arguments or task success.

Complete environment coverage. This measures whether the agent acts in every required environment, detecting tasks where it omits an entire service. For task τ\tau, let Eτ\mathcal{E}_{\tau} and E^τ(m)\widehat{\mathcal{E}}_{\tau}(m) be the required and actually used environment sets. On evaluation tasks Denv\mathcal{D}_{\mathrm{env}},

Senv(m)=100∣Denv∣∑τ∈Denv1[Eτ⊆E^τ(m)].(20)S_{\mathrm{env}}(m) = \frac{100}{\lvert\mathcal{D}_{\mathrm{env}}\rvert}\sum_{\tau\in\mathcal{D}_{\mathrm{env}}} \mathbf{1}\left[\mathcal{E}_{\tau} \subseteq\widehat{\mathcal{E}}_{\tau}(m)\right]. \tag*{(20)}

Late-workflow tool coverage. This measures execution of tool requirements in the later portion of reference workflows, assessing whether the agent continues beyond early steps. For the evaluated late-workflow requirements UlateU_{\mathrm{late}},

Slate(m)=rm(Ulate).(21)S_{\mathrm{late}}(m) = r_m(U_{\mathrm{late}}). \tag*{(21)}

Target-state check pass rate. This measures whether execution produces the required business states, complementing action coverage with outcome correctness. For target-state checks UstateU_{\mathrm{state}} evaluable across the compared models,

Sstate(m)=rm(Ustate).(22)S_{\mathrm{state}}(m) = r_m(U_{\mathrm{state}}). \tag*{(22)}

Unavailable checks are excluded consistently across models, rather than counted as failures.

User Interaction Metric

This metric assesses three aspects of user interaction: obtaining required information through a relevant question, using the reply in appropriate tool arguments with normal tool execution, and passing native strict task checks. Their combination captures intermediate progress as well as task completion. Let nqn_q, nun_u, and nsn_s count tasks satisfying these criteria on the same N=40N = 40 held-out interaction tasks:

Sint=100nq+nu+nsN.(23)S_{\mathrm{int}} = 100\frac{n_q+n_u+n_s}{N}. \tag*{(23)}

The score ranges from 0 to 300. The criteria may hold on different tasks, so it is neither a success percentage nor the rate of completing all three steps together.

Curriculum and Mixed RL Metrics

Both schedules initialize from the same Qwen3-8B L1 SFT checkpoint. The compared curriculum and Mixed checkpoints use 243.04 and 238.85 cumulative RL GPU-hours, respectively. Mixed training samples from the L2, L3, and L4 pools of 579, 620, and 600 tasks in a 1:1:1 ratio. Each batch contains eight tasks from each level, for 24 tasks in total, with eight rollouts per task (192 rollouts per batch). Tasks are shuffled independently within each level, and the combined batch is shuffled again. The runs differ in parallelism, batch configuration, and reference-model settings; this comparison therefore assesses the two training schedules at similar compute budgets under their respective configurations, rather than isolating curriculum order.

Strict success measures complete task attainment; cumulative rollouts measure sampling volume at a given compute budget. Let ym(τ)y_m(\tau) indicate that all task requirements pass and njn_j be the rollout count for completed update jj. We report

Success⁡(m)=100∣D∣∑τ∈Dym(τ),Rollouts⁡(h)=∑j:hj≤hnj,(24)\begin{aligned} \operatorname{Success}(m) &= \frac{100}{|\mathcal{D}|}\sum_{\tau\in\mathcal{D}} y_m(\tau),\\ \operatorname{Rollouts}(h) &= \sum_{j:h_j\le h} n_j, \tag*{(24)} \end{aligned}

where hjh_j is cumulative RL GPU-hours at update jj. The comparison uses the same 180 validation tasks at similar GPU-hours. Rollout volume does not measure trajectory validity or task success; the comparison reflects the current training configurations.

Generalization Analysis

We define the tests and metrics used in § 5.4. Combination tests evaluate transfer to new environment pairs, and long-horizon tests evaluate transfer to longer workflows; task-similarity analysis compares CrossEnv and Base at 4B and 8B.

Combination Generalization

This test asks whether an agent can coordinate familiar environments in new combinations. Seen pairs co-occur in training; unseen pairs never co-occur, including within larger training combinations. Each group contains 150 tasks from 30 environment pairs. Strict success uses all tasks, retaining model failures in the denominator. Let ym(τ)y_m(\tau) indicate that model mm passes all task requirements. For group gg,

Sg(m)=100∣Dg∣∑τ∈Dgym(τ).(25)S_g(m)=\frac{100}{|D_g|}\sum_{\tau\in D_g} y_m(\tau). \tag*{(25)}

Table 4 reports Sg(CrossEnv)−Sg(Base)S_g(\mathrm{CrossEnv})-S_g(\mathrm{Base}) in percentage points. Observation, State, and Answer scores localize gains to business observations, final states, and final answers. For category cc, let Dg,cD_{g,c} contain applicable tasks with native scores available for both models, and Cτ,cC_{\tau,c} contain the task’s category-specific hard checks. With binary check outcomes bm(τ,k)b_m(\tau,k),

Sg,c(m)=100∣Dg,c∣∑τ∈Dg,c∑k∈Cτ,cbm(τ,k).(26)S_{g,c}(m)=\frac{100}{|D_{g,c}|}\sum_{\tau\in D_{g,c}}\sum_{k\in C_{\tau,c}} b_m(\tau,k). \tag*{(26)}

Category gains are also CrossEnv minus Base. They require all checks in a category to pass and describe the jointly scored subset, not the full test population.

Long-Horizon Generalization

This test measures transfer to workflows longer than those used in training. Two sets of 40 tasks have reference lengths of 16–18 and 24–28 tool calls, exceeding the training maximum of 14. To capture partial progress, we average each task’s fraction of passed observation and target-state checks:

Score⁡(m)=100∣D∣∑τ∈D∑k∈Cτbm(τ,k)∣Cτ∣.(27)\operatorname{Score}(m)=\frac{100}{|\mathcal{D}|}\sum_{\tau\in\mathcal{D}}\frac{\sum_{k\in C_\tau} b_m(\tau,k)}{|C_\tau|}. \tag*{(27)}

where CτC_\tau contains those checks. Tasks receive equal weight; this is not strict task success. Reference length describes the supplied solution, not a minimum for all valid solutions.

External-Task Similarity

Following the similarity-analysis motivation of EnvScaler (Song et al., 2026), we test whether gains are concentrated on instructions close to training data. We encode instructions with sentence-transformers/all-MiniLM-L6-v2. For test instruction xx, training-instruction set Xtrain\mathcal{X}_{\mathrm{train}}, and embedding function ff, similarity is

s(x)=max⁡z∈Xtrainf(x)Tf(z)∥f(x)∥∥f(z)∥.(28)s(x)=\max_{z\in\mathcal{X}_{\mathrm{train}}}\frac{f(x)^{\mathsf{T}}f(z)}{\lVert f(x)\rVert\lVert f(z)\rVert}. \tag*{(28)}

For normalized native task scores qm(x)q_m(x), per-task and similarity-group gains are

Δ(x)=100(qCrossEnv(x)−qBase(x)),\Delta(x)=100\left(q_{\mathrm{CrossEnv}}(x)-q_{\mathrm{Base}}(x)\right),
Δ‾b=1∣Bb∣∑x∈BbΔ(x).(29)\overline{\Delta}_b=\frac{1}{|\mathcal{B}_b|}\sum_{x\in\mathcal{B}_b}\Delta(x). \tag*{(29)}

where BbB_b is one of four similarity-quantile groups. Figure 6 shows group means with 95% confidence intervals. The VitaBench-8B panel uses 71 paired tasks, native rubric pass fractions, and paired-task bootstrap intervals; this score differs from strict task success. Results describe the plotted subsets, and instruction similarity alone does not establish unseen environments or domains.

Cross-Environment Training Analysis

This appendix defines the execution diagnostics in Table 5. SingleEnv and CrossEnv RL start from a shared SFT checkpoint and differ in whether their training tasks involve single or multiple environments. Base execution scores are historical references.

Execution Diagnostics and Measurement Rules

The three diagnostics describe data dependencies, continuation of execution, and final outcomes. They are related views: one downstream failure can affect multiple metrics, so they do not identify three independent mechanisms.

Use of prior tool outputs. Annotate required cross-service dependencies from task instructions and verification rules, then check whether actual objects, identifiers, amounts, or states returned by earlier services are correctly bound to later operation parameters. Both models must use the same applicable tasks and dependency edges. Failing to obtain required information or omitting its downstream operation counts as unsatisfied. Any conditional rate given successful upstream retrieval must identify that restricted denominator.

Later-step completion. Pre-annotate the business operations required after earlier steps, including retries, notifications, and actions after clearing a blockage. An operation counts as complete only if it executes successfully and produces the required state change. A tool call, mention of its name, or verbal completion claim alone is insufficient; omitted necessary operations remain unsatisfied.

All task constraints met. On tasks with joint goals, require all necessary service outcomes and constraints to hold simultaneously, including correct orders and notifications, specified cleanup objects, and restrictions on extra writes. Score each task by the conjunction of its requirements rather than the mean fraction of atomic checks passed.

Applicable tasks, dependencies, actions, and constraints use the same annotation rules and denominators across models. Infrastructure anomalies and missing scores are recorded separately; execution failures and omitted required operations remain in the denominator.

Synthesis and Verification Quality

This appendix supplements § 5.6 with the current task-quality evaluation and construction-cost accounting.

Execution and Verification Checks

We sample 100 retained L5 tasks, with 50 each from MCP and Skill environments and stratification by domain. All reference workflows execute successfully and receive full scores. On the tested subsets, replay from a reset environment reproduces these outcomes, omission of a required operation prevents a full score, and semantically equivalent query reorderings preserve full scores. These checks concern reference execution, required operations, and equivalent query orders.

Construction-Cost Accounting

Figure 7 compares candidate output yield as the environment pool grows and average environment-construction cost per output. CrossEnv composes new environments with existing ones and reuses their data, tools, and entity relations. The reported CrossEnv pool of 100 environments yields 51,566 candidate tasks, with a recorded environment-construction cost of 206,496,276 tokens. The average cost is therefore

206,496,27651,566≈4,004.5(30)\frac{206{,}496{,}276}{51{,}566} \approx4{,}004.5 \tag*{(30)}

tokens per candidate, consistent with the approximately 4.0k value in § 5.6.

CrossEnv and AgentWorld outputs are screened candidates; EnvScaler outputs are released scenarios. AgentWorld values come from our reproduction, whereas EnvScaler values are estimates derived from its reported figures. Costs cover environment construction rather than end-to-end task generation, and exclude subsequent task instantiation and acceptance. The denominator is candidate output, not the final set of training examples. Dashed extensions in the figure indicate projections under unchanged mean yield and construction cost per additional environment.

Environment and Task Synthesis Comparison Criteria

Table 1 compares explicitly reported synthesis capabilities rather than empirical guarantees or only the default training recipe. A supported optional branch counts as supported; an unsupported mark means that the described pipeline does not explicitly provide the capability.

Executable (Exec.). Actions run through real services or executable code. Execution during data collection counts, without implying that an online RL training environment is released.

Verifiable (Verif.). Executable checks evaluate task outcomes, rather than only syntax or tool functionality. Pure-code verification branches count even when another branch uses an LLM judge.

Controllable (Ctrl.). Explicit settings adjust task complexity through tool count, graph length, branching, constraints, environment count, or discrete complexity levels. Limited support denotes qualitative workflow expansion or adaptive difficulty targeting; a fixed request for diverse or challenging tasks does not constitute an adjustable control.

Cross-environment (Cross). A synthesized task coordinates multiple environments, applications, or services. AWM’s limited support covers bundled service suites, without demonstrated general composition across independently constructed environments.

Consistent (Consist.). The pipeline explicitly aligns entities or data across environments, or enforces cross-environment constraints. Local database consistency alone does not establish this capability.

Extensible (Ext.). New environments or services can be integrated with reusable existing ones to generate joint tasks. Interface-based integration counts; integration need not require zero adaptation.

References

  1. [1]Emre Can Acikgoz, Cheng Qian, Jonas Hübotter, Heng Ji, Dilek Hakkani-Tür, and Gokhan Tur. 2026. Self-Evolving LLM Agents for Tool-Learning from Zero Data. Preprint, arXiv:2602.21320.
  2. [3]Victor Barres, Honghua Dong, Soham Ray, Xujie Si, and Karthik Narasimhan. 2025. τ²-Bench: Evaluating Conversational Agents in a Dual-Control Environment. Preprint, arXiv:2506.07982.arxiv.org/abs/2506.07982
  3. [4]Yoshua Bengio, Jérôme Louradour, Ronan Collobert, and Jason Weston. 2009. Curriculum learning. In Proceedings of the 26th Annual International Conference on Machine Learning, ICML ’09, pages 41–48. ACM.DOI
  4. [5]Wendong Bu, Yang Wu, Qifan Yu, Minghe Gao, Bingchen Miao, Zhenkui Zhang, Kaihang Pan, Yunfei Li, Mengze Li, Wei Ji, Juncheng Li, Siliang Tang, and Yueting Zhuang. 2025. What Limits Virtual Agent Application? OmniBench: A Scalable Multi-Dimensional Benchmark for Essential Virtual Agent Capabilities. In Proceedings of the 42nd International Conference on Machine Learning, volume 267 of Proceedings of Machine Learning Research, pages 5725–5748. PMLR.arxiv.org/abs/2506.08933
  5. [6]Zhaorun Chen, Zhuokai Zhao, Kai Zhang, Bo Liu, Qi Qi, Yifan Wu, Tarun Kalluri, Sara Cao, Yuanhao Xiong, Haibo Tong, Huaxiu Yao, Hengduo Li, Jiacheng Zhu, Xian Li, Dawn Song, Bo Li, Jason Weston, and Dat Huynh. 2025. Scaling Agent Learning via Experience Synthesis. Preprint, arXiv:2511.03773.arxiv.org/abs/2511.03773
  6. [7]DeepSeek. 2026. DeepSeek-V4-Pro Update. Accessed September 21, 2026.
  7. [8]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 Chen, Jiazhan Feng, Ji-Rong Wen, and Zhicheng Dou. 2026. Agent-World: Scaling Real-World Environment Synthesis for Evolving General Agent Intelligence. Preprint, arXiv:2604.18292.arxiv.org/abs/2604.18292
  8. [9]Zhiyuan Fan, Tinghao Yu, Yuanjun Cai, Jiangtao Guan, Yun Yang, Dingxin Hu, Jiang Zhou, Xing Wu, Zhuo Han, Feng Zhang, and Lilin Wang. 2026. Toward Scalable Terminal Task Synthesis via Skill Graphs. Preprint, arXiv:2604.25727.arxiv.org/abs/2604.25727
  9. [10]Carlos Florensa, David Held, Xinyang Geng, and Pieter Abbeel. 2018. Automatic Goal Generation for Reinforcement Learning Agents. In Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pages 1515–1528. PMLR.

Paper details

vlnc:W_u69uhkt5
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 2

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

generative AI tools

View statement
Looking for related papers…
Contents