6G Sandbox: Experimental Network Platforms

• 6G sandbox is a class of experimental environments enabling prototyping, simulation, and validation of advanced network protocols and integrated AI components.
• These platforms emphasize modular design, interface decoupling, and closed-loop adaptation, linking abstract research intent with scalable implementation.
• Key applications include automated ns-3 simulations, GPU-based ray tracing for cell-free networks, semantic and quantum communication workflows, and agentic network management.

A 6G sandbox is a research environment for prototyping, simulating, validating, and analyzing sixth-generation network functions before real-world implementation. In the literature summarized here, the term spans at least four distinct but related forms: a fully automated, multi-agent framework that translates free-form user requirements into end-to-end ns-3 simulations and executes them with 5G-LENA; an open-source end-to-end ray-tracing simulator for cell-free 6G wireless networks; a prototype testbed for integrated generative AI, quantum computing, and semantic communication; and a closed-loop network-management environment built around tool execution and a learned environment proxy (Rezazadeh et al., 17 Mar 2025, Tärneberg et al., 2023, Arfeto et al., 17 Jan 2025, Chen et al., 31 Mar 2026). Taken together, these systems define a 6G sandbox as an extensible experimental substrate in which channel models, protocol stacks, AI components, and control policies can be exercised under reproducible conditions.

1. Conceptual scope and distinguishing characteristics

Within the cited work, a 6G sandbox is not a single software pattern but a class of experimental platforms organized around full-stack controllability. The generative simulation framework is described as a “fully automated, multi-agent framework” that translates free-form requirements into ns-3 simulations, executes them using the 5G-LENA module, and delivers human-readable insights (Rezazadeh et al., 17 Mar 2025). LuSim is described as an “open-source end-to-end ray-tracing simulator” engineered to serve as a 6G sandbox for both physical-layer propagation research and system-level protocol design (Tärneberg et al., 2023). GenSC-6G is presented as a “prototype testbed” for a dataset and workflow spanning data generation, semantic encoding, generative-AI and quantum interfaces, communication channels, and goal-oriented decoders (Arfeto et al., 17 Jan 2025). 6GAgentGym is explicitly framed as a “6G sandbox environment supporting closed-loop tool execution, observation of state changes, and adaptive decision-making” (Chen et al., 31 Mar 2026).

These instances share a common structural property: they expose a manipulable intermediate environment between abstract research intent and hardware deployment. This suggests that the defining criterion of a 6G sandbox is not merely simulation fidelity, but the presence of a reusable loop linking specification, execution, feedback, and refinement. A plausible implication is that the term increasingly encompasses both classical simulators and agent-oriented, AI-native experimental environments.

2. Recurrent architectural patterns

Across the four systems, several architectural motifs recur. One is explicit modular decomposition. The generative ns-3 framework orchestrates four specialized agents—Simulation Generation, Test Designer, Test Executor, and Result Interpretation—under LangChain, with shared state and iterative refinement (Rezazadeh et al., 17 Mar 2025). LuSim divides its implementation into Configuration, a Unity Module for the PHY layer, and a Python System Simulator for MAC and above, coupled through a ZeroMQ proxy (Tärneberg et al., 2023). GenSC-6G organizes its workflow into five major modules: Data Generation, Semantic Encoder / Compressor, Generative-AI & Quantum Interfaces, Communication Channel, and Semantic Decoder / Goal-Oriented Task Blocks (Arfeto et al., 17 Jan 2025). 6GAgentGym centers its design on an Interactive Environment Interface, a Tool Registry, and an Experiment Model $M_\theta$ (Chen et al., 31 Mar 2026).

A second motif is decoupling through interfaces. In LuSim, both physical and system layers are decoupled by a network interface, which allows new radio-resource schemes to be plugged in with minimal overhead (Tärneberg et al., 2023). In GenSC-6G, backbone, compressor, channel, and decoder blocks are modular Python classes, and new goal tasks are introduced by subclassing GoalTask (Arfeto et al., 17 Jan 2025). In 6GAgentGym, tools have typed inputs and outputs drawn from a type hierarchy $\mathcal H$, and the state transition is mediated by the learned surrogate $M_\theta$ (Chen et al., 31 Mar 2026). In the generative ns-3 sandbox, parameterized and templated components plus persistent history make the environment reusable (Rezazadeh et al., 17 Mar 2025).

