arXiv CSopen access

Agent-World: Scaling Real-World Environment Synthesis for Evolving General Agent Intelligence

Unknown · 2026 · arxiv_cs

arXiv CS · Papers · License: Open Access · 2026

artificialintelligence knowledgerepresentation reasoning

artificial intelligence, reasoning, knowledge representation

Agent-World: Scaling Real-World Environment Synthesis for Evolving General Agent Intelligence Renmin University of China , ByteDance Seed

arXiv:2604.18292v1 [cs.AI] 20 Apr 2026

See Contributions section for a full author list.

Abstract Large language models are increasingly expected to serve as general-purpose agents that interact with external, stateful tool environments. The Model Context Protocol (MCP) and broader agent skills offer a unified interface for connecting agents with scalable real-world services, but training robust agents remains limited by the lack of realistic environments and principled mechanisms for life-long learning. In this paper, we present Agent-World, a self-evolving training arena for advancing general agent intelligence through scalable environments. Agent-World has two main components: (1) Agentic Environment-Task Discovery, which autonomously explores topic-aligned databases and executable tool ecosystems from thousands of real-world environment themes and synthesizes verifiable tasks with controllable difficulty; and (2) Continuous Self-Evolving Agent Training, which combines multi-environment reinforcement learning with a self-evolving agent arena that automatically identifies capability gaps through dynamic task synthesis and drives targeted learning, enabling the co-evolution of agent policies and environments. Across 23 challenging agent benchmarks, Agent-World-8B and 14B consistently outperforms strong proprietary models and environment scaling baselines. Further analyses reveal scaling trends in relation to environment diversity and self-evolution rounds, offering insights for building general agent intelligence. Date: April 21, 2026 Correspondence: Guanting Dong at [email protected], Zhicheng Dou at [email protected] Project Page: https://agent-tars-world.github.io/-/

Introduction

In recent years, large language models (LLMs) have delivered remarkable progress across a wide range of language understanding and decision-making tasks [18, 68, 82, 95, 114]. As their capability frontier continues to expand, expectations for LLMs are shifting from chat-oriented text generation toward general-purpose agent assistants [7, 16, 34, 47, 64, 65]. Ideally, such agents should seamlessly integrate real-world interaction with verbal reasoning, and continuously learn from experience to improve themselves, much like human intelligence [29, 72, 86, 132]. Realizing these agentic capabilities requires not only training LLMs in dynamic environments, but also equipping them with executable tools. On this basis, agents can take actions and observe timely feedback from the environment, forming a “Generation–Execution–Feedback” interaction loop [61, 73, 110, 116, 117]. With the rise of agentic reinforcement learning (Agent RL), several agent systems built on static tool environments have demonstrated strong practical value, especially in deep information-seeking and software

Figure 1 Overview of Agent-World (left) and downstream general agent performance (right). The environmentscaling analysis reports the average score across representative subdomains of MCP-Mark, BFCL V4, and 𝜏 2 -Bench.

engineering [21, 22, 42, 49, 92, 103, 115, 126]. However, open-world tool environments are inherently compositional and stateful. For instance, in a flight-booking workflow, an agent should follow a valid action order (check inventory → execute booking → update the calendar), while each action also modifies the underlying environment state. Consequently, agents must orchestrate multi-tool usage flows while tracking state transitions induced by their agent-environment interactions. Prior work centered on stateless or singletool settings is therefore insufficient for realistic applications [26, 42, 51]. This limitation has motivated growing interest in building general agents around standards such as the Model Context Protocol (MCP) [6, 44, 66] and broader agent skills [40, 56, 119], as well as harness engineering [59, 60, 71, 133]. In this setting, an ideal agent serves as a unified orchestrator that can invoke scalable real-world tools, track state changes in real time, and seamlessly integrate large-scale agentic services into automated workflows [37, 44, 62]. Importantly, a key requirement for such general-purpose agents is access to diverse and realistic interactive environments [3, 38]. However, manually crafting such environments is expensive and difficult to scale, which has driven research toward two main directions: (i) Simulated environments use LLMs as implicit textual world models to produce environment feedback for agent training [27, 32, 52, 55, 102, 109]. While highly scalable, such simulators are vulnerable to hallucinations and often deviate from real-world dynamics. In contrast, (ii) Realistic environments combine executable tools with real databases, providing stronger grounding for complex interactions [5, 9, 58, 75, 90, 94, 98, 105, 107, 111, 121, 124, 127, 129]. Benchmarks such as 𝜏 2 -Bench and ClawEval have moved evaluation closer to frontier agent applications through stateful environments [12, 16, 73, 117]. More recently, several studies have taken initial steps toward synthesizing programmatic environments and tasks for agent training [11, 25, 88, 98, 108]. Unfortunately, their reliance on single-round training makes it difficult for agents to acquire robust, transferable interaction logic in broad environment spaces. Consequently, although these approaches improve the efficiency of environment construction, two key bottlenecks remain unresolved: • Scalable realism and complex environment synthesis: Existing environments are often purely LLMgenerated or derived from limited open-source toolchains, which often mismatch real-world interaction logic. Moreover, synthetic environments are often limited in complexity, restricting the training of agents on long-horizon, state-intensive tasks. • Continuous self-evolving training mechanisms: Although realistic environments can naturally serve as effective training arenas, existing work has primarily emphasized environment construction and scaling, 2

while lacking principled mechanisms that use such scalable environments to diagnose agent weaknesses and drive continual self-improvement. In this paper, we propose Agent-World, a general-purpose agent training arena that unifies scalable real-world environment synthesis with continuous self-evolving training. As shown in Figure 1, Agent-World follows a two-stage design that forms a closed-loop training process. (1) Agentic Environment-Task Discovery. We collect thousands of real-world environment themes and build a

deep-research pipeline that autonomously mines topic-aligned databases and executable toolsets from the web, forming a scalable and realistic environment ecosystem (including 1978 environments and 19822 tools). On top of these environments, we synthesize high-quality agent tasks through both graph-based and programmatic generation, and further expand task difficulty with executable verification.

(2) Continuous Self-Evolving Agent Training. We train agents via multi-environment reinforcement learning

over “agent–tool–database” interaction rollouts, using executable rewards for state-aware supervision. Notably, our environment ecosystem naturally serves as a self-evolving arena for evolving agents. Built on these scalable environments, the arena can iteratively synthesize new tasks, automatically identify capability gaps in trained agents, and drive targeted learning, thereby forming a co-evolution loop between agent policies and environments.

We conduct comprehensive evaluations on 23 benchmarks covering agentic tool-use, advanced AI assistant, software engineering, deep research, and general reasoning. As shown in Figure 1, Agent-World-8B and 14B consistently outperforms strong foundation models and competitive baselines. Our analysis further reveals clear scaling relationships among the number of synthesized environments, self-evolution rounds, and downstream agent performance, providing empirical insights into the development of more general agent intelligence. In summary, our main contributions are as follows: • We introduce Agent-World, a general-purpose agent training arena that unifies scalable real-world environment synthesis with a continuous self-evolving training mechanism, forming a co-evolution loop between agent policies and environments. • We propose Agentic Environment-Task Discovery, which mines realistic executable environments from real-world environment themes and synthesizes diverse verifiable tasks with controllable difficulty. • We propose Continuous Self-Evolving Agent Training, which integrates multi-environment agentic RL with a self-evolving arena to automatically diagnose agent weaknesses and drive targeted learning in a closed training loop. • Experiments across 23 challenging agent benchmarks demonstrate the superior performance of Agent-World. Further analysis reveals scaling relationships among environment diversity, evolution rounds, and agent performance.

Preliminary: Agentic Interaction with Multi-Environments

Following AgentSkiller [93], we model multi-turn agentic interaction with external environments as a Partially Observable Markov Decision Process (POMDP) [10], represented by the tuple (𝑈, 𝑆, 𝐴, 𝑂, 𝑃). Let 𝑞 ∈ 𝑈 denote the user’s latent intent. The assistant progressively infers 𝑞 from the accumulated interaction history and environment feedback to choose appropriate actions. Intent space (𝑈).

State space (𝑆). We factor the global state into an environment state and a dialogue state: 𝑆 = 𝑆 𝐸 × 𝑆 𝐻 . At turn 𝑡, the full state is 𝑠𝑡 = (𝑠𝑡𝐸 , 𝑠𝑡𝐻 ) ∈ 𝑆. The environment state 𝑠 𝐸 ∈ 𝑆 𝐸 captures the external world the assistant can query or modify (e.g., databases, files, services), while the dialogue state 𝑠 𝐻 ∈ 𝑆 𝐻 summarizes conversational context (e.g., dialogue history, constraints, user preferences).

To connect the POMDP with multiple environments, we explicitly parameterize each environment by a pair 𝑒 = (D, F ), where D denotes an environment database and F denotes a toolset. Concretely, the database D is a primary carrier (storage) of the environment state 𝑠 𝐸 —it contains the structured records and/or files that constitute the mutable external world. The toolset F = { 𝑓 𝑘 } provides executable interfaces to interact with 𝑠 𝐸 : each tool 𝑓 ∈ F can be seen as a callable operator that reads and optionally writes the database, thereby inducing environment state transitions. Databases and tools.

The assistant chooses between tool-use actions and language-response actions: 𝐴 = 𝐴tool ∪ 𝐴resp . For 𝑎 𝑡 ∈ 𝐴tool , the assistant invokes a tool with structured arguments (e.g., a function name with JSON parameters) to query/modify the environment; for 𝑎 𝑡 ∈ 𝐴resp , it emits a natural-language message (including intermediate responses or the final answer). Action space (𝐴).

Observation space (𝑂). At each turn 𝑡, the assistant observes 𝑜 𝑡 ∈ 𝑂 and then takes an action 𝑎 𝑡 . We define 𝑂 = 𝑂 𝐸 ∪ 𝑂 𝐻 , where 𝑂 𝐸 contains structured tool observations returned by tool execution (e.g., query results, logs, error codes), and 𝑂 𝐻 contains dialogue-side observations (e.g., user utterances, system prompts, or an explicit termination signal in offline training). Importantly, the environment state 𝑠 𝐸 is not directly observed and must be inferred indirectly from tool observations in 𝑂 𝐸 .

The transition model 𝑃 : 𝑆 × 𝐴 → Π(𝑆 × 𝑂) specifies how the system evolves after an action. Given (𝑠𝑡 , 𝑎 𝑡 ), the process transitions to 𝑠𝑡+1 and emits the next observation 𝑜 𝑡+1 : State dynamics (𝑃).

