Closed-Loop Dynamic Network (CLDyN)

• Closed-Loop Dynamic Network (CLDyN) is a systems paradigm that integrates feedback into networked structures to dynamically update internal control laws and operational behaviors.
• It employs control-theoretic methods, multi-timescale operations, and locality principles to ensure scalable stability and adaptivity in applications such as wireless communications and image fusion.
• Empirical implementations demonstrate enhanced performance with reduced latency, improved resource management, and robust adaptation across diverse computational and communication domains.

Searching arXiv for CLDyN and closely related closed-loop dynamic network papers to ground the article. Closed-Loop Dynamic Network (CLDyN) denotes a class of architectures in which feedback is embedded into the networked system itself: the network is part of the closed loop, internal representations or control laws are updated from measured, predicted, or downstream signals, and the overall behavior is shaped jointly by topology, dynamics, and feedback adaptation. In current arXiv literature, the term appears both as an explicit architecture name—most directly in adaptive multi-task-aware infrared-visible image fusion—and as a broader systems perspective spanning scalable consensus, predictive service automation, digital-twin network management, dynamic ARQ, and closed-loop action correction for diffusion policies (Yang et al., 10 Apr 2026, Hansson et al., 2023, Wu et al., 2 Mar 2026).

1. Scope and contemporary usage

In recent work, CLDyN is not confined to a single formalism. In one line of research, it is a control-theoretic perspective in which “the network itself is part of the closed loop, and its structure constrains achievable dynamics” (Hansson et al., 2023). In another, it is the explicit name of a fusion framework that establishes a semantic transmission chain from downstream tasks back to the fusion backbone (Yang et al., 10 Apr 2026). Related architectures with the same closed-loop dynamic pattern appear in URLLC link-layer control, O-RAN service automation, GAI-driven digital twins, and diffusion-policy correction (Han et al., 2021, Thaliath et al., 2022, Huang et al., 2024, Wu et al., 2 Mar 2026).

This suggests that CLDyN is best understood as a systems pattern rather than a uniquely standardized model family. A common misconception is to treat it as synonymous with ordinary feedback control. In the cited literature, the distinctive feature is stronger: feedback does not merely regulate outputs, but directly reconfigures the networked computation, controller structure, scheduling policy, or semantic feature flow.

Domain	Feedback carrier	Adaptive mechanism
High-order consensus	Laplacians $L_k$ inside the closed-loop operator	serial consensus
URLLC data link	ACK/NACK and remaining blocklength	Closed-Loop ARQ (CLARQ)
O-RAN and ZTN	telemetry, KPI prediction, SLA deviation	predictive resource provisioning, Q-learning
Diffusion policy	recent observation history	per-step action correction
IR-visible fusion	downstream semantic features	RSC with BVB and A2SI

2. Structural principles

Across the literature, CLDyN instances implement a recurring loop: state acquisition, dynamic abstraction, adaptive decision or compensation, actuation, and performance-driven feedback. In CLARQ, the state is the remaining frame budget and the last uplink outcome; the protocol reallocates uplink and downlink symbols within a fixed loop-back latency (Han et al., 2021). In O-RAN slicing, the state is slice-level KPI and cloud telemetry; an LSTM-based predictor informs Non-RT RIC and Near-RT RIC actions to prevent SLA violations (Thaliath et al., 2022). In GAI-driven digital-twin management, the external loop adapts data collection frequency through a DT error discriminator, while the internal loop compares model-based and GAI-based decisions before actuation (Huang et al., 2024). In DCDP, a frozen diffusion planner supplies chunk-level actions and a fast corrective network injects per-step dynamic adjustments from fresh observations (Wu et al., 2 Mar 2026). In the image-fusion CLDyN, downstream task features are fed back to modify intermediate fusion features through Requirement-driven Semantic Compensation (RSC) (Yang et al., 10 Apr 2026).