A third motif is closed-loop adaptation. The ns-3 framework loops error reports and KPI failures back to the Simulation Generation Agent (Rezazadeh et al., 17 Mar 2025). LuSim permits the MAC to request a fresh $H$ snapshot at any instant and adapt user–AP associations on the fly (Tärneberg et al., 2023). GenSC-6G optimizes goal-task utility under rate and distortion constraints (Arfeto et al., 17 Jan 2025). 6GAgentGym is built around sequential tool use until intent verification or a step budget is reached (Chen et al., 31 Mar 2026). This suggests that the modern 6G sandbox is oriented less toward static benchmarking than toward interactive experimental control.

Sandbox instance	Core substrate	Primary focus
Generative ns-3 framework	LangChain + ns-3 + 5G-LENA	Automated simulation generation and analysis
LuSim	Unity + ZeroMQ + SimPy	Cell-free propagation and system-level co-simulation
GenSC-6G	Modular Python testbed	Semantic, generative-AI, and quantum communication
6GAgentGym	Tool registry + Experiment Model	Closed-loop network management

3. Generative simulation sandbox with ns-3 and 5G-LENA

The framework in “Toward Generative 6G Simulation: An Experimental Multi-Agent LLM and ns-3 Integration” defines a 6G sandbox as a pipeline from natural-language requirements to validated ns-3 scenarios (Rezazadeh et al., 17 Mar 2025). LangChain orchestrates four agents. The Simulation Generation Agent transforms high-level natural-language requirements into syntactically correct ns-3 C++ scripts using a structured chain-of-thought prompting strategy and retrieval-augmented generation. The Test Designer Agent auto-generates unit and edge test cases, including UE attachment, QoS checks, and high-mobility stress tests. The Test Executor Agent deploys and runs simulation and test harness across local or cloud hosts, using FlowMonitor, custom trace parsers, and pcap readers to capture throughput, latency, and loss. The Result Interpretation Agent correlates numeric KPIs with network conditions and outputs human-readable diagnostics.

The simulation-generation procedure is explicitly decomposed into extraction of parameters

$$P = \{f, B_w, N_{UE}, protocol, mobility\_model,\ldots\},$$

mapping to ns-3 constructs, and iterative assembly of code blocks. Retrieval is grounded in a Pinecone index of documentation excerpts, ranked by cosine similarity,

$$\text{score}(q,d_i)=\frac{v_q \cdot v_{d_i}}{\|v_q\| \; \|v_{d_i}\|}.$$

The integration target is the ns-3 5G-LENA module. User specifications such as “100 UEs, gNB @28 GHz, 200 MHz” fill template placeholders for node containers, channel models including 3GPP UMi, and helper classes such as NrHelper and SpectrumPhy. Compilation is invoked through CppSubprocessTool, for example ./waf --run scratch/my6g_sandbox.cc, and Python bindings can be used through PythonREPLTool during debugging.

The reported case study is a 5G-NR UMi microcell case with 100 UEs, beamforming, and TCP traffic. The aggregated metrics are: Avg. Iterations to convergence 1.8, Syntax Error Rate 17.0%, Mean Response Time 7.3 s, Human Evaluation Score 7.5, and Pass Rate (Pass@5) 0.72 (Rezazadeh et al., 17 Mar 2025). The source text states that low iteration count shows that the CoT+RAG approach produces near-correct code on first draft, that a 17% syntax error rate is markedly lower than unguided LLM code generation, and that sub-10 s mean latency keeps the iterative workflow responsive. Because those interpretations are provided directly in the source material, they form part of the claimed significance of the sandbox rather than an external extrapolation.

4. Ray-tracing and end-to-end cell-free sandbox

LuSim operationalizes the 6G sandbox concept through a coupling of channel realism and system-level control (Tärneberg et al., 2023). Its architecture has three major components. Configuration files in JSON/YAML specify large-scale-channel-model parameters, physical/radio parameters, and scenario definitions. A Unity-based PHY-layer module performs interactive GPU-accelerated ray casting, multi-path component spawning, path gain computation, and channel-matrix generation $H$. A discrete-event SimPy-based Python engine controls time, sends commands such as UE movement and beam updates, and consumes the generated channels to implement MAC protocols, resource allocation algorithms, federations, beam-training procedures, feedback loops, and application-layer services including WPT, positioning, and sensing.