• If 𝑎 𝑡 ∈ 𝐴tool , a tool 𝑓 ∈ F is executed against the database D. This execution may update the environment 𝐸 via reads/writes on D and produce a structured observation 𝑜 𝐸 ∈ 𝑂 . The dialogue state 𝑠 𝐻 state 𝑠𝑡+ 𝐸 1 𝑡+1 𝑡+1 is updated by appending the new tool interaction. 𝐻 ) by emitting a response. In interactive • If 𝑎 𝑡 ∈ 𝐴resp , the assistant updates the dialogue state (i.e., 𝑠𝑡+ 1 𝐻 settings this may lead to a new user observation 𝑜 𝑡+1 ∈ 𝑂 𝐻 ; in offline training it typically yields a termination 𝐸 = 𝑠𝐸 . signal. The environment state remains unchanged for that turn: 𝑠𝑡+ 𝑡 1

Methodology

We propose Agent-World, a general-purpose agent training arena that unifies scalable environment-task discovery with continuous self-evolving agent training. The method contains two tightly coupled components: (1) Agentic Environment-Task Discovery. We collect thousands of real-world environment themes and build a deep-research pipeline that autonomously mines topic-aligned databases and executable tool interfaces from the web, forming a scalable and realistic environment ecosystem. On top of these environments, we synthesize diverse verifiable tasks through both graph-based and programmatic generation, and further expand task difficulty with executable validation. (2) Continuous Self-Evolving Agent Training. We train agents via multi-environment reinforcement learning over “agent–tool–database” interaction rollouts, using executable rewards for state-aware supervision. The same environment ecosystem also serves as a dynamic diagnostic arena that refreshes evaluation tasks, identifies capability gaps, and drives targeted environment-task expansion, thereby enabling the co-evolution of agent policies and environments. These two components form a closed loop: scalable environments support agent training, while training-time diagnosis feeds back into the next round of environment-task construction. Below, we describe each component in detail.

3.1

Agentic Environment-Task Discovery

Environment Theme Collection: Scalable environment synthesis begins with diverse and high-quality envi-

ronment themes as anchors. We therefore systematically gather environment themes from three real-world sources:

Environment Theme Collection

Agentic Database Mining: Web

DR Agent

MCP Server MCP Server - Name: Memory Bank MCP Server

- Name: Memory Bank - Description: The MCP - primarily Name: Memory Bank Server functions - Description: The MCP

as aServer memory management primarily functions - Description: The MCP system for AIprimarily assistants… as aServer memory management functions system for AI assistants… as a memory management system for AI assistants…

DB-grounded Tools:

Cluster

Cross-validation:

Level 1: 20 labels Level 2: 50 labels Level 3: 1978 labels

Output: Executable Python functions, Schemas, Descriptions

MCP Servers: (~2.8K) Tool Documentations (~0.5K) Industrial PRDs (~0.2K)

Output: sandbox test , unit test

Tool Schema

File Structure Memory Bank/ README.md

.clinerules-code

active-context.md

progress-log.json

…

progress.md

Graph-based Tasks: DAG graph + random walk

Classify

Programmatic Tasks: solution code + verifier script Difficulty Scaling: long horizon + logical complexity

Task Verification

Task Synthesis

MCP/

mcp-config.json

VerifiabaleTask Synthesis

Environment Taxonomy

Tool Generation & Verification

- Graph-based Synthesis

def read_product_context(): result = read_memory_bank_file({ "filename" : "product-context.md" }) return result

We decided to switch our audit trail to eventdriven ingestion …

def track_progress(action, description, updateActiveContext=True): payload = { "action" : action, "description" : description, "updateActiveContext" : updateActiveContext } result = track_progress(payload) return result

- Programmatic Synthesis

…

Our team uses a shared project workspace with standard …

- Checklist Single JSON object output

Ready_to_log

Exact key set

Consequences_count

Alternatives_count

…

- Verifier Script def validate_environment_state (state): """Rough check: dict root; contacts missing or a dict.""" return isinstance(state, dict) and ( (c := state.get("contacts")) is None or isinstance(c, dict))

Figure 2 The Pipeline of Agentic Environment-Task Discovery. We start from real-world environment themes, mine topic-aligned databases from the web, generate and verify executable tool interfaces, and synthesize verifiable tasks with controllable difficulty. (1) MCP Servers: We obtain real-world MCP server specifications from Smithery 1 . Each specification is

accompanied by a structured JSON document that includes source-data descriptions and standardized tool definitions. We denote the corresponding topics as 𝑚 ∈ M1 .

(2) Tool Documentations: We broadly collect and filter open-source datasets covering real tool-use scenarios,

extract tool-definition documents, and use an LLM to inversely map them to environment topics, denoted as 𝑚 ∈ M2 .

(3) Industrial PRDs: As product requirement documents for specific industries, PRDs naturally include

background, domain workflows and system interfaces. We use them as theme anchors, denoted as 𝑚 ∈ M3 .

We finally merge these sources to form the seed topic set: M = M1 ∪ M2 ∪ M3 . Agentic Database Mining: Given the topic set M, our goal is to mine topic-aligned real-world environment

databases. Unlike prior work that emphasizes LLM-synthesized databases [31, 88, 98], we argue that the World Wide Web already contains abundant, high-value structured data that can be updated in real time.

Motivated by this, we design an agentic workflow to autonomously mine and process web data into environment databases. Concretely, we build a deep-research agent G centered on a policy model 𝜋 𝜃 and an external toolset T including search, browser, code compiler, and operating-system (OS) tools. For each topic 𝑚 ∈ M, the agent conducts iterative loops for in-depth information retrieval and data mining. After that process, the agent leverages OS tools for structuring and persistent storage, yielding the environment database as: D (𝑚) = G(𝑚; 𝜋 𝜃 , T ),

𝑚∈M

where G(·) denotes the topic-conditioned automated research pipeline. Empirically, a single autonomous mining flow often yields databases with limited scale and simple structure. To address this, we introduce a database complexification process 𝜙, which iteratively prompts a deep-research agent to expand and enrich topic-specific databases: D (𝑛+1 ) (𝑚) = 𝜙 D (𝑛) (𝑚), 𝑚, T , 𝑛 = 0, . . . , 𝑁 − 1, where the final database denotes D ( 𝑁 ) (𝑚). In practice, repeating this procedure for 𝑁 rounds produces high-quality databases that better match realistic environment demands. Tool Interface Generation and Verification. To construct a database-grounded executable toolset, we introduce

a coding agent 𝜓 equipped with a code compiler and OS tools, denoted by T̂ . Given (𝑚, D ( 𝑁 ) (𝑚)), the agent generates candidate tools together with their unit-test sets: ( 𝑓ˆ, Ĉ 𝑓ˆ) = 𝜓(𝑚, D ( 𝑁 ) (𝑚); 𝜋 𝜃 , T̂ ), 𝑚 ∈ M, 1 https://smithery.ai/servers

Figure 3 Hierarchical environment taxonomy of Agent-World. Left: distribution of the 20 first-tier categories with their server counts. Right: top-10 second-tier categories ranked by server count.

where each tool 𝑓ˆ is associated with a set of test cases Ĉ 𝑓ˆ (i.e., a one-to-many mapping). Motivated by a series of automated execution-based verification procedures [19, 123], we then perform cross-validation for quality control. For each candidate tool 𝑓ˆ, its test accuracy is defined as Acc( 𝑓ˆ; Ĉ 𝑓ˆ) =

∑︁

| Ĉ 𝑓ˆ| 𝑐ˆ∈ Ĉ

1[ 𝑓ˆ( 𝑐ˆ) passes].

𝑓ˆ

A tool is retained only if it satisfies all of the following: • the function can be successfully compiled by the Python compiler; • Acc( 𝑓ˆ; Ĉ 𝑓ˆ) > 0.5 on its associated test set; • the corresponding environment contains at least one valid tool and one valid test case. After filtering, we obtain the quality-controlled tool set F (𝑚). Finally, we define the scalable environment ecosystem as E = {(D ( 𝑁 ) (𝑚), F (𝑚)) | 𝑚 ∈ M}. Environment Taxonomy Construction: To systematically organize the synthesized environments, we build a

hierarchical taxonomy. Based on thousands of environment themes, we apply hierarchical clustering [101] to obtain 50 cluster centers; we then trace back the sample set covered by each cluster and randomly select representative samples. Building on TOUCAN’s taxonomy [113], we use GPT-OSS-120B [70] as a supervised summarization model to identify the central environment theme of each cluster, yielding 50 second-tier labels. Since relying solely on LLM summarization may introduce templated text and bias, we invite three annotators to merge the second-tier labels and abstract them into 20 first-tier types; cross-validation and discussion yield the final hierarchical taxonomy of the environment ecosystem. As shown in Figure 3, the taxonomy contains 20 first-tier labels, 50 second-tier labels, and over 2K third-tier labels, providing a foundation for cross-environment task synthesis and stratified arena construction. We denote the set of first-tier categories by C. 3.1.1

Verifiable Task Synthesis

After constructing the scalable environment ecosystem E, we synthesize high-quality agentic tasks that simulate diverse real-world tool-use scenarios. To generate complex, long-horizon tasks grounded in reliable execution, 6

we use two complementary synthesis strategies: graph-based task synthesis for modeling sequential tool dependencies, and programmatic task synthesis for modeling complex, non-linear reasoning and control flow. Both approaches rely on sandbox execution to collect execution traces, derive ground-truth answers, and preserve task verifiability [9, 98]. In real-world scenarios, agents often need to invoke a sequence of tools in a specific logical order to accomplish a goal. Thus, a valid tool execution sequence and its returned results naturally define the underlying information requirements and data flows needed to answer a specific user query. Building on this insight, we adopt a reverse-engineering paradigm: we first synthesize a valid tool-call sequence and then generate the corresponding task description [113]. To ensure task rationality and diversity, we build connected tool graphs and walk on the graph to obtain the tool sequences. We detail the construction process as follows: (1) Graph-Based Task Synthesis.

Tool Graph Construction. For each environment (D ( 𝑁 ) (𝑚), F (𝑚)) ∈ E, we first construct a fully connected,

weighted directed graph 𝐺 = (𝑉, 𝐸), where each node 𝑣 ∈ 𝑉 corresponds to a tool 𝑓 ∈ F (𝑚) and each edge encodes call dependencies between tools. We define three types of edges, evaluated and assigned by an LLM: • Strong dependency ( 𝑓𝑖 → 𝑓 𝑗 , 𝑤 𝑖 𝑗 = 3): The input of tool 𝑓 𝑗 strictly relies on the output of tool 𝑓𝑖 (e.g., calling create_order to obtain an order_id before calling get_order_details). This forms a strictly directed edge, ensuring the most logical data flow. • Weak dependency ( 𝑓𝑖 ↔ 𝑓 𝑗 , 𝑤 𝑖 𝑗 = 2): The input of 𝑓 𝑗 can be derived from 𝑓𝑖 ’s output, but can also be obtained via other means (e.g., querying a database directly or using a constant). This is modeled as a bidirectional edge, offering flexibility during the walk. • Independent edge ( 𝑓𝑖 ↔ 𝑓 𝑗 , 𝑤 𝑖 𝑗 = 1): Tools with no parameter-level dependencies. These edges act as a fallback to guarantee that 𝐺 is fully connected, preventing dead ends during random walks. Random Walk on Tool Graph. We generate a raw tool-call sequence 𝜏 = [ 𝑓1 , 𝑓2 , . . . , 𝑓 𝑘 ] by performing a

random walk on 𝐺. We prioritize starting nodes 𝑓1 that return tool output but have no strong dependency precursors. At step 𝑡, the next tool 𝑓𝑡+1 is sampled from the successors of 𝑓𝑡 with a probability distribution biased by the edge weights 𝑤, encouraging sequences with realistic reasoning. Once the tool sequence 𝜏 is sampled, we instantiate its input parameters: (1) For strong/weak dependencies, we pass the output of the preceding tool; (2) For independent edges, we randomly sample valid values from the database D ( 𝑁 ) (𝑚). Finally, an LLM reviews the populated chain to prune redundancies, verify logical consistency, and output a refined, executable tool sequence 𝜏 ∗ . Task and Rubric Generation. Given 𝜏 ∗ , an LLM drafts an initial task description 𝑞 𝑖𝑛𝑖𝑡 . To prevent data

leakage, 𝑞 𝑖𝑛𝑖𝑡 is strictly prohibited from containing technical details such as tool names or database schema. Next, we execute 𝜏 ∗ step-by-step within a Python sandbox, recording the intermediate execution trace and the final return results. Observing the actual data fields and formats allows the LLM to refine 𝑞 𝑖𝑛𝑖𝑡 into a highly realistic and well-grounded final query 𝑞 𝑓 𝑖𝑛𝑎𝑙 . Simultaneously, the LLM generates a strictly formatted JSON ground-truth answer 𝑎 ∗ and structured evaluation rubrics 𝑅 [39, 83, 85, 112]. The rubrics 𝑅 enable automated evaluation across multiple dimensions, including field completeness, schema matching, and numerical tolerances. Quality Consistency and Verification. To ensure task stability, we evaluate the generated task (𝑞 𝑓 𝑖𝑛𝑎𝑙 , 𝑎 ∗ ) by

deploying a ReAct agent to solve it 5 separate times within the sandbox. We retain the task only if the agent successfully reaches a consistent answer in at least two independent runs. Difficulty Scaling. To increase task difficulty while maintaining solvability, we complicate the reasoning path

in each task. Specifically, we scale difficulty by increasing the maximum step count of the random walk to expand the tool chain, and by increasing the sampling probability of weak dependencies and independent edges to reduce reliance on obvious sequential outputs. We further rewrite the final task description to obscure explicit mentions of tool names and execution logic, forcing the agent to infer the required workflow purely from abstract task goals. The final task set synthesized by graph-based generation is denoted as Xgraph .

Figure 4 Comprehensive statistics of Agent-World environments and synthesized tasks, including environment diversity, tool coverage, file-type distribution, and task difficulty characteristics.

While graph-based synthesis effectively models sequential dependencies, real-world tasks often demand reasoning patterns that cannot be expressed linearly, such as conditional tool usage, multi-step loops, and result aggregation. To capture these behaviors, we introduce programmatic task synthesis. Unlike the graph-based method that simulates step-by-step sequences, this approach directly generates executable Python solutions capable of performing code-based reasoning over provided tools. (2) Programmatic Task Synthesis.

Task and Solution Code Generation. We prompt an LLM with the environment’s tool schemas and database

descriptions to generate a highly complex task query 𝑞 𝑝𝑟 𝑜𝑔 . The query must focus entirely on task scenarios and objectives without revealing details of tools or databases. Subsequently, the LLM acts as a solver to generate a comprehensive, end-to-end executable Python script 𝜋 𝑐𝑜𝑑𝑒 . This script must load the tool implementations and utilize complex control flows (e.g., for loops, if-else branches, statistical aggregations) to solve 𝑞 𝑝𝑟 𝑜𝑔 . To ensure 𝜋 𝑐𝑜𝑑𝑒 is executable, we wrap this step in a ReAct loop: if the sandbox throws syntax or runtime errors, the agent iteratively debugs and repairs the code. The successfully executed script yields the final ground-truth answer 𝑎 ∗ .

Verification Code Generation. Traditional string-matching evaluation falls short for complex programmatic

tasks. Therefore, we input (𝑞 𝑝𝑟 𝑜𝑔 , 𝜋 𝑐𝑜𝑑𝑒 , 𝑎 ∗ ) to an LLM to generate an executable verification script 𝑉𝑐𝑜𝑑𝑒 (𝑎, 𝑎 ∗ ). The script includes multi-level assertions and custom logic to robustly determine whether the candidate answer 𝑎 and the underlying database state 𝑠 𝐸 satisfy all task constraints. Similar to solution code generation, a ReAct agent debugs 𝑉𝑐𝑜𝑑𝑒 in the sandbox to guarantee its reliability. Quality Consistency and Verification. Following the same rigorous filtering protocol as the graph-based

method, we execute a ReAct agent 5 times against 𝑞 𝑝𝑟 𝑜𝑔 . The generated verification script 𝑉𝑐𝑜𝑑𝑒 evaluates the agent’s output. Tasks are preserved only if the agent achieves a stable pass rate (at least 2 successful runs), ensuring the synthesized tasks are challenging yet solvable.

Difficulty Scaling. Similar to graph-based synthesis, we also scale the difficulty of programmatic tasks.

Specifically, we increase the number of unique tools and invocations through modifying LLM instructions. We also inject instructions of implementing intricate inter-tool logic such as conditional branches and mandate advanced data operations like cross-database aggregations, sorting, and filtering. Finally, similar to the graph-based approach, we rewrite the task description of any direct references to APIs or execution traces, ensuring the agent must plan complex programmatic logic entirely from high-level user intents. The final task set synthesized by programmatic generation is denoted as Xprog . (3) Static Statistics of Environment--Task Data: To more comprehensively demonstrate the quality of our

agentic environment scaling stage, Figure 4 provides a detailed analysis of Agent-World environments and tasks through six subfigures. Environment Diversity: We observe that (a) Agent-World covers a broad range of environment types, with over 2,000 environments in total (1,978 retained after filtering). (b) Each environment is equipped with a diverse toolset, averaging more than 10 tools, with some environments containing over 40 tools. (c) The

overall ecosystem includes 19,822 distinct tools, each with rich parameters, ensuring both atomic functionality and tool diversity. Interestingly, (d) the underlying database file types are also highly diverse, including json, csv, sql, and html, as well as environment-specific formats such as tex and yaml. This further reflects the diversity of our databases and their alignment with real-world workspace file formats. Task Difficulty: As shown in (e), all synthesized tasks contain at least 7 interaction turns, with an average

of over 20 turns and a non-trivial portion exceeding 40 turns, already indicating substantial difficulty. To quantify difficulty more directly, in (f) we evaluate task execution under Pass@10 using the strong proprietary model Doubao-Seed-2.0-pro [81]. Only a small fraction of tasks are solved in all 10 attempts; most are solved only once out of 10, and some are not solved at all. This shows that our difficulty scaling strategy is effective at increasing task complexity. Beyond aggregate statistics, we provide reader-facing environment cards in Appendix B, where each card summarizes a seed domain’s on-disk layout and representative callable tool interfaces. In addition, Appendix C presents verifiable tasks, including the environment, tools, rubrics, and interaction trajectories.

3.2

Continuous Self-Evolving Agent Training

In this section, we introduce continuous self-evolving agent training. Given a scalable environment ecosystem E = {(D ( 𝑁 ) (𝑚), F (𝑚)) | 𝑚 ∈ M}, where each environment pairs a database with an executable toolset, we train general-purpose agents with multi-environment “agent–tool–database” interaction rollouts and executable rewards. Crucially, E also serves as a dynamic diagnostic arena: the current policy is evaluated on fresh tasks in held-out environments, its capability gaps are identified from executable evidence, and the resulting diagnosis guides targeted environment-task expansion. This creates a self-evolving loop in which agent policies and environments co-evolve over training rounds. 3.2.1

Multi-Environment Agent Reinforcement Learning

After constructing a scalable environment ecosystem and synthesizing verifiable tasks, we perform multienvironment agent RL to improve state-aware reasoning, long-horizon tool use, and environment interaction robustness. Multi-environment Rollout. Unlike static tool-calling scenarios, we implement a closed-loop interaction among

three components:

• An LLM policy 𝜋 𝜃 , which generates the next action conditioned on the dialogue history and tool feedback; • A tool interface/runtime, which executes the environment-specific tool set F (𝑚) and maintains environmentside states (database connections, caches, etc.); • A database state D ( 𝑁 ) (𝑚), which serves as the read/write substrate for tool execution and provides a verifiable, updatable structured data backbone. At each step, the model produces both natural-language reasoning and tool/action decisions. When a tool call is triggered, the interface executes the selected tool in a sandboxed environment to read or update the environment database state, and returns structured observations to the policy for subsequent decision making. Formally, given a task 𝑥 and its training environment (D ( 𝑁 ) (𝑚), F (𝑚)) ∈ E, following Section 2, the policy 𝜋 𝜃 samples an action 𝑎 𝑡 based on the instruction and history ℎ𝑡 = (𝑜0 , 𝑎 0 , . . . , 𝑜 𝑡 ). If 𝑎 𝑡 ∈ 𝐴tool , it executes 𝐸 ∈ 𝑂 ; if 𝑎 ∈ 𝐴 𝑓 ∈ F (𝑚) on D ( 𝑁 ) (𝑚) and returns a structured observation 𝑜 𝑡+ 𝐸 𝑡 resp , it outputs a natural1 language response (typically the final answer or completion marker) and terminates the trace. This yields a model output 𝑦 = (𝜏, 𝑎 final ), where 𝜏 = (𝑜0 , 𝑎 0 , . . . , 𝑜𝑇 , 𝑎𝑇 ) is the interaction trajectory and 𝑎 final is the final answer. Following Group Relative Policy Optimization (GRPO) [84], we sample 𝑁 outputs per task 9

(a) Multi-Environment Agent Reinforcement Learning

Output

Multi-Environment Rollout Module

Question

Policy Model

Tool Interface

Database State

�1

� � 1+1

� � 1+2 � 2⋯ ⋯ ⋯ � � 1+� 2 � �1

Reference Model Reward Model

(b) Self-Evolving Agent Arena Environments Ecosystems

Reward

Code Execution Reward

� � 1+1

Rubric-conditioned Reward

�1 � � 1+2 � 2⋯⋯ � � 1+� 2 ⋯ � �1

Advantages Group Computation

� � 1+1 �1 � � 1+2 � 2⋯⋯ � � 1+� 2 ⋯ �� 1

Dynamic Evaluation Tasks Synthesis Arena Construction

Agent-Arena

Dynamic Sampling

Evaluation

Agent-World

Scalable environment synthesis with continuous self-evolving training

Evolved Agent

Reward Types

Vanilla Agent

Weak Environments

Target Tasks

Dynamic Environment Sampling Round-by-round dynamic sampling based on an environment taxonomy

Task Generation Guidelines

Error Trajectory

Weak Environments Error Tool-use behaviors

Continue RL Targeted Data Evolving

Verifiable Task Synthesis

Out-of-distribution task synthesis for sampled environments.

Agentic Diagnosis

State Update Error

Diagnosis Agent

Figure 5 The Overall Framework of Continuous Self-Evolving Agent Training. The agent is trained with multi-environment RL under executable rewards (top), evaluated in a dynamic arena, diagnosed for capability gaps, and improved through targeted environment-task expansion (bottom).

𝑥, and tasks within each global batch are paired with independent and dynamic environments to realize multi-environment rollouts. Structured Verifiable Reward. Reward signals define the optimization objective and directly guide policy

behavior. Distinct from prior static tool-RL settings [20, 26], automatic reward assignment for environment agents must account for multiple factors beyond answer correctness, including environment state, efficiency constraints, and format compliance. Accordingly, we instantiate two reward types. (i) Graph-based tasks (Xgraph ) provide a structured rubric 𝑅 = {𝑟 𝑗 } 𝑛𝑗=1 (schema matching, fact checking, etc.). We use a rubric-conditioned LLM-as-judge to evaluate each criterion 𝑟 𝑗 from model output 𝑦 under task 𝑥, and compute an overall pass rate by averaging criterion-level pass indicators. (ii) Programmatic tasks (Xprog ) provide an executable validation script 𝑉code per task, which we run in the sandbox to verify either the predicted answer or the resulting database state. Therefore, the output-level reward is computed as i ( h Í I 𝑛1 𝑛𝑗=1 I Judge(𝑥, 𝑦, 𝑟 𝑗 ) == 1 , if 𝑥 ∈ Xgraph , 𝑟 𝑗 ∈ 𝑅 𝑟 (𝑥, 𝑦) = I Execute(𝑉code (𝑦, 𝑦 ∗ )) , if 𝑥 ∈ Xprog . where I[·] is the indicator function. Judge(𝑥, 𝑦, 𝑟 𝑗 ) denotes a rubric-conditioned LLM judge that assesses whether model output 𝑦 satisfies criterion 𝑟 𝑗 under task 𝑥. Execute(𝑉code (𝑦, 𝑦 ∗ )) denotes running the taskspecific validation script 𝑉code in a sandbox over model output 𝑦 to verify that answer/state are satisfied with the ground truth 𝑦 ∗ . Policy Update. To enable stable training with environment interaction, we adopt Group Relative Policy

Optimization (GRPO) [84] to directly maximize the verifiable returns defined above. Concretely, for each 𝐺 input task 𝑥 sampled from dataset 𝐷, we draw a group of 𝐺 trajectories/outputs {𝑦 𝑖 }𝑖= 1 from the behavior policy 𝜋 𝜃old (· | 𝑥), compute token-level advantages 𝐴ˆ𝑖,𝑡 , and update 𝜋 𝜃 by maximizing the GRPO objective

with a clipped importance ratio and a KL penalty to a reference policy 𝜋ref : " | 𝑦𝑖 | 𝐺 1 ∑︁ 1 ∑︁ 𝐽GRPO (𝜃) = E 𝑥∼𝐷, { 𝑦𝑖 } 𝐺 ∼ 𝜋 𝜃 (· | 𝑥 ) min 𝑟 𝑖,𝑡 (𝜃) 𝐴ˆ𝑖,𝑡 , 𝑖=1 old 𝐺 𝑖=1 |𝑦 𝑖 | 𝑡=1

(1)

clip 𝑟 𝑖,𝑡 (𝜃), 1 − 𝜖, 1 + 𝜖 𝐴ˆ𝑖,𝑡 − 𝛽𝐷 KL (𝜋 𝜃 ∥ 𝜋ref ) .

where 𝜖 and 𝛽 are hyperparameters, 𝑦 𝑖 denotes the model output (including interaction trajectory and final answer), and 𝐴ˆ𝑖,𝑡 is the normalized advantage of the 𝑖-th rollout within the group. 3.2.2

Self-Evolving Agent Arena

Motivation. Our scalable environment ecosystem E = {(D ( 𝑁 ) (𝑚), F (𝑚)) | 𝑚 ∈ M} serves not only as a training

source but also as an agentic diagnostic arena. Beyond synthesizing training data, we aim to continuously identify weaknesses of the current agent policy and then expand environments and tasks in a targeted manner to close those gaps. This yields a self-reinforcing loop in which evaluation, diagnosis, and data generation evolve together with the agent. Arena Construction. Based on the hierarchical environment taxonomy (Sec. 3.1), we construct an evaluation

arena by stratified sampling. Specifically, for each first-tier category 𝑐 ∈ C, we randomly select 𝐾 environments | Earena | (𝐾 = 5) and merge them into the arena set Earena = {(D ( 𝑁 ) (𝑚 𝑖 ), F (𝑚 𝑖 ))}𝑖= . This design ensures broad 1 coverage over different environment types while keeping evaluation cost controllable.

Dynamic Evaluation Task Synthesis. For each arena environment (D ( 𝑁 ) (𝑚 𝑖 ), F (𝑚 𝑖 )) ∈ Earena , we follow

Section 3.1.1 and synthesize a fresh batch of verifiable tasks and validators at each iteration. Concretely, (𝑟 ) at iteration 𝑟 we instantiate a task set Xarena (𝑚 𝑖 ) consisting of both graph-based tasks and programmatic tasks, each paired with an executable rubric 𝑅 or verification code 𝑉code . The full evaluation set is defined as Ð (𝑟 ) (𝑟 ) Xarena = 𝑖 Xarena (𝑚 𝑖 ). Importantly, both the sampled environments and the synthesized tasks are dynamic across rounds, preventing overfitting to a static evaluation and enabling continual diagnosis. (𝑟 )

Agentic Diagnosis. Given a trained agent policy 𝜋 𝜃 (𝑟 ) , we evaluate it on synthesized tasks Xarena under

the agent-tool-database execution protocol, with task-level assessment performed by the corresponding executable rubric 𝑅 or verification code 𝑉code .

We then employ an auto-diagnosis agent 𝛿, equipped with a Python interpreter and search tools, to analyze failure patterns. The diagnosis agent takes as input: (i) per-task failure traces (tool logs, intermediate observations, and validator feedback), (ii) error distribution statistics by environment and taxonomy category, and (iii) environment metadata (tool schemas and database descriptions). The diagnosis agent outputs (a) a ranked set of weak environments W (𝑟 ) ⊆ Earena and (b) environment(𝑟 ) specific task-generation guidelines Gguide (𝑚) that characterize missing capabilities (e.g., erroneous tool use or state-update mistakes). These outputs serve as anchors for subsequent environment and task expansion. Detailed prompts for agentic diagnosis are provided in Appendix A. (𝑟 )

(𝑟 )

Agent-Environment Co-Evolution. Conditioned on W (𝑟 ) and Gguide = {Gguide (𝑚 𝑖 )|(D ( 𝑁 ) (𝑚 𝑖 ), F (𝑚 𝑖 )) ∈ W (𝑟 ) }, (𝑟 ) we re-run the verifiable task synthesis pipeline (Sec. 3.1.1) to generate a targeted training set Xtarget , optionally accompanied by environment expansion via database complexification when the weakness is due to insufficient state diversity.

Starting from 𝜋 𝜃 (𝑟 ) , we then perform multi-environment agent RL (Sec. 3.2.1) on the augmented data to obtain an improved policy 𝜋 𝜃 (𝑟+1) . Iterating the above steps yields a self-evolving agent-arena loop: evaluate

diagnose+target

continue RL

(𝑟 ) 𝜋 𝜃 (𝑟 ) −−−−−−−→ W (𝑟 ) −−−−−−−−−−−−−→ Xtarget −−−−−−−−−−→ 𝜋 𝜃 (𝑟+1) .

This arena-driven loop turns scalable environments into an automated curriculum engine, continuously driving targeted learning and enabling the co-evolution of agent policies and environments. 11

Algorithm 1: Self-Evolving Agent Arena Loop Input: agent environment arena Earena ⊂ E; initial policy 𝜋 𝜃 ( 0) ; number of evolving rounds 𝑅 Output: Evolved policy 𝜋 𝜃 (𝑅) 1 for 𝑟 = 0, . . . , 𝑅 − 1 do // Phase 1: Dynamic Evaluation Task Synthesis foreach (D ( 𝑁 ) (𝑚 𝑖 ), F (𝑚 𝑖 )) ∈ Earena do

(𝑟 ) Synthesize fresh verifiable tasks Xarena (𝑚 𝑖 ) with executable rubric 𝑅 or verification code 𝑉code ; Ð (𝑟 ) (𝑟 ) Define the full evaluation set Xarena = 𝑖 Xarena (𝑚 𝑖 ); (𝑟 ) Evaluate 𝜋 𝜃 (𝑟 ) on Xarena under agent-tool-database execution with assessment by 𝑅 or 𝑉code ; // Phase 2: Agentic diagnosis Input per-task failure traces, environment error statistics and metadata to diagnosis agent 𝛿; (𝑟 ) outputs weak environments W (𝑟 ) ⊆ Earena and task-generation guidelines Gguide (𝑚); // Phase 3: Agent-Environment Co-Evolution. foreach (D ( 𝑁 ) (𝑚), F (𝑚)) ∈ W (𝑟 ) do Complexify database: D ( 𝑁 ) (𝑚) ← 𝜙(D ( 𝑁 ) (𝑚), ·); (𝑟 ) (𝑟 ) Generate targeted tasks Xtarget (𝑚) conditioned on Gguide (𝑚); Ð (𝑟 ) (𝑟 ) Define Xtarget = ( D ( 𝑁 ) (𝑚) , F (𝑚) ) ∈ W (𝑟 ) Xtarget (𝑚);

(𝑟 ) Continue RL on Xtarget obtain: 𝜋 𝜃 (𝑟+1) ← 𝜋 𝜃 (𝑟 ) ;

3 4 5

6 7

8 9 10

return 𝜋 𝜃 (𝑅) ;

Experiment

In this section, we conduct experiments to evaluate the effectiveness of Agent-World and further analyze its key properties. First, we introduce the details of the experimental settings (Sec. 4.1). Next, we present the main results of Agent-Wolrd (Sec. 4.2). Finally, we present quantitative and qualitative analyses of our approach (Sec. 4.3).

4.1

Experimental Settings

In this part, we introduce the datasets used for training and evaluation, the baseline approaches, and the implementation details. Baselines. We compare Agent-World against three baseline groups, consistent with Table 1:

• Frontier Proprietary Models: GPT-5.2 High [69], Claude Sonnet-4.5 [4], Gemini-3 Pro [23], Seed2.0 [8]. • Open-Source Foundation Models (8B–685B): DeepSeek-V3.2-685B [58], GPT-OSS-120B [70], Qwen3235B-A22B [114], and Qwen3-8B, 14B, 32B [114]. • Open-Source Environment Scaling Methods (7B-14B): Simulator-8B [54], TOUCAN-7B [113], EnvScaler8B [89], AWM-8B, 14B [100], and ScaleEnv-8B [98]. Evaluation Benchmarks. We evaluate Agent-World on 23 benchmarks spanning complementary capabilities:

• Core agentic tool-use suites: MCP-Mark [106], BFCL V4 [73], and 𝜏 2 -Bench [7]. • Advanced AI assistant benchmarks: SkillsBench [47], ARC-AGI-2 [15], and Claw-Eval [16]. • General reasoning benchmarks: MATH500 [57], GSM8K [17], MATH [36], AIME24 [1], AIME25 [2], KOR-Bench (Cipher) [63], and OlympiadBench (𝑂𝐸_𝑇𝑂_𝑚𝑎𝑡ℎ𝑠_𝑒𝑛_𝐶𝑂 𝑀 𝑃) [33]. • Agentic search & coding benchmarks: WebWalkerQA [104], SWE-Bench Verified (SWE) [41], SWEbench Multilingual [122], Terminal-Bench 1.0, Terminal-Bench 2.0 [64], General AI Assistants (GAIA) [65], 12

and Humanity’s Last Exam (HLE) [74]. • Knowledge and MCP benchmarks: MMLU [35], SuperGPQA [96], MCP-Universe 5 sub-domains (Financial Analysis, Browser Automation, Web Searching, Location Navigation, and Repository Management) [62]. All baselines and benchmarks are evaluated using in-house evaluation framework, with results aligned to official scores. Following prior work [20, 21, 43, 48, 50], we use sampled subsets for some benchmarks (e.g., GAIA and HLE) to accelerate evaluation. Implementation Details. In Agentic Environment-Task Discovery, we use GPT-OSS-120B [70] as the policy

model for environment mining. The same policy model is also used for task synthesis and for generating code and rubric artifacts across different toolsets. In Agentic Diagnosis, GPT-OSS-120B is likewise used to execute diagnosis trajectories and identify failure modes. For training initialization, we perform a cold-start supervised fine-tuning stage using the same data-synthesis strategy as Agentic Environment-Task Discovery, where 40K trajectories are generated by an in-house Doubao-Seed-1.8 policy version model [82]. After cold-start SFT, we initialize the Qwen3-8B/14B backbones [114], synthesize 5K RL samples, and apply GRPO [84] as the RLVR algorithm for subsequent training. To enhance training stability, we follow prior work [118] and set the clip ratio 𝜀low = 0.2 and 𝜀 high = 0.28. Moreover, the maximum trajectory length is set to 80K tokens, and the maximum generation length per step is capped at 32k tokens. In each training step, we sample 32 tasks and perform 8 rollouts to collect RLVR experience, with temperature = 1.0 and top_p = 1.0. For evaluation, we also use temperature = 1.0 and top_p = 1.0 for decoding. To reduce random variance, we repeat each experiment eight times and report average accuracy (%).

4.2

Main Results

The experimental results are shown in Table 1. Overall, Agent-World consistently outperforms existing environment-scaling baselines across diverse agentic tool-use benchmarks, demonstrating stronger robustness and more comprehensive generalization in long-horizon settings. We summarize the main findings as follows. (1) Foundation models remain limited in complex agentic tool-use scenarios. Even advanced proprietary models show clear limitations on challenging benchmarks. For instance, GPT-5.2 High achieves only 53.1% on MCP-Mark, while Gemini-3 Pro reaches 50.8%. Moreover, open-source foundation models are even more constrained, with GPT-OSS-120B and Qwen3-235B-A22B scoring only 4.7% and 5.8% on MCP-Mark. Since these benchmarks cover diverse stateful environments, the results suggest that current foundation models still struggle with long-horizon tool use requiring multi-step planning, tool orchestration, and state tracking. (2) Existing environment-scaling methods still suffer from uneven capability gains. Compared with the Qwen3 backbones, existing environment-scaling methods improve some benchmarks, but their gains remain uneven across environments. Simulator-based methods such as Simulator-8B achieve good results on 𝜏 2 -Bench, yet still perform poorly on MCP-Mark and BFCL V4, suggesting that simulated environments are insufficient to capture complex real-world state transitions. programmatic environment-scaling methods such as EnvScaler-8B and AWM-8B/14B provide broader gains, but still show clear weaknesses on specific environments, including GitHub and Notion. This highlights that robust generalization depends not only on realistic feedback, but also on the diversity and quality of synthesized environments. (3) Agent-World achieves more consistent cross-environment generalization. Under the same training setting, Agent-World consistently outperforms prior environment-scaling baselines across all three benchmark suites. In detail, Agent-World-8B achieves 61.8% on 𝜏 2 -Bench, 51.4% on BFCL V4, and 8.9% on MCP-Mark. These results clearly outperform EnvScaler-8B, ScaleEnv-8B and even Qwen3-235B-A22B. Moreover, Agent-World-14B achieves an additional improvement of about 5% over Agent-World-8B. It not only surpasses all prior environment-scaling baselines, but also delivers competitive performance against large open-source LLMs, particularly DeepSeek-V3.2-685B on BFCL-V4 (55.8% vs. 54.1%). These results indicate that Agent-World produces more consistent gains across diverse benchmarks and environments. We attribute

Table 1 Main results on agentic tool-use benchmarks. We report accuracy (%) across three benchmark suites: MCP-Mark, BFCL V4, and 𝜏 2 -Bench. In the Open-Source Environment Scaling Methods block, the best result in each column is marked in bold and the second best is underlined. MCP-Mark

BFCL V4

𝜏 2 -Bench

Method

File.

Github

Notion

Play.

Post. Avg. WebSearch Memory Multi-T. No live Live Relev. Irrelev. Avg. Retail Telecom Airline Avg.

GPT-5.2 High

60.0

47.8

42.9

40.0

66.7

53.1

75.5

45.8

48.5

81.9

70.4

75.0

88.7

62.9

81.6

95.8

62.5

80.2

○ Claude Sonnet-4.5

32.5

29.4

25.0

27.0

50.0

33.3

81.0

65.0

61.4

88.7

81.1

68.8

86.6

73.2

86.2

98.0

70.1

84.7

Frontier Proprietary Models

Gemini-3 Pro

56.7

45.7

43.8

40.0

70.2

50.8

80.0

61.7

60.8

90.7

83.1

68.8

85.6

72.5

85.3

98.0

72.7

85.4

Seed 2.0

60.0

39.1

53.6

40.0

81.0

54.7

92.0

57.8

62.3

89.0

82.2

76.6

75.0

73.4

90.4

94.2

64.4

83.0

DeepSeek-V3.2-685B

36.7

20.7

45.5

17.0

66.6

36.7

69.5

54.2

37.4

34.9

53.7

37.5

93.2

54.1

–

80.3

GPT-OSS-120B

5.8

4.4

3.6

3.0

7.1

4.7

–

67.8

49.2

48.0

55.0

Qwen3-8B

3.3

0.0

4.0

4.8

2.4

7.0

17.6

35.4

90.2

80.9

81.3

77.2

40.4

34.0

18.0

26.5

26.2

Qwen3-14B

3.3

4.4

0.0

9.5

3.4

4.0

19.8

36.9

90.0

82.4

81.3

79.4

41.0

55.3

14.9

27.0

32.4

Qwen3-32B

10.0

3.6

23.8

7.5

26.0

15.7

43.3

90.3

82.0

81.3

82.4

46.7

59.5

27.2

48.0

44.9

Qwen3-235B-A22B

13.3

10.7

4.8

5.8

54.0

23.9

45.4

37.4

68.9

87.5

81.7

47.9

71.9

58.0

45.6

58.5

Open-Source Foundation Models (8B–685B)

Open-Source Environment Scaling Methods (7B-14B)

Simulator-8B

3.3

0.0

4.0

4.8

2.4

17.5

6.0

4.1

47.6

44.6

31.3

87.3

23.9

32.2

29.2

34.0

31.8

TOUCAN-7B

0.0

4.8

1.0

21.0

18.5

17.8

81.0

73.9

81.3

78.6

36.6

22.8

10.5

20.0

17.7

EnvScaler-8B

10.0

4.4

0.0

4.0

9.5

5.6

23.0

21.9

47.1

88.5

82.2

93.8

74.6

47.6

49.6

32.7

31.5

37.9

AWM-8B

3.3

0.0

4.0

4.8

2.4

9.5

15.7

34.9

90.2

80.5

93.8

73.9

40.0

41.2

38.5

23.5

34.4

AWM-14B

3.3

8.7

0.0

4.0

9.5

5.1

10.0

19.8

37.6

90.2

81.5

75.0

79.4

42.4

63.6

17.8

31.5

39.0

ScaleEnv-8B

–

50.9

27.2

37.5

38.5

Agent-World-8B

13.3

4.4

3.6

4.0

19.1

8.9

47.0

21.7

44.5

83.3

79.6

93.8

80.2

51.4

72.8

50.9

40.0

61.8

Agent-World-14B

16.6

4.4

3.6

4.0

38.1

13.3

53.0

23.9

53.9

82.3

79.3

93.8

81.0

55.8

74.5

56.1

52.0

65.4

this advantage to its unified framework, which tightly integrates scalable environment-task discovery with continuous self-evolving agent training.

4.3

Quantitative and Qualitative Analyses

4.3.1

Generalization on Long-horizon Agentic Reasoning Scenarios

To further assess long-horizon generalization in agentic tool-use scenarios, we compare Agent-World-8B against strong baselines on 17 benchmarks, organized into three complementary perspectives in Figure 6: General Reasoning, Agentic Search & Coding, and Knowledge & MCP. Overall, Agent-World demonstrates strong cross-domain generalization without benchmark-specific tuning, further validating the transferability of our environment-scaling paradigm. The key findings are summarized below. (1) Agent-World strengthens agentic behavior while preserving strong general reasoning. On the General Reasoning axis, Agent-World-8B achieves the best overall profile across seven widely-used reasoning benchmarks (MATH500, GSM8K, MATH, AIME24, AIME25, KOR-Bench, and OlympiadBench), with clear gains on most dimensions and no degradation on core math reasoning. This indicates that our Agent-World training pipeline improves difficult multi-step reasoning without sacrificing foundational reasoning capability. (2) The largest gains are observed in long-horizon search and coding tasks. On Agentic Search & Coding, Agent-World-8B consistently outperforms both baselines on WebWalkerQA, SWE-bench Verified, SWE-bench Multilingual, Terminal 1.0, Terminal 2.0, GAIA, and HLE. These benchmarks stress iterative planning, long-horizon software engineering, deep information retrieval, and multi-tool coordination. The consistent improvements indicate that Agent-World acquires transferable agentic strategies rather than benchmarkspecific heuristics. Notably, EnvScaler-8B underperforms its Qwen3-8B backbone on SWE and Terminal 1.0, possibly because its environment expansion is less effective at eliciting complex software-engineering reasoning patterns.

Figure 6 Generalization across long-horizon agentic reasoning scenarios. Comparison of Qwen3-8B, EnvScaler8B, and Agent-World-8B from three capability groups: General Reasoning, Agentic Search & Coding, and Knowledge & MCP.

Figure 7 Generalization on advanced agentic assistant benchmarks. Comparison of Qwen3, EnvScaler, AWM, and Agent-World series on SkillsBench, ARC-AGI-2, and Claw-Eval.

(3) Agent-World shows stronger robustness in heterogeneous knowledge and MCP environments. On Knowledge & MCP, Agent-World-8B also substantially outperforms baselines on five relatively orthogonal MCPUniverse capabilities: Browser Automation, Web Searching, Location Navigation, Repository Management, and Financial Analysis. In addition, Agent-World-8B maintains consistent improvements on knowledge-centric dimensions (e.g., MMLU and SuperGPQA), highlighting stronger compositional generalization and adaptation to structurally diverse external tools. 4.3.2

Generalization on Agentic AI Assistant Scenarios

To further stress-test transfer in advanced assistant settings, we evaluate on three recent highly challenging AI Assistant benchmarks: SkillsBench, ARC-AGI-2, and ClawEval. These benchmarks emphasize long-horizon planning and execution in real-world assistant scenarios. We have the following observations: (1) Existing open-source baselines struggle in real-world AI assistant settings. Most baseline models obtain average scores below 20% across the three benchmarks and do not show consistent gains from 8B to 14B. For example, Qwen3 drops on ClawEval (25.6% → 24.7%), and AWM shows uneven improvements across tasks. This suggests that naive parameter scaling alone is insufficient for stable long-horizon agentic generalization. (2) Agent-World generalizes strongly to unseen advanced assistant domains. Without benchmark-specific training, Agent-World still outperforms strong open-source baselines on these challenging settings. At

Figure 8 Scaling relationship of training environments: Downstream agent performance scales positively with the number of synthesized training environments.

8B, Agent-World achieves 9.2%/6.5%/30.5% on SkillsBench/ARC-AGI-2/Claw-Eval, surpassing Qwen3-8B, EnvScaler-8B, and AWM-8B across all three tasks. (3) Agent-World exhibits stable cross-scale gains. Unlike the unstable scaling trends of several baselines, Agent-World improves consistently from 8B to 14B (SkillsBench: 9.2% → 12.6%, ARC-AGI-2: 6.5% → 8.5%, Claw-Eval: 30.5% → 31.5%). This supports that our method remains effective across parameter scales and transfers robustly to complex, integrated assistant scenarios. 4.3.3

Scaling Analysis of Training Environments

To analyze how environment scaling affects downstream agentic tool-use performance, we progressively increase the number of training environments from 0 to 10, 100, 500, 1000, and 2000 (1,978), and evaluate the resulting models on four representative domains in Figure 1: MCPMark (Postgres), BFCL (WebSearch), BFCL (Multi-Turn), and 𝜏 2 -Bench (Airline). Overall, performance improves consistently across all four domains as the environment scale grows, indicating a clear positive scaling relationship. Averaged over the four domains, the score rises from 18.4% to 38.5% (+20.1 points), more than doubling the initial level. A notable trend is the stage-wise gain pattern: performance jumps markedly from 10 to 100 environments and again from 100 to 500, suggesting that moderate-scale expansion rapidly improves coverage of critical interaction patterns. This effect is especially evident on BFCL-V4 and MCPMark: MCPMark (Postgres) improves from 4.8% to 19.9%, while BFCL (WebSearch) increases from 7.0% to 47.0%. BFCL (Multi-Turn) and 𝜏 2 -Bench (Airline) also improve steadily, indicating broad transfer across task types. From 500 to 2000 environments, the trend remains upward but the marginal improvement gradually decreases, indicating diminishing-yet-positive returns at larger scales. This suggests that early expansion mainly captures missing high-impact environment diversity, while later expansion contributes finer-grained robustness gains. 4.3.4

Analysis of Continuous Self-Evolution

To validate Continuous Self-Evolving Agent Training, we run the same tworound self-evolving arena loop (Sec. 3.2) from two different starting points: Agent-World-14B and the EnvScaler-8B base model. In each round, the current policy is first evaluated on newly synthesized verifiable tasks in held-out arena environments; a diagnosis agent then identifies weak environments and failure

Table 2 Effect of continuous self-evolution. We run iterative selfevolving loops for Agent-World-14B and the EnvScaler-8B base model. Model / Round

𝜏 2 -Bench

BFCL-V4

MCP-Mark (Post.)

Agent-World-14B (base) 60.2 52.4 +1 round 63.5 (+3.3) 54.9 (+2.5) +2 rounds 65.4 (+1.9) 55.8 (+0.9)

29.5 36.3 (+6.8) 38.1 (+1.8)

EnvScaler-8B (base) +1 round +2 rounds

9.5 13.9 (+4.4) 15.1 (+1.2)

37.9 47.6 40.2 (+2.3) 49.1 (+1.5) 41.6 (+1.4) 50.0 (+0.9)

0.40

0.7

0.35

entropy

score

0.6 0.5 0.4 0.3

0.30 0.25 0.20 0.15

0.2

Qwen3-14b 0

Qwen3-8b

Qwen3-14b

0.10

100 150 200 250 300

Step

(a) training score

Qwen3-8b

100 150 200 250 300 Step

(b) training entropy

Figure 9 Training Dynamics of Agent-World. (a) Training reward score and (b) actor entropy over training steps for Qwen3-8B and Qwen3-14B backbones using GRPO on synthesized environments. Curves are exponentially smoothed for clarity.

modes from executable traces; finally, targeted synthesis and continual RL produce the next-round policy. Table 2 shows monotonic gains on all three evaluation suites for both models. For Agent-World-14B, performance on 𝜏 2 -Bench/BFCL-V4/MCP-Mark improves from 45.3%/52.4%/29.5% to 50.5%/55.8%/38.1% after two rounds. Importantly, EnvScaler-8B also improves from 37.9%/47.6%/9.5% to 41.6%/50.0%/15.1%, indicating that the loop not only benefits our base model but also yields sustained gains for other environmentscaling baselines without relying on Agent-World initialization. Notably, the largest gains across two rounds appear on MCP-Mark: +8.6% for Agent-World and +5.6% for EnvScaler. This benchmark requires stronger state tracking and deeper interaction with realistic MCP server environments. This matches our self-evolving objective in Sec. 3.2: diagnosis continually localizes environment-specific weaknesses from closed-loop traces, while targeted synthesis generates harder instances around those failures, which is particularly beneficial for challenging agentic execution scenarios. BFCL-V4 and 𝜏 2 -Bench also improve steadily, indicating concurrent gains in environment grounding and multi-turn tool coordination. Furthermore, second-round gains are smaller than first-round gains but remain positive, reflecting diminishing yet still effective returns. From the environment-diagnosis perspective, we find that early rounds mainly fix pattern-level errors in unfamiliar environment interactions, while later rounds focus on residual failures, especially in long-horizon complex interaction cases. Overall, Agent-World treats scalable environments as a persistent diagnostic arena and achieves continual policy improvement through agent-environment co-evolution, substantially outperforming one-pass static training.

4.4

Training Dynamics of Agent-World.

As shown in Figure 9, we present the multi-environment reinforcement learning curves of Agent-World-8B and Agent-World-14B. We observe clear upward reward trends for both Qwen3-8B/14B backbones. These results indicate that policy performance improves steadily under GRPO supervision; this trend is also consistent across different environment complexities, further supporting the general effectiveness of multi-turn RL with executable rewards. Meanwhile, tool-use training shows relatively stable entropy growth over time (Figure 9b). This suggests that as the model gradually adapts to unseen APIs and heterogeneous state transitions, it maintains or even expands its exploration space, learning new interaction patterns instead of collapsing prematurely into narrow exploitation. This behavior indicates that Agent-World sustains exploration of agent execution patterns in structurally diverse and highly interactive real-world MCP environments. 17

Related Work

5.1

Scalable Environment Synthesis for Agent Training

As agent training shifts from imitation learning to self-exploration and evolution within interactive environments, training environments have become essential infrastructure [3, 24, 38]. However, real-world services and systems often have restricted access, while manually constructed sandboxes suffer from high costs and poor scalability. To automatically scale environments for training LLM agents, one line of research focuses on LLM-driven simulation [27, 52, 55, 80]. By leveraging the intrinsic world modeling and reasoning capabilities of LLMs, these systems use LLMs to simulate environmental feedback and state transitions. Another line of research focuses on programmatic environment synthesis, constructing deterministic sandboxes via programs, database backends, or finite-state machines [9, 24, 88, 91, 97, 98, 100]. Frameworks including EnvScaler [88], AWM [100], and AutoForge [9] leverage LLMs to plan and generate sandboxes and tasks comprising executable programs, databases, or tool interfaces, and provide rule-based reward signals for reinforcement learning. In addition, InfiniteWeb [129] expands synthesis to web-based and multimodal contexts. Meanwhile, ARE [3] incorporates asynchronous temporal dynamics to better align simulated environments with reality. Distinct from these works, Agent-World utilizes real MCP server metadata for intelligent environment discovery and modeling. By autonomously building theme-matched databases and executable tools from the web, it achieves deep anchoring within the real-world tool ecosystem. Moreover, by leveraging tool graphs and programmatic synthesis to generate verifiable tasks with progressive difficulty, it establishes a broad and challenging training foundation for agents.

5.2

Agentic Reinforcement Learning

Recent agentic reinforcement learning has rapidly expanded from single-tool optimization to long-horizon web agents [125]. Early search-centric systems show that rule-based or verifiable RL can improve autonomous information-seeking behavior [13, 42, 87]. Follow-up work further strengthens tool-use training through improved reward design and policy optimization, including Tool-Star, ToolRL, OTC, and ARPO [20, 21, 76, 99]. In parallel, scalability-oriented research explores asynchronous pipelines and large-scale post-training for long-horizon agents [30, 45], while tree-structured rollouts improve exploration efficiency under high-entropy action spaces [28, 53]. Beyond single-agent settings, recent studies increasingly adopt multi-agent and interactive training paradigms, such as agentic RL with multi-agent distillation and multi-turn, user-interacting RL [14, 46, 120, 130], and this line of work is now extending into multimodal settings [77–79, 128, 131]. Despite this progress, most existing methods still emphasize policy optimization on relatively fixed training distributions. Recent environment-scaling efforts expose agents to broader and more diverse environments [67, 88, 98, 100], yet explicit coupling of diagnosis, targeted environment–task refresh, and continual RL remains limited. Agent-World is designed to fill this gap through a continuous agent RL loop.

Conclusion

In this paper, we presented Agent-World, a self-evolving training arena for general-purpose agents in realistic tool environments. Agent-World unifies two tightly coupled components: Agentic Environment-Task Discovery, which mines topic-aligned real-world databases and executable toolsets from large-scale themes and synthesizes verifiable tasks with controllable difficulty; and Continuous Self-Evolving Agent Training, which combines multi-environment reinforcement learning with an agentic diagnostic arena to identify capability gaps and drive targeted iterative data expansion. Experiments across 23 challenging benchmarks demonstrate that Agent-World consistently improves performance over strong baselines. Further analyses reveal clear scaling trends with respect to environment diversity, evolution rounds, and task difficulty, suggesting that scalable realistic environments are not only useful data sources, but also critical infrastructure for advancing general agent capabilities.

Contributions Authors Guanting Dong1,∗ , Junting Lu2 , Junjie Huang2,∗ , Wanjun Zhong2,† , Longxiang Liu2 , Shijue Huang2,∗ ,

Zhenyu Li2 , Yang Zhao2,∗ , Xiaoshuai Song1 , Xiaoxi Li1 , Jiajie Jin1 , Yutao Zhu1 , Hanbin Wang2,∗ , Fangyu Lei2,∗ , Qinyu Luo2 , Mingyang Chen2 , Zehui Chen2 , Jiazhan Feng2 , Ji-Rong Wen1 , Zhicheng Dou1,† Affiliations 1 Gaoling School of Artificial Intelligence, Renmin University of China, 2 ByteDance Seed

Acknowledgment We greatly thank Yujia Qin2 and Guang Shi2 for supporting this work and providing

valuable suggestions. We also thank Yifei Chen1 for valuable discussions. ∗ Work was done during their internship at ByteDance Seed † Corresponding Author

References [1] AIME2024. Aime2024, 2024. URL https://huggingface.co/datasets/HuggingFaceH4/aime_2024. [2] AIME2025. Aime2025, 2025. URL https://huggingface.co/datasets/opencompass/AIME2025. [3] Pierre Andrews, Amine Benhalloum, Gerard Moreno-Torres Bertran, Matteo Bettini, Amar Budhiraja, Ricardo Silveira Cabral, Virginie Do, Romain Froger, Emilien Garreau, Jean-Baptiste Gaya, et al. Are: Scaling up agent environments and evaluations. arXiv preprint arXiv:2509.17158, 2025. [4] Anthropic. Introducing claude sonnet 4.5. https://www.anthropic.com/news/claude-sonnet-4-5, 2025. [5] Hao Bai, Alexey Taymanov, Tong Zhang, Aviral Kumar, and Spencer Whitehead. Webgym: Scaling training environments for visual web agents with realistic tasks, 2026. URL https://arxiv.org/abs/2601.02439. [6] Chaithanya Bandi, Ben Hertzberg, Geobio Boo, Tejas Polakam, Jeff Da, Sami Hassaan, Manasi Sharma, Andrew Park, Ernesto Hernandez, Dan Rambado, Ivan Salazar, Rafael Cruz, Chetan Rane, Ben Levin, Brad Kenstler, and Bing Liu. Mcp-atlas: A large-scale benchmark for tool-use competency with real mcp servers, 2026. URL https://arxiv.org/abs/2602.00933. [7] Victor Barres, Honghua Dong, Soham Ray, Xujie Si, and Karthik Narasimhan. 𝜏 2 -bench: Evaluating conversational agents in a dual-control environment, 2025. URL https://arxiv.org/abs/2506.07982. [8] ByteDance Seed. Seed2.0 model card: Towards intelligence frontier for real-world complexity. Technical report, ByteDance, 2025. URL https://seed.bytedance.com/en/seed2. Model card PDF: https://lf3static.bytednsdoc.com/obj/eden-cn/lapzild-tss/ljhwZthlaukjlkulzlp/seed2/0214/Seed2.0 [9] Shihao Cai, Runnan Fang, Jialong Wu, Baixuan Li, Xinyu Wang, Yong Jiang, Liangcai Su, Liwen Zhang, Wenbiao Yin, Zhen Zhang, Fuli Feng, Pengjun Xie, and Xiaobin Wang. Autoforge: Automated environment synthesis for agentic reinforcement learning, 2025. URL https://arxiv.org/abs/2512.22857. [10] Anthony R Cassandra. A survey of pomdp applications. In Working notes of AAAI 1998 fall symposium on planning with partially observable Markov decision processes, volume 1724, 1998. [11] Aili Chen, Chi Zhang, Junteng Liu, Jiangjie Chen, Chengyu Du, Yunji Li, Ming Zhong, Qin Wang, Zhengmao Zhu, Jiayuan Song, Ke Ji, Junxian He, Pengyu Zhao, and Yanghua Xiao. Dive: Scaling diversity in agentic task synthesis for generalizable tool use, 2026. URL https://arxiv.org/abs/2603.11076. [12] Chen Chen, Xinlong Hao, Weiwen Liu, Xu Huang, Xingshan Zeng, Shuai Yu, Dexun Li, Yuefeng Huang, Xiangcheng Liu, Wang Xinzhi, and Wu Liu. ACEBench: A comprehensive evaluation of LLM tool usage. In Christos Christodoulopoulos, Tanmoy Chakraborty, Carolyn Rose, and Violet Peng, editors, Findings of the Association for Computational Linguistics: EMNLP 2025, pages 12970–12998, Suzhou, China, November 2025. Association for Computational Linguistics. ISBN 979-8-89176-335-7. doi: 10.18653/v1/2025.findings-emnlp.697. URL https://aclanthology.org/2025.findings-emnlp.697/. [13] Mingyang Chen, Tianpeng Li, Haoze Sun, Yijie Zhou, Chenzheng Zhu, Haofen Wang, Jeff Z. Pan, Wen Zhang, Huajun Chen, Fan Yang, Zenan Zhou, and Weipeng Chen. Research: Learning to reason with search for llms via reinforcement learning, 2025. URL https://arxiv.org/abs/2503.19470. [14] Yiqun Chen, Lingyong Yan, Weiwei Sun, Xinyu Ma, Yi Zhang, Shuaiqiang Wang, Dawei Yin, Yiming Yang, and Jiaxin Mao. Improving retrieval-augmented generation through multi-agent reinforcement learning. arXiv preprint arXiv:2501.15228, 2025. [15] Francois Chollet, Mike Knoop, Gregory Kamradt, Bryan Landers, and Henry Pinkard. Arc-agi-2: A new challenge for frontier ai reasoning systems, 2026. URL https://arxiv.org/abs/2505.11831. [16] claw-eval. Claw-eval: End-to-end transparent benchmark for ai agents in the real world. https://github.com/ claw-eval/claw-eval, 2026. GitHub repository. [17] Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Mark Chen, Heewoo Jun, Lukasz Kaiser, Matthias Plappert, Jerry Tworek, Jacob Hilton, Reiichiro Nakano, Christopher Hesse, and John Schulman. Training verifiers to solve math word problems, 2021. URL https://arxiv.org/abs/2110.14168. [18] DeepSeek-AI. Deepseek-r1: Incentivizing reasoning capability in llms via reinforcement learning. CoRR, abs/2501.12948, 2025.

[19] Guanting Dong, Keming Lu, Chengpeng Li, Tingyu Xia, Bowen Yu, Chang Zhou, and Jingren Zhou. Selfplay with execution feedback: Improving instruction-following capabilities of large language models. CoRR, abs/2406.13542, 2024. doi: 10.48550/ARXIV.2406.13542. URL https://doi.org/10.48550/arXiv.2406.13542. [20] Guanting Dong, Yifei Chen, Xiaoxi Li, Jiajie Jin, Hongjin Qian, Yutao Zhu, Hangyu Mao, Guorui Zhou, Zhicheng Dou, and Ji-Rong Wen. Tool-star: Empowering llm-brained multi-tool reasoner via reinforcement learning. CoRR, abs/2505.16410, 2025. doi: 10.48550/ARXIV.2505.16410. URL https://doi.org/10.48550/arXiv.2505.16410. [21] Guanting Dong, Hangyu Mao, Kai Ma, Licheng Bao, Yifei Chen, Zhongyuan Wang, Zhongxia Chen, Jiazhen Du, Huiyang Wang, Fuzheng Zhang, Guorui Zhou, Yutao Zhu, Ji-Rong Wen, and Zhicheng Dou. Agentic reinforced policy optimization. CoRR, abs/2507.19849, 2025. doi: 10.48550/ARXIV.2507.19849. URL https: //doi.org/10.48550/arXiv.2507.19849. [22] Guanting Dong, Licheng Bao, Zhongyuan Wang, Kangzhi Zhao, Xiaoxi Li, Jiajie Jin, Jinghan Yang, Hangyu Mao, Fuzheng Zhang, Kun Gai, Guorui Zhou, Yutao Zhu, Ji-Rong Wen, and Zhicheng Dou. Toward generalized web agent training: A deep dive into entropy-balanced reinforcement learning. In Proceedings of the ACM Web Conference 2026, WWW ’26, page 2126–2137, New York, NY, USA, 2026. Association for Computing Machinery. ISBN 9798400723070. doi: 10.1145/3774904.3792301. URL https://doi.org/10.1145/3774904.3792301. [23] Rohan Doshi. Gemini 3 pro: the frontier of vision ai. https://blog.google/innovation-and-ai/technology/ developers-tools/gemini-3-pro-vision/, 2025. [24] Runnan Fang, Shihao Cai, Baixuan Li, Jialong Wu, Guangyu Li, Wenbiao Yin, Xinyu Wang, Xiaobin Wang, Liangcai Su, Zhen Zhang, et al. Towards general agentic intelligence via environment scaling. arXiv preprint arXiv:2509.13311, 2025. [25] Runnan Fang, Shihao Cai, Baixuan Li, Jialong Wu, Guangyu Li, Wenbiao Yin, Xinyu Wang, Xiaobin Wang, Liangcai Su, Zhen Zhang, et al. Towards general agentic intelligence via environment scaling. arXiv preprint arXiv:2509.13311, 2025. [26] Jiazhan Feng, Shijue Huang, Xingwei Qu, Ge Zhang, Yujia Qin, Baoquan Zhong, Chengquan Jiang, Jinxin Chi, and Wanjun Zhong. Retool: Reinforcement learning for strategic tool use in llms, 2025. URL https: //arxiv.org/abs/2504.11536. [27] Jichen Feng, Yifan Zhang, Chenggong Zhang, Yifu Lu, Shilong Liu, and Mengdi Wang. Web world models, 2025. URL https://arxiv.org/abs/2512.23676. [28] Lang Feng, Zhenghai Xue, Tingcong Liu, and Bo An. Group-in-group policy optimization for llm agent training. arXiv preprint arXiv:2505.10978, 2025. [29] Xueyang Feng, Zhi-Yuan Chen, Yujia Qin, Yankai Lin, Xu Chen, Zhiyuan Liu, and Ji-Rong Wen. Large language model-based human-agent collaboration for complex task solving. In Findings of the Association for Computational Linguistics: EMNLP 2024, pages 1336–1357, 2024. [30] Jiaxuan Gao, Wei Fu, Minyang Xie, Shusheng Xu, Chuyi He, Zhiyu Mei, Banghua Zhu, and Yi Wu. Beyond ten turns: Unlocking long-horizon agentic search with large-scale asynchronous rl, 2025. URL https://arxiv.org/ abs/2508.07976. [31] Jiacheng Guo, Ling Yang, Peter Chen, Qixin Xiao, Yinjie Wang, Xinzhe Juan, Jiahao Qiu, Ke Shen, and Mengdi Wang. Genenv: Difficulty-aligned co-evolution between llm agents and environment simulators. arXiv preprint arXiv:2512.19682, 2025. [32] Jiacheng Guo, Ling Yang, Peter Chen, Qixin Xiao, Yinjie Wang, Xinzhe Juan, Jiahao Qiu, Ke Shen, and Mengdi Wang. Genenv: Difficulty-aligned co-evolution between llm agents and environment simulators, 2025. URL https://arxiv.org/abs/2512.19682. [33] Chaoqun He, Renjie Luo, Yuzhuo Bai, Shengding Hu, Zhen Leng Thai, Junhao Shen, Jinyi Hu, Xu Han, Yujie Huang, Yuxiang Zhang, Jie Liu, Lei Qi, Zhiyuan Liu, and Maosong Sun. Olympiadbench: A challenging benchmark for promoting agi with olympiad-level bilingual multimodal scientific problems, 2024. URL https: //arxiv.org/abs/2402.14008. [34] Chaoyue He, Xin Zhou, Di Wang, Hong Xu, Wei Liu, and Chunyan Miao. Openclaw as language infrastructure: A case-centered survey of a public agent ecosystem in the wild. 2026. [35] Dan Hendrycks, Collin Burns, Steven Basart, Andy Zou, Mantas Mazeika, Dawn Song, and Jacob Steinhardt. Measuring massive multitask language understanding, 2021. URL https://arxiv.org/abs/2009.03300.

[36] Dan Hendrycks, Collin Burns, Saurav Kadavath, Akul Arora, Steven Basart, Eric Tang, Dawn Song, and Jacob Steinhardt. Measuring mathematical problem solving with the math dataset, 2021. URL https://arxiv.org/ abs/2103.03874. [37] Xinyi Hou, Yanjie Zhao, Shenao Wang, and Haoyu Wang. Model context protocol (mcp): Landscape, security threats, and future research directions. ACM Transactions on Software Engineering and Methodology, 2025. [38] Yuchen Huang, Sijia Li, Wei Liu, Zhiyuan Fan, Yi R Fung, et al. Scaling environments for llm agents in the era of learning from interaction: A survey. In Workshop on Scaling Environments for Agents, 2025. [39] Zenan Huang, Yihong Zhuang, Guoshan Lu, Zeyu Qin, Haokai Xu, Tianyu Zhao, Ru Peng, Jiaqi Hu, Zhanming Shen, Xiaomeng Hu, Xijun Gu, Peiyi Tu, Jiaxin Liu, Wenyu Chen, Yuzhuo Fu, Zhiting Fan, Yanmei Gu, Yuanyuan Wang, Zhengkai Yang, Jianguo Li, and Junbo Zhao. Reinforcement learning with rubric anchors. CoRR, abs/2508.12790, 2025. doi: 10.48550/ARXIV.2508.12790. URL https://doi.org/10.48550/arXiv.2508.12790. [40] Guanyu Jiang, Zhaochen Su, Xiaoye Qu, and Yi R. Fung. Xskill: Continual learning from experience and skills in multimodal agents, 2026. URL https://arxiv.org/abs/2603.12056. [41] Carlos E. Jimenez, John Yang, Alexander Wettig, Shunyu Yao, Kexin Pei, Ofir Press, and Karthik Narasimhan. Swe-bench: Can language models resolve real-world github issues?, 2024. URL https://arxiv.org/abs/2310. 06770. [42] Bowen Jin, Hansi Zeng, Zhenrui Yue, Dong Wang, Hamed Zamani, and Jiawei Han. Search-r1: Training llms to reason and leverage search engines with reinforcement learning. CoRR, abs/2503.09516, 2025. [43] Jiajie Jin, Xiaoxi Li, Guanting Dong, Yuyao Zhang, Yutao Zhu, Yang Zhao, Hongjin Qian, and Zhicheng Dou. Decoupled planning and execution: A hierarchical reasoning framework for deep search, 2025. URL https://arxiv.org/abs/2507.02652. [44] Junlong Li, Wenshuo Zhao, Jian Zhao, Weihao Zeng, Haoze Wu, Xiaochen Wang, Rui Ge, Yuxuan Cao, Yuzhen Huang, Wei Liu, Junteng Liu, Zhaochen Su, Yiyang Guo, Fan Zhou, Lueyang Zhang, Juan Michelini, Xingyao Wang, Xiang Yue, Shuyan Zhou, Graham Neubig, and Junxian He. The tool decathlon: Benchmarking language agents for diverse, realistic, and long-horizon task execution. 2025. URL https://arxiv.org/abs/2510.25726. [45] Kuan Li, Zhongwang Zhang, Huifeng Yin, Liwen Zhang, Litu Ou, Jialong Wu, Wenbiao Yin, Baixuan Li, Zhengwei Tao, Xinyu Wang, Weizhou Shen, Junkai Zhang, Dingchu Zhang, Xixi Wu, Yong Jiang, Ming Yan, Pengjun Xie, Fei Huang, and Jingren Zhou. Websailor: Navigating super-human reasoning for web agent. CoRR, abs/2507.02592, 2025. doi: 10.48550/ARXIV.2507.02592. URL https://doi.org/10.48550/arXiv.2507.02592. [46] Weizhen Li, Jianbo Lin, Zhuosong Jiang, Jingyi Cao, Xinpeng Liu, Jiayu Zhang, Zhenqiang Huang, Qianben Chen, Weichen Sun, Qiexiang Wang, Hongxuan Lu, Tianrui Qin, Chenghao Zhu, Yi Yao, Shuying Fan, Xiaowan Li, Tiannan Wang, Pai Liu, King Zhu, He Zhu, Dingfeng Shi, Piaohong Wang, Yeyi Guan, Xiangru Tang, Minghao Liu, Yuchen Eleanor Jiang, Jian Yang, Jiaheng Liu, Ge Zhang, and Wangchunshu Zhou. Chain-of-agents: End-to-end agent foundation models via multi-agent distillation and agentic RL. CoRR, abs/2508.13167, 2025. doi: 10.48550/ARXIV.2508.13167. URL https://doi.org/10.48550/arXiv.2508.13167. [47] Xiangyi Li, Wenbo Chen, Yimin Liu, Shenghan Zheng, Xiaokun Chen, Yifeng He, Yubo Li, Bingran You, Haotian Shen, Jiankai Sun, Shuyi Wang, Binxu Li, Qunhong Zeng, Di Wang, Xuandong Zhao, Yuanli Wang, Roey Ben Chaim, Zonglin Di, Yipeng Gao, Junwei He, Yizhuo He, Liqiang Jing, Luyang Kong, Xin Lan, Jiachen Li, Songlin Li, Yijiang Li, Yueqian Lin, Xinyi Liu, Xuanqing Liu, Haoran Lyu, Ze Ma, Bowei Wang, Runhui Wang, Tianyu Wang, Wengao Ye, Yue Zhang, Hanwen Xing, Yiqi Xue, Steven Dillmann, and Han chung Lee. Skillsbench: Benchmarking how well agent skills work across diverse tasks, 2026. URL https://arxiv.org/abs/2602.12670. [48] Xiaoxi Li, Wenxiang Jiao, Jiarui Jin, Guanting Dong, Jiajie Jin, Yinuo Wang, Hao Wang, Yutao Zhu, Ji-Rong Wen, Yuan Lu, and Zhicheng Dou. Deepagent: A general reasoning agent with scalable toolsets, 2025. URL https://arxiv.org/abs/2510.21618. [49] Xiaoxi Li, Jiajie Jin, Guanting Dong, Hongjin Qian, Yutao Zhu, Yongkang Wu, Ji-Rong Wen, and Zhicheng Dou. Webthinker: Empowering large reasoning models with deep research capability. arXiv preprint arXiv:2504.21776, 2025. [50] Xiaoxi Li, Wenxiang Jiao, Jiarui Jin, Shijian Wang, Guanting Dong, Jiajie Jin, Hao Wang, Yinuo Wang, Ji-Rong Wen, Yuan Lu, and Zhicheng Dou. Omnigaia: Towards native omni-modal ai agents, 2026. URL https://arxiv.org/abs/2602.22897.

[51] Xuefeng Li, Haoyang Zou, and Pengfei Liu. Torl: Scaling tool-integrated RL. CoRR, abs/2503.23383, 2025. doi: 10.48550/ARXIV.2503.23383. URL https://doi.org/10.48550/arXiv.2503.23383. [52] Yixia Li, Hongru Wang, Jiahao Qiu, Zhenfei Yin, Dongdong Zhang, Cheng Qian, Zeping Li, Pony Ma, Guanhua Chen, Heng Ji, and Mengdi Wang. From word to world: Can large language models be implicit text-based world models?, 2025. URL https://arxiv.org/abs/2512.18832. [53] Yizhi Li, Qingshui Gu, Zhoufutu Wen, Ziniu Li, Tianshun Xing, Shuyue Guo, Tianyu Zheng, Xin Zhou, Xingwei Qu, Wangchunshu Zhou, et al. Treepo: Bridging the gap of policy optimization and efficacy and inference efficiency with heuristic tree-based modeling. arXiv preprint arXiv:2508.17445, 2025. [54] Yuetai Li, Huseyin A Inan, Xiang Yue, Wei-Ning Chen, Lukas Wutschitz, Janardhan Kulkarni, Radha Poovendran, Robert Sim, and Saravan Rajmohan. Simulating environments with reasoning models for agent training. arXiv preprint arXiv:2511.01824, 2025. [55] Yuetai Li, Huseyin A Inan, Xiang Yue, Wei-Ning Chen, Lukas Wutschitz, Janardhan Kulkarni, Radha Poovendran, Robert Sim, and Saravan Rajmohan. Simulating environments with reasoning models for agent training, 2025. URL https://arxiv.org/abs/2511.01824. [56] Yuan Liang, Ruobin Zhong, Haoming Xu, Chen Jiang, Yi Zhong, Runnan Fang, Jia-Chen Gu, Shumin Deng, Yunzhi Yao, Mengru Wang, Shuofei Qiao, Xin Xu, Tongtong Wu, Kun Wang, Yang Liu, Zhen Bi, Jungang Lou, Yuchen Eleanor Jiang, Hangcheng Zhu, Gang Yu, Haiwen Hong, Longtao Huang, Hui Xue, Chenxi Wang, Yijun Wang, Zifei Shan, Xi Chen, Zhaopeng Tu, Feiyu Xiong, Xin Xie, Peng Zhang, Zhengke Gui, Lei Liang, Jun Zhou, Chiyu Wu, Jin Shang, Yu Gong, Junyu Lin, Changliang Xu, Hongjie Deng, Wen Zhang, Keyan Ding, Qiang Zhang, Fei Huang, Ningyu Zhang, Jeff Z. Pan, Guilin Qi, Haofen Wang, and Huajun Chen. Skillnet: Create, evaluate, and connect ai skills, 2026. URL https://arxiv.org/abs/2603.04448. [57] Hunter Lightman, Vineet Kosaraju, Yura Burda, Harri Edwards, Bowen Baker, Teddy Lee, Jan Leike, John Schulman, Ilya Sutskever, and Karl Cobbe. Let’s verify step by step, 2023. URL https://arxiv.org/abs/2305. 20050. [58] Aixin Liu, Aoxue Mei, Bangcai Lin, Bing Xue, Bingxuan Wang, Bingzheng Xu, Bochao Wu, Bowei Zhang, Chaofan Lin, Chen Dong, et al. Deepseek-v3. 2: Pushing the frontier of open large language models. arXiv preprint arXiv:2512.02556, 2025. [59] Ryan Lopopolo. Harness engineering: leveraging codex in an agent-first world. https://openai.com/index/ harness-engineering/, feb 2026. OpenAI Engineering Blog. Accessed: 2026-04-06. [60] Xinghua Lou, Miguel Lázaro-Gredilla, Antoine Dedieu, Carter Wendelken, Wolfgang Lehrach, and Kevin P. Murphy. Autoharness: improving llm agents by automatically synthesizing a code harness, 2026. URL https://arxiv.org/abs/2603.03329. [61] Jiarui Lu, Thomas Holleis, Yizhe Zhang, Bernhard Aumayer, Feng Nan, Haoping Bai, Shuang Ma, Shen Ma, Mengyu Li, Guoli Yin, Zirui Wang, and Ruoming Pang. ToolSandbox: A stateful, conversational, interactive evaluation benchmark for LLM tool use capabilities. In Luis Chiruzzo, Alan Ritter, and Lu Wang, editors, Findings of the Association for Computational Linguistics: NAACL 2025, pages 1160–1183, Albuquerque, New Mexico, April 2025. Association for Computational Linguistics. ISBN 979-8-89176-195-7. doi: 10.18653/v1/2025. findings-naacl.65. URL https://aclanthology.org/2025.findings-naacl.65/. [62] Ziyang Luo, Zhiqi Shen, Wenzhuo Yang, Zirui Zhao, Prathyusha Jwalapuram, Amrita Saha, Doyen Sahoo, Silvio Savarese, Caiming Xiong, and Junnan Li. Mcp-universe: Benchmarking large language models with real-world model context protocol servers. arXiv preprint arXiv:2508.14704, 2025. [63] Kaijing Ma, Xinrun Du, Yunran Wang, Haoran Zhang, Zhoufutu Wen, Xingwei Qu, Jian Yang, Jiaheng Liu, Minghao Liu, Xiang Yue, Wenhao Huang, and Ge Zhang. Kor-bench: Benchmarking language models on knowledge-orthogonal reasoning tasks, 2025. URL https://arxiv.org/abs/2410.06526. [64] Mike A. Merrill, Alexander G. Shaw, Nicholas Carlini, Boxuan Li, Harsh Raj, Ivan Bercovich, Lin Shi, Jeong Yeon Shin, Thomas Walshe, E. Kelly Buchanan, Junhong Shen, Guanghao Ye, Haowei Lin, Jason Poulos, Maoyu Wang, Marianna Nezhurina, Jenia Jitsev, Di Lu, Orfeas Menis Mastromichalakis, Zhiwei Xu, Zizhao Chen, Yue Liu, Robert Zhang, Leon Liangyu Chen, Anurag Kashyap, Jan-Lucas Uslu, Jeffrey Li, Jianbo Wu, Minghao Yan, Song Bian, Vedang Sharma, Ke Sun, Steven Dillmann, Akshay Anand, Andrew Lanpouthakoun, Bardia Koopah, Changran Hu, Etash Guha, Gabriel H. S. Dreiman, Jiacheng Zhu, Karl Krauth, Li Zhong, Niklas Muennighoff, Robert Amanfu, Shangyin Tan, Shreyas Pimpalgaonkar, Tushar Aggarwal, Xiangning Lin, Xin

Lan, Xuandong Zhao, Yiqing Liang, Yuanli Wang, Zilong Wang, Changzhi Zhou, David Heineman, Hange Liu, Harsh Trivedi, John Yang, Junhong Lin, Manish Shetty, Michael Yang, Nabil Omi, Negin Raoof, Shanda Li, Terry Yue Zhuo, Wuwei Lin, Yiwei Dai, Yuxin Wang, Wenhao Chai, Shang Zhou, Dariush Wahdany, Ziyu She, Jiaming Hu, Zhikang Dong, Yuxuan Zhu, Sasha Cui, Ahson Saiyed, Arinbjörn Kolbeinsson, Jesse Hu, Christopher Michael Rytting, Ryan Marten, Yixin Wang, Alex Dimakis, Andy Konwinski, and Ludwig Schmidt. Terminal-bench: Benchmarking agents on hard, realistic tasks in command line interfaces, 2026. URL https://arxiv.org/abs/2601.11868. [65] Grégoire Mialon, Clémentine Fourrier, Thomas Wolf, Yann LeCun, and Thomas Scialom. GAIA: a benchmark for general AI assistants. In The Twelfth International Conference on Learning Representations, ICLR 2024, Vienna, Austria, May 7-11, 2024. OpenReview.net, 2024. URL https://openreview.net/forum?id=fibxvahvs3. [66] Model Context Protocol. Model context protocol specification. specification/latest, 2025. Accessed: 2026-04-06.

https://modelcontextprotocol.io/

[67] Yutao Mou, Zhangchi Xue, Lijun Li, Peiyang Liu, Shikun Zhang, Wei Ye, and Jing Shao. Toolsafe: Enhancing tool invocation safety of llm-based agents via proactive step-level guardrail and feedback. arXiv preprint arXiv:2601.10156, 2026. Learning to reason with llms, [68] OpenAI. learning-to-reason-with-llms.

September 2024.

URL https://openai.com/index/

[69] OpenAI. Introducing gpt-5.2. https://openai.com/zh-Hans-CN/index/introducing-gpt-5-2/, 2025. [70] OpenAI, :, Sandhini Agarwal, Lama Ahmad, Jason Ai, Sam Altman, Andy Applebaum, Edwin Arbus, Rahul K. Arora, Yu Bai, Bowen Baker, Haiming Bao, Boaz Barak, Ally Bennett, Tyler Bertao, Nivedita Brett, Eugene Brevdo, Greg Brockman, Sebastien Bubeck, Che Chang, Kai Chen, Mark Chen, Enoch Cheung, Aidan Clark, Dan Cook, Marat Dukhan, Casey Dvorak, Kevin Fives, Vlad Fomenko, Timur Garipov, Kristian Georgiev, Mia Glaese, Tarun Gogineni, Adam Goucher, Lukas Gross, Katia Gil Guzman, John Hallman, Jackie Hehir, Johannes Heidecke, Alec Helyar, Haitang Hu, Romain Huet, Jacob Huh, Saachi Jain, Zach Johnson, Chris Koch, Irina Kofman, Dominik Kundel, Jason Kwon, Volodymyr Kyrylov, Elaine Ya Le, Guillaume Leclerc, James Park Lennon, Scott Lessans, Mario Lezcano-Casado, Yuanzhi Li, Zhuohan Li, Ji Lin, Jordan Liss, Lily, Liu, Jiancheng Liu, Kevin Lu, Chris Lu, Zoran Martinovic, Lindsay McCallum, Josh McGrath, Scott McKinney, Aidan McLaughlin, Song Mei, Steve Mostovoy, Tong Mu, Gideon Myles, Alexander Neitz, Alex Nichol, Jakub Pachocki, Alex Paino, Dana Palmie, Ashley Pantuliano, Giambattista Parascandolo, Jongsoo Park, Leher Pathak, Carolina Paz, Ludovic Peran, Dmitry Pimenov, Michelle Pokrass, Elizabeth Proehl, Huida Qiu, Gaby Raila, Filippo Raso, Hongyu Ren, Kimmy Richardson, David Robinson, Bob Rotsted, Hadi Salman, Suvansh Sanjeev, Max Schwarzer, D. Sculley, Harshit Sikchi, Kendal Simon, Karan Singhal, Yang Song, Dane Stuckey, Zhiqing Sun, Philippe Tillet, Sam Toizer, Foivos Tsimpourlas, Nikhil Vyas, Eric Wallace, Xin Wang, Miles Wang, Olivia Watkins, Kevin Weil, Amy Wendling, Kevin Whinnery, Cedric Whitney, Hannah Wong, Lin Yang, Yu Yang, Michihiro Yasunaga, Kristen Ying, Wojciech Zaremba, Wenting Zhan, Cyril Zhang, Brian Zhang, Eddie Zhang, and Shengjia Zhao. gpt-oss-120b & gpt-oss-20b model card, 2025. URL https://arxiv.org/abs/2508.10925. [71] Linyue Pan, Lexiao Zou, Shuo Guo, Jingchen Ni, and Hai-Tao Zheng. Natural-language agent harnesses, 2026. URL https://arxiv.org/abs/2603.25723. [72] Joon Sung Park, Joseph C. O’Brien, Carrie J. Cai, Meredith Ringel Morris, Percy Liang, and Michael S. Bernstein. Generative agents: Interactive simulacra of human behavior, 2023. URL https://arxiv.org/abs/2304.03442. [73] Shishir G Patil, Huanzhi Mao, Fanjia Yan, Charlie Cheng-Jie Ji, Vishnu Suresh, Ion Stoica, and Joseph E. Gonzalez. The berkeley function calling leaderboard (BFCL): From tool use to agentic evaluation of large language models. In Forty-second International Conference on Machine Learning, 2025. URL https://openreview.net/ forum?id=2GmDdhBdDk. [74] Long Phan, Alice Gatti, Ziwen Han, Nathaniel Li, Josephina Hu, Hugh Zhang, Chen Bo Calvin Zhang, Mohamed Shaaban, John Ling, Sean Shi, et al. Humanity’s last exam. arXiv preprint arXiv:2501.14249, 2025. [75] Akshara Prabhakar, Zuxin Liu, Ming Zhu, Jianguo Zhang, Tulika Awalgaonkar, Shiyu Wang, Zhiwei Liu, Haolin Chen, Thai Hoang, Juan Carlos Niebles, Shelby Heinecke, Weiran Yao, Huan Wang, Silvio Savarese, and Caiming Xiong. Apigen-mt: Agentic pipeline for multi-turn data generation via simulated agent-human interplay, 2025. URL https://arxiv.org/abs/2504.03601. [76] Cheng Qian, Emre Can Acikgoz, Qi He, Hongru Wang, Xiusi Chen, Dilek Hakkani-Tür, Gokhan Tur, and Heng Ji. Toolrl: Reward is all tool learning needs. arXiv preprint arXiv:2504.13958, 2025.

[77] Runqi Qiao, Qiuna Tan, Guanting Dong, MinhuiWu MinhuiWu, Jiapeng Wang, Yifan Zhang, Zhuoma GongQue, Chong Sun, Yida Xu, Yadong Xue, et al. V-oracle: Making progressive reasoning in deciphering oracle bones for you and me. In Proceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 20124–20150, 2025. [78] Runqi Qiao, Qiuna Tan, Guanting Dong, Minhui Wu, Chong Sun, Xiaoshuai Song, Jiapeng Wang, Zhuoma Gongque, Shanglin Lei, Yifan Zhang, Zhe Wei, Miaoxuan Zhang, Runfeng Qiao, Xiao Zong, Yida Xu, Peiqing Yang, Zhimin Bao, Muxi Diao, Chen Li, and Honggang Zhang. We-math: Does your large multimodal model achieve human-like mathematical reasoning? In Wanxiang Che, Joyce Nabende, Ekaterina Shutova, and Mohammad Taher Pilehvar, editors, Proceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), ACL 2025, Vienna, Austria, July 27 - August 1, 2025, pages 20023–20070. Association for Computational Linguistics, 2025. URL https://aclanthology.org/2025.acl-long.983/. [79] Runqi Qiao, Qiuna Tan, Peiqing Yang, Yanzi Wang, Xiaowan Wang, Enhui Wan, Sitong Zhou, Guanting Dong, Yuchen Zeng, Yida Xu, Jie Wang, Chong Sun, Chen Li, and Honggang Zhang. We-math 2.0: A versatile mathbook system for incentivizing visual mathematical reasoning. CoRR, abs/2508.10433, 2025. doi: 10.48550/ARXIV.2508.10433. URL https://doi.org/10.48550/arXiv.2508.10433. [80] Jiawei Ren, Yan Zhuang, Xiaokang Ye, Lingjun Mao, Xuhong He, Jianzhi Shen, Mrinaal Dogra, Yiming Liang, Ruixuan Zhang, Tianai Yue, Yiqing Yang, Eric Liu, Ryan Wu, Kevin Benavente, Rajiv Mandya Nagaraju, Muhammad Faayez, Xiyan Zhang, Dhruv Vivek Sharma, Xianrui Zhong, Ziqiao Ma, Tianmin Shu, Zhiting Hu, and Lianhui Qin. Simworld: An open-ended realistic simulator for autonomous agents in physical and social worlds, 2026. URL https://arxiv.org/abs/2512.01078. [81] Bytedance Seed. Seed2. 0 model card: Towards intelligence frontier for real-world complexity. Technical report, Technical report, Bytedance, 2025. URL https://lf3-static. bytednsdoc. com . . . , 2026. [82] Bytedance Seed. Seed1.8 model card: Towards generalized real-world agency, 2026. URL https://arxiv.org/ abs/2603.20633. [83] Rulin Shao, Akari Asai, Shannon Zejiang Shen, Hamish Ivison, Varsha Kishore, Jingming Zhuo, Xinran Zhao, Molly Park, Samuel G. Finlayson, David A. Sontag, Tyler Murray, Sewon Min, Pradeep Dasigi, Luca Soldaini, Faeze Brahman, Wen-tau Yih, Tongshuang Wu, Luke Zettlemoyer, Yoon Kim, Hannaneh Hajishirzi, and Pang Wei Koh. DR tulu: Reinforcement learning with evolving rubrics for deep research. CoRR, abs/2511.19399, 2025. doi: 10.48550/ARXIV.2511.19399. URL https://doi.org/10.48550/arXiv.2511.19399. [84] Zhihong Shao, Peiyi Wang, Qihao Zhu, Runxin Xu, Junxiao Song, Mingchuan Zhang, Y. K. Li, Y. Wu, and Daya Guo. Deepseekmath: Pushing the limits of mathematical reasoning in open language models. CoRR, abs/2402.03300, 2024. [85] Leheng Sheng, Wenchang Ma, Ruixin Hong, Xiang Wang, An Zhang, and Tat-Seng Chua. Reinforcing chain-ofthought reasoning with self-evolving rubrics. CoRR, abs/2602.10885, 2026. doi: 10.48550/ARXIV.2602.10885. URL https://doi.org/10.48550/arXiv.2602.10885. [86] Noah Shinn, Federico Cassano, Ashwin Gopinath, Karthik Narasimhan, and Shunyu Yao. Reflexion: Language agents with verbal reinforcement learning. Advances in neural information processing systems, 36:8634–8652, 2023. [87] Huatong Song, Jinhao Jiang, Yingqian Min, Jie Chen, Zhipeng Chen, Wayne Xin Zhao, Lei Fang, and Ji-Rong Wen. R1-searcher: Incentivizing the search capability in llms via reinforcement learning. CoRR, abs/2503.05592, 2025. doi: 10.48550/ARXIV.2503.05592. URL https://doi.org/10.48550/arXiv.2503.05592. [88] Xiaoshuai Song, Haofei Chang, Guanting Dong, Yutao Zhu, Zhicheng Dou, and Ji-Rong Wen. Envscaler: Scaling tool-interactive environments for llm agent via programmatic synthesis. arXiv preprint arXiv:2601.05808, 2026. [89] Xiaoshuai Song, Haofei Chang, Guanting Dong, Yutao Zhu, Zhicheng Dou, and Ji-Rong Wen. Envscaler: Scaling tool-interactive environments for llm agent via programmatic synthesis, 2026. URL https://arxiv.org/abs/ 2601.05808. [90] Yueqi Song, Ketan Ramaneti, Zaid Sheikh, Ziru Chen, Boyu Gou, Tianbao Xie, Yiheng Xu, Danyang Zhang, Apurva Gandhi, Fan Yang, Joseph Liu, Tianyue Ou, Zhihao Yuan, Frank Xu, Shuyan Zhou, Xingyao Wang, Xiang Yue, Tao Yu, Huan Sun, Yu Su, and Graham Neubig. Agent data protocol: Unifying datasets for diverse, effective fine-tuning of llm agents, 2025. URL https://arxiv.org/abs/2510.24702.

[91] Michael Sullivan, Mareike Hartmann, and Alexander Koller. Procedural environment generation for tooluse agents. In Christos Christodoulopoulos, Tanmoy Chakraborty, Carolyn Rose, and Violet Peng, editors, Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing, pages 18544–18562, Suzhou, China, November 2025. Association for Computational Linguistics. ISBN 979-8-89176-332-6. doi: 10.18653/v1/2025.emnlp-main.936. URL https://aclanthology.org/2025.emnlp-main.936/. [92] Shuang Sun, Huatong Song, Lisheng Huang, Jinhao Jiang, Ran Le, Zhihao Lv, Zongchao Chen, Yiwen Hu, Wenyang Luo, Wayne Xin Zhao, Yang Song, Hongteng Xu, Tao Zhang, and Ji-Rong Wen. Swe-world: Building software engineering agents in docker-free environments, 2026. URL https://arxiv.org/abs/2602.03419. [93] Zexu Sun, Bokai Ji, Hengyi Cai, Shuaiqiang Wang, Lei Wang, Guangxia Li, and Xu Chen. Agentskiller: Scaling generalist agent intelligence through semantically integrated cross-domain data synthesis. arXiv preprint arXiv:2602.09372, 2026. [94] Zexu Sun, Bokai Ji, Hengyi Cai, Shuaiqiang Wang, Lei Wang, Guangxia Li, and Xu Chen. Agentskiller: Scaling generalist agent intelligence through semantically integrated cross-domain data synthesis, 2026. URL https://arxiv.org/abs/2602.09372. [95] Kimi Team, Angang Du, Bofei Gao, Bowei Xing, Changjiu Jiang, Cheng Chen, Cheng Li, Chenjun Xiao, Chenzhuang Du, Chonghua Liao, et al. Kimi k1. 5: Scaling reinforcement learning with llms. arXiv preprint arXiv:2501.12599, 2025. [96] M.-A-P. Team, Xinrun Du, Yifan Yao, Kaijing Ma, Bingli Wang, Tianyu Zheng, Kang Zhu, Minghao Liu, Yiming Liang, Xiaolong Jin, Zhenlin Wei, Chujie Zheng, Kaixin Deng, Shian Jia, Sichao Jiang, Yiyan Liao, Rui Li, Qinrui Li, Sirun Li, Yizhi Li, Yunwen Li, Dehua Ma, Yuansheng Ni, Haoran Que, Qiyao Wang, Zhoufutu Wen, Siwei Wu, Tianshun Xing, Ming Xu, Zhenzhu Yang, Zekun Moore Wang, Jun Zhou, Yuelin Bai, Xingyuan Bu, Chenglin Cai, Liang Chen, Yifan Chen, Chengtuo Cheng, Tianhao Cheng, Keyi Ding, Siming Huang, Yun Huang, Yaoru Li, Yizhe Li, Zhaoqun Li, Tianhao Liang, Chengdong Lin, Hongquan Lin, Yinghao Ma, Tianyang Pang, Zhongyuan Peng, Zifan Peng, Qige Qi, Shi Qiu, Xingwei Qu, Shanghaoran Quan, Yizhou Tan, Zili Wang, Chenqing Wang, Hao Wang, Yiya Wang, Yubo Wang, Jiajun Xu, Kexin Yang, Ruibin Yuan, Yuanhao Yue, Tianyang Zhan, Chun Zhang, Jinyang Zhang, Xiyue Zhang, Xingjian Zhang, Yue Zhang, Yongchi Zhao, Xiangyu Zheng, Chenghua Zhong, Yang Gao, Zhoujun Li, Dayiheng Liu, Qian Liu, Tianyu Liu, Shiwen Ni, Junran Peng, Yujia Qin, Wenbo Su, Guoyin Wang, Shi Wang, Jian Yang, Min Yang, Meng Cao, Xiang Yue, Zhaoxiang Zhang, Wangchunshu Zhou, Jiaheng Liu, Qunshu Lin, Wenhao Huang, and Ge Zhang. Supergpqa: Scaling LLM evaluation across 285 graduate disciplines. CoRR, abs/2502.14739, 2025. doi: 10.48550/ARXIV.2502.14739. URL https://doi.org/10.48550/arXiv.2502.14739. [97] Xiaoyu Tian, Haotian Wang, Shuaiting Chen, Hao Zhou, Kaichi Yu, Yudian Zhang, Jade Ouyang, Junxi Yin, Jiong Chen, Baoyan Guo, Lei Zhang, Junjie Tao, Yuansheng Song, Ming Cui, and Chengwei Liu. Astra: Automated synthesis of agentic trajectories and reinforcement arenas, 2026. URL https://arxiv.org/abs/2601.21558. [98] Dunwei Tu, Hongyan Hao, Hansi Yang, Yihao Chen, Yi-Kai Zhang, Zhikang Xia, Yu Yang, Yueqing Sun, Xingchen Liu, Furao Shen, Qi Gu, Hui Su, and Xunliang Cai. Scaleenv: Scaling environment synthesis from scratch for generalist interactive tool-use agent training, 2026. URL https://arxiv.org/abs/2602.06820. [99] Hongru Wang, Cheng Qian, Wanjun Zhong, Xiusi Chen, Jiahao Qiu, Shijue Huang, Bowen Jin, Mengdi Wang, Kam-Fai Wong, and Heng Ji. Otc: Optimal tool calls via reinforcement learning. arXiv preprint arXiv:2504.14870, 2025. [100] Zhaoyang Wang, Canwen Xu, Boyi Liu, Yite Wang, Siwei Han, Zhewei Yao, Huaxiu Yao, and Yuxiong He. Agent world model: Infinity synthetic environments for agentic reinforcement learning, 2026. URL https://arxiv.org/abs/2602.10090. [101] Joe H Ward Jr. Hierarchical grouping to optimize an objective function. Journal of the American statistical association, 58(301):236–244, 1963. [102] Yule Wen, Yixin Ye, Yanzhe Zhang, Diyi Yang, and Hao Zhu. Real-time reasoning agents in evolving environments, 2025. URL https://arxiv.org/abs/2511.04898. [103] Jialong Wu, Baixuan Li, Runnan Fang, Wenbiao Yin, Liwen Zhang, Zhengwei Tao, Dingchu Zhang, Zekun Xi, Yong Jiang, Pengjun Xie, Fei Huang, and Jingren Zhou. Webdancer: Towards autonomous information seeking agency. CoRR, abs/2505.22648, 2025. doi: 10.48550/ARXIV.2505.22648. URL https://doi.org/10. 48550/arXiv.2505.22648.

[104] Jialong Wu, Wenbiao Yin, Yong Jiang, Zhenglin Wang, Zekun Xi, Runnan Fang, Linhai Zhang, Yulan He, Deyu Zhou, Pengjun Xie, and Fei Huang. Webwalker: Benchmarking llms in web traversal. CoRR, abs/2501.07572, 2025. doi: 10.48550/ARXIV.2501.07572. URL https://doi.org/10.48550/arXiv.2501.07572. [105] Yifan Wu, Yiran Peng, Yiyu Chen, Jianhao Ruan, Zijie Zhuang, Cheng Yang, Jiayi Zhang, Man Chen, Yenchi Tseng, Zhaoyang Yu, Liang Chen, Yuyao Zhai, Bang Liu, Chenglin Wu, and Yuyu Luo. Autowebworld: Synthesizing infinite verifiable web environments via finite state machines, 2026. URL https://arxiv.org/abs/ 2602.14296. [106] Zijian Wu, Xiangyan Liu, Xinyuan Zhang, Lingjun Chen, Fanqing Meng, Lingxiao Du, Yiran Zhao, Fanshi Zhang, Yaoqi Ye, Jiawei Wang, Zirui Wang, Jinjie Ni, Yufan Yang, Arvin Xu, and Michael Qizhe Shieh. Mcpmark: A benchmark for stress-testing realistic and comprehensive mcp use, 2025. URL https://arxiv.org/abs/2509. 24002. [107] Ziqiao Xi, Shuang Liang, Qi Liu, Jiaqing Zhang, Letian Peng, Fang Nan, Meshal Nayim, Tianhui Zhang, Rishika Mundada, Lianhui Qin, Biwei Huang, and Kun Zhou. Toolgym: an open-world tool-using environment for scalable agent testing and data curation, 2026. URL https://arxiv.org/abs/2601.06328. [108] Zikai Xiao, Jianhong Tu, Chuhang Zou, Yuxin Zuo, Zhi Li, Peng Wang, Bowen Yu, Fei Huang, Junyang Lin, and Zuozhu Liu. Webworld: A large-scale world model for web agent training. CoRR, abs/2602.14721, 2026. doi: 10.48550/ARXIV.2602.14721. URL https://doi.org/10.48550/arXiv.2602.14721. [109] Zikai Xiao, Jianhong Tu, Chuhang Zou, Yuxin Zuo, Zhi Li, Peng Wang, Bowen Yu, Fei Huang, Junyang Lin, and Zuozhu Liu. Webworld: A large-scale world model for web agent training, 2026. URL https: //arxiv.org/abs/2602.14721. [110] Tianbao Xie, Danyang Zhang, Jixuan Chen, Xiaochuan Li, Siheng Zhao, Ruisheng Cao, Toh Jing Hua, Zhoujun Cheng, Dongchan Shin, Fangyu Lei, Yitao Liu, Yiheng Xu, Shuyan Zhou, Silvio Savarese, Caiming Xiong, Victor Zhong, and Tao Yu. Osworld: Benchmarking multimodal agents for open-ended tasks in real computer environments, 2024. [111] Tianbao Xie, Danyang Zhang, Jixuan Chen, Xiaochuan Li, Siheng Zhao, Ruisheng Cao, Toh Jing Hua, Zhoujun Cheng, Dongchan Shin, Fangyu Lei, Yitao Liu, Yiheng Xu, Shuyan Zhou, Silvio Savarese, Caiming Xiong, Victor Zhong, and Tao Yu. Osworld: Benchmarking multimodal agents for open-ended tasks in real computer environments, 2024. URL https://arxiv.org/abs/2404.07972. [112] Zengzhuang Xu, Bingguang Hao, Zechuan Wang, Yuntao Wen, Xinyi Xu, Yang Liu, Long Chen, Dong Wang, Maolin Wang, Tong Zhao, Yicheng Chen, Cunyin Peng, Jinjie Gu, Leilei Gan, Xiangyu Zhao, Chenyi Zhuang, and Shi Gu. Funreason-mt technical report: Advanced data synthesis solution for real-world multi-turn tool-use, 2025. URL https://arxiv.org/abs/2510.24645. [113] Zhangchen Xu, Adriana Meza Soria, Shawn Tan, Anurag Roy, Ashish Sunil Agrawal, Radha Poovendran, and Rameswar Panda. Toucan: Synthesizing 1.5 m tool-agentic data from real-world mcp environments. arXiv preprint arXiv:2510.01179, 2025. [114] An Yang, Anfeng Li, Baosong Yang, Beichen Zhang, Binyuan Hui, Bo Zheng, Bowen Yu, Chang Gao, Chengen Huang, Chenxu Lv, Chujie Zheng, Dayiheng Liu, Fan Zhou, Fei Huang, Feng Hu, Hao Ge, Haoran Wei, Huan Lin, Jialong Tang, Jian Yang, Jianhong Tu, Jianwei Zhang, Jian Yang, Jiaxi Yang, Jingren Zhou, Jingren Zhou, Junyang Lin, Kai Dang, Keqin Bao, Kexin Yang, Le Yu, Lianghao Deng, Mei Li, Mingfeng Xue, Mingze Li, Pei Zhang, Peng Wang, Qin Zhu, Rui Men, Ruize Gao, Shixuan Liu, Shuang Luo, Tianhao Li, Tianyi Tang, Wenbiao Yin, Xingzhang Ren, Xinyu Wang, Xinyu Zhang, Xuancheng Ren, Yang Fan, Yang Su, Yichang Zhang, Yinger Zhang, Yu Wan, Yuqiong Liu, Zekun Wang, Zeyu Cui, Zhenru Zhang, Zhipeng Zhou, and Zihan Qiu. Qwen3 technical report. CoRR, abs/2505.09388, 2025. doi: 10.48550/ARXIV.2505.09388. URL https://doi.org/10.48550/arXiv.2505.09388. [115] John Yang, Kilian Lieret, Carlos E. Jimenez, Alexander Wettig, Kabir Khandpur, Yanzhe Zhang, Binyuan Hui, Ofir Press, Ludwig Schmidt, and Diyi Yang. Swe-smith: Scaling data for software engineering agents, 2025. URL https://arxiv.org/abs/2504.21798. [116] Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik Narasimhan, and Yuan Cao. React: Synergizing reasoning and acting in language models. arXiv preprint arXiv:2210.03629, 2022. [117] Shunyu Yao, Noah Shinn, Pedram Razavi, and Karthik R Narasimhan. {$\tau$}-bench: A benchmark for \underline{T}ool-\underline{A}gent-\underline{U}ser interaction in real-world domains. In The

Thirteenth International Conference on Learning Representations, 2025. URL https://openreview.net/forum? id=roNSXZpUDN. [118] Qiying Yu, Zheng Zhang, Ruofei Zhu, Yufeng Yuan, Xiaochen Zuo, Yu Yue, Tiantian Fan, Gaohong Liu, Lingjun Liu, Xin Liu, Haibin Lin, Zhiqi Lin, Bole Ma, Guangming Sheng, Yuxuan Tong, Chi Zhang, Mofan Zhang, Wang Zhang, Hang Zhu, Jinhua Zhu, Jiaze Chen, Jiangjie Chen, Chengyi Wang, Hongli Yu, Weinan Dai, Yuxuan Song, Xiangpeng Wei, Hao Zhou, Jingjing Liu, Wei-Ying Ma, Ya-Qin Zhang, Lin Yan, Mu Qiao, Yonghui Wu, and Mingxuan Wang. DAPO: an open-source LLM reinforcement learning system at scale. CoRR, abs/2503.14476, 2025. [119] Simon Yu, Gang Li, Weiyan Shi, and Peng Qi. Polyskill: Learning generalizable skills through polymorphic abstraction, 2026. URL https://arxiv.org/abs/2510.15863. [120] Huining Yuan, Zelai Xu, Zheyue Tan, Xiangmin Yi, Mo Guang, Kaiwen Long, Haojia Hui, Boxun Li, Xinlei Chen, Bo Zhao, Xiao-Ping Zhang, Chao Yu, and Yu Wang. Marshal: Incentivizing multi-agent reasoning via self-play with strategic llms, 2025. URL [https://arxiv.org/abs/2510.15414](https://arxiv.org/abs/2510.15414). [121] Abhay Zala, Jaemin Cho, Han Lin, Jaehong Yoon, and Mohit Bansal. Envgen: Generating and adapting environments via llms for training embodied agents, 2024. URL https://arxiv.org/abs/2403.12014. [122] Daoguang Zan, Zhirong Huang, Wei Liu, Hanwu Chen, Linhao Zhang, Shulin Xin, Lu Chen, Qi Liu, Xiaojian Zhong, Aoyan Li, Siyao Liu, Yongsheng Xiao, Liangqiang Chen, Yuyu Zhang, Jing Su, Tianyu Liu, Rui Long, Kai Shen, and Liang Xiang. Multi-swe-bench: A multilingual benchmark for issue resolving, 2025. URL https://arxiv.org/abs/2504.02605. [123] Weihao Zeng, Can Xu, Yingxiu Zhao, Jian-Guang Lou, and Weizhu Chen. Automatic instruction evolving for large language models. CoRR, abs/2406.00770, 2024. doi: 10.48550/ARXIV.2406.00770. URL https: //doi.org/10.48550/arXiv.2406.00770. [124] Yunpeng Zhai, Shuchang Tao, Cheng Chen, Anni Zou, Ziqian Chen, Qingxu Fu, Shinji Mai, Li Yu, Jiaji Deng, Zouying Cao, Zhaoyang Liu, Bolin Ding, and Jingren Zhou. Agentevolver: Towards efficient self-evolving agent system, 2025. URL https://arxiv.org/abs/2511.10395. [125] Guibin Zhang, Hejia Geng, Xiaohang Yu, Zhenfei Yin, Zaibin Zhang, Zelin Tan, Heng Zhou, Zhongzhi Li, Xiangyuan Xue, Yijiang Li, et al. The landscape of agentic reinforcement learning for llms: A survey. arXiv preprint arXiv:2509.02547, 2025. [126] Guibin Zhang, Hejia Geng, Xiaohang Yu, Zhenfei Yin, Zaibin Zhang, Zelin Tan, Heng Zhou, Zhongzhi Li, Xiangyuan Xue, Yijiang Li, Yifan Zhou, Yang Chen, Chen Zhang, Yutao Fan, Zihu Wang, Songtao Huang, Francisco Piedrahita-Velez, Yue Liao, Hongru Wang, Mengyue Yang, Heng Ji, Jun Wang, Shuicheng Yan, Philip Torr, and Lei Bai. The landscape of agentic reinforcement learning for llms: A survey, 2026. URL https://arxiv.org/abs/2509.02547. [127] Jiayi Zhang, Yiran Peng, Fanqi Kong, Cheng Yang, Yifan Wu, Zhaoyang Yu, Jinyu Xiang, Jianhao Ruan, Jinlin Wang, Maojia Song, HongZhang Liu, Xiangru Tang, Bang Liu, Chenglin Wu, and Yuyu Luo. Autoenv: Automated environments for measuring cross-environment agent learning, 2025. URL https://arxiv.org/abs/2511.19304. [128] Yi-Fan Zhang, Xingyu Lu, Shukang Yin, Chaoyou Fu, Wei Chen, Xiao Hu, Bin Wen, Kaiyu Jiang, Changyi Liu, Tianke Zhang, et al. Thyme: Think beyond images. arXiv preprint arXiv:2508.11630, 2025. [129] Ziyun Zhang, Zezhou Wang, Xiaoyi Zhang, Zongyu Guo, Jiahao Li, Bin Li, and Yan Lu. Infiniteweb: Scalable web environment synthesis for gui agent training, 2026. URL https://arxiv.org/abs/2601.04126. [130] Weikang Zhao, Xili Wang, Chengdi Ma, Lingbin Kong, Zhaohua Yang, Mingxiang Tuo, Xiaowei Shi, Yitao Zhai, and Xunliang Cai. Mua-rl: Multi-turn user-interacting agent reinforcement learning for agentic tool use, 2025. URL https://arxiv.org/abs/2508.18669. [131] Ziwei Zheng, Michael Yang, Jack Hong, Chenxiao Zhao, Guohai Xu, Le Yang, Chao Shen, and Xing Yu. Deepeyes: Incentivizing "thinking with images" via reinforcement learning, 2026. URL https://arxiv.org/abs/2505.14362. [132] Wanjun Zhong, Ruixiang Cui, Yiduo Guo, Yaobo Liang, Shuai Lu, Yanlin Wang, Amin Saied, Weizhu Chen, and Nan Duan. Agieval: A human-centric benchmark for evaluating foundation models, 2023. URL https://arxiv. org/abs/2304.06364, 2024. [133] Chenyu Zhou, Huacan Chai, Wenteng Chen, Zihan Guo, Rong Shan, Yuanyi Song, Tianyi Xu, Yingxuan Yang, Aofan Yu, Weiming Zhang, Congming Zheng, Jiachen Zhu, Zeyu Zheng, Zhuosheng Zhang, Xingyu Lou,

Changwang Zhang, Zhihui Fu, Jun Wang, Weiwen Liu, Jianghao Lin, and Weinan Zhang. Externalization in llm agents: A unified review of memory, skills, protocols and harness engineering, 2026. URL https: //arxiv.org/abs/2604.08224.

Appendix A Agentic Diagnosis Prompt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

B Environment Visualizations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

B.1 Arxiv_local . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

B.2 Emails . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

B.3 Calendar

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

B.4 Hotels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

B.5 App_stores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

B.6 Food_delivery . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

C Case Study . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

C.1 Case 1: Ecomm MCP Server . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

C.2 Case 2: Slack Workspace Automation Server . . . . . . . . . . . . . . . . . . . . . . . . . . .

C.3 Case 3: Population Data Server . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Agentic Diagnosis Prompt

As described in Section 3.2.2, the diagnosis agent 𝛿 receives per-task failure traces, error statistics, and environment metadata, and outputs a structured weakness report with targeted task-generation guidelines. The full prompt template is presented below; Table A specifies the expected output schema. Prompt A: System Prompt for Diagnosis Agent 𝛿 You are an expert agent diagnostician. You will be given evaluation results from an AI agent operating in tool-calling environments. Your task is to: 1. Identify failure patterns: Categorize each failure into root-cause types. 2. Rank weak environments: Determine which environments are most problematic. 3. Generate targeted guidelines: For each weak environment, produce specific task-generation guidelines to address the identified weaknesses. Output a structured JSON diagnosis report following the schema provided. Prompt B: User Prompt Template for Diagnosis Agent 𝛿 Agent Under Test

Model: {model_name} Evaluation Protocol: Closed-loop rollout with tool-calling, followed by rubric-based verification Total Instances: {total_instances} Overall Pass Rate: {pass_rate} Error Distribution by Environment

{error_distribution_table} Failure Traces (per-task)

For each failed instance, the following fields are provided: • Environment: the domain/environment type • Task Description: what the agent was asked to do • Rubrics: the evaluation criteria (JSON with per-criterion checks)

• Tool Schemas: available tool interfaces • Agent Conversation: the full multi-turn interaction trace • Evaluation Result: per-criterion scores and failure reasons • Eval Stats: steps taken, finish reason, per-tool success/fail counts — BEGIN FAILURE TRACES — {failure_traces} — END FAILURE TRACES — Output Requirement

Produce a JSON diagnosis report with the schema defined in Table A. Focus on actionable, specific diagnosis grounded in evidence from the traces above. Avoid generic advice.

Environment Visualizations

This section collects self-contained tcolorbox capsules for representative environments (same layout as standalone appendix_arxiv_local_env.tex): environment summary, directory-style file map, tool list with intent, and one listing-style tool implementation. Duplicate the subsection + envviscapsule pattern to add more domains.

B.1

Arxiv_local

Environment: Arxiv_local Environment This environment simulates a small, fully offline “local arXiv” library: each paper is represented by a Markdown metadata card on disk, plus a JSON manifest for fast title indexing. Agents never call the public arXiv API directly here; instead they use deterministic Python-backed tools that read manifest.json and files under papers/. The domain is training-friendly and self-contained: prompts, on-disk fixtures, reference answers, and verifiers can all assume these paths and schemas.

File summary

Directory layout (repository root) ./ manifest.json papers/ 1706.03762.md 1810.04805.md 1512.03385.md 1406.2661.md 1806.07366.md 2005.14165.md 2102.12092.md 2103.00020.md 2003.08934.md 1910.11333.md

-- JSON map: relative path -> canonical paper title -- Metadata card (Attention Is All You Need) -- Metadata card (BERT) -- Metadata card (ResNet) -- Metadata card (GANs) -- Metadata card (Neural ODEs) -- Metadata card (GPT-3 / few-shot LMs) -- Metadata card (DALL-E / zero-shot T2I) -- Metadata card (CLIP) -- Metadata card (NeRF) -- Metadata card (quantum supremacy supplement)

Manifest and cards (what each file is for) • manifest.json — Maps each papers/<id>.md path to the human-readable title; used for 𝑂 (1)-ish

listing and search without opening every card.

• papers/*.md — One Markdown file per arXiv ID with lines such as Authors:, Abstract:, Subjects:, optional Comments:, DOI:, URL:, and when present Journal reference: / Project page:. The first # heading is treated as the title line for parsers that only skim headings.

Tool list Tools (each paired with intent) • list_local_papers — Returns every (paper_id, title) pair discovered via manifest.json; empty

list if the manifest is missing so callers can distinguish “no corpus” from “parse error”.

• get_local_paper_metadata — Given paper_id, opens the corresponding Markdown card and returns a JSON-friendly dict of canonical fields (title, authors, abstract, subjects, comments, doi, url, journal_reference, project_page) with None for absent lines; raises if the file is missing. • search_local_papers — Case-insensitive substring search over titles only (values in the manifest), returning matching id/title rows; cheap and deterministic, suitable for agent planning loops before paying the cost of opening cards.

Tool example Below is the reference implementation for get_local_paper_metadata; the function name matches the exposed tool name and the body is intentionally boring, line-oriented parsing so it is easy to audit in reviews. def get_local_paper_metadata(paper_id): import os md_path = os.path.join(’papers’, f’{paper_id}.md’) if not os.path.isfile(md_path): raise FileNotFoundError(f’Paper metadata file not found: {md_path}’) with open(md_path, ’r’, encoding=’utf-8’) as f: lines = f.readlines() fields = { ’paper_id’: paper_id, ’title’: None, ’authors’: None, ’abstract’: None, ’subjects’: None, ’comments’: None, ’doi’: None, ’url’: None, ’journal_reference’: None, ’project_page’: None, } for line in lines: line = line.strip() if not line: continue if fields[’title’] is None and line.startswith(’#’): fields[’title’] = line.lstrip(’#’).strip() continue low = line.lower() if low.startswith(’authors:’): fields[’authors’] = line.split(’:’, 1)[1].strip() elif low.startswith(’abstract:’): fields[’abstract’] = line.split(’:’, 1)[1].strip() elif low.startswith(’subjects:’): fields[’subjects’] = line.split(’:’, 1)[1].strip() elif low.startswith(’comments:’): fields[’comments’] = line.split(’:’, 1)[1].strip() elif low.startswith(’doi:’): fields[’doi’] = line.split(’:’, 1)[1].strip() elif low.startswith(’url:’): fields[’url’] = line.split(’:’, 1)[1].strip() elif low.startswith(’journal reference:’): fields[’journal_reference’] = line.split(’:’, 1)[1].strip() elif low.startswith(’project page:’): fields[’project_page’] = line.split(’:’, 1)[1].strip() return fields

B.2

Emails

Environment: Emails Environment This environment simulates a file-backed mailbox for training and evaluation: a large historical Enron spam/ham CSV supplies raw distribution statistics, while a compact synthetic export (emails_export.json) holds 2,000 fully structured messages (folders, headers, bodies, labels, attachment filenames). Agents interact through read-only JSON/CSV tools rooted at the workspace working directory (e.g. emails_export.json, folders.json, mailbox_stats.json, attachments/, enron_spam_data/) rather than a live IMAP surface; the reference “emails” MCP catalog (25 tools such as send_email, move_email) is a conceptual superset, but the bundled verifier assumes the local file toolset below.

File summary

Directory layout (repository root) ./ emails_export.json from, to, cc, bcc,

-- JSON array: 2000 synthetic emails (email_id, folder,

-- subject, body, date, spam_ham, attachments[]) folders.json -- JSON array of folder names present in the export mailbox_stats.json -- JSON: total_emails + per-folder counts enron_spam_data/ enron_spam_data.csv -- ~814k-row Enron Spam/Ham CSV (Message ID, Subject, Message, Spam/Ham, Date) attachments/ attachment1.txt -- Plain-text sample attachment for download tests attachment2.txt -- Plain-text sample attachment for download tests

Data roles • emails_export.json — Primary corpus for listing, lookup, search, and spam/ham aggregation; each

record mirrors a realistic MIME-like payload without requiring a network.

• folders.json / mailbox_stats.json — Lightweight indices so agents can validate folder vocabulary and global counts before expensive scans. • enron_spam_data/enron_spam_data.csv — Source-scale file for sampling and distributional questions; implementations should avoid loading the entire CSV into memory. • attachments/*.txt — On-disk payloads referenced when an email lists an attachment name; get_attachment_content joins export metadata with these files.

Tool list Tools (each paired with intent) • list_emails — Paginated slice over emails_export.json with optional folder filter; returns total,

page, page_size, and emails.

• get_email_by_id — Returns a single message dict by email_id, or a structured error object if missing. • get_folders — Reads folders.json and returns the folder name array (or an error wrapper).

• get_mailbox_stats — Loads mailbox_stats.json; optional folder_name narrows to one bucket, otherwise returns the full summary object. • search_emails — Case-insensitive substring match over subject, body, from, and to (list-aware), with optional folder scoping and pagination matching list_emails. • get_attachment_content — Verifies the filename appears in the email’s attachments list, then reads attachments/<attachment_filename> as UTF-8 text. • sample_enron_spam — Reservoir-style sampling of up to n rows from the Enron CSV with optional spam_ham ∈ {spam, ham, both}. • get_email_counts_by_folder_and_spam — Derives per-folder spam/ham counts directly from the synthetic export for charting and consistency checks.

Tool example Reference implementation for list_emails (paths resolved with os.getcwd(), matching the tool name). def list_emails(folder=None, page=1, page_size=20): import json, os path = os.path.join(os.getcwd(), ’emails_export.json’) try: with open(path, ’r’, encoding=’utf-8’) as f: emails = json.load(f) except Exception as e: return {"error": f"Failed to load emails: {str(e)}"} if folder: emails = [e for e in emails if e.get(’folder’) == folder] total = len(emails) start = (page - 1) * page_size end = start + page_size paginated = emails[start:end] return {"total": total, "page": page, "page_size": page_size, "emails": paginated}

B.3

Calendar

Environment: Calendar Environment This environment backs a synthetic Calendar service used in evaluation: all state lives under /app/database/ as JSON plus a short README.md. Users (users.json) supply stable UUIDs, corporatestyle emails, display names, and IANA time zones; holidays (holidays.json) enumerate U.S. all-day markers for 2025 with federal/regional typing; events (events.json) hold 34 timed meetings from

January–June 2025 (all-hands, kickoff, eight weekly syncs, twenty one-on-ones, four client reviews) with UTC Z timestamps, attendee email lists drawn from the user roster, and string locations (rooms or Zoom/Teams/Meet). A richer production calendar MCP might expose calendar_create_event, calendar_get_event, etc.; here the read/query file toolset below is what agents and verifiers assume.

File summary

Directory layout (/app/database/) /app/database/ README.md -- Markdown: purpose of the directory + schema overview for the three JSON files users.json -- JSON array: id (UUID), email, name, timezone (IANA string) holidays.json -- JSON array: event_id, title, start_time/end_time (UTC all-day window), -attendees [], location null, type (Federal / Regional / Not a Public Holiday, ...) events.json -- JSON array: event_id, title, start_time, end_time (UTC), attendees[], location

Data roles • users.json — Canonical directory for resolving attendee emails to people and time zones; also

supports standalone user lookups.

• holidays.json — Public-holiday layer with empty attendee lists and null locations; range filters use the calendar date of start_time. • events.json — Primary workload for scheduling queries: overlaps, per-user agendas, and title search all scan this array. • README.md — Human-readable contract tying on-disk layout to the intended calendar tool surface for developers.

Tool list Tools (each paired with intent) • list_all_users — Loads and returns the full users.json array.

• get_user_by_email — Case-insensitive email match; returns one user dict or None. • get_user_by_id — UUID equality on id; returns one user dict or None. • list_all_holidays — Returns every holiday record from holidays.json. • list_holidays_in_range — Inclusive YYYY-MM-DD window on the holiday’s start date (UTC-derived calendar day).

• get_holiday_by_id — Lookup by event_id in holidays.json. • list_all_events — Returns the full events.json array (all 34 events). • list_events_in_range — Inclusive date filter on each event’s start_time calendar day in UTC. • get_event_by_id — Lookup by event_id in events.json. • list_user_events_on_date — Filters events where user_email appears in attendees (caseinsensitive) and the start date equals the given day. • search_events_by_title — Case-insensitive substring filter over title only.

Tool example Reference implementation for list_events_in_range (fixed /app/database/events.json path, matching the tool name). def list_events_in_range(start_date, end_date): import json, pathlib, datetime start = datetime.date.fromisoformat(start_date) end = datetime.date.fromisoformat(end_date) path = pathlib.Path(’/app/database/events.json’) with path.open() as f: events = json.load(f) result = [] for e in events: e_start = datetime.datetime.fromisoformat( e[’start_time’].replace(’Z’, ’+00:00’) ).date() if start <= e_start <= end: result.append(e) return result

B.4

Hotels

Environment: Hotels Environment This environment backs a Hotels service used in evaluation: structured inventory and booking state live under /app/database/. A compact Hangzhou-focused trio in hotels.json / hotel_details.json supports end-to-end drills (geocode → search → room details → book), while rates.json maps many numeric supplier hotel IDs to synthetic Standard/Deluxe/Suite rate rows, hotels_sample.csv carries wide scraped-style listing rows (bilingual names, scores, embedded JSON facility blobs, media URLs), and world_cities.csv supplies a global city/lat/lng/population reference. Production systems might expose dozens of OTA tools; here agents assume the six-tool surface below, with book_hotel as the sole writer of persistent booking records.

File summary

Directory layout (/app/database/) /app/database/ bookings.json -facilities.json hotel_details.json -hotels.json -hotels_sample.csv URLs) places.json rates.json world_cities.csv

-- JSON array (initially empty): booking_id, hotel_id, rate_id, user_id, payment_link, status; appended by book_hotel -- JSON array: id (e.g. FREE_WIFI), name, description -- JSON array: hotel_id, description, rooms[] (rate_id, name, price, currency, amenities[], cancellation_policy) -- JSON array: hotel_id, name, address, city, province, star_rating, lat/lng, price_per_night, rating, facilities[] -- Wide CSV: many columns (names, geo, scores, nested JSON text, -- JSON array: query, name, latitude, longitude, country -- JSON object: hotel_id (string key) -> array of rate rows -- CSV: city, lat, lng, country, population

Data roles • places.json — Normalizes free-text locations (Hangzhou, Paris, . . . ) to coordinates for find_place before search_hotels.

• facilities.json — Canonical amenity vocabulary: internal IDs (FREE_WIFI, GYM, . . . ) with English labels used for search filters and room metadata. • hotels.json — Paged search index: summary rows with star rating, optional list price and guest score, and facility ID lists aligned with facilities.json. • hotel_details.json — Per-hotel narrative blurb plus priced rooms with rate_id values that book_hotel must echo into the ledger. • rates.json / hotels_sample.csv / world_cities.csv — Heavier reference slices for tasks that join bulk pricing, listing exports, or city-level geography against the small curated hotel set. • bookings.json — Append-only booking store created at cold start as []; each successful reservation adds an object with stable identifiers and a payment hand-off field.

Tool list Tools (each paired with intent)

• find_place — Maps a user query string plus optional language hint to a normalized place name and coordinates using places.json. • search_hotels — Location-driven availability search: accepts latitude/longitude, optional name hint, stay dates (defaults 2025-06-25 / 2025-06-26), and party size; returns a session handle for follow-on calls. • load_more_hotels — Pagination helper that continues a prior search_hotels (or self) result stream given session_id. • get_hotel_details — Requires session_id and hotel_id; returns long-form copy and room/rate rows from hotel_details.json (or an equivalent merge with cached search context). • book_hotel — Starts checkout for a chosen rate_id under hotel_id; persists a booking record into bookings.json. • get_facilities — Returns the full facility dictionary for display or filter construction (optional language argument; evaluation fixtures are English-centric).

Tool example Reference implementation for get_facilities (fixed /app/database/facilities.json path, matching the tool name). def get_facilities(language=’en’): import json, pathlib path = pathlib.Path(’/app/database/facilities.json’) with path.open(encoding=’utf-8’) as f: facilities = json.load(f) return {’language’: language, ’facilities’: facilities}

B.5

App_stores

Environment: App_stores Environment This environment packages a read-only, file-backed mirror of public storefront metadata for three flagship social apps (Instagram, TikTok, WhatsApp): one App Store slice (search summary row plus full app-store-details style objects and recent Apple reviews per app) and one Google Play slice (details with embedded score/installs/summary, synthetic review threads, structured Data Safety objects, and permission string lists). All payloads live as static JSON under /app/database/; agents never call live App Store or Play APIs. Tools are thin json.load wrappers with fixed absolute paths, so tasks can require deterministic cross-platform joins (ratings, dates, permission overlap, data-sharing posture) without network variance.

File summary

Directory layout (/app/database/) /app/database/ app_store_search_results.json -- Array: one row each for Instagram, TikTok, WhatsApp (id, appId, title, icon, url, price, currency, free, description, developer, ...) app_store_details_instagram.json -- Full App Store metadata object for Instagram (devices, screenshots, ratings, version, advisories, ...) app_store_details_tiktok.json -- Full App Store metadata object for TikTok app_store_details_whatsapp.json -- Full App Store metadata object for WhatsApp app_store_reviews_instagram.json -- Array of recent Apple reviews (id, userName , rating, title, text, date) app_store_reviews_tiktok.json -- Array of recent Apple reviews for TikTok google_play_details_instagram.json -- Play listing dict (title, appId, url, developer, score, installs, updated, dataSafety summary text, permissions[]) google_play_details_tiktok.json -- Play listing dict for TikTok google_play_details_whatsapp.json -- Play listing dict for WhatsApp google_play_reviews_instagram.json -- Array of Play-style reviews (id, userName, rating, title, text, date, version) google_play_reviews_tiktok.json google_play_reviews_whatsapp.json google_play_datasafety_instagram.json -- Object: dataShared[], dataCollected[], securityPractices[], deletionRequest google_play_datasafety_tiktok.json google_play_datasafety_whatsapp.json google_play_permissions_instagram.json -- JSON array of human-readable Android permission strings google_play_permissions_tiktok.json google_play_permissions_whatsapp.json

Data roles • app_store_search_results.json — Compact index of the three apps for list/compare tasks before

opening heavy detail blobs.

• app_store_details_*.json — Canonical iOS-side fields (version strings, content advisories, language lists, rating counts) for rubrics that reference Apple-only semantics.

• app_store_reviews_instagram.json / app_store_reviews_tiktok.json — Short recent-review windows for sentiment or moderation-themed queries on the Apple side (no separate WhatsApp App Store review file in this snapshot). • google_play_details_*.json — Android-side headline metrics plus inline dataSafety prose and permissions arrays suitable for permission-set reasoning. • google_play_datasafety_*.json — Structured sharing/collection/security labels that pair with the narrative dataSafety field in details when tasks require consistency checks. • google_play_reviews_*.json / google_play_permissions_*.json — Sidecar corpora for cross-store contrast (e.g., average rating vs. Play score, or permission deltas across messengers).

Tool list Tools (each paired with intent) • get_app_store_search_results — Returns the full search array (three apps) from app_store_search_results.json.

• get_app_store_details_instagram — Load full App Store metadata for Instagram. • get_app_store_details_tiktok — Load full App Store metadata for TikTok. • get_app_store_details_whatsapp — Load full App Store metadata for WhatsApp. • get_app_store_reviews_instagram — Load Apple-side reviews for Instagram. • get_app_store_reviews_tiktok — Load Apple-side reviews for TikTok. • get_google_play_details_instagram — Load Google Play listing dict for Instagram (scores, installs, summary, inline data-safety text, permissions). • get_google_play_details_tiktok — Load Google Play listing dict for TikTok. • get_google_play_details_whatsapp — Load Google Play listing dict for WhatsApp. • get_google_play_reviews_instagram — Load Play review array for Instagram. • get_google_play_reviews_tiktok — Load Play review array for TikTok. • get_google_play_reviews_whatsapp — Load Play review array for WhatsApp. • get_google_play_datasafety_instagram — Load structured Data Safety object for Instagram. • get_google_play_datasafety_tiktok — Load structured Data Safety object for TikTok. • get_google_play_datasafety_whatsapp — Load structured Data Safety object for WhatsApp. • get_google_play_permissions_instagram — Load Android permission strings for Instagram. • get_google_play_permissions_tiktok — Load Android permission strings for TikTok. • get_google_play_permissions_whatsapp — Load Android permission strings for WhatsApp.

Tool example Reference implementation for get_app_store_search_results (fixed path under /app/database/, matching the exposed tool name). def get_app_store_search_results(): ’’’Load App Store search results from JSON file.’’’ import json

path = ’/app/database/app_store_search_results.json’ with open(path, ’r’, encoding=’utf-8’) as f: return json.load(f)

B.6

Food_delivery

1 Environment: Food_delivery Environment This environment simulates a multi-city food-delivery storefront backed entirely by JSON under /app/database/: users, restaurants (stores), menu items (products), order histories with delivery timing and status, a pre-materialized user--store distance table (Haversine meters), a 2025 China public-holiday calendar, a compact early-January 2025 weather panel for five major cities, and per-user behavior aggregates (order counts and average spend on paid/delivered orders). Prices are in RMB. Tools are read-only queries and scans over these fixtures; there is no live ordering API.

File summary

Directory layout (/app/database/) /app/database/ users.json -- user_id, name, address, lat/lon, phone, dietary_restrictions[], favorite_tags[], order_history[] stores.json -- store_id, name, address, lat/lon, rating, tags[], product_ids[] (catalog pointers) products.json -- product_id, name, price (RMB), rating, tags[], store_id orders.json -- order_id, user_id, store_id, products[{product_id, quantity}], total_price, address, timestamps, distance_m, estimated_delivery_minutes, status, update_time distances.json -- user_id, store_id, distance_m (precomputed for every user x store pair) holidays_2025.json -- date (YYYY-MM-DD), name (Chinese public holidays for 2025) weather_2025.json -- city, date, temperature_c, condition (Beijing, Shanghai, Guangzhou, Chengdu, Shenzhen; first week of Jan 2025) user_behaviors.json -- user_id, home_address, dietary_restrictions[], favorite_tags[], order_count, average_spend

Data roles • users.json / stores.json / products.json — Core dimensional tables for personalization, catalog

filtering, and price/rating joins.

• orders.json — Transactional facts for fulfillment timelines, status filters, and basket reconstruction. • distances.json — O(1)-style lookup for routing or SLA tasks without recomputing geodesics at runtime. • holidays_2025.json / weather_2025.json — Calendar and meteorology side channels for cross-domain prompts (e.g., holiday surcharges, snow-day delays). • user_behaviors.json — Denormalized rollups aligned with user profiles for cohort-style questions without re-scanning all orders.

Tool list Tools (each paired with intent) • get_user_by_id — Return one user dict by user_id, or None.

• list_users — Return the full users.json array.

• get_store_by_id — Return one store dict by store_id, or None. • list_stores — Return the full stores.json array. • get_product_by_id — Return one product dict by product_id, or None. • list_products — Filter products.json by optional store_id and/or tag membership. • get_order_by_id — Return one order dict by order_id, or None. • list_user_orders — List orders for a user_id, optionally restricted by status (delivered, paid, unpaid, cancelled, . . . ). • get_distance — Return precomputed distance_m for a (user_id, distances.json.

store_id) pair from

• get_holiday_by_date — Return holiday name for a YYYY-MM-DD key in holidays_2025.json, else None. • get_weather — Return {temperature_c, condition} for a (city, date) row in weather_2025.json, else None. • get_user_behavior — Return the aggregated behavior row for user_id from user_behaviors.json, or None. • search_products_by_tag — Return all products whose tags list contains the query tag. • search_stores_by_tag — Return all stores whose tags list contains the query tag.

Tool example Reference implementation for list_users (paths built with os.path.join under /app/database/). def list_users(): import json, os path = os.path.join(’/app/database’, ’users.json’) with open(path, ’r’, encoding=’utf-8’) as f: return json.load(f)

Case Study

We present three representative trajectories with at least 7 interaction turns. For each case, we report the environment context, task requirement, tool inventory, rubric criteria, and an abbreviated interaction trajectory.

C.1

Case 1: Ecomm MCP Server Case 1: Ecomm MCP Server — Multi-Step Return Execution Tools Used: 4/17

Environment: ecomm_mcp_server

Steps: 9

Task Requirement. Handle a customer return request by completing identity verification, enumerating

historical orders, identifying eligible delivered orders, collecting item-level return intent, confirming refund destination, and submitting the return action under policy constraints. Tool

Description

find_user_id_by_name_zip get_user_details get_order_details return_delivered_order_items

Resolve customer identifier from profile metadata Retrieve account, payment method, and order identifiers Retrieve per-order status and item-level fulfillment details Submit return request for selected delivered items

Rubrics. C1 : Returned items must belong to a delivered order. C2 : Refund method must follow

user-confirmed payment path. C3 : Order state transition must become return requested. C4 : Selected returned item IDs must match user intent exactly. Trajectory. Turn Interaction

[User] Requests help returning multiple recent products (content abbreviated ).

[Assistant] Identity verification requested and resolved via name+zip

find_user_id_by_name_zip(first_name="Anya", last_name="Sanchez", zip="43171") 3

[Tool] anya_sanchez_9707 [Assistant] get_user_details(user_id="anya_sanchez_9707")

4– 6

[Assistant] Iteratively checks four orders for eligibility

[Assistant] Presents eligible delivered order #W4442043, collects item selection and refund

[Assistant] Executes return submission

get_order_details(order_id="#W5402785") get_order_details(order_id="#W2136962") get_order_details(order_id="#W4442043") get_order_details(order_id="#W6002958") confirmation (content abbreviated ).

return_delivered_order_items(order_id="#W4442043", item_ids=[6697922351,7758198585,3187628796], payment_method_id="paypal_1191071") 9

[Tool] {status: "return requested", return_items: [3187628796, 6697922351, 7758198585]} [Assistant] Confirms completed return and refund processing window.

Figure 10 Case 1: The agent executes a complete e-commerce return transaction under policy constraints with iterative order-state verification and user-confirmed actuation.

C.2

Case 2: Slack Workspace Automation Server Case 2: Slack Workspace Automation Server — Compliance Triage

Environment: slack_workspace_automation_server

Tools Used: 5/18

Steps: 7

Task Requirement. Conduct Slack compliance triage for a reported message by identifying sender

attributes, computing text similarity and temporal proximity against a target user’s CSV history, checking login state and contact graph dependency, and generating a deterministic triage comment payload for issue synchronization. Tool

Description

get_message_by_ts get_user_by_id filter_message_csv_by_user get_login_status list_contacts

Retrieve reported message by timestamp Retrieve sender profile / existence signal Retrieve historical CSV utterances for comparison target Retrieve login state for workflow dependency user Retrieve contact graph to determine add-contact necessity

Rubrics. C1 : Required JSON fields and value types must be correct. C2 : Similarity and time-difference

computations must be reproducible. C3 : need_add_contact must reflect login + contact-state logic. C4 : Comment body must include branch name, score, time gap, level, and contact conclusion. Trajectory. Turn Interaction

[User] Requests compliance triage JSON for reported Slack message with fixed output schema (content abbreviated ).

[Assistant] get_message_by_ts(ts="1512104434.000490")

[Tool] {user: "U222BBB222", text: "What, you want to smell my shoes better?"} [Assistant] get_user_by_id(user_id="U222BBB222")

[Tool] {status: "not_found"} [Assistant] filter_message_csv_by_user(user_id="U123ABC456")

[Tool] Returns one CSV utterance at 1512085950.000216 [Assistant] get_login_status(user_id="W012A3CDE")

[Tool] {is_logged_in: true} [Assistant] list_contacts()

[Tool] Contact W07QCRPA4 already exists [Assistant] Final JSON: similarity_score = 0.18, time_diff_seconds = 18484,

need_add_contact = false, triage level ignore.

Figure 11 Case 2: The agent combines message forensics, lexical similarity scoring, temporal reasoning, and contactgraph constraints into a deterministic Slack triage decision.

C.3

Case 3: Population Data Server Case 3: Population Data Server — Quantitative Ranking Under Tool Constraints Tools Used: 5/11

Environment: population_data_server

Steps: 10

Task Requirement. Construct a city-influence ranking using top-10 population cities plus Karachi,

apply growth-adjusted scoring for Karachi, and output winner plus transformed magnitude metric. The workflow must integrate sampled population data, category-specific percentage lookups, and logarithm constants under available tool precision limits. Tool

Description

list_top_cities_by_population get_city_population get_city_population_percentage get_logarithms_for_value get_precision_constant

Retrieve ranked top-𝑁 city populations Retrieve city-level population and growth metadata Retrieve global listed-population percentage for target city Retrieve log10 , log2 , and ln from lookup table Retrieve high-precision constants (with fallback when unavailable)

Rubrics. C1 : Candidate pool must include top-10 cities plus Karachi. C2 : Scoring and Karachi

growth adjustment must follow declared formula. C3 : Tie-break logic must be deterministic and reproducible. C4 : Output fields and numeric precision must match schema. Trajectory. Turn Interaction

[User] Requests winner-city computation with explicit logarithmic and tie-break rules (content abbreviated ).

[Assistant] list_top_cities_by_population(limit=10)

[Tool] Returns top-10 list headed by Tokyo [Assistant] get_city_population(city="Karachi", country="Pakistan")

[Tool] {Pop2023: 17236230, growthRate: 0.0235} [Assistant] get_city_population_percentage(city="Tokyo")

get_city_population_percentage(city="Mumbai") 5

[Tool] Returns percentages for Tokyo and Mumbai [Assistant] get_logarithms_for_value(x=40)

get_precision_constant(constant_name="log2_10") 6

[Tool] get_precision_constant returns None; assistant triggers fallback via

7– 9

[Assistant] <think> Resolves constant fallback, computes score ordering, and confirms Tokyo

[Assistant] Final JSON: winner_city = "Tokyo", winner_country = "Japan", score_S = 13.7423, magnitude_M = 1.1384.

get_logarithms_for_value(x=10) and additional checks (content abbreviated ). as winner after growth-adjusted Karachi comparison . . . </think>

Figure 12 Case 3: The agent solves a constrained quantitative ranking problem with explicit fallback reasoning when preferred constants are unavailable.

Record · ID 120567 · SHA-256 d9d803ef67a329f0
Conceptio Open Knowledge Archive — every document is proof-bundled with source, license, and retrieval metadata.