A second structural principle is multi-timescale operation. Several works separate a slower planning or optimization layer from a faster execution layer. The O-RAN design places prediction and high-level resource planning in the Non-RT loop and policy execution in the Near-RT loop (Thaliath et al., 2022). DCDP uses a slow diffusion policy every $H$ steps and a fast corrective decoder every step (Wu et al., 2 Mar 2026). Serial consensus can likewise be read as a structured cascade of first-order closed-loop blocks that collectively realize higher-order behavior (Hansson et al., 2023).

A third principle is locality under global objectives. In scalable consensus, admissible controllers are relative, bounded, and local in graph distance (Hansson et al., 2023). In CLARQ, adaptation is local to a single loop but directly optimizes the end-to-end closed-loop success probability (Han et al., 2021). In CLDyN-based fusion, only a 0.46M-parameter compensation module is trained, while the fusion backbone and downstream task networks remain frozen (Yang et al., 10 Apr 2026).

3. Control-theoretic foundations

A foundational network model appears in dynamic-network identification, where internal variables $w_j(t)$, external signals $r_k(t)$, and process noise $v_j(t)$ satisfy

$w(t) = G^0(q)\,w(t) + R^0(q)\,r(t) + H^0(q)\,e(t),$

with network transfer

$$T^0(q) := [I - G^0(q)]^{-1} \begin{bmatrix} H^0(q) & R^0(q) \end{bmatrix}.$$

This formulation generalizes classical plant models to structured, interconnected systems and makes closed-loop behavior intrinsic whenever directed cycles are present in the graph of modules $G_{jl}^0$ (Hof et al., 2017).

The most explicit control-theoretic CLDyN formulation is the serial-consensus design for $n$th-order integrators

$x_i^{(n)}(t) = u_i(t),$

with the proposed closed-loop dynamics

$H$0

Here each $H$1 is a graph Laplacian, and the closed loop can be realized as a cascade of $H$2 first-order consensus systems. The main theorem states that the poles of the closed loop are

$H$3

so under the assumption that each graph underlying $H$4 has a connected spanning tree, all non-zero poles lie strictly in the left half-plane regardless of graph size (Hansson et al., 2023).

This is the basis for the paper’s scalable-stability claim. Conventional high-order consensus depends nontrivially on Laplacian eigenvalues and can lose stability as graphs grow, including on directed cycles and strings. By contrast, serial consensus restores a first-order-like stability condition and is scalably stable over graph families that satisfy the connected-spanning-tree assumption (Hansson et al., 2023). The same work shows that if each $H$5 is 1-step implementable and relative, then the resulting controller is $H$6-step implementable and relative, so locality and relative measurements are preserved.

Identification theory provides the complementary analytic side of CLDyN. Network identifiability depends on topology, excitation, and disturbance structure rather than on isolated plant models alone. The model set

$H$7

is network identifiable when equality of network transfer matrices implies equality of the full network model. The cited conditions show that sparsity, diagonal or structured excitation/noise channels, and rank constraints are central to deciding whether a closed-loop dynamic network can be uniquely identified from data (Hof et al., 2017).

4. Communication-network realizations

In wireless control, CLARQ is a data-link-layer realization of closed-loop dynamic networking. It forces an information exchange round to complete within a fixed loop-back latency $H$8 and dynamically reallocates the remaining resource between uplink and downlink slots upon the result of the last uplink transmission. Its closed-loop success probability for one frame is

$H$9

and in the multi-attempt setting

$w_j(t)$0

The protocol is optimized by dynamic programming and, over a Rayleigh channel with 0dB mean SNR, it is able to provide a closed-loop error rate below $w_j(t)$1 within 10ms loop-back latency (Han et al., 2021).

Predictive closed-loop service automation in O-RAN implements the same pattern at slice-management scale. Monitoring via O1 and O2 feeds an AI server and Non-RT RIC; a PCL rApp predicts slice-level demand, computes RAN slice descriptors and cloud scaling actions, and a PCL xApp applies those decisions over E2. Using a real-world dataset from a large Indian operator, the paper reports training accuracy of approximately 91% and testing accuracy of approximately 86% for LSTM, compared with approximately 75% for ARIMA, and shows that predictive adaptation reduces the number of non-optimally served users relative to static allocation (Thaliath et al., 2022).

