AgentScaler: Scalable Agent Training

• AgentScaler is a framework that constructs and scales simulated environments using automated API integration, enabling robust function-calling intelligence.
• It employs a two-phase fine-tuning strategy—foundational learning followed by domain specialization—to enhance agent performance across diverse tool interactions.
• Empirical evaluations demonstrate significant improvements in function-calling accuracy and efficiency in real-world deployment scenarios.

AgentScaler is a scalable framework and agent training pipeline designed to advance general agentic intelligence through principled environment construction and systematic environment scaling. It enables LLM agents to develop robust function-calling intelligence by interacting in a vast array of simulated, heterogeneous environments, each built on structured database schemas and executable API toolsets. AgentScaler’s core contribution is an automated, programmatic approach to environment generation, coupled with a two-phase fine-tuning strategy that produces agents adept in both general and domain-specific tool interactions. Empirical evaluations across agentic benchmarks substantiate significant increases in function-calling accuracy and consistency, highlighting its utility for real-world deployment scenarios involving LLMs.

1. Programmatic Environment Construction

AgentScaler’s framework begins by abstracting the agent’s world as a database $\mathcal{D}$, with all tools (APIs) classified as either read-type (query operations) or write-type (modification operations). Over 30,000 APIs are collected from repositories such as ToolBench, API-Gen, and proprietary sources. These APIs undergo enrichment to achieve precise input-output specifications, facilitating rigorous evaluation procedures.

A tool dependency graph is constructed by embedding tool parameter lists ($P_{\text{func}}$) into high-dimensional vector spaces via $\phi$ and calculating pairwise cosine similarities. Formally, edges are created between pairs of tools $(i, j)$ if $$\operatorname{sim}(\phi(P_{\text{func}_i}), \phi(P_{\text{func}_j})) > \tau$$, where $\tau$ is a predefined similarity threshold:

$$E = \{ (i, j) \mid \operatorname{sim}(\phi(P_{\text{func}_i}), \phi(P_{\text{func}_j})) > \tau,\ i \ne j \}$$

Louvain community detection segments the graph into domains, each corresponding to a coherent subset of tools and a unified underlying schema $\mathcal{S}_k$. For each domain, the tool parameters are programmatically materialized into database schemas and the API endpoints instantiated as executable Python code. This approach ensures environments are fully simulated and verifiable, enabling the system to check both database states and the exact sequence of tool calls after each episode.

2. Principles and Implementation of Environment Scaling

Environment scaling refers to the automated generation of large numbers (>1000) of domain-specific environments broadly covering the space of possible API interactions. By constructing a comprehensive tool graph from the collected APIs and then partitioning it into domains via community detection, AgentScaler exposes agents to a wide spectrum of tool schemas and permissible action spaces.

During the task-generation phase, agentic tasks are synthesized by sampling valid tool-call sequences within each domain. Each environment is an instance featuring a domain-specific database, connected directly to executable API functions. This systematic scaling produces a high diversity of training experiences, which is critical for robust generalization in function-calling and autonomous decision-making across unfamiliar or complex interfaces.

3. Two-Phase Agent Fine-Tuning Strategy

AgentScaler’s training pipeline consists of two distinct phases:

• Foundational Learning (Phase 1): Agents are trained in general domains encompassing a wide range of tools, fostering broad-based, foundational agentic capabilities. This includes learning to select appropriate tools, generate parameters, and process tool responses in an environment-agnostic manner.
• Domain Specialization (Phase 2): Agents are then fine-tuned within vertical, domain-specific scenarios, where tool choice, parameterization, and response interpretation must adhere to contextual constraints and finer details. This specialization is essential for transitioning agents from general reasoning to nuanced, real-world tool use.

Supervised learning targets assistant-generated trajectories $\mathcal{H} = (h_0, a_1, \ldots, a_n)$, with each turn decomposed into tool-call tokens, tool response tokens, and natural language segments. The training loss restricts supervision to tokens in $\mathcal{T}$ (tool calls and assistant responses):

$$\mathcal{L}(\theta) = -\frac{1}{\sum_{k} I[x_k \in \mathcal{T}]} \sum_k I[x_k \in \mathcal{T}] \cdot \log \pi_\theta(x_k | x_{<k})$$

Gradient flow is masked for human instructions and tool responses, ensuring agents optimize for effective tool interaction under realistic conversational and execution contexts.

4. Empirical Evaluation and Performance

AgentScaler is evaluated on tau-bench, tau$^2$-Bench, and ACEBench agentic benchmarks. Notable findings include:

• State-of-the-art pass metrics in domains such as retail, airline, and telecom, with AgentScaler-30B-A3B outperforming existing open-source baselines in function-calling accuracy and across-domain tool use consistency.
• Compact models, e.g., AgentScaler-4B, achieve performance competitive with much larger baselines, suggesting efficient scaling of agentic intelligence to constrained resource budgets.
• Ablation studies affirm the value of the two-stage fine-tuning approach; foundational learning and subsequent specialization yield higher accuracy on both general agentic subsets and context-specific tasks.
• The systematic, fully simulated environment construction enables verifiable episode traces—both at the state and sequential tool-call level—enhancing reproducibility and robustness versus prior frameworks.

5. Real-World Applicability and Deployment

The practical implications of AgentScaler’s methodology are substantial:

• Integration with Real-World APIs: The diversity and scope of simulated environments permit agents to develop actionable function-calling skills transferable to domains such as retail, airlines, telecommunications, and more.
• Efficiency in Low-Resource Contexts: Competitive performance of smaller models enables deployment in edge settings and latency-sensitive applications without major sacrifices in agentic capability.
• Autonomous Decision Making: Systematic construction and episodic verification train agents for multi-turn, self-directed task completion in dynamic, real-world environments.

A plausible implication is that AgentScaler’s approach could facilitate rapid expansion to additional modalities (e.g., visual APIs or multimodal interfaces) and extension to reinforcement learning for autonomous policy optimization.

6. Contextual Significance and Future Directions

AgentScaler introduces a principled and automated pipeline for scaling environments and training agents for general agentic intelligence, aligning with research trends that recognize the direct link between environmental diversity and robust agent capabilities. The combination of environment programmaticity, graph-based domain discovery, and progressive agent fine-tuning addresses both the breadth and contextual nuance challenges central to deploying LLMs as autonomous, function-calling agents.

Future work may focus on extending environment schema beyond structured database interactions and incorporating continuous learning or reinforcement learning signals to further enhance agent adaptivity and performance in open-ended, dynamic environments. This suggests an avenue for broader adoption in settings requiring high reliability of autonomous tool interaction and decision making across unpredictable real-world API landscapes (Fang et al., 16 Sep 2025).