The channel model is a hybrid GSCM/exhaustive-casting formulation: $$H(f)=\sum_{\ell=1}^{L}\alpha_\ell e^{-j2\pi f\tau_\ell} a_{tx}(\theta_\ell)a_{rx}^H(\phi_\ell).$$ Here $\alpha_\ell$ includes the log-distance path loss

$PL_\ell = PL_0 + 10\,n\,\log_{10}(d_\ell/d_0),$

plus a Gamma-distributed shadow-fading term with exponential autocorrelation; $\mathcal H$0 is determined by the total ray path length divided by $\mathcal H$1; and array steering vectors parameterize transmitter and receiver responses. Frequency selectivity is captured by sampling $\mathcal H$2 over FFT points. Large Intelligent Surfaces are modeled as a special MIMO array, where each LIS element is a virtual antenna contributing additional MPCs and specular reflections with tunable phase shifts for RIS emulation.

The ray-tracing engine uses Unity’s optimized GPU ray-casting pipeline rather than classical CPU-bound ray tracing. MPC spawning follows the COST IRACON model; path gain combines distance-based decay, angular-dependent reflection loss, random large-scale fading, and diffraction; diffuse components arise from jittered surface normals and small random angular spreads; and a direct ray per timestep is used to detect dynamic line-of-sight obstructions for moving UEs. Scenario description is fully externalized in JSON/YAML, covering environment meshes, material properties, node placements, mobility patterns, frequency bands, antenna patterns, and cell-free federations.

The reported validation metrics are specific. Delay-spread and Doppler-spread statistics match published urban measurement campaigns within 1 dB. Path-loss exponent and shadow-fading variance align with 3GPP UMi and UMa models to within 0.5 dB. In a 16-AP, 32-UE cell-free scenario at 28 GHz, throughput gains of 20–30% over conventional cellular layouts were observed under a proportional-fair scheduler. End-to-end latency in an interactive run remains under 100 ms for up to 100 UEs on a GPU desktop (Tärneberg et al., 2023). These data establish the intended role of the sandbox as both a propagation emulator and a system-level experimentation platform.

5. Semantic, generative-AI, and quantum communication sandbox

GenSC-6G extends the sandbox concept from radio simulation to goal-oriented communication workflows (Arfeto et al., 17 Jan 2025). Its overall architecture includes Data Generation, a Semantic Encoder / Compressor, Generative-AI & Quantum Interfaces, a Communication Channel supporting Classical JSCC and Quantum JSCC, and a Semantic Decoder / Goal-Oriented Task stage. The classical noise-augmented channel model is

$\mathcal H$3

The semantic encoder and decoder are specified as

$\mathcal H$4

$\mathcal H$5

The dataset generation pipeline consists of prompt-driven diffusion models, forward noising

$\mathcal H$6

reverse diffusion guided by text embeddings, auto-labelling via pretrained detectors such as SAM and YOLO, feature extraction through backbone networks, and noise injection. Classical perturbation is represented as

$\mathcal H$7

and the quantum perturbation for the QSC dataset is

$\mathcal H$8

Hybrid quantum-classical layers are inserted after the classical encoder, using amplitude embedding, entanglement via CNOT cascade, and parameterized rotations $\mathcal H$9, with interface via PennyLane/Qiskit to QPU over gRPC.

The semantic communication objective is given in terms of semantic rate $M_\theta$0 and semantic distortion $M_\theta$1, with rate-distortion constraint

$M_\theta$2

and the goal-oriented trade-off

$M_\theta$3

