Towards General Agentic Intelligence via Environment Scaling | Summary

This article explains the key points of Towards General Agentic Intelligence via Environment Scaling.

• 2025-09-16 (arXiv)
• Fang, Runnan, Cai, Shihao, Li, Baixuan, Wu, Jialong, Li, Guangyu, Yin, Wenbiao, Wang, Xinyu, Wang, Xiaobin, Su, Liangcai, Zhang, Zhen, et al.
• Tongyi Lab, Alibaba Group
• Paper

Read this article in Korean

Summary

• Language agents lack enough verifiable training interactions for function calling, the execution of tools with specified arguments. Under the paper’s evaluation protocols, AgentScaler-30B-A3B improves overall accuracy on ACEBench-en, an English tool-use benchmark, from 67.2 for its Qwen3-Thinking-30B-A3B backbone, the model used as the starting point for training, to 75.7, and improves telecom performance on τ²-Bench, a conversational tool-use benchmark, from 26.3 to 55.3.
• The pipeline organizes more than 30,000 APIs, application programming interfaces exposed as tools, into more than 1,000 domains and implements their operations as executable Python code over database states. Simulated user–agent interactions are filtered using conversation validity, final-state agreement, and exact tool-call matching before two-stage supervised fine-tuning, training on accepted assistant outputs, first across general domains and then within specialized domains.
• The results support improved tool use and transfer to ACEBench-zh, the Chinese benchmark variant, but gains vary across subsets and models. Reliability across repeated trials and accuracy on long tool-call sequences remain limited, and Table 1 does not establish the paper’s broad claim of leadership across open-source models below 1T parameters, meaning one trillion parameters.

1 Introduction

The introduction identifies agentic data, interaction trajectories containing executed tool calls, as a bottleneck for training language agents. It distinguishes reverse synthesis, which generates user queries to fit existing calls, from forward synthesis, which begins with user intent and simulates an interaction; the authors argue that realism and automated environment construction remain difficult. Their contribution combines scalable executable environments with filtered experience collection and training of AgentScaler models at 4B, 8B, and 30B-A3B scales, where B denotes billions of parameters.

2 Environment Build and Scaling

The design treats a function call as either a read operation that queries an environmental database or a write operation that changes its state. Tools with similar read–write structures share a domain-specific database schema, the structure defining the stored state. Environment construction therefore becomes a problem of partitioning tools into domains and assigning each domain a database schema and executable tools.

2.1 Environment Automatic Build

The authors collect more than 30,000 APIs from ToolBench and API-Gen, existing sources of tools and function-calling data, and an internal repository; they remove low-quality tools and refine some descriptions with explicit input–output specifications. They construct a tool dependency graph, a network whose edges represent compatible tool compositions, by comparing parameter vectors using cosine similarity, a measure of vector alignment, against a predefined threshold; Louvain community detection, a graph-clustering method, identifies domains, and a large language model checks dependencies within each domain. The resulting more than 1,000 domains receive generated database structures and Python tool implementations, forming the executable environments illustrated in Figure 1.

The diagram connects tool documentation to dependency graphs, domain partitions, executable functions, and database structures. Its construction example shows how a sampled sequence produces a user intent together with initial and reference final states, making task generation executable and checkable.

2.2 Agentic Task Construction

Task construction initializes a domain-specific database state and samples tool sequences through directed walks, traversals that follow dependency edges in the tool graph. A walk starts at a randomly selected tool and stops at the maximum execution length or a node without outgoing edges; generated arguments are then used to execute each call and track state changes. The resulting reference sequences and final states provide two checks: database-state consistency and exact matching of tool calls.

3 Agent Experience Learning

Agent Experience Learning uses an overall user intent to drive interactions between a simulated user and an agent inside the generated environment. Figure 2 shows how interaction traces and environment states are compared with reference tool sequences and reference final states. Accepted experiences feed a two-phase training process.

The interaction example separates conversation from execution: the agent obtains information through generated functions while the system records traces and database states. Comparing both outputs with references explains how the pipeline checks tool sequences as well as state-changing task completion.

