RIDAS: Representation & Intention Driven Agents

• RIDAS is a multi-agent framework for AI-RAN that employs user-side Representation-Driven Agents and a base-station Intention-Driven Agent to convert high-level user intent into low-level network actions.
• It explicitly exposes tunable parameters like rank and quantization bits, enabling a direct control over the rate–distortion tradeoff and efficient bandwidth allocation under QoS constraints.
• The architecture integrates an LLM-based two-stage planning system with a stateful memory module to dynamically adjust configurations and maximize network capacity in complex deployment scenarios.

Searching arXiv for the RIDAS paper and closely related AI-RAN / LLM-agent references to ground the article. Searching arXiv for “RIDAS AI-RAN Representation- and Intention-Driven Agents”. RIDAS is a multi-agent framework for AI-RAN proposed for sixth-generation wireless systems in which the radio access network must translate high-level user intent into low-level, parameterized control actions. In the formulation introduced by “RIDAS: A Multi-Agent Framework for AI-RAN with Representation- and Intention-Driven Agents” (Ding et al., 17 Jul 2025), the framework is composed of user-side Representation-Driven Agents (RDAs) and a base-station-side Intention-Driven Agent (IDA). RDAs expose an open interface through tunable control parameters—rank and quantization bits—so that representation fidelity and transmission rate can be traded off explicitly, while the IDA uses a LLM and a two-stage planning scheme to map user requirements and system state into bandwidth assignments and RDA configurations (Ding et al., 17 Jul 2025).

1. Concept and problem formulation

RIDAS is situated in the context of AI-RAN, where artificial intelligence is integrated into the radio access network to automate management and optimize both quality of service (QoS) and resource utilization. The specific systems problem it addresses is the mismatch between high-level user intent, often expressed in abstract service terms, and low-level RAN actions such as compression level, representation fidelity, bit budget, and bandwidth allocation (Ding et al., 17 Jul 2025).

The framework is motivated by two design challenges stated explicitly in the underlying paper. The first is the need to design underlying AI models with an open interface exposing tunable operating parameters so that an external controller can navigate the QoS/resource tradeoff. The second is the need to design an LLM-based control framework that maps user intent into concrete control actions and dynamically adapts those actions based on network status (Ding et al., 17 Jul 2025). RIDAS is presented as solving both by pairing controllable representation modules at the user equipment with an intention-aware planner at the base station.

In this architecture, “representation-driven” refers to the fact that the user-side agents operate on learned representations of source data and expose explicit controls over representation quality and size. “Intention-driven” refers to the base-station-side agent, which starts from user QoS requirements and current system context, and then decides how the RDAs should be configured and how bandwidth should be allocated (Ding et al., 17 Jul 2025). This division of labor is central to the framework’s design.

A plausible implication is that RIDAS treats AI-RAN not merely as a scheduling problem, but as a joint control problem over communications and learned representations. The paper’s formalization supports this interpretation because the optimization target is not only bandwidth assignment, but also the selection of representation operating points under task-quality constraints (Ding et al., 17 Jul 2025).

2. System architecture and agent roles

RIDAS comprises two agent classes. At the user side, each RDA generates a learned representation of source data using a deep neural network, compresses that representation, and exposes a control interface to the network. At the base station, the IDA orchestrates all RDAs in the system by receiving user QoS requirements and current system state, and then proposing RDA control parameters and bandwidth assignments (Ding et al., 17 Jul 2025).

The control parameter exposed by each RDA is

$\boldsymbol{\theta} = \{r, q\},$

where $r$ is rank and $q$ is quantization bits (Ding et al., 17 Jul 2025). These are the only explicit control knobs described in the paper, and they define the representation-level actuation surface available to the IDA.

The system state seen by the IDA includes the new user requirement $R$, the current system state $S$, and the existing control configurations $\{\boldsymbol{\theta}_i\}_{i=1}^N$. The IDA is formalized as a mapping

$$\boldsymbol{\theta}_{N+1} = f_{\boldsymbol{\Phi}}\big(S, R, \{\boldsymbol{\theta}_i\}\big),$$