The reported case studies span lightweight classification, semantic upsampling, edge LLM inference, and semantic localization. For lightweight classification, backbones include ViT-L-32, ResNet-50, and EfficientNet-B1 under AWGN at SNR $M_\theta$4 dB, with Accuracy, F1, and Recall as metrics. The excerpted results include ResNet-50 at 10 dB with Accuracy 84.47%, F1 $M_\theta$5, Recall $M_\theta$6, and EfficientNet-B1 at 10 dB with Accuracy 86.89%, F1 $M_\theta$7 (Arfeto et al., 17 Jan 2025). For semantic upsampling, LPIPS and PSNR are reported against SNR, with ResNet+FeatUp showing lower LPIPS and PSNR rising from approximately 20 dB to 30 dB as channel SNR increases. For edge LLM inference, BLIP-2 and LLaMA-3 are used with CLIP-S alignment score, including LLaMA-3 on Image 1 at approximately 35.52. For semantic localization, YOLO detection and pixel-level segmentation are evaluated using IoU and Mean Pixel Accuracy.

As a sandbox, GenSC-6G is defined by plug-and-play modules for diffusion, GAN, PQC, encoder backbones, compressors, channels, and semantic decoders, together with end-to-end metrics under classical and quantum noise (Arfeto et al., 17 Jan 2025). This suggests a broadening of the 6G sandbox notion beyond network simulation toward programmable semantic-communication experimentation.

6. Closed-loop management sandbox and agentic evaluation

6GAgentGym frames the 6G sandbox as a closed-loop environment for network management rather than a conventional simulator (Chen et al., 31 Mar 2026). At each time step $M_\theta$8, the system takes the current network state $M_\theta$9 and operator intent $H$0, the agent selects a typed tool $H$1 with arguments $H$2, the call is submitted to the Experiment Model $H$3, and the model returns tool result $H$4 and updated state $H$5. The loop continues until intent verification or a maximum number of steps. The tool registry has $H$6 typed tools partitioned into observation tools $H$7 with $H$8, reasoning tools $H$9 with $$P = \{f, B_w, N_{UE}, protocol, mobility\_model,\ldots\},$$0, and configuration tools $$P = \{f, B_w, N_{UE}, protocol, mobility\_model,\ldots\},$$1 with $$P = \{f, B_w, N_{UE}, protocol, mobility\_model,\ldots\},$$2.

The Experiment Model operates over a six-dimensional state space

$$P = \{f, B_w, N_{UE}, protocol, mobility\_model,\ldots\},$$3

where $$P = \{f, B_w, N_{UE}, protocol, mobility\_model,\ldots\},$$4 is active slice type, $$P = \{f, B_w, N_{UE}, protocol, mobility\_model,\ldots\},$$5 latency, $$P = \{f, B_w, N_{UE}, protocol, mobility\_model,\ldots\},$$6 jitter, $$P = \{f, B_w, N_{UE}, protocol, mobility\_model,\ldots\},$$7 loss rate, $$P = \{f, B_w, N_{UE}, protocol, mobility\_model,\ldots\},$$8 throughput, and $$P = \{f, B_w, N_{UE}, protocol, mobility\_model,\ldots\},$$9 edge-compute load. Its predictive form is

$$\text{score}(q,d_i)=\frac{v_q \cdot v_{d_i}}{\|v_q\| \; \|v_{d_i}\|}.$$0

and it is calibrated on NS-3 simulation traces through the supervised loss

$$\text{score}(q,d_i)=\frac{v_q \cdot v_{d_i}}{\|v_q\| \; \|v_{d_i}\|}.$$1

Only tools in $$\text{score}(q,d_i)=\frac{v_q \cdot v_{d_i}}{\|v_q\| \; \|v_{d_i}\|}.$$2 mutate the network state: $$\text{score}(q,d_i)=\frac{v_q \cdot v_{d_i}}{\|v_q\| \; \|v_{d_i}\|}.$$3

The data synthesis pipeline, 6G-Forge, bootstraps closed-loop trajectories from NS-3 seeds via iterative Self-Instruct with execution verification. It begins from raw NS-3 traces, uses a teacher LLM to annotate seed trajectories, expands them iteratively into new tasks and tool sequences, verifies them step-by-step on $$\text{score}(q,d_i)=\frac{v_q \cdot v_{d_i}}{\|v_q\| \; \|v_{d_i}\|}.$$4, retains both golden and recovery trajectories, filters near-duplicates by ROUGE-L, and outputs a synthetic corpus $$\text{score}(q,d_i)=\frac{v_q \cdot v_{d_i}}{\|v_q\| \; \|v_{d_i}\|}.$$5 (Chen et al., 31 Mar 2026). Agentic SFT is then performed on $$\text{score}(q,d_i)=\frac{v_q \cdot v_{d_i}}{\|v_q\| \; \|v_{d_i}\|}.$$6, reported as 53,000 trajectories with 30% L1, 45% L2, and 25% L3. Reinforcement learning uses DAPO or GRPO with reward