A related Zero Touch Network design uses an XGBoosted BiLSTM predictor and Q-learning controller. The state is the predicted network state in terms of bandwidth, the action is a traffic-shaping configuration, and the reward is

$w_j(t)$2

The Q-value update is

$w_j(t)$3

In the congestion scenario studied, the proposed mechanism achieves 95% accuracy in matching the actual network state by selecting the appropriate action based on the predicted state (K et al., 29 Mar 2025).

GAI-driven digital-twin management generalizes CLDyN to a dual-loop architecture. The external closed loop regulates telemetry intensity: physical measurements update the DT, GAI emulates status, a DT error discriminator compares emulated and actual status, and the error adapts data collection frequency. The internal closed loop compares candidate decisions from model-based and GAI-based modules inside the DT and applies the better one to the network controller. The paper identifies model light-weighting, adaptive model selection, and data-model-driven network management as three enabling approaches (Huang et al., 2024).

5. Learning-based and generative closed-loop dynamics

The robotics literature provides a compact example of CLDyN as a two-timescale policy architecture. DCDP wraps a frozen diffusion policy $w_j(t)$4 with a dynamic feature encoder $w_j(t)$5 and an asymmetric action VAE. Every $w_j(t)$6 steps the diffusion policy generates an action chunk

$w_j(t)$7

which is encoded once into a latent $w_j(t)$8. At each step $w_j(t)$9, recent observations are passed through the dynamic encoder to obtain $r_k(t)$0, and the corrected action is decoded as

$r_k(t)$1

The dynamic encoder uses ResNet18 features, temporal attention, differential features

$r_k(t)$2

and cross-attention fusion, while the VAE is trained with reconstruction, KL, and self-supervised differential losses (Wu et al., 2 Mar 2026).

The operational significance is that temporal coherence and real-time responsiveness are separated rather than traded off directly. In dynamic PushT simulations, DCDP improves adaptability by 19% without retraining while requiring only 5% additional computation. The reported success rates are 88.4/58.2/52.8 for Open-Loop, 84.6/76.1/61.6 for Closed-Loop $r_k(t)$3, and 92.5/77.6/71.9 for DCDP on Static/Constant/Random perturbations. Latency is 7.05 ms per step for OL$r_k(t)$4, 53.60 ms for CL$r_k(t)$5, 53.74 ms for Temporal Ensemble, and 7.39 ms for DCDP$r_k(t)$6 (Wu et al., 2 Mar 2026).

A plausible implication is that CLDyN in learning systems is less about adding a generic feedback signal than about choosing where feedback enters the computation graph. In DCDP it enters after chunk generation but before execution; in the GDT architecture it enters both before data collection and before decision selection; in the ZTN design it enters between predicted state and traffic-shaping action (Huang et al., 2024, K et al., 29 Mar 2025).

6. CLDyN in adaptive multi-task-aware infrared-visible fusion

The most explicit architectural use of the term is the infrared-visible fusion framework “Customized Fusion: A Closed-Loop Dynamic Network for Adaptive Multi-Task-Aware Infrared-Visible Image Fusion” (Yang et al., 10 Apr 2026). Its goal is to produce a fused image that maintains high fusion quality while adapting to different downstream tasks without retraining the fusion backbone. The architecture consists of a frozen Vision-guided Fusion Network (VFN), multiple frozen downstream task networks (DTNs), and a trainable Requirement-driven Semantic Compensation (RSC) module.

The closed-loop semantic transmission chain begins with

$r_k(t)$7

then a chosen downstream task network $r_k(t)$8 produces

$r_k(t)$9

and RSC computes

$v_j(t)$0

These compensated features are fed back into VFN to generate a task-customized fused image

$v_j(t)$1

The closed-loop loss for each task is

$v_j(t)$2

where $v_j(t)$3 is the task loss on the compensated output and

$v_j(t)$4

penalizes semantic compensation that degrades performance relative to the baseline fused image (Yang et al., 10 Apr 2026).

RSC itself is built from a Basis Vector Bank (BVB) and Architecture-Adaptive Semantic Injection (A2SI). For each modality, BVB stores 32 orthogonal basis vectors for each of four convolution configurations, collected as

