Near-RT RIC: Real-Time RAN Control

• Near-RT RIC is a cloud-native, software-defined control plane in the O-RAN architecture offering closed-loop, sub-second optimization of 5G/6G networks.
• It employs standardized interfaces such as E2, A1, and Y1 to facilitate real-time telemetry, policy distribution, and rapid xApp orchestration.
• The platform integrates AI/ML-driven xApps, containerized microservices, and conflict management to ensure efficient resource allocation and system resilience.

A Near-Real-Time RAN Intelligent Controller (near-RT RIC) is a cloud-native, software-defined platform within the O-RAN architecture responsible for closed-loop, time-sensitive optimization and control of 5G and 6G Radio Access Networks. Operating in the latency regime of 10 ms to 1 s, the near-RT RIC serves as an extensible, programmable control plane for deploying AI-, ML-, and rule-based applications (xApps) that ingest real-time network telemetry, execute optimization or control logic, and enforce decisions across multiple RAN entities via standardized interfaces (Bao et al., 25 Apr 2025).

1. Architectural Placement and Core Functions

The near-RT RIC is logically positioned between the non-RT RIC (latency ≥ 1 s), which handles high-level policy, model training, and long-horizon optimization (rApps), and the distributed or centralized units (O-DU/O-CU) that implement the lower-layer RAN stack. All RAN control loops targeting sub-second response times—dynamic slicing, handover management, interference mitigation, elastic resource allocation—are executed here (Santos et al., 2024, Navidan et al., 15 Feb 2026).

The architectural stack typically consists of:

• E2 Termination (E2T): endpoint for the E2 interface implementing SCTP/E2AP, responsible for protocol/data encoding, decoding, and service model support (e.g., E2SM-KPM for performance measurements, E2SM-RC for control).
• xApp Execution Environment: isolation and orchestration platform (Kubernetes pods, resource quotas); hosts containerized xApps.
• Shared Data Layer (SDL): time-series and relational DB for cross-xApp telemetry and state sharing.
• Subscription Management: coordinates xApp data subscriptions, manages lifecycle.
• Routing/Message Managers: handle internal REST/RMR/Kafka messaging.

The controller is designed for multi-vendor, extensible deployment, with full support for third-party xApps accessing standardized APIs, telemetry, and control primitives (Santos et al., 2024, Almeida et al., 2023).

2. Interfaces, Data Flow, and Latency Requirements

The near-RT RIC is defined by two principal standardized south- and northbound interfaces:

Interface	Direction	Protocol	Purpose	Update Rate
E2	Southbound	E2AP/E2SM	Streaming RAN telemetry, executing control	10–100 ms
A1	Northbound	HTTP/REST	Policy/model distribution from non-RT RIC	1 s–minutes
Y1	Lateral (6G use)	JSON/ASN.1	Exporting radio analytics for AI/infra.	100 ms

The E2 interface enables real-time KPI streaming (per-cell, per-slice, per-UE) and actuation; the A1 interface distributes policies and guides xApp behaviors; the Y1 interface supports 6G cross-domain workload orchestration (Bao et al., 25 Apr 2025, Shah et al., 10 Mar 2025).

End-to-end actuation latency—including data ingestion, inference, and E2 messaging—must be consistently < 100 ms and under 50 ms for many RAN control loops. This is achieved via efficient telemetry streaming (e.g., 10–100 ms E2 report intervals), lightweight neural inference (single- or two-layer MLPs, <2 ms per decision), and edge-centric deployment of latency-critical xApps (Bao et al., 25 Apr 2025, Alimohammadi et al., 1 Dec 2025). Resource-intensive global reasoning (e.g., LLM inference) remains offloaded to the non-RT RIC (Navidan et al., 15 Feb 2026).

3. xApp Lifecycle, Containerization, and Control Loop Design

xApps are containerized microservices (Docker/Kubernetes) orchestrated via the near-RT RIC's AppMgr. Each xApp typically implements the following operational stages:

1. Subscription: Registers for E2SM-KPM/E2SM-RC via SubMgr (RESTful API), specifying required telemetry and reporting periodicity.
2. Inference/Decision: On each E2 Indication event, xApp logic processes input state, may fuse A1 guidance, executes optimization (RL policy, convex solver, rule logic).
3. Control Enforcement: Formats and dispatches E2SM-RC (control) or A1 (policy compliance) messages to actuate decisions.
4. Feedback Loop: Monitors post-control KPIs for stability/convergence, detects anomalies, and triggers retraining or conflict mitigation if required.

xApp development mandates careful attention to (a) strict latency budgets, (b) concurrency and state management (especially when subscribing to overlapping KPIs), (c) performance isolation, and (d) life-cycle hooks for upgrades, rollbacks, and health monitoring (Santos et al., 2024, Almeida et al., 2023).

4. AI/ML Empowered Decision Engines and Data Fusion

The near-RT RIC increasingly leverages advanced AI/ML models, notably:

• Reinforcement Learning xApps: DDPG, PPO, Soft Actor-Critic, and TD3 actor–critic frameworks are deployed for continuous control spaces—typically optimizing resource slicing, load balancing, mobility management, and access control via MDP formulations. Feature vectors ingest real-time E2 telemetry and optionally A1-distributed LLM priors (Bao et al., 25 Apr 2025, Tang et al., 2023, Barker et al., 2 Feb 2025, Yan et al., 17 Sep 2025).
  • Input: preprocessed KPMs, user/load/channel features, non-RT RIC guidance vectors.
  • Output: continuous or discrete control actions (e.g., power splits, PRB quotas, ACB parameters).
  • Model size: 500 KB–8 MB typical (two-layer MLP or GNN-based actor/critics), inference latency: < 2 ms.
