Source-linked AI summary
Towards General Agentic Intelligence via Environment Scaling
Runnan Fang, Shihao Cai, Baixuan Li, Jialong Wu, Guangyu Li, Wenbiao Yin, Xinyu Wang, Xiaobin Wang, Liangcai Su, Zhen Zhang, Shibin Wu, Zhengwei Tao, Yong Jiang, Pengjun Xie, Fei Huang, Jingren Zhou
TL;DR
The paper tackles the scarcity of scalable, diverse environments and reliable experience for training robust function-calling agents. It automatically constructs simulated database-backed environments and uses two-stage experience learning, yielding AgentScaler models with state-of-the-art open-source performance across three benchmarks. The work supports compact-model deployment while leaving reinforcement learning and larger-scale validation for future work.
Problem
Agentic intelligence requires diverse environment interactions for robust function calling, but agentic data and scalable environment construction remain limited.
Method
The paper automatically builds heterogeneous simulated environments from APIs and trains agents with two-stage experience learning: general tool-use training followed by domain specialization.
Results
AgentScaler achieves state-of-the-art performance among open-source models across τ-bench, τ2-Bench, and ACEBench, with 30B-A3B results comparable to trillion-parameter models.
Takeaways & Limitations
Systematic environment scaling and staged experience learning can produce competitive agentic capabilities in relatively compact models.
Takeaways & Limitations
The framework has not yet been validated on models larger than 30B, and it currently relies on supervised fine-tuning without reinforcement learning.
Abstract
from arXiv · showhide
Advanced agentic intelligence is a prerequisite for deploying Large Language Models in practical, real-world applications. Diverse real-world APIs demand precise, robust function-calling intelligence, which needs agents to develop these capabilities through interaction in varied environments. The breadth of function-calling competence is closely tied to the diversity of environments in which agents are trained. In this work, we scale up environments as a step towards advancing general agentic intelligence. This gives rise to two central challenges: (i) how to scale environments in a principled manner, and (ii) how to effectively train agentic capabilities from experiences derived through interactions with these environments. To address these, we design a scalable framework that automatically constructs heterogeneous environments that are fully simulated, systematically broadening the space of function-calling scenarios. We further adapt a two-phase agent fine-tuning strategy: first endowing agents with fundamental agentic capabilities, then specializing them for domain-specific contexts. Extensive experiments on agentic benchmarks, tau-bench, tau2-Bench, and ACEBench, demonstrate that our trained model, AgentScaler, significantly enhances the function-calling capability of models.
1 Introduction
The paper addresses scarce agentic data and limited environment scalability by systematically scaling simulated environments and learning from resulting agent experiences. Its AgentScaler models achieve strong performance across multiple agentic benchmarks.
- Motivation: Agentic progress is constrained by scarce trajectories from autonomous agents interacting with environments through tool calls.The paper frames these interaction-generated trajectories as a shift toward learning from experience.
- Motivation: Prior synthetic-data approaches generate either potentially unrealistic reverse trajectories or potentially unnatural forward human–agent interactions.Forward approaches also remain difficult to scale because environment construction lacks automation and requires manual intervention.
- Approach: The proposed pipeline combines fully simulated environment construction with agent experience learning to broaden diverse agentic scenarios.The two stages separately support scenario creation and capability acquisition from interaction trajectories.
- Approach: AgentScaler trains fundamental tool-calling skills across general domains before specializing agents for domain-specific contexts.The experience-learning framework uses simulated human–agent interactions and filtered trajectories.
- Results: AgentScaler achieves state-of-the-art performance at comparable 4B and 8B scales, while AgentScaler-30-A3B matches 1T-parameter models and leading closed-source systems.Experiments cover τ-bench, τ2-Bench, and ACEBench.
2 Environment Build and Scaling
The environment-building system represents tools as database operations, organizes compatible APIs into domains, and programmatically materializes executable environments. It then constructs diverse, verifiable trajectories through simulated agent–human interaction.
- Design Principle: Each function call is modeled as a read or write operation over an underlying environmental database.Read tools query database state, while write tools induce state transitions.
- Environment Construction: The pipeline collects real-world APIs, models tool dependencies, partitions tools into domains, and materializes domain-specific database-backed tools.These stages form the overall environment-construction process.
- Scenario Collection: More than 30,000 APIs are collected, filtered, refined, and composed using input–output relationships to form API pools.The resulting pool supports systematic environment construction.
- Dependency Graph Modeling: Tool dependencies are inferred from parameter-vector cosine similarity and refined with LLM examination before Louvain community detection identifies coherent domains.The process produces more than 1,000 domains.
- Task Construction: Forward simulated agent–human interplay initializes diverse database states and synthesizes logically coherent tool-use tasks for trajectory construction.The resulting interactions fully simulate the environment, user, and agent.
3 Agent Experience Learning
Agent experience learning collects filtered trajectories from fully simulated user–agent–environment interactions, then trains agents in two phases: broad tool-use foundation followed by domain specialization.
- Human–Agent Interplay for Experience Collection: Forward simulated interplay lets a simulated user and agent interact until task completion, producing scalable end-to-end experience traces.The agent uses domain-specific tools while the environment records the interaction.
- Trajectory Filtering: The filtering pipeline checks trajectory validity, aligns final database states with golden states, and exact-matches tool sequences and arguments to the intended task.State alignment validates write operations, while exact matching provides the most stringent tool-sequence filter.
- Trajectory Filtering: Trajectories containing intermediate tool-call errors are retained when they can still accomplish the intended goal, supporting robustness in the training data.The filtering framework permits successful task completion despite intermediate failures.
- Agentic Fine-tuning: Fine-tuning masks human instructions and tool responses from the loss while optimizing assistant tool calls and natural-language responses.These inputs remain visible as context, but gradients target assistant-generated outputs.
- Two-stage Experience Learning: Two-phase learning first builds general tool-calling and user-interaction skills, then specializes tool selection, call parameterization, and responses for vertical domains.The first phase emphasizes breadth and generality; the second grounds learning in domain-specific tasks, tools, and intents.
4 Experiments
The experiments evaluate AgentScaler across three agentic benchmarks and compare it with closed- and open-source baselines. AgentScaler establishes strong performance at compact parameter scales, while ablations support the value of both training stages.
- Experimental Setup: Evaluation uses pass^1 on τ-bench and τ2-Bench, analyzes pass^k trends, and reports category and Overall accuracy on ACEBench-en.The benchmarks cover retail, airline, and telecom domains across the evaluated suites.
- Experimental Setup: The comparison includes closed-source systems, open-source models, and AgentScaler models trained from Qwen3 backbones at 4B, 8B, and 30B-A3B scales.AgentScaler-4B and AgentScaler-30B-A3B use Qwen3-Thinking backbones, while AgentScaler-8B uses Qwen3-8B.
- Experimental Results: AgentScaler establishes a new state-of-the-art among open-source models below 1T parameters across τ-bench, τ2-Bench, and ACEBench-en, although closed-source models lead most benchmarks.The comparison covers the main results in Table 1.
- Experimental Results: AgentScaler-4B performs on par with 30B-parameter models, while AgentScaler-30B-A3B is comparable to trillion-parameter open-source models and approaches closed-source systems in several domains.These results indicate competitive performance without massive parameter counts.
- Ablation Study: Both training stages substantially improve ACEBench-en performance over the Qwen3-Thinking-30B-A3B base model across Normal, Agent, and Overall subsets.Stage 2 further improves the Agent subset and Overall score through multi-step agent training.
5 Analysis
On ACEBench-zh, AgentScaler improves over Qwen baselines across model scales, while τ2-Bench results show stronger consistency than a comparable baseline but declining pass^k stability as k increases.
- ACEBench-zh: 81.5 overall score makes AgentScaler-30B-A3B the best ACEBench-zh model, while AgentScaler models outperform their Qwen baselines across all scales.AgentScaler-4B’s overall score increases by 21.7 points, from 6.7 to 38.4.
- Stability: AgentScaler-30B-A3B consistently surpasses Qwen3-Thinking-30B-A3B across all evaluated pass^k settings on τ2-Bench.The pass^k metric measures accuracy when the same question is answered correctly in all k independent trials.
- Stability: Pass^k scores decline as k increases, indicating that stability remains a considerable challenge for existing language models.
- Tool-call count: Figure 5 reports τ-bench accuracy by tool call count, but the supplied passages do not state the outcome of that comparison.
6 Related Work
Prior work constructs tool-use environments through real-world execution, LLM simulation, or offline state-configured execution, while tool-utilization methods improve models through synthetic data and preference optimization.
- Environment construction: Real-world environments provide authentic tool feedback but require frequent MCP calls, creating high costs and signaling overhead.
- Environment construction: LLM-simulated environments generate plausible tool responses but struggle with hallucination and inconsistent response variability.
- Environment construction: Offline tool-execution environments address limitations of real-world and LLM-simulated approaches for model training and evaluation.
- Tool utilization: Tool-utilization methods such as xLAMs, ToolAce, and DiaTool-DPO improve tool calling through large-scale agentic data synthesis or preference optimization.
7 Conclusion
The paper concludes that systematic environment scaling paired with two-stage agent experience learning enables scalable, verifiable training and strong agentic benchmark performance.
- Conclusion: AgentScaler achieves state-of-the-art performance among open-source models under 1T parameters and sometimes matches much larger or closed-source counterparts.
- Conclusion: The pipeline programmatically materializes tools in database-structured environments to construct large-scale verifiable trajectories, then trains general and domain-specific tool-use capabilities.
- Future directions: Future work includes reinforcement learning on the fully simulated environments and expansion to broader modalities and real-world deployment scenarios.
Limitation
The paper identifies missing reinforcement-learning optimization and limited validation of model scale as remaining limitations.
- Reinforcement learning: The current approach uses two-stage supervised fine-tuning without reinforcement learning, although the simulated environment is designed to support future RL optimization.
- Model scale: The method has been validated only on a 30B-scale architecture, without testing models larger than 200B or at trillion-parameter scale.