3.1 Human–Agent Interplay for Experience Collection

The simulated user pursues the assigned intent while the agent invokes domain-specific tools, continuing until the simulated user considers the task complete. Filtering removes malformed exchanges and severely repetitive reasoning, checks agreement with the reference final database state, and applies exact tool-and-argument matching, particularly for read-only tasks whose success cannot be determined from state changes. Intermediate tool errors do not automatically disqualify a trajectory if it still achieves the intended goal and passes the applicable checks.

3.2 Agentic Experience Learning

The training loss supervises assistant-generated tool calls and natural-language responses while masking user instructions and tool responses, excluding them from the loss but retaining them as context. Stage 1 teaches general tool selection, argument generation, and user interaction across broad domains. Stage 2 specializes those skills using tasks, tools, and user intents from target vertical domains, application areas with domain-specific requirements.

4 Experiments

The experiments evaluate the AgentScaler family against its Qwen3 backbones and a range of open-source and closed-source models. They report performance on three tool-use benchmarks with English evaluations and examine the contribution of sequential general-domain and specialized training.

4.1 Setup

τ-bench, a benchmark of user–agent interactions with tools, evaluates retail and airline tasks, while τ²-Bench covers retail, airline, and telecom; the paper reports pass^1, single-trial task success, and analyzes pass^k, success on the same task in all k independent trials. ACEBench-en reports accuracy for its Normal, Special, and Agent subsets and an Overall score. AgentScaler-4B and AgentScaler-30B-A3B use Qwen3-Thinking-4B-2507 and Qwen3-Thinking-30B-A3B-2507 respectively, while AgentScaler-8B uses Qwen3-8B; comparisons include Gemini-2.5-pro, Claude-Sonnet-4, GPT-o3, GPT-o4-mini, GPT-5-think, and the open-source models listed in Table 1.

4.2 Experimental Results

Table 1 shows AgentScaler-30B-A3B scoring 70.4 and 54.0 on τ-bench retail and airline, 70.2, 60.0, and 55.3 on τ²-Bench retail, airline, and telecom, and 75.7 overall on ACEBench-en. These improve on its backbone’s corresponding 67.8, 48.0, 58.8, 58.0, 26.3, and 67.2, although ACEBench-en Special accuracy falls from 86.7 to 82.7. Figure 3 shows that Stage 1 produces most of the overall improvement, while Stage 2 further improves the Agent subset with little change in overall accuracy.

The grouped bars compare the backbone with Stage 1 and Stage 2 on ACEBench-en Normal, Agent, and Overall categories. Stage 1 raises performance substantially, and Stage 2 adds a clearer gain on Agent than on Overall; Normal performance does not increase monotonically across the two stages.

The smaller models also improve overall ACEBench-en accuracy: AgentScaler-4B reaches 65.9 versus 49.5 for its backbone, and AgentScaler-8B reaches 67.4 versus 65.9. However, the 4B model’s Special score drops from 84.7 to 76.7, and the 8B model’s Normal score drops from 71.4 to 69.2. The paper’s broad state-of-the-art claim requires qualification because Table 1 includes higher scores from several open-source models below 1T parameters, including Seed-OSS-36B at 76.7 overall on ACEBench-en.

The table shows improvements over the AgentScaler backbones, especially on τ²-Bench telecom and ACEBench-en Agent. It also qualifies the headline claim: AgentScaler-30B-A3B’s ACEBench-en overall score of 75.7 trails GPT-OSS-120B-A5B at 76.0 and Seed-OSS-36B at 76.7, while some subset scores decline after training.

5 Analysis

Table 2 evaluates ACEBench-zh as an out-of-distribution setting, an evaluation setting different from the training setup, and reports overall gains at every trained scale: 43.9 to 65.6 for 4B, 71.3 to 73.7 for 8B, and 74.2 to 81.5 for 30B-A3B. These gains are uneven: the 4B and 30B-A3B Special scores decline, and the 8B Normal score declines. The results support transfer on the reported overall metric without establishing uniformly improved performance.