• Graph Neural Networks: For multi-user resource allocation, GCNs embed variable-size RAN graphs into fixed-dimensional embeddings, as in xSlice. This supports xApps that dynamically optimize over changing session sets (Yan et al., 17 Sep 2025).
• Hierarchical (LLM-hRIC) Architectures: LLMs in the non-RT RIC derive global, high-level policies and distill them into guidance vectors (e.g., initial power allocation, slice weights) sent to the RL-driven near-RT RIC as bias/priors for faster convergence and improved cooperation (Bao et al., 25 Apr 2025, Navidan et al., 15 Feb 2026).
• Hybrid/Agentic Architectures (Editor’s term): Multi-tier frameworks with LLM agents (non-RT RIC for operator intent parsing, model lifecycle), SLMs (small LLMs) in near-RT RIC for local reasoning/activation/orchestration, and physical-layer agents (WPFMs) for sub-10 ms prediction/control (Navidan et al., 15 Feb 2026).

Fusion strategies combine local telemetry (real-time channel/user/load), global guidance (via A1), and sliding-window histories in configurable, low-latency pipelines (Bao et al., 25 Apr 2025).

5. Conflict Management and Multi-xApp Arbitration

When concurrent xApps issue overlapping or conflicting control actions, the near-RT RIC employs conflict management systems (CMSs), such as:

• Conflict Detection: Monitors pre-action (direct/indirect) and post-action (implicit) conflicts among xApps. Categorizes conflicts using O-RAN’s taxonomy (direct: shared parameter, indirect: coupled parameter groups, implicit: KPI degradation through interaction).
• Conflict Mitigation: Applies policy-driven arbitration (static priority, utility maximization) or game-theoretic bargaining (e.g., Nash Social Welfare or Eisenberg-Gale solutions) to compute Pareto-efficient, fair solutions (Wadud et al., 2023, Adamczyk et al., 2023).
  • NSWF optimizes the product of utilities for fairness; EG allows operator-prioritized weighted sums for efficiency.
  • Experimental results validate real-time adaptivity (<1 s correction latency) and measurable system-wide KPI improvements.
• CMF (Conflict Mitigation Framework): Centralized module that intercepts all E2 control requests, checks for conflicts via rule, time-window, and KPI-based logic, and modifies or blocks actions to safeguard network stability (Adamczyk et al., 2023).

This systematic management ensures time-critical optimization is not destabilized by multi-vendor or adversarial xApps.

6. Security, Resilience, and Future-Proofing

Security is a first-class concern for near-RT RIC deployments:

• Multi-layer Defenses: Dedicated modules implement (a) signature-based E2 message inspection (structural/semantic ASN.1 pattern matching), (b) temporal KPI anomaly detectors (e.g., LSTM networks for telemetry poisoning), and (c) continuous xApp attestation (hash-based challenge–response on memory images). These are integrated with policy-driven mitigation to block, quarantine, or revoke malicious actors (Alimohammadi et al., 1 Dec 2025).
• Overhead: Integrated defenses operate within strict timing (<80 ms overhead for 500 UEs), supporting scale-out with near-linear latency scaling.
• Operational Robustness: Disaggregation enables dynamic placement of latency-critical RIC components and xApps at the edge, with background optimization and failover mechanisms to restore sub-10 ms control loops after node failures or latency spikes (Almeida et al., 2023).
• Resilience to ML Threats: Adversarial ML attacks (e.g., FGSM, PGD) targeting xApps can severely impact system performance if unmitigated; defenses include secure shared data layers, adversarial training, runtime anomaly detection, and attestation (Sapavath et al., 2023).

Future directions include more advanced multi-modal ML integration, model compression and distillation for edge-native inference, federated learning for model robustness, and standardized policy-driven orchestration for horizontally scaling near-RT RICs (Bao et al., 25 Apr 2025, Alimohammadi et al., 1 Dec 2025, Almeida et al., 2023).

7. Empirical Validation and Open Research Challenges

Empirical studies across both simulation (ns-3, ns-O-RAN) and physical testbeds (OAIC, srsRAN, FlexRIC) confirm the effectiveness of near-RT RIC control loops and xApp-based optimization:

• Throughput and SLA Gains: RL-augmented xApps (xSlice, RL-slicing) reduce performance regret by up to 67% and boost cell-edge throughput and application-level QoS by 8–25% over proportional-fair or static heuristics (Bao et al., 25 Apr 2025, Yan et al., 17 Sep 2025).
• Latency: Closed-loop control with contiguous xApp deployments achieves median decision/actuation RTTs < 50 ms, matching RAN SLA requirements.
• Resource Efficiency: Dynamic resource partitioning between RAN and GenAI workloads demonstrates 100% hardware utilization without SLA violations (Shah et al., 10 Mar 2025).
• Adaptivity and Resilience: Disaggregated, orchestrated deployments can restore failed edge loops within 40–70 s, maintaining service continuity (Almeida et al., 2023).

Open challenges include scalable multi-modal/tensor data fusion, domain-specific LLM fine-tuning, continuous RIC co-training, sub-1 s LLM-inference, robust federated/agentic orchestration, dynamic standard/model versioning, and trusted xApp marketplaces (Bao et al., 25 Apr 2025, Navidan et al., 15 Feb 2026, Santos et al., 2024, Almeida et al., 2023).