$v_j(t)$5

with $v_j(t)$6. A2SI dynamically selects a convolution configuration using

$v_j(t)$7

chooses the most similar basis vector by cosine similarity, predicts a dynamic kernel $v_j(t)$8, and injects semantics through residual compensation: $v_j(t)$9 The reported configuration uses $w(t) = G^0(q)\,w(t) + R^0(q)\,r(t) + H^0(q)\,e(t),$0, $w(t) = G^0(q)\,w(t) + R^0(q)\,r(t) + H^0(q)\,e(t),$1, $w(t) = G^0(q)\,w(t) + R^0(q)\,r(t) + H^0(q)\,e(t),$2, and $w(t) = G^0(q)\,w(t) + R^0(q)\,r(t) + H^0(q)\,e(t),$3 (Yang et al., 10 Apr 2026).

Empirically, CLDyN is evaluated on M$w(t) = G^0(q)\,w(t) + R^0(q)\,r(t) + H^0(q)\,e(t),$4FD, FMB, and VT5000. On multi-task evaluation, it reports object-detection mAP$w(t) = G^0(q)\,w(t) + R^0(q)\,r(t) + H^0(q)\,e(t),$5 of 0.6304, semantic-segmentation mIoU of 60.34, and salient-object-detection $w(t) = G^0(q)\,w(t) + R^0(q)\,r(t) + H^0(q)\,e(t),$6 and $w(t) = G^0(q)\,w(t) + R^0(q)\,r(t) + H^0(q)\,e(t),$7 of 0.8129 and 0.9087, respectively. The trainable part is 0.46M parameters with 174.06G FLOPs. In cross-detector testing, VFN + RSC improves DETR from 0.5610 to 0.5810 and YOLOv5 from 0.6076 to 0.6304 without retraining RSC (Yang et al., 10 Apr 2026).

7. Limitations, misconceptions, and research directions

The present literature makes clear that CLDyN is not a single benchmarked theory with a universal state-space template. Rather, it names several domain-specific mechanisms that share a feedback-centric design logic. A common misconception is therefore to expect identical mathematics across multi-agent control, wireless resource management, generative policies, and semantic image fusion. The cited works instead emphasize different feedback objects: Laplacian factors, ACK/NACK outcomes, KPI forecasts, dynamic observation histories, and downstream semantic features (Hansson et al., 2023, Han et al., 2021, Wu et al., 2 Mar 2026, Yang et al., 10 Apr 2026).

The limitations are similarly domain-specific. The serial-consensus formulation is developed for linear integrator agents and time-invariant graphs, with future directions including performance measures and observer-based implementations (Hansson et al., 2023). CLARQ is single-user and single-hop in its main formulation, and multi-user or multi-hop generalizations are left open (Han et al., 2021). The O-RAN service-automation design is implementation-focused, uses heuristic adaptation rather than an explicit global optimization, and notes that feedback to the ML model is not yet closed-loop (Thaliath et al., 2022). The GDT framework identifies efficient GDT module collaboration, specialized generative models at the edge, and resource management for GDT operation as open issues (Huang et al., 2024). The ZTN congestion study uses bandwidth as the effective state variable and a small discrete action space (K et al., 29 Mar 2025). The image-fusion CLDyN assumes normal weather conditions and notes degradation under heavy rain, low light, severe noise, or sensor aging (Yang et al., 10 Apr 2026).

Taken together, these works indicate a broad research program. One branch seeks scalable stability and identifiability in networked control systems (Hansson et al., 2023, Hof et al., 2017). Another targets ultra-reliable communication and zero-touch automation through predictive or dynamic resource loops (Han et al., 2021, Thaliath et al., 2022, K et al., 29 Mar 2025). A third embeds feedback into learned representations so that frozen backbones can adapt online without retraining (Wu et al., 2 Mar 2026, Yang et al., 10 Apr 2026). A plausible implication is that future CLDyN research will continue to converge on modular architectures in which slow planning, fast correction, structured feedback, and topology-aware adaptation are designed as a single closed-loop system rather than as loosely connected components.