where $\boldsymbol{\Phi}$ denotes IDA parameters (Ding et al., 17 Jul 2025). This mapping yields the proposed configuration for a new incoming RDA.

The end-to-end encoding path on the user side is represented as

$$\mathcal{B} = f_{\boldsymbol{\phi}}(x;\boldsymbol{\theta}),$$

where $x$ is the source input, $r$0 denotes the RDA model parameters, and $r$1 is the transmitted bitstream (Ding et al., 17 Jul 2025). The IDA therefore does not directly manipulate the internal neural representation; instead, it chooses the operating point $r$2 under which the RDA produces the bitstream.

The paper also describes a memory module for the IDA. This memory stores the current configuration set—namely the control parameters of all connected RDAs and their allocated bandwidth—as well as experience configurations, including achieved bitstream lengths and achieved distortions under various settings (Ding et al., 17 Jul 2025). The memory is maintained in a real-time database and serves as the perceptual input to the LLM-based controller.

This suggests that RIDAS is not a purely reactive prompt-based controller. Rather, it is a stateful multi-agent system in which the LLM reasons over both live network state and accumulated empirical operating data (Ding et al., 17 Jul 2025).

3. Representation-Driven Agents and controllable compression

An RDA is defined as a user-end agent that transforms source data into a learned representation and then compresses it in a way that exposes an explicit rate–distortion tradeoff. The internal RDA architecture consists of a trained DNN $r$3, an SVID decomposition module, quantization, and entropy coding (Ding et al., 17 Jul 2025).

Let the DNN output representation be

$r$4

To reduce transmission overhead, the framework applies sign-value-independent decomposition (SVID), giving

$r$5

where $r$6, $r$7 is the Hadamard product, and $r$8 is the rank-$r$9 singular value decomposition of $q$0 (Ding et al., 17 Jul 2025). The sign function is defined elementwise as

$q$1

The paper states a proposition that SVID yields reconstruction error no larger than conventional SVD in Frobenius norm. For a matrix $q$2 and its absolute value $q$3, with decompositions

$q$4

the SVID approximation satisfies

$q$5

The authors note that this extends naturally to rank-$q$6 decomposition (Ding et al., 17 Jul 2025).

After SVID, the factors are quantized and entropy-coded. The complete RDA is written as

$q$7

with

$q$8

Here, $q$9 denotes the SVID approximation, $R$0 denotes quantization, and $R$1 denotes entropy coding (Ding et al., 17 Jul 2025).

The two exposed parameters control the distortion–rate tradeoff explicitly. Increasing $R$2 and $R$3 decreases distortion and increases rate; decreasing $R$4 and $R$5 increases distortion and decreases rate (Ding et al., 17 Jul 2025). The average rate under configuration $R$6 is defined as

$R$7

and the average distortion is denoted

$R$8

The paper does not provide a closed-form analytic expression for $R$9 (Ding et al., 17 Jul 2025).

In the reported experiments, the transmitted objects are learned representations derived from the source rather than the raw source itself, and task quality is operationalized through classification accuracy (Ding et al., 17 Jul 2025). This makes the RDA a communication-aware representation module rather than a generic compressor.

4. Intention-Driven Agent and two-stage planning

The IDA is the high-level controller hosted at the base station. Its purpose is to determine the configuration for a new RDA so that transmission rate is minimized subject to QoS and total bandwidth constraints (Ding et al., 17 Jul 2025). The paper emphasizes that the IDA uses an LLM because of its instruction-following and contextual understanding capability.

The LLM used in the experimental realization is DeepSeek-V3-0324 (Ding et al., 17 Jul 2025). Its role is not to replace domain-specific modules, but to interpret user requirements, retrieve suitable configurations from prior experience, propose near-optimal $S$0 settings, and reason about whether already-connected users can be reconfigured to release bandwidth.

The planning process has two stages. In the first, bandwidth pre-allocation, the IDA receives the user’s QoS requirements, including distortion and rate requirements, plus the current idle system bandwidth. The LLM proposes a control parameter $S$1 and a bandwidth allocation. Because LLMs may hallucinate numerically, the proposal is then validated empirically by measuring the actual transmission rate under the chosen configuration before finalizing the assignment (Ding et al., 17 Jul 2025).