All three AgentScaler models improve overall ACEBench-zh accuracy over their respective backbones. The largest overall gain is 21.7 points for 4B, but negative changes in Special for 4B and 30B-A3B and in Normal for 8B show that transfer gains depend on the subset.

Figure 4 reports higher weighted overall pass^k scores for AgentScaler-30B-A3B than its backbone at k = 1, 2, 3, and 4, but its score declines from 62.5 to 30.6 as the success requirement becomes stricter. The advantage is not universal within domains: at airline k = 4, AgentScaler scores 24.0 against the backbone’s 34.0. Figure 5 also shows declining accuracy with longer tool-call sequences, leaving long-horizon tool use, successful execution of extended chains of calls, unresolved.

Weighted overall performance remains above the backbone for all four repeated-trial requirements, falling from 62.5 to 30.6 for AgentScaler and from 45.3 to 27.7 for the backbone. Domain-level curves qualify this advantage: AgentScaler’s airline score falls below the backbone at k = 3 and k = 4.

The scatter plot relates tool-call count to task accuracy in retail and airline, with marker size indicating relative sample size. The fitted trends decline as call counts increase, particularly for airline, but variable marker sizes and isolated high-accuracy points mean the plot supports a descriptive association rather than a controlled causal effect.

6 Related Work

The related-work discussion separates environment construction from methods for learning tool use. It positions the contribution around automatically constructed executable environments and verifiable state changes that support filtering of synthetic interaction data.

6.1 Tool-Use Environments

The paper distinguishes real-world tool environments, language-model-generated tool responses, and offline executable environments backed by databases or state files. It associates real services with cost and availability constraints, generated responses with hallucination, outputs unsupported by the underlying environment, and inconsistency, and manually constructed offline environments with limited scalability. Its proposed alternative uses tool-graph sampling and rule-based validation to automate environment and task construction.

6.2 Tool Learning

The paper reviews synthetic-data methods such as xLAM and ToolAce, direct preference optimization in DiaTool-DPO, learning from preferred and dispreferred interaction trajectories, and reinforcement learning, optimization through interaction feedback, in Tool-RL and Tool-N1. It argues that these approaches depend on stable executable environments and also discusses Kimi-K2’s use of a tool simulator for multi-turn data synthesis. AgentScaler verifies collected interactions through database-state changes and reference tool sequences before supervised training.

7 Conclusion

The conclusion connects executable database-backed tools, verifiable interaction trajectories, and two-stage experience learning as a pipeline for improving language-agent tool use. The benchmark tables support gains over the evaluated backbones, while stronger individual baseline results qualify the broader leadership claim. Reinforcement learning, broader modalities, and real-world deployment are proposed future directions rather than evaluated outcomes.

Limitation

Under Lack of Reinforcement Learning, the authors acknowledge that training uses only two-stage supervised fine-tuning and leaves reinforcement learning over the simulated environments for future work. Under Model Scale, they identify the absence of validation beyond the 30B scale, including models exceeding 200B or reaching trillion-parameter scales. Although this paragraph describes validation only on a 30B-scale architecture, the experiments also include 4B and 8B models; the supported limitation is that the largest trained model is 30B-A3B.

Appendix

• The supplied 14-page PDF contains no appendix; pages 11–14 contain References. The paper is identified as arXiv:2509.13311v1 and provides https://tongyi-agent.github.io/blog and https://github.com/Alibaba-NLP/DeepResearch as project links.

Brief Thoughts

The concrete verification mechanism is useful: executable tools expose state changes, and reference call sequences provide supervision for read-only tasks that final-state checks cannot distinguish. The evidence supports improved benchmark tool use, but it does not isolate environment diversity as the cause because no controlled environment-count scaling experiment is reported. Reproduction and deployment assessment remain constrained by unreported training-data counts, optimization settings, generation costs, and measured latency; subset regressions and long-call failures also limit claims of general agentic intelligence.