LeDRL: Hybrid LLM-DRL for Edge Offloading

• The paper presents LeDRL as a hybrid decision framework integrating a lightweight LLM with DRL to enhance decentralized task offloading in dynamic edge networks.
• It employs a self-attention alignment module to convert discrete LLM outputs into differentiable features, ensuring coherent integration of semantic priors with real-time state observations.
• Experimental results show up to a 17% improvement in task success rate over baselines, demonstrating faster convergence and robust performance under volatile network conditions.

Searching arXiv for the cited works to ground the article and resolve the naming ambiguity. LeDRL is a hybrid decision framework for task offloading in collaborative edge computing that couples a lightweight LLM with self-attention-enhanced DRL for real-time task offloading under dynamic, unreliable conditions (Guo et al., 7 May 2026). In the cited literature, the same string can also appear in connection with LED, the “Lighting Every Darkness” pipeline for extreme low-light RAW image denoising, where it denotes a denoiser-centric implicit calibration mechanism rather than an edge-computing controller (Jin et al., 2023). The two usages are distinct: the former addresses decentralized offloading in a collaborative edge computing environment, while the latter addresses extreme low-light RAW image denoising.

1. Optimization problem and system model

In collaborative edge computing, LeDRL operates in a system modeled as a time-varying undirected graph,

$\mathcal{G}(t) = (\mathcal{V}(t),\mathcal{E}(t)),$

where $\mathcal{V}(t)$ is the set of active edge nodes at slot $t$ and $\mathcal{E}(t)$ is the set of available bidirectional links (Guo et al., 7 May 2026). Each node $v_i \in \mathcal{V}(t)$ has computing capacity $F_{v_i}$, $m_i$ communication queues, and transmission rate $R_{v_i v_j}$ on link $(v_i,v_j)$. Tasks are indivisible and independent atomic work units; more complex DAG workflows are assumed pre-partitioned into such atomic tasks.

Time is slotted, $t=1,2,\dots,T$. At each slot, node $\mathcal{V}(t)$0 receives a task $\mathcal{V}(t)$1 with probability $\mathcal{V}(t)$2. For each task, the input size is $\mathcal{V}(t)$3, the computation intensity is $\mathcal{V}(t)$4, and the total CPU cycles required are

$\mathcal{V}(t)$5

If task $\mathcal{V}(t)$6 is executed at node $\mathcal{V}(t)$7, the computation delay is $\mathcal{V}(t)$8 and the one-hop transmission delay is $\mathcal{V}(t)$9. Queueing delays are represented by $t$0 for transmission waiting time and $t$1 for execution waiting time.

The reliability model includes three independent Poisson failure processes: software failure rate $t$2, hardware failure rate $t$3, and link failure rate $t$4. The probability of no software failure during execution is $t$5, the probability that the node remains hardware-operational is $t$6, and the probability of successful transmission is $t$7. The end-to-end reliability constraint is

$t$8

The decision variable is binary:

$t$9

indicating whether task $\mathcal{E}(t)$0 is executed at node $\mathcal{E}(t)$1. Each task can be assigned to at most one node, must satisfy its deadline $\mathcal{E}(t)$2, and must respect resource constraints over the horizon $\mathcal{E}(t)$3. The optimization objective is to maximize task success rate, defined as the fraction of tasks that meet both delay and reliability constraints. The resulting formulation is a mixed integer nonlinear program, and Theorem 1 proves NP-hardness via reduction from Bin Packing. This is the formal basis for the paper’s shift from exact optimization to a learning-based policy (Guo et al., 7 May 2026).

2. Hybrid decision architecture

LeDRL combines four components: a lightweight LLM, a DRL agent implemented as a MAPPO-style actor-critic, a self-attention alignment module, and a reflective evaluator (Guo et al., 7 May 2026). The high-level workflow is fixed. At each time step, a node forms a structured prompt containing current node, task, and link state together with relevant memory context; the LLM returns a high-level suggestion; the suggestion is encoded and fused with environmental features through self-attention; the DRL actor uses the fused representation to select the actual offloading action; and subsequent rewards and outcomes feed a reflective process that updates memory.

This architecture is explicitly positioned between two failure modes. Relative to pure DRL, the framework injects semantic priors so that policy search does not rely exclusively on trial-and-error in a large, non-stationary state-action space. Relative to LLM-only control, it avoids using a stochastic LLM as the final real-time controller. The LLM produces strategy priors, not final actions, and the DRL policy performs the fast action selection.

The LLM output is constrained by a strict output schema. A recommendation is interpreted as an LLM policy $\mathcal{E}(t)$4 whose action is either local execution at node $\mathcal{E}(t)$5 or offloading to a particular neighbor node $\mathcal{E}(t)$6. If the output is malformed, the fallback is local execution. This constraint is operationally important because it converts free-form language output into a bounded offloading prior that can be consumed by the downstream policy network (Guo et al., 7 May 2026).

