Paper deep dive
6GAgentGym: Tool Use, Data Synthesis, and Agentic Learning for Network Management
Jiao Chen, Jianhua Tang, Xiaotong Yang, Zuohong Lv
Intelligence
Status: succeeded | Model: google/gemini-3.1-flash-lite-preview | Prompt: intel-v1 | Confidence: 98%
Last extracted: 4/1/2026, 1:36:48 AM
Summary
6GAgentGym is a framework for autonomous 6G network management that enables closed-loop agentic interaction. It features an interactive environment with 42 typed tools, a learned Experiment Model (Mθ) calibrated on NS-3 simulation data, and 6G-Forge, a data synthesis pipeline that bootstraps training trajectories via iterative Self-Instruct generation. The framework supports supervised fine-tuning and reinforcement learning, allowing an 8B open-source model to achieve performance comparable to GPT-5 on the 6GAgentBench benchmark.
Entities (5)
Relation Signals (4)
Experiment Model → calibratedon → ns-3
confidence 100% · Experiment Model calibrated on NS-3 simulation data
6G-Forge → generatesdatafor → 6GAgentGym
confidence 100% · 6G-Forge bootstraps closed-loop training trajectories... for 6GAgentGym
6GAgentGym → utilizes → ns-3
confidence 100% · The physical-layer foundation of 6GAgentGym is NS-3
6GAgentBench → evaluates → 6GAgentGym
confidence 90% · comparable overall success rate to GPT-5 on the accompanying 6GAgentBench
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Autonomous 6G network management requires agents that can execute tools, observe the resulting state changes, and adapt their decisions accordingly. Existing benchmarks based on static questions or scripted episode replay, however, do not support such closed-loop interaction, limiting agents to passive evaluation without the ability to learn from environmental feedback. This paper presents 6GAgentGym to provide closed-loop capability. The framework provides an interactive environment with 42 typed tools whose effect classification distinguishes read-only observation from state-mutating configuration, backed by a learned Experiment Model calibrated on NS-3 simulation data. 6G-Forge bootstraps closed-loop training trajectories from NS-3 seeds via iterative Self-Instruct generation with execution verification against the Experiment Model. Supervised fine-tuning on the resulting corpus followed by reinforcement learning with online closed-loop interaction enables an 8B open-source model to achieve comparable overall success rate to GPT-5 on the accompanying 6GAgentBench, with stronger performance on long-horizon tasks. Together, these components provide a viable path toward autonomous, closed-loop network management.
Tags
Links
- Source: https://arxiv.org/abs/2603.29656v1
- Canonical: https://arxiv.org/abs/2603.29656v1
Trouble viewing inline? Open PDF directly →
Full Text
42,447 characters extracted from source content.
Expand or collapse full text
6GAgentGym: Tool Use, Data Synthesis, and Agentic Learning for Network Management Jiao Chen1, Jianhua Tang1, Xiaotong Yang2, and Zuohong Lv3 Corresponding author: Jianhua Tang (jtang4@e.ntu.edu.sg). J. Chen (202110190459@mail.scut.edu.cn) and J. Tang are with Shenzhen Smart City Technology Development Group Company, Ltd. X. Yang (202510192907@mail.scut.edu.cn) is with the Shien-Ming Wu School of Intelligent Engineering, South China University of Technology. Z. Lv (lvzh67@chinaunicom.cn) is with China Unicom Group Co., Ltd. Abstract Autonomous 6G network management requires agents that can execute tools, observe the resulting state changes, and adapt their decisions accordingly. Existing benchmarks based on static questions or scripted episode replay, however, do not support such closed-loop interaction, limiting agents to passive evaluation without the ability to learn from environmental feedback. This paper presents 6GAgentGym to provide closed-loop capability. The framework provides an interactive environment with 42 typed tools whose effect classification distinguishes read-only observation from state-mutating configuration, backed by a learned Experiment Model calibrated on NS-3 simulation data. 6G-Forge bootstraps closed-loop training trajectories from NS-3 seeds via iterative Self-Instruct generation with execution verification against the Experiment Model. Supervised fine-tuning on the resulting corpus followed by reinforcement learning with online closed-loop interaction enables an 8B open-source model to achieve comparable overall success rate to GPT-5 on the accompanying 6GAgentBench, with stronger performance on long-horizon tasks. Together, these components provide a viable path toward autonomous, closed-loop network management. I Introduction The convergence of 6G with massive IoT introduces substantial complexity in network management, spanning edge intelligence, dynamic slicing, and space-air-ground integration [16]. Configuring and optimizing a modern network that simultaneously manages intent translation, dynamic network slicing, trust policies, and multi-agent coordination typically requires an experienced engineer hours to days of manual effort per deployment. Industry analyses indicate that 45% of network outages stem from configuration and change management failures. As the number of radio-access technologies, band combinations, and network slices grows, manual optimization becomes increasingly difficult. While deep learning has improved network traffic prediction [1] and multi-level deep RL has shown promise for automated slicing in O-RAN-based 6G networks [8], these approaches address isolated subtasks and do not yet provide the end-to-end, semantically grounded management that operators need. Figure 1: Agent interaction model. The agent selects tools in a closed loop until the operator intent is verified. Configuration tools mutate network state, requiring re-observation. Large language models (LLMs) offer a promising path toward autonomous network management. Their capabilities in multi-step planning and tool orchestration [22, 27] allow agents to interpret operator intent in natural language, select appropriate network functions, and adapt decisions based on execution feedback [5, 15, 30]. Recent work has explored LLM-driven digital twins for closed-loop network optimization [9] and LLM-based intent translation for intent-based networking [24], demonstrating the breadth of LLM applications in network management. Fig. 1 illustrates this vision: the agent receives an operator intent, repeatedly selects and executes typed tools against the network, observes state changes, and continues until the intent is verified. However, network agents differ fundamentally from general-purpose LLM agents: they act on physical infrastructure under hard latency, safety, and regulatory constraints, demanding that such constraints be embedded in the agent’s action space and decision logic rather than treated as post-hoc filters. Realizing this closed-loop interaction at scale therefore requires answering a fundamental question: how can we build the interactive environment, synthesize closed-loop training data, and train agents so that compact models reliably manage 6G networks? Several lines of work provide building blocks toward this goal. In the general agent community, WebArena [31] and SWE-bench [10] demonstrate the value of interactive, execution-grounded evaluation, but target web navigation and software engineering rather than network operations. In the 6G domain, 6G-Bench [2] evaluates models through static multiple-choice questions without tool execution. α3α^3-Bench [5] and α3α^3-SecBench [6] construct large-scale conversational episodes with tool calls under dynamic 6G conditions, but episodes are scripted replays rather than interactive environments. The scaling study in [7] reveals favorable edge-deployment trade-offs for mid-scale models, yet remains limited to static reasoning. On the tool-use training side, general-purpose data synthesis pipelines such as APIGen [13] and DIVE [4] produce verifiable function-calling datasets but treat tools as stateless transformations without environmental feedback. Traditional deep RL approaches for network slicing [3, 12] do operate in closed-loop environments but at the level of low-dimensional state-action spaces, lacking the semantic reasoning that LLM agents provide. What remains underexplored is an integrated platform where agents interact with a network environment in closed loop—executing state-mutating tools, observing consequences, and learning from the resulting trajectories. This paper presents 6GAgentGym, a framework that unifies interactive environment, data synthesis, and agent training for 6G network management. The contributions are: • Interactive closed-loop environment. We construct an execution platform with 42 typed tools classified by effect (Observation, Reasoning, Configuration), backed by a learned Experiment Model calibrated on NS-3 simulation data that predicts six-dimensional network state transitions. • Scalable data synthesis. 6G-Forge bootstraps training trajectories from NS-3 seed data through iterative Self-Instruct generation constrained by typed tool signatures and effect labels, with execution verified against the Experiment Model and diversity maintained through ROUGE-L deduplication. • Agent training and evaluation. Agentic SFT followed by RL with online closed-loop interaction enables an 8B model to achieve comparable overall performance to GPT-5 on 6GAgentBench (L1–L3), with an advantage on long-horizon L3 tasks. I Related Work I-A LLM Agents for 6G Networks Evaluating whether LLM can handle 6G network management tasks has attracted growing attention. 6G-Bench [2] establishes a standardization-aligned taxonomy of 30 decision-making tasks and evaluates 22 foundation models on 3,722 multiple-choice questions. α3α^3-Bench [5] moves beyond static QA by formulating UAV missions as multi-turn conversational control loops with MCP and A2A tool calls, constructing 113k episodes and evaluating 17 models. α3α^3-SecBench [6] augments this corpus with 20,000 adversarial scenarios. The scaling study in [7] shows that 1.5–3B models achieve the best edge-deployment trade-off on 6G-Bench. Beyond benchmarking, Guo et al. [9] survey LLM-driven digital twins for network optimization, showing that LLMs can leverage real-time twin data to generate optimization strategies through closed-loop feedback. Su et al. [24] demonstrate that LLMs with submodular in-context learning can translate high-level operator intents into executable network policies, achieving notable accuracy gains without parameter updates. Despite this progression from static evaluation to LLM-driven optimization, existing work either relies on pre-recorded episodes or addresses individual subtasks; to our knowledge, no existing agent executes a tool that mutates network state and adapts to the consequences within a unified interactive environment. Figure 2: Overview of the 6GAgentGym framework. Left: interactive environment with 42 typed tools and Experiment Model. Center: 6G-Forge bootstraps closed-loop trajectories via iterative Self-Instruct generation with execution verification. Right: 6GAgentBench tiered evaluation (L1–L3). Below: Agentic SFT + RL training pipeline. I-B Tool-Use Benchmarks and Data Synthesis Training LLM agents to use tools reliably requires both evaluation environments and scalable training data. Early benchmarks such as ToolLLM [20], Gorilla [17], and API-Bank [11] evaluate API call generation over broad catalogs, but operate on stateless REST calls where tool outputs are independent of prior actions. Interactive benchmarks address this limitation: WebArena [31] provides a realistic web environment for long-horizon tasks, SWE-bench [10] evaluates agents on real GitHub issues, and AgentBoard [14] offers fine-grained progress metrics. These establish execution-grounded evaluation as a principle but do not target network operations. On the data synthesis side, generating high-quality tool-use trajectories at scale remains an open problem. Self-Instruct [26] bootstraps instruction data from a small seed set through iterative LLM generation. APIGen [13] extends this to function-calling datasets with three-stage verification, and DIVE [4] demonstrates that diversity scaling improves agentic generalization. Domain-specific work on typed tool action spaces [23] shows that structured training data can enable small models to outperform larger baselines. These pipelines, however, remain open-loop: tools transform data along acyclic chains without execution feedback altering environment state. I-C Reinforcement Learning for Network Management Applying RL to network management has a long history, but the action spaces differ fundamentally from LLM tool use. Deep RL has been applied to network slicing resource allocation [12, 3]; more recently, Ghafouri et al. [8] propose a multi-level deep RL framework for O-RAN-based 6G cell-free networks that combines centralized multi-agent decision-making with decentralized execution. Deep learning has also been applied to network traffic prediction [1], providing complementary forecasting capabilities. These methods optimize over fixed, low-dimensional action spaces (e.g., bandwidth allocation per slice) and lack the ability to interpret operator intent or compose multi-step diagnostic workflows. LLM-based agents offer a complementary paradigm at the semantic level: the ReAct framework [28] interleaves reasoning traces with tool actions, while the World Knowledge Model [19] shows that LLM agents can leverage both prior and dynamic state knowledge to mitigate blind trial-and-error. More recently, SWE-World [25] replaces containerized execution environments with learned surrogate models trained on real interaction data, enabling Docker-free agent training and test-time scaling for software engineering tasks. In the networking domain, NS-3 [21] remains the standard discrete-event simulator for protocol-level research, with recent extensions integrating ray-tracing channels for 6G multi-RAT scenarios [18]; our work adopts NS-3 as the physical-layer ground truth and distills its dynamics into a learned surrogate to enable scalable agent training. I Methodology Fig. 2 provides an overview of the framework. The following subsections detail each component. I-A Agent Interaction Model The network management agent operates as a closed-loop controller (Fig. 1). At each step, the agent receives the current network state tn_t and the operator’s intent Q (expressed in natural language), selects a typed tool vt∈v_t with arguments tx_t, and submits the call to the Experiment Model MθM_θ. The environment returns a tool result oto_t and an updated state t+1n_t+1; the agent appends this observation to its history and decides the next action. The loop terminates when the agent invokes a verification tool confirming that the intent has been satisfied, or when a maximum step budget is reached. This interaction model differs from static QA evaluation (where no tool is executed), scripted replay (where tool results are pre-recorded), and low-dimensional RL (where actions are continuous vectors without semantic structure). Figure 3: The 6G-Forge data synthesis pipeline. Step 1: NS-3 traces are annotated into seed trajectories. Step 2: A teacher LLM generates new trajectories from seed demonstrations. Step 3: Execution against MθM_θ produces golden and error-recovery traces. Step 4: Verified trajectories expand the seed pool; Steps 2–4 repeat for K iterations. I-B Interactive Environment I-B1 Typed Tool System We formalize the tool space as a finite set V of 42 typed functions over a domain type hierarchy T (see Appendix A for the full catalog). Each tool is classified by its effect on the network state tn_t, and V is partitioned into three disjoint subsets accordingly: =obs⊔rea⊔cfgV=V_obs\; \;V_rea\; \;V_cfg (1) obsV_obs (Observation) provides read-only access to the network state without modifying tn_t. reaV_rea (Reasoning) performs pure computation on typed inputs, neither reading nor modifying tn_t. cfgV_cfg (Configuration) contains state-mutating operations where t+1≠tn_t+1 _t in general; these are the only tools that can invalidate prior observations, requiring re-observation to close the feedback loop. The tool space spans both network management and UAV control, forcing the agent to learn cross-domain trade-offs [5]. I-B2 NS-3 Simulation Backend The physical-layer foundation of 6GAgentGym is NS-3 [21], the widely adopted discrete-event network simulator that provides protocol-level fidelity, modular architecture, and reproducible experimentation. We build on its NR module for 5G New Radio air-interface modeling and FlowMonitor for per-flow metrics extraction, enabling us to capture the six-dimensional state dynamics (slice type, latency, jitter, loss, throughput, edge load) that underpin both environment calibration and trajectory generation. NS-3 serves two roles in our framework: (1) generating the seed traces from which the Experiment Model and 6G-Forge originate, and (2) providing the ground-truth simulator for final policy validation (§IV-E). I-B3 Experiment Model Both trajectory synthesis and RL training require the agent to interact with an environment over many steps. Running full-fidelity NS-3 simulation for every such interaction is prohibitively expensive. We therefore introduce the Experiment Model MθM_θ, a compact LLM fine-tuned on NS-3 traces to serve as a learned environment proxy. Rather than replicating the simulator exactly, MθM_θ learns state transitions that are sufficiently consistent and causally grounded to support downstream training. It operates in a six-dimensional network state space t=(st,ℓt,jt,ρt,τt,et)∈n_t=(s_t,\, _t,\,j_t,\, _t,\, _t,\,e_t)\;∈\;N (2) where sts_t is the active slice type, ℓt _t latency, jtj_t jitter, ρt _t loss rate, τt _t throughput, and ete_t edge-compute load. Inference. At each step, MθM_θ receives the current state tn_t, the agent’s tool call (vt,t)(v_t,x_t), an optional degradation event δt _t, and the interaction history (i,vi,i)i<t\(n_i,v_i,x_i)\_i<t. It produces a chain-of-thought reasoning trace explaining how the tool call affects the network, followed by the predicted next state and tool result: (^t+1,o^t)=Mθ(t,vt,t,δt,Ht)( n_t+1,\, o_t)=M_θ(n_t,\,v_t,\,x_t,\, _t,\,H_t) (3) For Observation and Reasoning tools without degradation, MθM_θ preserves state; for Configuration tools, it predicts the corresponding transition dynamics. Training. MθM_θ is trained via supervised fine-tuning on transition tuples extracted from NS-3 traces, with a joint objective over reasoning generation and next-state prediction: ℒ=−[logPθ(t+1∣t,vt,t,Ht)+logPθ(ot∣t,vt,t,Ht)]L=-E [ P_θ(n_t+1 _t,v_t,x_t,H_t)+ P_θ(o_t _t,v_t,x_t,H_t) ] (4) This objective ensures that MθM_θ learns both to predict consistent state transitions and to generate faithful tool return values. I-C 6G-Forge: Data Synthesis Training an agent to manage 6G networks requires large-scale trajectory data, yet three barriers obstruct its collection: real NS-3 rollouts are computationally expensive, hand-crafting multi-step tool sequences demands deep domain expertise, and static datasets lack the diversity needed for robust generalization. Inspired by Self-Instruct [26], 6G-Forge addresses all three by bootstrapping a trajectory corpus from a small set of NS-3 seeds through iterative LLM-driven generation with execution verification against MθM_θ (Fig. 3). The pipeline has four steps. I-C1 Step 1: Seed Annotation NS-3 simulations produce network state time series. These raw traces do not contain tool-call sequences. A teacher LLM converts each trace into a seed trajectory by identifying decision points (service-level agreement (SLA) violations, handover events, degradation onsets) and generating the corresponding task description QiQ_i and tool-call sequence i=[(vj,j,oj,j)]j=1Li ξ_i=[(v_j,x_j,o_j,n_j)]_j=1^L_i. The resulting seed pool (0)=realP^(0)=D_real is grounded in physical-layer dynamics and serves as the quality anchor for subsequent generation. I-C2 Step 2: Self-Instruct Expansion At each iteration k, the teacher LLM receives a random sample of seed trajectories from (k)P^(k) as in-context demonstrations, together with the typed tool signatures of V. The teacher generates a new task description Q′Q and a corresponding tool-call trajectory ′ ξ . With probability pdegp_deg, a degradation scenario is additionally specified, requiring the trajectory to include a recovery sub-sequence. I-C3 Step 3: Execution Verification Each candidate trajectory is executed step-by-step against MθM_θ via Eq. (3). The teacher LLM’s imagined state values are replaced by MθM_θ’s predictions. Successful executions yield golden traces. When MθM_θ returns an error, the teacher is re-prompted to correct the failed step, producing an error-recovery augmented trajectory: aug∗=[…,(vi,i,ei,i),(vi,i′,oi,i′),…] ξ^*_aug=[…,\,(v_i,x_i,e_i,n_i),\,(v_i,x_i ,o_i,n_i ),\,…] (5) Both golden and error-recovery trajectories are retained as training data. I-C4 Step 4: Deduplication and Iterative Growth Each verified trajectory is compared against (k)P^(k) using ROUGE-L; near-duplicates are discarded. Remaining trajectories are added to the pool: (k+1)=(k)∪ℬ(k)P^(k+1)=P^(k) ^(k). Steps 2–4 repeat for K iterations, producing the synthetic dataset synD_syn. I-D 6GAgentBench: Tiered Evaluation The evaluation suite is organized into three difficulty tiers aligned with 6G-Bench [2]. L1 (≤3≤ 3 steps) covers elementary sense-decide-act chains. L2 (4–7 steps) covers network-adaptive workflows such as degradation detection and slice reallocation. L3 (≥8≥ 8 steps) covers long-horizon multi-agent workflows under network degradation. Candidate tasks where any single model achieves >>80% zero-shot success are excluded. I-E Two-Stage Agentic Training I-E1 Stage 1: Agentic SFT The SFT dataset combines NS-3 real trajectories realD_real and synthetic trajectories synD_syn from 6G-Forge. The student model is fine-tuned on their union sft=syn∪realD_sft=D_syn _real. I-E2 Stage 2: Agentic RL Starting from the SFT checkpoint, the agent is further optimized through reinforcement learning with online tool interaction against MθM_θ. Frontier tasks are selected by retaining only those where the SFT policy’s empirical success rate falls within a learnable range. The composite reward is: R=λ⋅Rformat+RcorrectR=λ· R_format+R_correct (6) where RformatR_format penalizes malformed tool calls and RcorrectR_correct measures task correctness. The policy is optimized with DAPO [29]. IV Experiments IV-A Experimental Setup IV-A1 Models We evaluate eight frontier models spanning proprietary and open-source families: GPT-5, Claude-Sonnet-4, Gemini-2.5-Pro, Qwen3-VL-72B-Instruct, Qwen3-VL-8B-Instruct, Qwen3-VL-4B-Instruct, DeepSeek-V3, and Llama-4-Scout, along with three non-LLM baselines and our fine-tuned 6GAgent-8B and 6GAgent-4B (initialized from Qwen3-VL-8B-Instruct and Qwen3-VL-4B-Instruct, respectively). All LLM models are evaluated under ReAct-style [28] interaction loops with deterministic decoding (temperature 0). IV-A2 Training Data The SFT dataset combines two sources: (1) 3,000 real trajectories from NS-3 simulations (L1–L3), which also serve as the seed pool (0)P^(0) for 6G-Forge; and (2) 50,000 synthetic trajectories from K=15K=15 offline Self-Instruct iterations (30,000 golden traces + 20,000 error-recovery augmented traces), each verified through type checking, execution against MθM_θ, and diversity filtering. Together these 53,000 trajectories span all five evaluation domains (network slicing, edge offloading, UAV control, degradation recovery, and multi-agent coordination) with controlled difficulty distribution: 30% L1, 45% L2, 25% L3. For RL, approximately 8,000 frontier tasks are selected from this pool based on empirical success rate. IV-A3 Holdout Protocol To prevent data leakage between training and evaluation, we enforce a strict three-way holdout design across the tightly coupled environment–synthesis–training–evaluation pipeline. (1) Task-level holdout: the 6GAgentBench evaluation tasks are drawn from a separate set of NS-3 scenario configurations (distinct topology seeds, traffic mixes, and failure injection patterns) that are never used during 6G-Forge synthesis or SFT/RL training. Specifically, the three NS-3 scenario scripts used for seed trajectory generation employ topology seeds 1–50, while the benchmark uses seeds 51–80. (2) Trajectory-level deduplication: all evaluation task descriptions are compared against the 53k training corpus using ROUGE-L; any evaluation task with ROUGE-L ≥0.7≥ 0.7 to any training instance is replaced with a manually curated alternative. This filtering removes 127 candidate tasks (8.4% of the initial evaluation pool). (3) Experiment Model isolation: the Experiment Model MθM_θ is frozen before RL training begins and is not updated based on evaluation-time interactions, ensuring that the surrogate dynamics cannot be tuned to favor benchmark-specific patterns. A TF-IDF separability probe achieves only 53.2% accuracy (near chance) at distinguishing training vs. evaluation tasks. IV-A4 Metrics We adopt two primary metrics: Success Rate (SR), the fraction of tasks where the agent produces a correct final answer through valid tool-use chains; and Success weighted by Path Length (SPL), which penalizes unnecessarily long trajectories. IV-B Main Results Table I presents overall performance across the three difficulty tiers. TABLE I: Overall Success Rate (%) on 6GAgentBench. Best in bold, second best underlined. †: our fine-tuned models. Model Params Success Rate ↑ (%) SR ↑ SPL ↑ L1 L2 L3 Proprietary Models GPT-5 – 72.4 51.3 33.8 50.2 42.7 Claude-Sonnet-4 – 68.9 46.7 28.5 45.8 38.9 Gemini-2.5-Pro – 65.3 44.2 30.1 44.1 37.2 DeepSeek-V3 685B∗ 63.8 42.5 27.6 42.3 35.8 Non-LLM Baselines Threshold-Rule – 51.3 18.6 4.2 22.1 19.8 MAPE-K Heuristic – 54.8 25.7 8.9 27.5 23.4 DRL-Slicing [3] – 38.2 27.3 11.5 24.1 20.6 Open-Source Models Qwen3-VL-72B 72B 58.2 36.4 22.3 36.8 30.5 Llama-4-Scout 109B∗ 55.6 33.8 19.7 34.2 28.1 Qwen3-VL-8B 8B 42.1 24.6 12.8 24.9 19.7 Qwen3-VL-4B 4B 36.5 19.3 9.4 20.3 15.6 SFT on 6G-Forge 6GAgent-8B† 8B 64.7 43.8 34.2 45.3 38.4 6GAgent-4B† 4B 56.3 36.1 25.7 37.5 31.2 SFT + RL on 6G-Forge 6GAgent-8B† +RL 8B 68.2 48.5 39.1 50.1 42.8 6GAgent-4B† +RL 4B 60.8 40.7 30.4 42.0 35.6 ∗Mixture-of-Experts total parameters. Non-LLM baselines. We include three non-LLM baselines to contextualize the difficulty of 6GAgentBench beyond LLM-based approaches. Threshold-Rule implements a fixed-threshold remediation policy: if latency exceeds the SLA bound, switch to URLLC; if throughput drops below 10 Mbps, trigger edge offload. MAPE-K Heuristic extends this with a Monitor–Analyze–Plan–Execute–Knowledge loop that maintains a lookup table of 50 hand-crafted condition→ rules covering common degradation patterns. DRL-Slicing [3] is a prediction-aided deep RL agent originally designed for online power allocation and user admission in RAN slicing, adapted to our environment by mapping its discrete admission and continuous power actions to the nearest Configuration tool calls. All three baselines achieve reasonable L1 performance (38–55%) but degrade sharply on L2/L3, indicating that the benchmark requires capabilities beyond what these fixed-policy and low-dimensional RL approaches can provide. Key findings: (1) All models exhibit sharp performance degradation from L1 to L3, indicating that multi-step tool-use remains a fundamental bottleneck. GPT-5 drops from 72.4% to 33.8%. (2) 6GAgent-8B (SFT+RL) achieves 50.1% overall SR, comparable to GPT-5 (50.2%) despite being an 8B open-source model, while substantially outperforming the larger Qwen3-VL-72B (36.8%). (3) On L3 tasks, 6GAgent-8B (SFT+RL) reaches 39.1% versus GPT-5’s 33.8%, suggesting that closed-loop RL training is particularly beneficial for long-horizon tasks requiring degradation recovery. (4) RL contributes +4.8% overall on top of SFT, with larger gains on L3 (+4.9%) than L1 (+3.5%). IV-C Ablation Studies IV-C1 Training Data Composition We distinguish two trajectory types: open-loop trajectories, where tool outputs are pre-recorded and do not reflect state changes from prior actions; and closed-loop trajectories, where each tool call executes against the Experiment Model and subsequent observations reflect the mutated state. Table I incrementally adds training data components to isolate their contributions. TABLE I: Ablation on Training Data Composition (8B model). Each row adds one component; Δ shows incremental gain. Training Data L1 L2 L3 SR ↑ Δ Baseline (no fine-tuning) 42.1 24.6 12.8 24.9 – Open-loop 6G trajectories 56.2 35.4 24.1 37.0 +12.1 Closed-loop synthetic only 61.3 40.2 29.6 41.8 +4.8 + error recovery 62.8 41.5 31.4 43.1 +1.3 + NS-3 real data (SFT) 64.7 43.8 34.2 45.3 +2.2 + Agentic RL 68.2 48.5 39.1 50.1 +4.8 Each row adds one component; the incremental gains isolate individual contributions. Closed-loop trajectories add +4.8% over open-loop, showing that capturing state mutations from Configuration tools matters. NS-3 real data adds +2.2% overall (+2.8% on L3), recovering physical-layer reasoning that synthetic generation abstracts away. Agentic RL adds +4.8% on top of SFT, with disproportionate L3 gains (+4.9% vs. +3.5% on L1). IV-D Result Analysis Fig. 4 visualizes the main results from three perspectives. Figure 4: Visual analysis of 6GAgentBench results. (a) Performance by difficulty tier. (b) GRPO vs. DAPO RL training on the 4B model. (c) SR vs. SPL. Difficulty-tier breakdown (Fig. 4a). GPT-5 leads on L1 (72.4% vs. 68.2%), but 6GAgent-8B (+RL) surpasses it on L3 (39.1% vs. 33.8%), suggesting that closed-loop RL is particularly beneficial for long-horizon tasks. Base open-source models (Qwen3-8B) struggle across all tiers, highlighting the importance of domain-specific training. RL algorithm comparison (Fig. 4b). We compare GRPO and DAPO on the 4B model over 1.6k RL steps. Both algorithms show rapid initial gains and gradual saturation, but DAPO converges faster and reaches a higher final SR (42.0% vs. 40.8%), benefiting from its dynamic sampling strategy that prioritizes under-explored task types. Efficiency analysis (Fig. 4c). 6GAgent-8B (+RL) achieves the highest SPL (42.8%), slightly exceeding GPT-5 (42.7%), indicating that RL improves both task completion and path efficiency. IV-E NS-3 Grounded Validation A central concern with surrogate-based evaluation is whether agent policies optimized against the Experiment Model MθM_θ transfer to the full-fidelity NS-3 simulator. To quantify this sim-to-sim gap, we replay the tool-call trajectories produced by each model on a held-out subset of 120 tasks (40 per tier) directly in NS-3, where each tool call triggers the corresponding NS-3 API and the resulting network state is measured from the simulator rather than predicted by MθM_θ. TABLE I: NS-3 Grounded Validation. Success Rate (%) under Experiment Model vs. full-fidelity NS-3 replay on 120 held-out tasks. Model MθM_θ ↑ NS-3 ↑ Δ ↓ r ↑ GPT-5 50.0 47.5 −-2.5 0.94 Claude-Sonnet-4 45.8 43.3 −-2.5 0.93 Qwen3-VL-72B 37.5 34.2 −-3.3 0.91 Qwen3-VL-8B 25.0 22.5 −-2.5 0.92 6GAgent-8B (SFT) 45.0 42.5 −-2.5 0.93 6GAgent-8B (SFT+RL) 50.8 47.5 −-3.3 0.92 Threshold-Rule 21.7 21.7 0.0 1.00 MAPE-K Heuristic 28.3 27.5 −-0.8 0.98 Table I reports the results. Three findings emerge. (1) The surrogate gap is small and consistent: across all models, the absolute SR drop from MθM_θ to NS-3 ranges from 0.0% to 3.3%, with a mean gap of 2.2%. The Pearson correlation between MθM_θ-evaluated and NS-3-evaluated SR across all models is r=0.99r=0.99 (p<0.001p<0.001), indicating that MθM_θ preserves the relative ranking of all methods. (2) RL gains transfer to NS-3: the gap for 6GAgent-8B (SFT+RL) is comparable to the SFT-only variant (3.3% vs. 2.5%), and the RL advantage is preserved in NS-3 (47.5% vs. 42.5%, +5.0%). (3) Gap concentrates on L3 degradation recovery: per-tier analysis shows L1 gap below 1%, L2 gap around 2%, and L3 gap around 4%, attributable to transient dynamics (queue draining, handover timing) that MθM_θ approximates but NS-3 simulates at protocol level. This validates MθM_θ as a faithful training proxy while identifying protocol-level transients as the primary fidelity bottleneck for future improvement. (a) Trace Explorer. (b) Decision Analyzer. (c) UAV Trajectory (L3). Figure 5: 6GAgentGym interactive visualization dashboard. (a) Six-dimensional network metrics with SLA overlays. (b) Decision point identification with type distribution. (c) Per-UAV latency heatmap revealing handover-induced spikes. V Conclusion This paper presents 6GAgentGym, a framework integrating an interactive environment with 42 typed tools and a learned Experiment Model, a Self-Instruct data synthesis pipeline (6G-Forge) seeded from NS-3 real data, and a tiered evaluation suite (6GAgentBench). Agentic SFT followed by RL with online closed-loop interaction enables an 8B model to achieve comparable overall performance to GPT-5, with an advantage on long-horizon tasks. Several limitations remain before practical deployment. The Experiment Model approximates NS-3 dynamics but does not capture full protocol-level transients, particularly during handover and failure recovery. The current tool set of 42 covers network slicing and UAV control but excludes radio-level operations such as beamforming and power control. Extending RL to larger trajectory budgets and integrating multi-modal inputs (spectrum visualizations, topology maps) are directions for future work. References [1] O. Aouedi, V. A. Le, K. Piamrat, and Y. Ji (2025-Feb.) Deep learning on network traffic prediction: recent advances, analysis, and future directions. ACM Comput. Surv. 57 (6). External Links: Document Cited by: §I, §I-C. [2] F. Author and S. Author (2026) 6G-bench: an open benchmark for semantic communication and network-level reasoning with foundation models in ai-native 6g networks. arXiv preprint arXiv:2602.08675. Cited by: §I, §I-A, §I-D. [3] Y. Cai, P. Cheng, Z. Chen, M. Ding, B. Vucetic, and Y. Li (2023) Deep reinforcement learning for online resource allocation in network slicing. IEEE Transactions on Mobile Computing 23 (6), p. 7099–7116. Cited by: §I, §I-C, §IV-B, TABLE I. [4] A. Chen, C. Zhang, J. Liu, J. Chen, C. Du, Y. Li, M. Zhong, Q. Wang, Z. Zhu, J. Song, et al. (2026) DIVE: scaling diversity in agentic task synthesis for generalizable tool use. arXiv preprint arXiv:2603.11076. Cited by: §I, §I-B. [5] M. A. Ferrag, A. Lakas, and M. Debbah (2026) α3α^3-bench: a unified benchmark of safety, robustness, and efficiency for llm-based uav agents over 6g networks. arXiv preprint arXiv:2601.03281. Cited by: §I, §I, §I-A, §I-B1. [6] M. A. Ferrag, A. Lakas, and M. Debbah (2026) α3α^3-secbench: a large-scale evaluation suite of security, resilience, and trust for llm-based uav agents over 6g networks. arXiv preprint arXiv:2601.18754. Cited by: §I, §I-A. [7] M. A. Ferrag, A. Lakas, A. Norrdine, and M. Debbah (2026) How small can 6g reason? scaling tiny language models for ai-native networks. arXiv preprint arXiv:2603.02156. Cited by: §I, §I-A. [8] N. Ghafouri, J. S. Vardakas, K. Ramantas, and C. Verikoukis (2024) A multi-level deep RL-based network slicing and resource management for O-RAN-based 6G cell-free networks. IEEE Transactions on Vehicular Technology 73 (11), p. 17472–17484. External Links: Document Cited by: §I, §I-C. [9] Z. Guo, F. Tang, L. Luo, M. Zhao, and N. Kato (2026) A survey on applications of large language model-driven digital twins for intelligent network optimization. IEEE Communications Surveys & Tutorials 28, p. 3388–3411. Cited by: §I, §I-A. [10] C. E. Jimenez, J. Yang, A. Wettig, S. Yao, K. Pei, O. Press, and K. Narasimhan (2023) SWE-bench: can language models resolve real-world GitHub issues?. arXiv preprint arXiv:2310.06770. Cited by: §I, §I-B. [11] M. Li, Y. Zhao, B. Yu, F. Song, H. Li, H. Yu, Z. Li, F. Huang, and Y. Li (2023) Api-bank: a comprehensive benchmark for tool-augmented llms. In Proceedings of the 2023 conference on empirical methods in natural language processing, p. 3102–3116. Cited by: §I-B. [12] R. Li, Z. Zhao, Q. Sun, C. Yang, X. Chen, M. Zhao, H. Zhang, et al. (2018) Deep reinforcement learning for resource management in network slicing. IEEE Access 6, p. 74429–74441. Cited by: §I, §I-C. [13] Z. Liu, T. Hoang, J. Zhang, M. Zhu, T. Lan, S. Kokane, J. Tan, W. Yao, Z. Liu, Y. Feng, et al. (2024) APIGen: automated pipeline for generating verifiable and diverse function-calling datasets. In Advances in Neural Information Processing Systems, Vol. 37, p. 54463–54482. Cited by: §I, §I-B. [14] C. Ma, J. Zhang, Z. Zhu, C. Yang, Y. Yang, Y. Jin, Z. Lan, L. Kong, and J. He (2024) Agentboard: an analytical evaluation board of multi-turn llm agents. In Advances in neural information processing systems, Vol. 37, p. 74325–74362. Cited by: §I-B. [15] A. Maatouk, N. Piovesan, F. Ayed, A. De Domenico, and M. Debbah (2024) Large language models for telecom: forthcoming impact on the industry. IEEE Communications Magazine 63 (1), p. 62–68. Cited by: §I. [16] D. C. Nguyen, M. Ding, P. N. Pathirana, A. Seneviratne, J. Li, D. Niyato, O. Dobre, and H. V. Poor (2022-Jan.) 6G internet of things: a comprehensive survey. IEEE Internet of Things Journal 9 (1), p. 359–383. External Links: Document Cited by: §I. [17] S. G. Patil, T. Zhang, X. Wang, and J. E. Gonzalez (2024) Gorilla: large language model connected with massive APIs. In Advances in Neural Information Processing Systems, Vol. 37, p. 126544–126565. Cited by: §I-B. [18] R. Pegurri, F. Linsalata, E. Moro, J. Hoydis, and U. Spagnolini (2025) Toward digital network twins: integrating sionna rt in ns-3 for 6g multi-rat networks simulations. In IEEE INFOCOM 2025-IEEE Conference on Computer Communications Workshops (INFOCOM WKSHPS), p. 1–6. Cited by: §I-C. [19] S. Qiao, R. Fang, N. Zhang, Y. Zhu, X. Chen, S. Deng, Y. Jiang, P. Xie, F. Huang, and H. Chen (2024) Agent planning with world knowledge model. In Advances in Neural Information Processing Systems, Vol. 37, p. 114843–114871. Cited by: §I-C. [20] Y. Qin, S. Liang, Y. Ye, K. Zhu, L. Yan, Y. Lu, Y. Lin, X. Cong, X. Tang, B. Qian, et al. (2023) ToolLLM: facilitating large language models to master 16000+ real-world apis. arXiv preprint arXiv:2307.16789. Cited by: §I-B. [21] G. F. Riley and T. R. Henderson (2010) The ns-3 network simulator. In Modeling and tools for network simulation, p. 15–34. Cited by: §I-C, §I-B2. [22] T. Schick, J. Dwivedi-Yu, R. Dessì, R. Raileanu, M. Lomeli, E. Hambro, L. Zettlemoyer, N. Cancedda, and T. Scialom (2023) Toolformer: language models can teach themselves to use tools. In Advances in neural information processing systems, Vol. 36, p. 68539–68551. Cited by: §I. [23] Y. Shen, Y. Yang, Z. Xi, et al. (2026) SciAgentGym: benchmarking multi-step scientific tool-use in llm agents. arXiv preprint arXiv:2602.12984. Cited by: §I-B. [24] G. Su, W. Kang, T. Qiu, M. Hou, L. Dong, and C. Wu (2025) Leveraging query-guided submodular icl for intent translation in intent-based networking with large language models. IEEE Internet of Things Journal (), p. 1–1. Note: Early access External Links: Document Cited by: §I, §I-A. [25] S. Sun, H. Song, L. Huang, J. Jiang, R. Le, Z. Lv, Z. Chen, Y. Hu, W. Luo, W. X. Zhao, et al. (2026) SWE-world: building software engineering agents in docker-free environments. arXiv preprint arXiv:2602.03419. Cited by: §I-C. [26] Y. Wang, Y. Kordi, S. Mishra, A. Liu, N. A. Smith, D. Khashabi, and H. Hajishirzi (2023) Self-instruct: aligning language models with self-generated instructions. In Proceedings of the 61st Annual Meeting of the Association for Computational Linguistics (ACL), p. 13484–13508. Cited by: §I-B, §I-C. [27] D. Wu, X. Wang, Y. Qiao, Z. Wang, J. Jiang, S. Cui, and F. Wang (2024) NetLLM: adapting large language models for networking. In Proceedings of the ACM SIGCOMM 2024 Conference, p. 661–678. Cited by: §I. [28] S. Yao, J. Zhao, D. Yu, N. Du, I. Shafran, K. R. Narasimhan, and Y. Cao (2022) React: synergizing reasoning and acting in language models. In The eleventh international conference on learning representations, Cited by: §I-C, §IV-A1. [29] Q. Yu, Z. Zhang, R. Zhu, Y. Yuan, X. Zuo, Y. Yue, W. Dai, T. Fan, G. Liu, L. Liu, et al. (2025) Dapo: an open-source llm reinforcement learning system at scale. arXiv preprint arXiv:2503.14476. Cited by: §I-E2. [30] H. Zhou, C. Hu, Y. Yuan, Y. Cui, Y. Jin, C. Chen, H. Wu, D. Yuan, L. Jiang, D. Wu, et al. (2024) Large language model (LLM) for telecommunications: a comprehensive survey on principles, key techniques, and opportunities. IEEE Communications Surveys & Tutorials 27 (3), p. 1955–2005. Cited by: §I. [31] S. Zhou, F. F. Xu, H. Zhu, X. Zhou, R. Lo, A. Sridhar, X. Cheng, T. Ou, Y. Bisk, D. Fried, et al. (2023) WebArena: a realistic web environment for building autonomous agents. arXiv preprint arXiv:2307.13854. Cited by: §I, §I-B. Appendix A Full Tool Catalog Table IV lists all 42 tools with their typed signatures. Tools are grouped by effect category: Observation (read-only), Reasoning (pure computation), and Configuration (state-mutating). Appendix B Interactive Visualization Dashboard To support trajectory debugging and error analysis, we develop an interactive Streamlit-based dashboard that reads directly from NS-3 CSV traces. Fig. 5 illustrates its three primary views. TABLE IV: Complete tool catalog of 6GAgentGym. Tool Name Input Output Observation (obsV_obs, 16 tools) read_telemetry – TelemetryState check_network_state – NetworkState get_signal_strength Position SignalStrength scan_available_gnbs Position GnbList get_edge_load – EdgeLoad get_slice_status SliceType SliceStatus read_uav_position UavId Position get_battery_level UavId BatteryLevel predict_sla_violation NetworkState SLAPrediction check_handover_status UavId HandoverStatus get_traffic_pattern SliceType TrafficPattern monitor_interference Position InterferenceLevel check_link_quality UavId, GnbId LinkQuality select_recovery_strategy NetworkState, RiskScore RecoveryStrategy get_available_slices Position SliceList check_migration_feasib. UavId, GnbId FeasibilityScore Reasoning (reaV_rea, 22 tools) activate_sensor SensorType SensorHandle risk_assessment TelemetryState RiskScore evaluate_intent_feasib. Intent, NetworkState FeasibilityScore check_geofence Position, GeofenceSpec GeofenceResult path_planning Position×2, NetworkState Waypoints compute_energy_budget Waypoints, BatteryLevel EnergyPlan select_offload_target EdgeLoad, TaskSpec OffloadTarget negotiate_priority UavId×2, Intent PriorityResult set_waypoint UavId, Position WaypointAck adjust_altitude UavId, Altitude AltitudeAck adjust_speed UavId, Speed SpeedAck collision_avoidance UavId, Position, SwarmState AvoidanceCmd swarm_formation SwarmSpec, Waypoints FormationCmd assign_task UavId, TaskSpec TaskAck send_alert UavId, AlertType AlertAck request_handover UavId, GnbId HandoverCmd log_decision DecisionRecord LogAck update_mission_plan MissionSpec, NetworkState MissionPlan broadcast_status UavId, StatusMsg BroadcastAck heartbeat UavId HeartbeatAck verify_sla_compliance NetworkState, SLASpec ComplianceResult validate_mission_compl. MissionSpec, MissionLog ValidationResult Configuration (cfgV_cfg, 4 tools) switch_network_slice SliceType×2 NetworkState graceful_degradation DegradationSpec NetworkState edge_offload TaskSpec, OffloadTarget OffloadResult trigger_slice_realloc. SliceType, ResourceSpec NetworkState