AgentScaler Framework: Scalable Agent Training

• AgentScaler Framework is a scalable methodology for advancing general agentic intelligence by integrating principled environment scaling with systematic agent training.
• It utilizes large-scale API collection, dependency graph analysis, and domain partitioning to simulate diverse function-calling scenarios with verifiable state transitions.
• The two-phase fine-tuning regimen enhances multi-hop tool call accuracy while balancing generalization and specialization across various domains.

The AgentScaler Framework is a scalable methodology for advancing general agentic intelligence through principled environment scaling and systematic agent training. It enables LLMs to acquire robust, precise function-calling capabilities by interacting within highly diverse, programmatically constructed simulated environments. The framework integrates several technical components—including large-scale API collection, tool dependency graph analysis, domain partitioning, rigorous verifiability filters, and a two-phase agent fine-tuning regimen—yielding improved performance on agentic benchmarks and enhanced ability for multi-hop, long-horizon tool use.

1. Architecture and Environment Construction

AgentScaler is architected to automatically generate heterogeneous, fully simulated environments wherein each function call by an agent is interpreted as a read–write operation upon an underlying database (𝒟). The process begins by collecting over 30,000 real-world APIs sourced from repositories such as ToolBench and API-Gen. These APIs function as atomic tools available for invocation by agents.

Tool interrelatedness is modeled using a tool dependency graph. Each tool’s function description and parameters are vectorized, and tools are linked by edges if the cosine similarity between their respective parameter vectors exceeds a threshold $\tau$:

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

where $\phi(\cdot)$ denotes the vectorization of a parameter list and $\text{sim}(\cdot, \cdot)$ is cosine similarity.

Domains are identified by community detection—specifically, the Louvain algorithm—performed on the dependency graph, which isolates coherent sets of tools sharing similar schema and operational semantics. Over 1,000 domains are automatically defined, each associated with a distinct database schema $(\mathcal{S}_k)$.

Function schema programmatic materialization transforms APIs in each domain into executable functions that operate on their domain-specific databases. Agentic tasks are constructed by initializing database states, sampling valid tool call sequences from the dependency graph, and executing these calls to yield verifiable state transitions. This ensures both consistency of final database states and exact correspondence of tool call trajectories.

2. Principles of Scalable Environment Design

The guiding principle is that automatic, programmatic environment construction eliminates manual bias and scales coverage to broad real-world scenarios. By partitioning APIs into domains based on database schema similarity, AgentScaler rigorously broadens the space of function-calling scenarios. Each simulated interaction must meet two levels of verifiability: alignment of database state and exactness of tool call sequences.

To maintain realism, the framework applies multi-level filtering:

• Validity Control: Excludes ill-formed or incoherent trajectories.
• State Alignment: Ensures that the end-state of the simulated database matches a golden standard.
• Exact Match: Verifies that the agent’s tool call sequence corresponds precisely to the intended task design.

A plausible implication is that this structure allows AgentScaler to replicate the diversity and complexity of real-world API usage, an essential property for training generalist agents.

3. Two-Phase Agent Training Regimen

AgentScaler advances agentic intelligence through a two-phase fine-tuning process. In foundation learning (Phase 1), agents are exposed to a wide selection of general domains, learning generic tool-calling strategies, argument synthesis, and natural language integration. Training trajectories include human instructions, assistant responses, tool calls, and tool responses:

$$\text{Trajectory:} \quad (h_0, y_0, \tau_1, \rho_1, \dots, h_n, y_n, \tau_{n+1}, \rho_{n+1})$$

However, only tokens associated with assistant ($y$) and tool call ($\tau$) outputs are optimized, via:

$$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 \mid x_{<k})$$

where $\mathcal{T} = \{\tau, y\}$ and $\pi_\theta$ is the model’s predicted distribution.

Domain-specific specialization (Phase 2) further refines agent performance by concentrating on vertical domains and specialized tasks, consolidating domain-relevant knowledge and increasing inter-tool reasoning fidelity.

4. Experimental Benchmarks and Performance

AgentScaler models—spanning 4B, 8B, and 30B-A3B parameter scales (using Qwen3 variants)—were validated on agentic benchmarks: τ–bench, τ²–Bench, and ACEBench-en. The 30B-A3B variant demonstrated superior scores in domains such as retail, airline, and telecom, as well as on ACEBench-en’s Normal, Special, and Agent subsets. Notably, even the compact 4B model matched or exceeded the performance of larger-scale baselines on several criteria.

Ablation studies confirm that two-phase training yields measurable increases in multi-turn tool call accuracy. Specifically, Stage 2 fine-tuning delivers consistent gains in agent subsets and overall scores, particularly for complex, long-horizon trajectories. However, chain-of-function accuracy decreases as chain length increases, underscoring persistent challenges in multi-hop reasoning.

5. Challenges and Resolution Strategies

Key technical challenges addressed by AgentScaler include:

• Principled, Automated Environment Scaling: The systematic pipeline (API collection → dependency graphing → domain partitioning → programmatic materialization) circumvents manual environment setup and supports diverse, highly heterogeneous scenario synthesis.
• Verifiable Agent Experience: Multi-level filters (validity, state alignment, exact match) ensure the integrity of experience trajectories. Notably, the framework retains trajectories with intermediate tool call errors to support robust agent learning.
• Agent Training Under High Complexity: Declining multi-hop accuracy as function call chains grow longer highlights the difficulty in managing long-horizon dependencies. The two-phase training regimen moderates this challenge by balancing cross-domain generalization with vertical specialization.

A plausible implication is that these solutions position AgentScaler to serve as a benchmark for future investigations into agentic reasoning under realistic API-driven interaction constraints.

6. Comparative Context and Related Methodologies

AgentScaler diverges from previous ad hoc and manually configured frameworks by providing a rigorously automated, verifiable environment for agent training and evaluation. Its reliance on large-scale, community-detected domains and exact-state simulation enhances reproducibility and domain coverage compared to alternatives that rely on handcrafted scenarios.

The framework further integrates lessons from the ScalerEval testbed (Xie et al., 11 Apr 2025), which emphasizes automating the evaluation lifecycle of microservice auto-scalers. ScalerEval’s use of standardized interfaces, isolated thread execution, and automated metric collection can be adopted in AgentScaler to support efficient one-click evaluation and consistent benchmarking. This synergy allows for rapid testing and fair comparison of various agentic scaling strategies in microservices management.

7. Significance and Prospective Developments

The AgentScaler framework establishes a robust foundation for scaling agentic intelligence across functionally diverse and complex domains. Its technical rigor in environment construction and agent training directly addresses known limitations in function-calling robustness and multi-turn reasoning. By outperforming larger closed-source models with compact architectures and fostering agentic robustness through realistic, error-inclusive trajectories, AgentScaler manifests a scalable path toward general-purpose, API-driven LLM deployment.

Future progress is likely to focus on further elevating multi-hop tool calling accuracy and integrating evaluation methodologies akin to ScalerEval, thereby coupling environment scaling with standardized, automated performance assessment. Such developments would potentially expand applicability to more intricate microservices orchestration scenarios, strengthening the empirical foundation for general agentic intelligence research.