3. Prompting, memory, and reflective evaluation

Prompt construction is organized around the structured template

$\mathcal{E}(t)$7

where $\mathcal{E}(t)$8 denotes node status, $\mathcal{E}(t)$9 denotes task semantics, and $v_i \in \mathcal{V}(t)$0 denotes link dynamics (Guo et al., 7 May 2026). Node status includes computing capacity, queue levels, and failure rates. Task semantics include size, intensity, derived compute demand, deadline, hop count, and accumulated waiting time. Link dynamics include bandwidth and failure rate for each neighbor. The purpose of this prompt design is to present the LLM with a context-aware representation of the current offloading state.

LeDRL augments this prompt with a dual memory

$v_i \in \mathcal{V}(t)$1

Short-term memory stores recent trajectories $v_i \in \mathcal{V}(t)$2, while long-term memory stores compressed summaries of typical successful or failed patterns. Memory retrieval is formalized as

$v_i \in \mathcal{V}(t)$3

Relevance ranking uses weighted terms for location, task type, task similarity, and load similarity, and the top-$v_i \in \mathcal{V}(t)$4 items form the contextual memory inserted into the prompt.

The reflective evaluator is the mechanism that updates long-term memory. For poor outcomes, the system constructs a diagnostic tuple

$v_i \in \mathcal{V}(t)$5

where $v_i \in \mathcal{V}(t)$6 is a risk summary built from observable signals such as expected waiting time, execution failure risk, expected transmission delay, link failure risk, and target-node load. The LLM is then prompted with a failure-oriented query asking for the likely cause and a safer strategy for similar states. The resulting reflection is stored in $v_i \in \mathcal{V}(t)$7. In the paper’s terminology, this distills semantic feedback from past trajectories to guide future prompts and makes LLM queries more informative and temporally generalizable (Guo et al., 7 May 2026).

4. DRL backbone and self-attention alignment

The online offloading problem is modeled as a decentralized partially observable MDP. Each agent $v_i \in \mathcal{V}(t)$8 has local observation $v_i \in \mathcal{V}(t)$9 and chooses an action from $F_{v_i}$0: execute locally, forward to neighbor $F_{v_i}$1, or take no action if there is no task arrival (Guo et al., 7 May 2026). A topology-aware mask $F_{v_i}$2 enforces the currently available links. The reward is defined through task success and violation indicators,

$F_{v_i}$3

with team reward

$F_{v_i}$4

Joint policy factorization is

$F_{v_i}$5

and optimization uses a MAPPO-like actor-critic with PPO updates, GAE, and entropy regularization.

A central technical difficulty is that LLM outputs are discrete and non-differentiable. LeDRL addresses this with a self-attention alignment module $F_{v_i}$6 that converts LLM suggestions into a differentiable prior feature. The environment observation is embedded as

$F_{v_i}$7

and the LLM decision is converted to text, encoded with BERT, and mapped by another MLP,

$F_{v_i}$8

The attention mechanism computes

$F_{v_i}$9

with score

$m_i$0

and fused feature

$m_i$1

The module is trained with two losses: a feature alignment loss based on mean squared error between the attention output and target LLM feature, and an action alignment loss based on cross entropy over action logits. The combined alignment objective is

$m_i$2

The final policy input fuses DRL and LLM representations through

$m_i$3

where $m_i$4 is temporally scheduled. The paper describes this self-attention layer as a context-aware gate: when an LLM suggestion aligns with the current state, the model can weight the LLM feature more heavily; when it conflicts with local congestion or failure conditions, the model can down-weight it and rely more on the environment embedding (Guo et al., 7 May 2026).

5. Experimental results and prototype deployment

The simulation environment uses a time horizon of 100 slots, network sizes of 10–20 heterogeneous nodes, task input size uniformly distributed in $m_i$5 KB, task complexity in $m_i$6 cycles/bit, deadline 4 s, node CPU 3 GHz, link rates uniformly distributed in $m_i$7 MB/s, node failure rate 0.01, and node appearance probability 0.1 (Guo et al., 7 May 2026). LeDRL uses Qwen3-4B as the LLM, actor-critic MLP layers with hidden size 64, self-attention with embedding dimension 8, max length 512, dropout 0.1, PPO learning rate $m_i$8, and discount factor $m_i$9. Baselines include VDN-TO, MAPPO-TO, MASAC-TO, RATC, AGSP, and Reflexion.

