🤖 AI

Agentic AI for Bilevel Long-Term Optimization of Policy-Driven Physical Layer Systems

This paper introduces Agentic-LTPO, a nested bilevel optimization framework that leverages agentic AI to dynamically configure physical layer problems based on evolving policies and historical experiences, demonstrating a 57.2% improvement in long-term performance for cell-free MIMO beamforming compared to traditional methods.

Original authors: Bingnan Xiao, Chenhao Yang, Wei Ni, Xin Wang, Tony Q. S. Quek

Published 2026-06-24

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Bingnan Xiao, Chenhao Yang, Wei Ni, Xin Wang, Tony Q. S. Quek

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine a massive, high-tech wireless network as a giant orchestra. In this orchestra, the cell towers (Access Points) are the musicians, the phones are the audience, and the signal beams are the music being played.

For a long time, conducting this orchestra was rigid. The conductor (the network operator) would write a fixed score: "Play loud!" or "Save energy!" Once the score was written, the musicians played it exactly that way until the conductor changed the whole sheet music. The problem? Real life is messy. Sometimes the audience wants a rock concert (high speed), and five minutes later, they want a quiet jazz session (energy saving). If the conductor can't change the score fast enough, the music suffers.

This paper introduces a new kind of conductor called Agentic-LTPO. Instead of just reading a score, this conductor is an AI agent that thinks, learns, and adapts in real-time.

Here is how it works, broken down into simple concepts:

1. The Two-Speed Brain (Bilevel Optimization)

The system has two "brains" working at different speeds:

The Slow Brain (The Strategist): This is the Agentic AI. It thinks in "big picture" chunks (like every 20 minutes). It listens to the operator's natural language requests (e.g., "Prioritize video calls right now" or "Save battery life"). It doesn't touch the radio waves directly; instead, it sets the rules for the game.
The Fast Brain (The Tactician): This is the traditional math solver. It works in "milliseconds." It takes the rules set by the Slow Brain and instantly calculates exactly how to beam the signals to the phones to follow those rules perfectly.

The Analogy: Think of a General and a Soldier. The General (Slow Brain) looks at the map and says, "We need to secure the hill by noon, but conserve ammo." The Soldier (Fast Brain) immediately figures out the specific steps to climb that hill without wasting a single bullet. The General doesn't tell the Soldier how to step; the General just sets the goal.

2. The "Memory Book" (Retrieval-Augmented Generation)

The AI isn't just guessing. It has a Memory Book (called a RAG module).

When the General gets a new order, it doesn't just make it up. It flips through its Memory Book to find past situations that were similar.
Example: If the order is "Save energy," the AI checks its book: "Last time we tried to save energy, we turned off half the towers, but the signal dropped too low. Let's try turning down the power slightly instead."
This prevents the AI from making the same mistakes twice.

3. The "Editor and Critic" Team (Multi-Agent Collaboration)

The paper doesn't use just one AI; it uses a team of four specialized AI agents working together:

The Interpreter: Translates the human's messy English ("Make it faster!") into a strict, mathematical list of rules.
The Observer: Looks at what happened in the last round and says, "Hey, we were too aggressive last time; the towers were overheating."
The Planner: Proposes a new set of rules based on the Interpreter and Observer.
The Critic: This is the most important part. The Critic acts like a strict editor. It looks at the Planner's new rules and checks them against the Memory Book.
- The Critic asks: "Does this plan look like something that worked before? Is it safe?"
- If the plan looks risky, the Critic sends it back to the Planner to fix it. This loop happens until the plan is perfect.

4. The Results: Why It Matters

The researchers tested this system in a simulated city with 16 cell towers and 8 users. They compared their new "Agentic" system against:

Static Strategy: A system that never changes its settings.
Single Agent: A system with just one AI trying to do everything alone.
No Memory: A system that forgets its past experiences.

The Outcome:
The Agentic-LTPO system was 57.2% better at keeping the network happy over the long run compared to the old static methods.

When the operator wanted speed, the system aggressively boosted performance.
When the operator wanted to save energy, the system calmly dialed it back.
Crucially, it did this without crashing or making mistakes, because the "Critic" agent kept it in check.

Summary

This paper proposes a way to make wireless networks smart enough to listen to human goals and adaptable enough to change their strategy on the fly, all while using a "team of AI" to double-check that the new strategy is safe and effective. It turns a rigid, pre-programmed machine into a flexible, learning partner that can handle the unpredictable nature of real-world networks.

Technical Summary: Agentic AI for Bilevel Long-Term Optimization of Policy-Driven Physical Layer Systems

1. Problem Statement

Future wireless networks face increasing complexity due to dense connectivity, diverse service requirements, and software-defined operations. A critical challenge arises from the dynamic nature of network operator policies, intents, and Key Performance Indicators (KPIs), which can change over time (e.g., shifting from throughput maximization to energy efficiency).

Existing physical-layer control frameworks suffer from two main limitations:

Fixed Objectives: Classical model-based solvers and Deep Reinforcement Learning (DRL) methods are typically designed with pre-specified utility or reward functions. When operator intents change, these systems require manual reconfiguration and retraining, rendering them ineffective in non-stationary environments.
Real-Time Constraints: While Large Language Models (LLMs) and Agentic AI show promise in interpreting natural language intents, directly applying them to generate instantaneous physical-layer decisions (e.g., beamforming vectors) is infeasible due to strict real-time latency and numerical feasibility requirements under instantaneous Channel State Information (CSI).

The paper addresses the need for a framework that can adaptively update physical-layer optimization configurations in response to evolving operator policies while maintaining the optimality and low latency of instantaneous physical-layer decisions.