In the second stage, bandwidth reallocation, the system is invoked when idle bandwidth is insufficient. Instead of rejecting the new user immediately, the IDA examines already-connected RDAs and determines whether some can be shifted to alternative $S$2 settings that still satisfy their QoS while consuming less bandwidth. If enough bandwidth is freed, the new user is admitted; otherwise, reallocation continues until either sufficient bandwidth is secured or no further useful adjustments exist (Ding et al., 17 Jul 2025).

This two-stage design distinguishes RIDAS from a single-shot prompting architecture. The paper includes a “Prompt-Based” baseline precisely to isolate the value of verification and reallocation, indicating that the full framework derives part of its benefit from repeated, state-dependent adjustment rather than initial intent parsing alone (Ding et al., 17 Jul 2025).

The paper does not provide exact prompt wording for the IDA. It does, however, state that the prompt is designed so that the LLM retrieves from experience a configuration minimizing transmission rate while satisfying the distortion constraint (Ding et al., 17 Jul 2025).

5. Optimization model and bandwidth computation

The central optimization problem in RIDAS is to choose the control parameter for a new user so as to minimize expected rate under a bandwidth budget and a distortion requirement. The paper writes this as

$S$3

where $S$4 is the total bandwidth budget determined by system state $S$5, and $S$6 is the distortion requirement implied by user requirement $S$7 (Ding et al., 17 Jul 2025).

This formulation makes clear that RIDAS is a constrained operating-point selection problem. The new user’s configuration is not chosen independently; it is constrained by the aggregate rate of all existing and incoming users (Ding et al., 17 Jul 2025). A plausible implication is that the framework can be viewed as admission control coupled to representation adaptation.

The paper also gives the bandwidth formula used in experiments:

$S$8

Although the typesetting is visibly corrupted in the source, the intended structure is that required bandwidth depends on transmitted bits, code rate, transmission time, and spectral efficiency $S$9 (Ding et al., 17 Jul 2025).

In the experimental section, QoS is categorized by top-1 classification accuracy:

• Low: accuracy $\{\boldsymbol{\theta}_i\}_{i=1}^N$0
• Medium: accuracy $\{\boldsymbol{\theta}_i\}_{i=1}^N$1
• High: accuracy $\{\boldsymbol{\theta}_i\}_{i=1}^N$2 (Ding et al., 17 Jul 2025)

Thus, although the optimization is written in terms of distortion, the operational QoS proxy in the experiments is task accuracy (Ding et al., 17 Jul 2025). This suggests that the framework is task-aware in practice even where the analytical model is rate–distortion oriented.

6. Experimental evaluation and reported performance

The evaluation uses CIFAR-10 as the task dataset and image classification as the downstream task. The representation backbone for the RDA is ViT-B/16 from CLIP (Ding et al., 17 Jul 2025). The experiments assume a total bandwidth budget of 100 MHz, each RDA’s SNR is random in 5 dB to 30 dB, the code rate is selected from

$\{\boldsymbol{\theta}_i\}_{i=1}^N$3

and the maximum allowable transmission delay per RDA is 0.05 ms to 0.5 ms (Ding et al., 17 Jul 2025).

The baselines are WirelessAgent, Prompt-Based, and Rule-Based (Ding et al., 17 Jul 2025). For representation-quality comparisons, the paper also includes DT-JSCC, BPG + 1/2 LDPC, and an RDA variant without SVID (Ding et al., 17 Jul 2025).

The headline systems result is that RIDAS supports 123 users, compared with 85 for WirelessAgent, corresponding to 44.71% more users under equivalent QoS constraints (Ding et al., 17 Jul 2025). The paper further reports that as allocated bandwidth approaches 100% of capacity, RIDAS admits 123 users, versus 112 for Rule-Based, 85 for WirelessAgent, and 68 for Prompt-Based (Ding et al., 17 Jul 2025).

At 85 concurrent users, the average bandwidth per connected user is 0.893 MHz for RIDAS, 0.925 MHz for Rule-Based, and 1.175 MHz for WirelessAgent (Ding et al., 17 Jul 2025). This indicates that RIDAS is reported to use bandwidth more efficiently even at the same user count.