On the main quantitative benchmark, LeDRL attains the highest task success rate in both 10-node and 20-node settings. In the 10-node case, it reports $R_{v_i v_j}$0 success with inference time $R_{v_i v_j}$1 s, versus MAPPO-TO at $R_{v_i v_j}$2 and $R_{v_i v_j}$3 s and Reflexion at $R_{v_i v_j}$4 and $R_{v_i v_j}$5 s. In the 20-node case, it reports $R_{v_i v_j}$6 and $R_{v_i v_j}$7 s, versus MAPPO-TO at $R_{v_i v_j}$8 and $R_{v_i v_j}$9 s and Reflexion at $(v_i,v_j)$0 and $(v_i,v_j)$1 s (Guo et al., 7 May 2026). The paper states that LeDRL improves success rate by $(v_i,v_j)$2 over MAPPO-TO in the 10-node scenario and reports over $(v_i,v_j)$3 improvement in success rate in the broader experimental summary.

Training curves show faster convergence and lower variance than DRL baselines. Under increasing task size and task complexity, all methods decline, but LeDRL remains consistently best. Under execution and transmission failure rates, the curves are smoother and the success rates higher than competing methods. At failure rate $(v_i,v_j)$4, the reported improvements over MAPPO-TO are about $(v_i,v_j)$5 for execution failures and $(v_i,v_j)$6 for transmission failures. Across random connected graphs and rings, LeDRL achieves the highest success rate, and the ablation study attributes this to the joint contribution of LLM priors, self-attention alignment, and reflective memory (Guo et al., 7 May 2026).

The framework is also implemented in the prototype system CoEdgeSys. The hardware deployment uses 10 Jetson devices, specifically 4 Jetson Nano and 6 Jetson Xavier NX, connected by a wired 1 Gbps LAN. Each node runs a local scheduler and a YOLOv8 detector on the COCO dataset. Qwen3-4B is hosted on a server with a single NVIDIA RTX 4090, and CoEdgeSys supports parallel LLM requests from multiple nodes. The actor network has 3 fully connected layers and model size below 100 KB. Under random DoS states and a strict 4 s latency constraint, LeDRL achieves up to $(v_i,v_j)$7 success rate, exceeding the best baseline by $(v_i,v_j)$8, while maintaining latency close to pure DRL methods (Guo et al., 7 May 2026).

6. Assumptions, limitations, and future directions

The framework assumes that node and link states, including bandwidths and failure rates, can be estimated or are known to the scheduler (Guo et al., 7 May 2026). It also assumes Poisson and stationary failure processes over the training horizon, that the LLM server is reachable with acceptable latency, and that tasks are atomic rather than unpartitioned DAGs. These assumptions delimit the conditions under which the reported success-rate gains are established.

The limitations are explicit. Experiments focus on 10–20 nodes, so behavior in networks with hundreds or thousands of nodes is not evaluated. Although Qwen3-4B is lightweight relative to larger LLMs, inference still costs about $(v_i,v_j)$9 s per decision, which can be tight for ultra-low-latency systems or very high request rates. The prototype uses a centralized LLM server, which can become a bottleneck or single point of failure. Joint DRL and LLM training is also resource-intensive, even though runtime actor inference is lightweight.

Future work proposed in the paper includes decoupling the LLM from online execution, using LLM guidance mainly during training and then deploying pure DRL at runtime, distilling LLM guidance into smaller on-device models, scaling to larger and more heterogeneous networks, and studying multi-tenant, multi-objective, privacy, and security extensions (Guo et al., 7 May 2026). A plausible implication is that LeDRL is best understood as a training-and-guidance architecture rather than as a commitment to persistent online LLM invocation.

7. Nomenclature and the LED-related usage

The term “LeDRL” is not unique in the provided literature. One usage refers to the collaborative edge-computing framework described above; another refers to LED, “Lighting Every Darkness,” an implicit calibration framework for extreme low-light RAW image denoising (Guo et al., 7 May 2026, Jin et al., 2023).

Usage	Paper	Meaning
LeDRL	(Guo et al., 7 May 2026)	LLM-enhanced DRL for task offloading in collaborative edge computing
LeDRL / LED	(Jin et al., 2023)	“Lighting Every Darkness” pipeline for extreme low-light RAW image denoising

In the denoising context, LED replaces explicit noise-model calibration with implicit fine-tuning of the denoiser. It pre-trains once on synthetic data from virtual cameras sampled in noise-parameter space and fine-tunes per camera using only a few real noisy-clean RAW pairs. Its core mechanisms are Camera-Specific Alignment, Out-of-Model Noise Removal, and RepNR blocks, and its purpose is to calibrate the denoiser instead of the noise model (Jin et al., 2023). In that literature, some references or implementations may label the pipeline as LeDRL, but conceptually it is the same LED method.

This naming overlap matters because the two methods address different technical domains and should not be conflated. In current usage within the supplied sources, LeDRL denotes either a hybrid LLM-DRL offloading controller for collaborative edge computing or, in the denoising literature, the LED implicit calibration pipeline for extreme low-light RAW image denoising.