$$\text{score}(q,d_i)=\frac{v_q \cdot v_{d_i}}{\|v_q\| \; \|v_{d_i}\|}.$$7

where $$\text{score}(q,d_i)=\frac{v_q \cdot v_{d_i}}{\|v_q\| \; \|v_{d_i}\|}.$$8 penalizes malformed calls and $$\text{score}(q,d_i)=\frac{v_q \cdot v_{d_i}}{\|v_q\| \; \|v_{d_i}\|}.$$9 indicates successful intent satisfaction at episode end.

The benchmark results are central to the sandbox’s purpose. The primary metrics are Success Rate (SR) and Success-weighted by Path Length (SPL), with L1 tasks at $H$0 steps, L2 at 4–7 steps, and L3 at $H$1 steps. Reported overall results include GPT-5 with SR 50.2% and SPL 42.7%; Qwen3-VL-72B with SR 36.8%; 6GAgent-8B (SFT only) with SR 45.3%; and 6GAgent-8B + RL with SR 50.1% and SPL 42.8%, including L3 performance 39.1%, which is stated to outperform GPT-5 on L3 (Chen et al., 31 Mar 2026). On 120 held-out tasks replayed in NS-3, the mean SR drop from surrogate to NS-3 is 2.2%, with Pearson $H$2 between surrogate and NS-3 evaluations. These values define the claimed fidelity of the sandbox as an evaluation proxy.

7. Research uses, boundaries, and emerging interpretation

The cited systems support different research workloads. The generative ns-3 sandbox is oriented toward simulation generation, debugging, execution, and KPI interpretation from natural-language specifications (Rezazadeh et al., 17 Mar 2025). LuSim targets physical propagation research and system-level protocol design for cell-free deployments, with support for MIMO, LIS/RIS, WPT, positioning, and sensing (Tärneberg et al., 2023). GenSC-6G supports synthetic data generation and evaluation for semantic decoding, classification, localization, semantic upsampling, and edge-based language inference under classical and quantum noise (Arfeto et al., 17 Jan 2025). 6GAgentGym supports autonomous network management research through typed tool use, data synthesis, and long-horizon agent training in a closed loop (Chen et al., 31 Mar 2026).

The main conceptual boundary is that these platforms instantiate different layers of the 6G stack. One focuses on ns-3 scenario synthesis, one on propagation and MAC co-simulation, one on semantic and quantum communication pipelines, and one on operator-intent-driven management. It would therefore be inaccurate to treat “6G sandbox” as the name of a single canonical framework. Instead, the term denotes a family of modular, reusable, and feedback-rich experimental environments.

A common misconception is that a 6G sandbox must be limited to PHY-layer simulation. The cited work contradicts that view: some sandboxes are explicitly end-to-end; some integrate semantic decoders and quantum interfaces; and some are constructed as agentic control environments rather than radio simulators (Tärneberg et al., 2023, Arfeto et al., 17 Jan 2025, Chen et al., 31 Mar 2026). Another plausible implication is that future 6G sandbox design will continue to merge environment simulation with LLM-mediated control and evaluation. That implication is consistent with the stated future directions of expanding the tool set, introducing multi-modal inputs, and tightening surrogate-to-sim fidelity in 6GAgentGym, as well as the reusable parameterization and extensibility emphasized in the other systems (Chen et al., 31 Mar 2026, Rezazadeh et al., 17 Mar 2025).

In this broader sense, a 6G sandbox is best understood as an experimental infrastructure for controlled hypothesis testing across network design, protocol behavior, semantic utility, and autonomous operations. The surveyed work shows that the term now covers environments ranging from GPU ray tracing and ns-3 automation to semantic communication prototypes and closed-loop management benchmarks, all linked by reproducibility, modularity, and iterative feedback.