A concrete reallocation example is also provided: when 117 users are already connected, bandwidth is nearly exhausted, and on the 118th connection attempt the IDA triggers reallocation and frees enough capacity from existing RDAs to admit the additional user (Ding et al., 17 Jul 2025). This is one of the clearest demonstrations that the second planning stage affects system capacity in the reported experiments.

On the representation side, the paper reports that at around 0.008 bpp, the proposed RDA outperforms DT-JSCC with 4-QAM by over 20% accuracy and outperforms the RDA variant without SVID by over 18% accuracy (Ding et al., 17 Jul 2025). At higher bits per pixel, RDA accuracy approaches that of the original representation model (Ding et al., 17 Jul 2025).

The reported allocation behavior is also differentiated by user latency tolerance: users with higher delay tolerance get less bandwidth, while users requiring lower latency get more bandwidth (Ding et al., 17 Jul 2025). The authors interpret this as evidence that RIDAS better captures user intent than WirelessAgent, which tends to allocate bandwidth more uniformly.

7. Relation to prior work, significance, and limitations

RIDAS is positioned against prior LLM-based wireless control approaches such as WirelessAgent and LLM-hRIC, which the paper argues do not adequately orchestrate lower-level AI representation models with explicit, tunable interfaces (Ding et al., 17 Jul 2025). In this framing, the novelty of RIDAS lies not simply in using an LLM for wireless control, but in coupling an intention-level planner with representation-level actuators.

The framework’s main conceptual contribution is the open interface exposed by RDAs:

$\{\boldsymbol{\theta}_i\}_{i=1}^N$4

This converts a learned representation model into an externally controllable endpoint whose communication footprint and task fidelity can be programmed by the network (Ding et al., 17 Jul 2025). The significance of this design is that it makes the rate–QoS tradeoff explicit and actionable for AI-RAN orchestration.

A second contribution is the multi-agent decomposition itself. The paper suggests a broader architectural principle: lower-level specialized agents should expose structured control interfaces, while higher-level LLM agents should reason over intent and system state to orchestrate them (Ding et al., 17 Jul 2025). This suggests a general pattern for AI-native network control in which LLMs act as planners rather than monolithic decision systems.

The paper’s limitations are also clear. The evaluation is task-specific, being conducted on an image-classification workload over CIFAR-10 using CLIP ViT-B/16 (Ding et al., 17 Jul 2025). QoS is represented through top-1 classification accuracy, which is narrower than the full range of AI-RAN service metrics (Ding et al., 17 Jul 2025). The framework does not provide a full analytic model of $\{\boldsymbol{\theta}_i\}_{i=1}^N$5 and $\{\boldsymbol{\theta}_i\}_{i=1}^N$6, relying instead on empirical experience tables and measurement (Ding et al., 17 Jul 2025). It also explicitly notes that LLMs can hallucinate numerically, which is why empirical verification is inserted into the decision loop (Ding et al., 17 Jul 2025).

The paper further states that future work will incorporate end-to-end delay control and adapt the framework to more complex deployment scenarios (Ding et al., 17 Jul 2025). This suggests that the current formulation is an initial systems design rather than a complete operational AI-RAN stack.

A common misconception would be to treat RIDAS as merely an LLM scheduler. The architecture described in the paper is broader: it is a joint framework for representation control, bandwidth allocation, stateful memory-based planning, and reallocation under QoS constraints (Ding et al., 17 Jul 2025). Another misconception would be to interpret “intent” as free-form natural language only. In the experiments, intent is operationalized through QoS constraints such as accuracy and delay tolerance, which the IDA then maps to concrete configuration variables and bandwidth decisions (Ding et al., 17 Jul 2025).

Overall, RIDAS defines an AI-RAN design in which controllable representation modules and an intention-aware LLM planner are integrated into a single multi-agent resource-management system. Its reported empirical result—supporting 123 users versus 85 for WirelessAgent under equivalent QoS constraints—makes the case that coupling representation-level control with intent-level planning can materially improve resource efficiency in AI-RAN environments (Ding et al., 17 Jul 2025).