An LLM-Driven Traffic-Control xApp for Dynamic 5G RAN Intents

Valerio Triolo, Luca Valcarenghi, Emilio PaoliniarXiv 2026 · arXiv

This paper, recently published by researchers at the TeCIP Institute in Italy, explores a novel intersection of generative AI and telecommunications: using Large Language Models (LLMs) to manage 5G network traffic in real-time.

TL;DR

The authors introduce an LLM-driven "xApp" that translates high-level operator goals (intents) into low-level 5G traffic-control configurations. By combining LLM reasoning with a deterministic safety validator, the system achieves a 91% intent satisfaction rate, significantly outperforming traditional static configurations, especially under fluctuating network conditions.

What Problem Does This Paper Address?

Modern 5G networks must simultaneously support diverse applications—like low-latency cloud gaming and high-throughput video streaming—each with different requirements for jitter, packet loss, and speed. Traditionally, network operators manage this using "traffic control" (TC) functions.

However, two major hurdles exist:

  1. Complexity: Mapping a high-level goal (e.g., "ensure smooth video for User A while maximizing background downloads") to specific technical parameters like queue lengths, pacing rates, and classification rules is incredibly difficult.
  2. Rigidity: Conventional solutions use static rules or specialized Machine Learning (ML) models. If the operator’s goals change or a new type of application emerges, these models often require manual redesign or extensive retraining.

Methods

The researchers propose an architecture that integrates an LLM into the near-Real-Time RAN Intelligent Controller (near-RT RIC), a standard component in Open RAN (O-RAN) architectures.

Fig. 1: Architecture and closed-loop workflow of the proposed LLM-driven xApp. Runtime telemetry and service intents are processed by the LLM agent to generate a TC-RAN configuration, which is enforced at the gNB through the E2 interface.

The workflow consists of several key stages:

  • Intent Submission: The operator defines high-level bounds on KPIs (latency, loss, throughput).
  • Asynchronous Inference: The xApp captures a snapshot of the network state (telemetry via the E2 interface) and current configuration. It sends this, along with the intent, to an LLM (specifically Qwen3-8B). Crucially, this happens asynchronously so that the data plane (packet forwarding) is never blocked.
  • Policy Validation: Because LLMs can "hallucinate" or produce invalid syntax, the output passes through a Policy Validator. This deterministic stage checks the JSON output against a whitelist of allowed actions and "clips" numerical values (like queue delays) to safe ranges.
  • Enforcement: The validated policy is translated into control messages and sent to the 5G base station (gNB) to reconfigure the traffic-control pipeline (e.g., CoDel queues, shapers, and pacers).

Datasets

The study does not use a static dataset but rather a live OpenAirInterface (OAI) 5G software stack environment.

  • Traffic Workload: Generated using iperf3, combining a time-sensitive UDP flow (simulating gaming/voice) and multiple background TCP flows.
  • Generalization Test: To see if the LLM could handle "unseen" scenarios, the authors used Latin Hypercube Sampling to generate five unique service intents with varying KPI thresholds and priorities that the model hadn't encountered during initial testing.

Key Insights and Ideas

  • LLMs as Policy Selectors, Not Allocators: The paper argues that LLMs shouldn't be used for millisecond-level resource scheduling. Instead, they excel as a "reasoning layer" that selects the best strategy (the pipeline of components) based on high-level context.
  • The Safety Boundary is Essential: The deterministic validator is what makes this "production-ready." It ensures that even if the LLM suggests something nonsensical, the network remains stable by falling back to a default safe configuration.
  • Zero-Shot Adaptability: Unlike Reinforcement Learning models that need to be retrained for new KPIs, the LLM-driven approach can accommodate new requirements simply by changing the text in the "system prompt."

Key Results

The primary metric used is the Intent Satisfaction Ratio (ISR)—the percentage of time all intent constraints are met.

  • Dynamic Adaptation: Under changing intents (switching from throughput-heavy to reliability-heavy), the LLM-driven xApp achieved an average ISR of 0.91, compared to just 0.52 for a static baseline.
  • Resilience to Channel Noise: When the radio channel quality (CQI) dropped, the LLM controller maintained an ISR of ~0.88 by dynamically introducing traffic shaping to protect sensitive flows. The static baseline plummeted to ~0.4.
Fig. 2: Temporal evolution of the Intent Satisfaction Ratio (ISR) under runtime intent changes, following a throughput– reliability–throughput sequence.
  • Performance Overhead: Using Qwen3-8B, a policy decision took roughly 1.47 seconds. While too slow for the "real-time" data plane, it is well within the requirements for the "near-real-time" control loop (0.1s to 1s+).

Limitations and Future Work

The authors acknowledge several areas for growth:

  • Scalability: The current experiments focus on a single User Equipment (UE). Real-world cells have hundreds of users with conflicting requirements.
  • Inference Latency: While 1.47s is acceptable for some tasks, the authors suggest that fine-tuning smaller, specialized models (SLMs) could reduce this latency and the memory footprint.
  • Memory: The current system doesn't "remember" past successful decisions. Future work could involve caching or memory techniques to speed up recurring scenarios.

Summary updated

Abstract

Programmable Radio Access Networks (RANs) enable runtime deployment of traffic-control functions, but selecting the appropriate configuration remains challenging as network conditions and service requirements change over time. Conventional solutions often rely on static rules or learning-based controllers with predefined state and action spaces, limiting their ability to accommodate changing intents. This paper introduces an LLM-driven xApp for traffic control in programmable RANs. The proposed architecture combines operator-defined service intents, runtime E2 interface telemetry, and the currently deployed configuration to generate traffic-management policies without blocking packet forwarding or the processing of incoming E2 measurements during LLM inference. Experiments on an OpenAirInterface 5G environment show that the proposed controller dynamically adapts the traffic-control pipeline to runtime intent changes, achieving an average intent satisfaction ratio of 0.91, compared with 0.52 for a static TC-RAN configuration. When channel conditions degrade, the controller maintains an intent satisfaction ratio of approx. 0.88, compared with approx. 0.4 for the static baseline.
BibTeX
@misc{triolo2026llm,
  author = {Valerio Triolo and Luca Valcarenghi and Emilio Paolini},
  title = {{An LLM-Driven Traffic-Control xApp for Dynamic 5G RAN Intents}},
  year = {2026},
  eprint = {2611.25736},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2611.25736},
}
Figure