2. Methodology: Agentic-LTPO Framework

The authors propose Agentic long-term performance optimization (Agentic-LTPO), a nested bilevel optimization framework designed to decouple long-term policy adaptation from short-term physical-layer execution.

A. Nested Bilevel Structure

The problem is formulated as a two-timescale optimization:

Upper Level (Slow Timescale): Operates over large time intervals ( $N$ intervals, each containing $T_s$ slots). An Agentic AI system interprets operator policies (natural language), summarizes network behavior, and retrieves historical experiences to generate a structured configuration vector $c^{(n)}$ . This vector defines the constraints and targets for the lower level (e.g., target robust QoS levels $\Gamma^{(n)}_k$ and AP power-budget exposure factors $\phi^{(n)}_\ell$ ).
Lower Level (Fast Timescale): Operates on a per-slot basis ( $t \in \mathcal{T}$ ). Given the configuration $c^{(n)}$ from the upper level, a fast solver computes instantaneous beamforming decisions to minimize transmit power subject to robust QoS constraints and per-AP power limits, using imperfect CSI.

B. Upper-Level Multi-Agent Architecture

To translate heterogeneous inputs (natural language policies, environment summaries, historical data) into feasible configurations, the upper level employs a coordinated multi-agent system with four distinct roles:

Policy Interpreter ( $A_{int}$ ): Converts natural language operator policies into a structured, machine-readable JSON context. It utilizes a Retrieval-Augmented Generation (RAG) module to retrieve relevant historical policy evidence, ensuring consistency and resolving ambiguities.
Network Observer ( $A_{obs}$ ): Analyzes the performance of the previous interval (operating statistics and semantic diagnosis) to summarize the current network state and identify bottlenecks.
Configuration Planner ( $A_{plan}$ ): Proposes candidate configuration adjustments based on the current policy context and network state.
Performance Critic ( $A_{crit}$ ): Evaluates the planner's candidate configurations against retrieved historical case evidence (similar past operating regimes). It acts as a verification loop, accepting the configuration if it aligns with empirical evidence or requesting corrections from the planner.

This Planner-Critic refinement loop ensures that configurations are not generated in isolation but are grounded in accumulated operational evidence.

C. Lower-Level Optimization

For the specific use case of Cell-Free (CF) MIMO downlink beamforming, the lower level solves an energy-minimization problem.

Robustness: The system accounts for CSI uncertainty using a norm-bounded error model.
Efficiency: By adopting a Zero-Forcing (ZF) beamforming structure, the authors derive a closed-form worst-case Signal-to-Interference-plus-Noise Ratio (SINR) bound. This transforms the robust beamforming problem into a linear programming problem, solvable with global optimality and linear complexity, meeting strict per-slot latency requirements.

3. Key Contributions

The paper outlines the following specific contributions:

Formulation: It formulates adaptive physical-layer control under changing policies as a nested bilevel problem, decoupling policy interpretation (large timescale) from instantaneous optimization (small timescale).
Multi-Agent Design: It designs a multi-agent collaboration architecture (Interpreter, Observer, Planner, Critic) with a RAG module to convert policy inputs and historical experience into physically feasible configuration parameters.
Verification Mechanism: It introduces a planner-critic refinement loop where the Critic agent uses retrieved case evidence to validate and refine candidate configurations before deployment, reducing decision errors.
Efficient Solver: It reveals that the robust energy-minimization problem for CF-MIMO admits a closed-form worst-case SINR bound under a ZF criterion, enabling an efficient per-slot solver with global optimality.

4. Experimental Results

The framework was evaluated on a CF-MIMO system with 16 distributed APs serving 8 users under both random and piecewise-stationary operator policy settings.

Performance Gain: Agentic-LTPO improved the cumulative communication utility by 57.2% compared to a static baseline strategy.
Policy Adaptability: Unlike static strategies or single-agent controllers, Agentic-LTPO successfully tracked shifting policy regimes (e.g., switching between throughput-oriented and energy-saving modes), adjusting configuration parameters (QoS targets and power budgets) accordingly.
Component Analysis: Ablation studies demonstrated that removing either the RAG module or the Critic agent degraded performance, confirming that both historical evidence retrieval and the refinement loop are essential for sustained adaptation.
Robustness: The framework maintained high performance and low QoS violation ratios even under service-load stress (varying AP densities), outperforming single-agent and static approaches.
Language Grounding: When comparing raw natural-language inputs to oracle structured-policy inputs, Agentic-LTPO showed only a 1.9% performance gap, whereas a single-agent controller showed a 6.8% gap. This suggests the multi-agent structure effectively mitigates the ambiguity of natural language.
Trade-off: The framework incurs higher reasoning overhead (token usage) than static or single-agent methods, but this cost yields significantly higher long-term communication utility.

5. Significance and Claims

The paper claims that Agentic-LTPO provides a reliable interface between heterogeneous, high-level policy intents and executable, low-level physical-layer configurations. Its significance lies in:

Adaptability: It enables physical-layer controllers to adapt to time-varying operator policies without requiring retraining or manual reconfiguration of reward functions.
Reliability: By grounding decisions in historical evidence (via RAG) and verifying them through a critic mechanism, the framework produces structured, feasible configurations that are robust to language ambiguity and decision errors.
Scalability: The separation of concerns allows the use of powerful, slower-timescale Agentic AI for reasoning while preserving the speed and optimality of specialized mathematical solvers for real-time execution.

The authors conclude that this approach effectively bridges the gap between high-level network intent and low-level physical-layer execution, offering a viable path for policy-driven optimization in future 6G wireless networks.