A Low-Latency Semantic State Estimator using Latent Predictive Learning for Dynamic Network Monitoring and Orchestration Hari Madhukumar∗ , Haiyuan Li∗ , Xiaolan Liu∗ , Andy Corston-Petrie∥ , Dimitra Simeonidou∗
arXiv:2606.08869v1 [cs.DC] 7 Jun 2026
Smart Internet Lab, University of Bristol∗ , BS8 1UB, U.K., BT Group∥ , IP5 3RE, U.K. E-mail: {h.madhukumar, ocean.h.li, xiaolan.liu, dimitra.simeonidou}@bristol.ac.uk, [email protected]
Abstract—Closed-loop network monitoring and orchestration increasingly require semantic interpretations of live telemetry beyond raw counter collection. However, dynamic cloud-edge environments change both the active node set and the monitoring query at runtime, while control loops demand bounded millisecondscale responses. We introduce a latent predictive state estimator (LPSE) for dynamic network monitoring and orchestration, built on latent predictive learning over streaming telemetry. The framework converts variable-cardinality node telemetry into topology-adaptive temporal representations, fuses them with monitoring questions, and returns bounded answers from a semantic codebook instead of autoregressive text generation. This design enables fixed-cost, single-pass inference while preserving semantic interpretability. By operating on permutation-invariant, slot-routed node representations keyed by stable identity, the model maintains a fixed input space and generalizes to node addition, removal, and reordering without retraining. Experimental results on a multi-node Kubernetes cluster show semantic prediction accuracy of 82.42% at approximately 41× lower mean inference latency and 15× smaller memory footprint compared with a deployable 4B LLM endpoint. Index Terms—Network telemetry, joint embedding predictive architecture (JEPA), self-supervised learning, Kubernetes, network monitoring, network orchestration, semantic state prediction.
I. I NTRODUCTION Future network infrastructures will increasingly rely on closed-loop monitoring and orchestration to maintain service quality under fluctuating traffic demands, service requirements, and resource conditions. In cloud-edge and virtualized environments, orchestration systems continuously collect network telemetry from distributed infrastructure nodes to support service placement, scaling, fault recovery, and admission-control decisions. This demand intensifies as network operation evolves toward multi-agent AI orchestration [1], [2], where concurrent reasoning agents issue semantic state queries to monitoring systems within bounded response budgets. In single-query settings, hand-tuned threshold rules and dashboards remain competitive. The case for a learned bounded-output semantic estimator emerges when an LLM-based orchestrator would otherwise become a per-query bottleneck. Semantic monitoring [3] in dynamic network infrastructures remains challenging as both telemetry structure and monitoring intent vary at runtime. Active infrastructure nodes may expand, contract, or change order as services are instantiated, migrated,
terminated, or recovered, causing fixed-position telemetry vectors to become semantically inconsistent after topology or service-state changes. Moreover, monitoring is not restricted to a single predefined prediction target. The same telemetry snapshot may be queried for CPU-pressure detection, memorybottleneck localization, node-level comparison, cluster-health assessment, or short-term trend estimation, depending on the operational context. A practical monitoring model must jointly encode live multi-node telemetry and query-specific intent, while producing stable and low-latency outputs suitable for closed-loop network automation. Prior approaches to deriving operational states from network telemetry fall into three groups. (i) Rule-based monitoring systems1 , such as threshold alarms and manually configured dashboards, provide interpretable signals for predefined conditions but require continuous rule maintenance as services, metrics, and node states change. (ii) Lightweight AI-based predictors, including statistical models and compact neural networks for anomaly detection [4] and resource-state classification [5], offer low inference latency but usually rely on fixed telemetry layouts and fixed prediction targets. (iii) LLMbased telemetry reasoning [6] can process heterogeneous metric contexts and monitoring queries without task-specific output heads, but depends on autoregressive decoding. All three groups assume fixed input structures that break under topology change and fixed output objectives that cannot serve multiple query types. LLM-based methods additionally incur autoregressive latency incompatible with control-loop budgets. Recent advances in self-supervised learning (SSL) show that latent predictive objectives produce robust and transferable representations for complex environments [7]–[9]. By predicting in latent space instead of reconstructing full observations, these methods improve efficiency, representation quality, and downstream control robustness. In network-oriented settings, Time Series Joint Embedding Predictive Architecture (TS-JEPA) and related semantic communication work emphasize low-bandwidth operation, temporal prediction, and task-relevant representations over raw-signal transport [10], [11]. Related studies extend latent predictive 1 The Prometheus/Alertmanager stack (https://prometheus.io) is the de facto state-of-the-art for cloud-native cluster monitoring.
learning to sequence modeling, graphs, control, and uncertainty estimation [10], [12]. However, most existing evidence remains simulation-based or benchmark-driven, whereas practical deployment exposes non-stationary telemetry distributions, runtime topology changes, online supervision without manual labels, and strict end-to-end latency bounds. In response, we design a hybrid semantic state estimator for continuous network monitoring and orchestration in dynamic infrastructure. 1) Question-conditioned semantic monitoring: We formulate closed-loop semantic monitoring as a question-conditioned state estimation problem over a variable-cardinality node set. The formulation models a dynamic telemetry input under variable node membership and a query-conditioned output drawn from a bounded semantic inventory, subject to permutation invariance over node ordering and a millisecond-scale latency constraint. 2) Topology-adaptive telemetry representation: We propose a node-token telemetry representation that maps a variable set of live Kubernetes nodes to a fixed-dimensional cluster state using identity-keyed slot routing invariant to node ordering. Stable node identities are kept for question grounding and answer rendering, so the representation remains valid when nodes are added, removed, or reordered. 3) Question-conditioned semantic estimation: Building on this representation, we develop a latent predictive semantic estimator combining temporal telemetry representations with structured monitoring questions and predicts answers from a fixed semantic codebook, enabling one model to handle multiple query types without autoregressive text generation. 4) Live deployment and low-latency validation: We deploy the model on a live multi-node Kubernetes cluster and construct question-answer supervision automatically from network telemetry. The proposed model lands within 11% of a 120B LLM on clean queries at approximately 364× lower mean latency, making it suitable for embedding inside multi-agent orchestrators where per-query LLM decoding would otherwise dominate end-to-end latency. II. S YSTEM M ODEL & P ROBLEM F ORMULATION We consider a live monitoring setting in which a service observes a changing set of compute nodes. Let Nt denote the set of active nodes observed at time t, indexed by n. Since nodes may join, leave, or recover over time, |Nt | is not fixed. Each node reports telemetry from multiple resource and systemlevel metric families. Let M denote the set of monitored metric families, indexed by m. For node n ∈ Nt and metric family m ∈ M, the samples collected at time t are summarized as a fixed-dimensional descriptor rn,m (t) ∈ RDr . The telemetry state of node n at time t is represented by the node token vn (t) = [rn,m1 (t); rn,m2 (t); . . . ; rn,m|M| (t)] ∈ RFnode ,
(1)
where Fnode = Dr |M|. Each node is also associated with a stable identity un . The telemetry snapshot at time t is then written as the variable-cardinality set Vt = {(vn (t), un ) | n ∈ Nt }.
(2)
This set representation does not assign semantic meaning to node order and naturally supports changes in the number of observed nodes. The monitoring service is queried by an operator or orchestration agent. Let qt denote the query at time t. A query specifies an operational intent, such as pressure detection, node comparison, bottleneck identification, condition checking, or short-horizon trend estimation. It may also include a metric scope, a node reference, or a time horizon. The answer space is a finite semantic inventory A = {a1 , . . . , aκ }, where each ak denotes an operational answer type. During training, each pair of telemetry history and query is assigned a target answer a⋆t ∈ A. The estimator takes a temporal history of telemetry snapshots, Ht = [Vt−T +1 , . . . , Vt ],
(3)
where T is the context-window length. Given Ht and qt , the estimator predicts a categorical distribution pθ (· | Ht , qt ) over A parameterised by θ, and returns ât = arg max pθ (ak | Ht , qt ),
(4)
ak ∈A
where θ denotes the model parameters. Let ℓθ (Ht , qt ) be the inference latency, let τctrl be the response-time budget of the closed loop, and let π(·) denote any permutation of node order within each snapshot’s tensor representation. The semantic monitoring problem is formulated as min Et [− log pθ (a⋆t | Ht , qt )]
(5a)
θ
s.t.
pθ (· | π(Ht ), qt ) = pθ (· | Ht , qt ),
∀π,
(5b)
ât ∈ A,
(5c)
ℓθ (Ht , qt ) ≤ τctrl .
(5d)
The objective in Eq. (5a) fits the estimator to the target semantic answer (the point target a⋆t is relaxed to a softlabel distribution at training time; see §III-C). Constraint (5b) enforces invariance to node ordering, so reordering observed nodes does not change the prediction. With the set-based snapshot Vt , this also allows the input to accommodate node addition and removal. Constraint (5c) keeps the prediction within the semantic inventory, while constraint (5d) imposes the response-time requirement of the closed loop; we adopt τctrl = 50 ms as a target consistent with closed-loop autoscaling and admission-control budgets, and verify it empirically in §V. III. LPSE F RAMEWORK At each sampling step, node-level metrics are collected across all discovered cluster nodes. The pipeline from data ingestion to answer selection is shown in Fig. 1. The framework computes six summary statistics per tracked metric family (count, minimum, maximum, mean, sum, and standard deviation), instantiating the per-node descriptor vn (t) ∈ RFnode and the variable-size node-token set Vt (2), with un given by the node’s IP address. Instead of flattening along an arbitrary node axis, LPSE routes each node into a fixed slot inside an S-slot cluster tensor. Slots are assigned in IP-sorted order
Data Ingestion
Topology-Invariant Cluster Token IP-Sorted Slot Allocation
Semantic Encoding
Temporal Encoder Online
Question
Per-Slot Block
T-K Prefix Slice
"What is the current state of this network"
Per-node feature block Node 1
Latent State Decoder Project to Answer-Code space
12-layer Transformer Online Context
Slot tensor
JEPA Predictor Node 2
Hybrid Question Embedding
Append active-slot fraction
0
Normal
Full T-window
1
High CPU
12-Layer Transformer
2
High Memory
3 . .
High I/O
EMA Target Node 3 Node Token
Answer Embedding
Identity-Invariant Slot-Routed Cluster Token (
Target latents
)
Answer
Node K
"The network is stable"
Answer Codebook
Cosine similarity
Question-Conditioned Fusion Cross-Attention Block
Losses Supervised QA Loss
JEPA Loss
Variance Reg
Covariance Reg
Cosine similarity Feed Forward Block Total Loss
=
Fused Representation
Argmax → Answer Index
Fig. 1. Pipeline for dynamic Kubernetes monitoring that includes multi-node metric ingestion, temporal latent encoding, question-conditioned latent fusion, codebook-based semantic answering, and confidence-aware output selection.
of un , so that any given physical machine is mapped to the same slot across consecutive scrapes. Each occupied slot stores its Fnode feature block, a four-dimensional normalised IP identity vector, and a one-dimensional presence flag. Empty slots are zero-padded. The cluster token also carries a final scalar ρt = min(|Nt |, S)/S holding the active-slot fraction: xt = [ slot1 ; slot2 ; . . . ; slotS ; ρt ] ∈ RFcluster ,
(6)
where Fcluster = S (Fnode + 5) + 1. Because each slot also carries the IP identity of whichever node currently occupies it, reordering the input set leaves xt unchanged: identical multisets of (features, IP) pairs always yield the same cluster token. This satisfies the permutation-invariance requirement of Eq. (5b) via stable identity rather than the symmetric pooling used by Deep Sets [13] and Set Transformer [14], and it keeps the input dimensionality constant as |Nt | varies up to the slot capacity S. New nodes simply occupy previously empty slots, and removed nodes leave their slot zero-filled until reuse, so a single trained checkpoint remains valid across topology changes. A temporal context window of length T is maintained: Xt = [xt−T +1 , . . . , xt ] ∈ RT ×Fcluster .
(7)
Before entering the model, each feature is normalised online using running mean/variance statistics to stabilize continual training under changing traffic conditions. The normaliser is updated on the slot-routed cluster token, while the per-slot identity entries are passed through unscaled, since centring categorical metadata would erase the routing information the slot-based design relies on. A. Metric Encoder and Question-Conditioned Fusion The metric stream is processed by a Transformer-based temporal encoder with sinusoidal positional encoding. This module outputs (i) a full latent sequence Zt = Encθ (Xt ), and (ii) a context summary vector ct = Zlast t .
In parallel, each natural-language query is converted into a structured intent representation (intent, metric, scope, horizon, node reference) and embedded into a fixed-dimensional question vector. A cross-attention fusion module then applies question-asquery attention over temporal metric latents ft = Fuseϕ (Zt , qt ), yielding a question-conditioned state representation for answer selection. The question encoder parses each query into intent, metric, scope, horizon, and node reference. The node reference is grounded by a stable node IP rather than a transient node-list position, so a node remains semantically identifiable even when the cluster gains or loses nodes. B. Semantic Codebook Output Space Instead of autoregressive decoding, LPSE uses a learnable answer codebook of κ code vectors, each tied to a fixed naturallanguage template. The fused representation is projected into the answer-code space and compared to all code vectors using temperature-scaled cosine similarity: sk =
⟨f̂t , âk ⟩ , τ
k ∈ {1, . . . , κ},
(8)
where f̂t and âk are the L2-normalised fused state and code vectors and τ = 0.07. The highest-scoring index determines the output template, which is subsequently filled with current nodelevel values (for example, node IDs or measured percentages) to produce a human-readable response. C. Training Objective and Continual Adaptation LPSE is trained online from live telemetry. Supervision is generated automatically through a QA synthesizer that transforms semantic metric features into question-template and answer-index pairs, eliminating manual annotation. This makes the model self-updating with respect to the live cluster rather than a static dataset.
The total loss combines a supervised QA objective, a JEPAstyle self-supervised objective, and a pair of VICReg-style anti-collapse regularisers on the QA latent: L = LQA + λJ LJEPA + λV Lvar + λC Lcov .
(9)
LQA is a soft-label cross-entropy: the true template (index k ⋆ ) keeps mass 1 − α = 0.70, with the remaining α distributed over ⋆ same-group templates j in proportion to e−|j−k |/τs , where τs is a spread temperature, plus optional uniform smoothing. LJEPA aligns the online encoder with an exponential-movingaverage target encoder by predicting EMA target latents at a held-out future horizon from a strictly truncated prefix. Lvar enforces a per-dimension standard-deviation floor on the question-conditioned answer latent, and Lcov penalises the squared off-diagonal entries of its covariance matrix. We retain the JEPA-style label for the auxiliary loss because it adopts the latent-prediction objective; the system as a whole adopts JEPA, BYOL, and VICReg as influences. Exact training-time details are given in §IV. To improve coverage of rare operational states (CPU-bound, memory pressure, I/O contention, asymmetric load), cluster stress profiles are randomised during training, and samples are retained in a replay buffer so each optimisation step sees a diverse mix of historical and recent states. At inference time, a single forward pass returns top-k candidate templates and confidence scores from the maximum codebook similarity, allowing uncertain responses to be escalated to fallback logic. IV. I MPLEMENTATION AND T RAINING The system runs as a single service on a live Kubernetes cluster; training and inference share a single checkpoint but run on separate request queues, so live serving is never blocked by an optimisation step. 1) Cluster Embedding: Each node_exporter scrape is parsed into structured (family, label, value) tuples. For each family the framework computes six summary statistics (i.e., count, minimum, maximum, mean, sum, and standard deviation), yielding a 300-dimensional feature block per node. These blocks are placed into a 16-slot cluster tensor in IP-sorted order; each occupied slot also carries a four-dimensional normalised IP vector and a presence flag, empty slots are zero-padded, and a final scalar records the active-slot fraction, giving a 4881dimensional cluster token. Sorting by IP yields a rank-based mapping, so a join or leave in the middle of the sorted range shifts every higherranked slot by one. This is tolerable because identity travels in the per-slot IP-octet vector and presence flag, so the encoder can recover identity from the contents of the slot rather than the position; the node-dropout augmentation described below actively trains it to do so. Clusters beyond the 16-slot capacity require retraining at a larger slot count. 2) Metric Encoder: The encoder consumes a sliding window of T = 16 cluster tokens, each linearly projected to 1024 dimensions, augmented with sinusoidal positional encoding, and processed by a 12-layer Transformer with 16 attention
heads, GELU activations, pre-normalisation, and a feed-forward width of 4096. The most recent timestep’s latent is the context summary supplied to the QA path, while the full sequence is retained for the JEPA self-supervised path. 3) Question Encoder and Fusion: We use a hybrid encoder with two parallel paths. A frozen SentenceTransformer2 (all-MiniLM-L6-v2) produces the sentence embedding, while an explicit identity path passes the four IP octets through a small MLP and looks up the scope label in an embedding table. The concatenation is projected to a 256-dimensional question vector. The fusion module is a four-layer cross-attention stack (16 heads, 1024 dimensions) where the question forms the query and the encoder sequence forms keys and values. 4) Answer Codebook: The output stage is what makes inference deterministic and bounded. Rather than decoding free-form text, the fused state is projected into a fixed inventory of 94 semantic templates, and the index of the closest template is emitted as the answer. The templates are organised into thirteen operational groups (CPU level, memory level, network state, disk and filesystem fill, load, processes, temperature, cluster-wide health, pairwise node comparison, extreme-node identification, short-horizon prediction, condition checks, and a small generic fallback). This grouping is what makes the soft-label cross-entropy described below well-defined, since probability mass can be shared between adjacent CPU-level bands but not between unrelated groups. 5) Online Supervision and Training Objective: Closing the loop requires supervision, but a live cluster cannot be handlabelled at the rate at which it generates data. Supervision is therefore produced online: raw counters are turned into interpretable quantities (e.g., CPU utilisation, memory used fraction, load-per-core ratio, filesystem fill, TCP and process states), and fixed rules emit the appropriate answer-template index. For example, mean CPU utilisation is bucketed into seven levels with thresholds at 1%, 10%, 30%, 50%, 70%, and 90% (idle through critical). The model’s purpose is not to discover them but to evaluate them jointly across the 16-step temporal context, multiple query types, and variable topology at bounded latency. Up to ten pairs are produced per snapshot and written to a replay buffer and one in every ten snapshots is diverted to a held-out validation buffer. LJEPA (λJ = 0.5, with λV = 1.0 and λC = 0.005 for the VICReg terms) provides the self-supervised signal that prevents the encoder from collapsing onto features that minimise the QA loss alone, following the online/EMA prediction-in-latentspace paradigm of I-JEPA [9] but with a temporal rather than spatial conditioning variable. Two encoders are maintained: an online encoder receiving gradients, and an EMA target encoder updated as θEMA ← m θEMA + (1 − m) θonline with m = 0.996. For a window of length T , the online encoder is run on the (T − K)-prefix to obtain a context latent cshort , t the EMA encoder on the full window to obtain target latents z̄t−K+1:t , and a small predictor hF (·) maps the prefix context 2 Sentence-BERT [15] embeds short text into dense vectors; the sentence-transformers library at https://www.sbert.net hosts pretrained checkpoints including the MiniLM variant used here.
Lvar and Lcov are the standard VICReg variance-floor and off-diagonal covariance penalties, applied to the questionconditioned answer latent rather than to the encoder output, so that the fusion module and codebook projector cannot satisfy the QA loss by collapsing the da = 512 answer dimensions onto a low-rank subspace. The optimiser is AdamW (learning rate 10−3 , weight decay −5 10 , gradient clip norm 1.0). Each step samples a batch of B = 32 tuples and updates the metric encoder, fusion, codebook, learnable parts of the question encoder, and the JEPA predictor jointly. 6) Online Adaptation: The key augmentation is bounded node dropout, applied before the cluster token is built and before QA generation runs. Because the live IP list, per-node tensors, and parsed metric families are all filtered by the same keep-mask, the cluster token, semantic features, and QA labels agree on which nodes exist for that step, so node-referenced questions only mention IPs the model actually sees. Combined with the IP-sorted slot routing introduced above, this is what trains the encoder to read identity from the per-slot IP feature rather than from slot position. V. E XPERIMENTAL R ESULTS LPSE reaches 82.42% rolling validation accuracy under changing node configurations on the held-out validation buffer accumulated during training. Two further benchmarks are reported below: a 100-question clean cross-system comparison (Table I, 89%) primarily for latency and cost, and a 700query per-type breakdown (Table II, 76.29%) for categorylevel accuracy. We report results against an LLM endpoint, a multilayer perceptron (MLP), and an XGBoost classifier. A. Setup All evaluated systems are exercised against the same sevennode live Kubernetes cluster in a single benchmark run. Synthetic load is injected by a stress randomiser that periodically deploys stress-ng jobs to random subsets of workers under five profiles (CPU-bound, memory pressure, I/O contention, mixed, and asymmetric load), so the evaluator sees both naturally idle and actively stressed cluster states within the same run. All non-LLM systems are trained and evaluated on a single NVIDIA RTX 6000 Ada Generation GPU. LPSE collects the snapshots and produces the question–answer pairs from its semantic-feature pipeline, and the MLP, XGBoost, and LLM baselines are then queried on those identical inputs. The MLP baseline flattens the 16-frame context window with the question embedding (78,352-dim input) through four 1,024unit GELU layers (106.30 M parameters). XGBoost uses the same input with multi:softprob, depth 8, and 500 rounds. Both baselines share our question encoder and codebook and train offline on replay data collected during LPSE’s training.
1.0
Validation top-1 accuracy
6 × 100
total
to a predicted latent compared to each target step in normalised cosine distance: K 1 X LJEPA = 1 − cos hF (cshort ), z̄t−K+i . (10) t K i=1
4 × 100 3 × 100
0.8 0.6 0.4 LPSE MLP XGBoost
0.2 0.0
0
1000
2000
3000
4000
5000
0
5000
Training step
0.82
0.69
0.91
XGBoost 0.2
20000
25000
30000
(b) Validation top-1 vs. step
LPSE
0.0
15000
Training step
(a) Joint loss
MLP
10000
0.4 0.6 0.8 Validation top-1 accuracy
(c) End-of-run accuracy
1.0
LPSE
9.6×105
MLP
9.6×105 1.4×108
XGBoost 105
107 108 106 Cumulative sample-views (log)
109
(d) Cumulative sample-views
Fig. 2. Training dynamics (a, b) and end-of-run accuracy and compute (c, d).
B. Comparison: Accuracy, Robustness, and Cost Table I consolidates the cross-system comparison, where every system answers the same 100 questions on the same sequence of fresh cluster snapshots. Table II (700 queries) is the primary accuracy reference. Against the deployable LLM alternative (Qwen3-4B, single GPU), LPSE is 3 points higher in clean accuracy, 41× faster, and 15× smaller, making co-location with the orchestrator feasible; against the 120B Nemotron upper bound it lands within 11% at 364× lower latency. The 6.65 ms mean leaves headroom for roughly seven sequential queries within a 50 ms control-loop budget. Fig. 2(a) shows the loss curve of LPSE, where after an initial drop in the loss, the model continues to improve. Fig. 2(b) shows the validation accuracy for each model during training. XGBoost is trained offline on the full accumulated replay data, so its higher endof-run accuracy (Fig. 2(c)) reflects a batch-mode advantage unavailable to a streaming system, and the computation and memory disadvantage of storing and resampling the batched data (Fig. 2(d)). Under topology shift LPSE loses 23 points when a node is dropped, against the MLP’s 36-point and XGBoost’s 24-point drops, supporting that slot routing plus node-dropout training generalises to unseen topology events. A self-supervised ablation on the same architecture with the futureprediction term disabled but EMA consistency retained reaches only 64% at matched step 30k (vs. 82% for the full model) and plateaus at 74% after 2.7× more training, confirming that the JEPA-style temporal asymmetry, not EMA consistency alone, carries the self-supervised signal. Memory is trivially separable on this cluster (100% for both LPSE and XGBoost in Table II), while Load is the hardest category at 56%, likely because load-per-core thresholds sit near typical operating points on the heterogeneous core-count mix. Every local system collapses below 50% under paraphrasing while the 120B LLM holds at 100%, identifying the frozen question encoder as the limiting component. In a multi-agent orchestrator issuing programmatic queries from a fixed template vocabulary, wording variation is controlled by the caller agent, so it characterises robustness to query-format drift rather than a primary operating mode.
TABLE I C ROSS - SYSTEM COMPARISON ON THE 100- QUESTION BENCHMARK .
System
Accuracy Clean (n=100)
Drop one node (n=100)
Cost per query
Paraphrased (n=100)
Unique para. (n=64)
Mean lat. P95 lat. (ms) (ms)
LPSE 89.00% 66.00% (−23.00) 39.00% (−50.00) 45.31% (−43.69) MLP baseline 74.00% 38.00% (−36.00) 38.00% (−36.00) 39.06% (−34.94) XGBoost baseline 84.00% 60.00% (−24.00) 27.00% (−57.00) 29.69% (−54.31) LLM (Qwen3-4B-Instruct, FP8) 86.00% 85.00% (−1.00) 91.00% (+5.00) 91.18% (+5.18) LLM (Nemotron-3, NVFP4, 120B) 100.00% 100.00% (0.00) 100.00% (0.00) 100.00% (0.00) †
6.65 3.22 9.91 272.59 2423.22
Memory (MB)
Params
7.02 932 240 M 3.10 407 83.5 M 10.75 123 660 trees 286.03 14,400 4B 4172.06 ≈180,000† 120 B
Total memory across the two RTX 6000 Pro Blackwell GPUs hosting the LLM, including weights and KV-cache.
TABLE II P ER - QUESTION - TYPE ACCURACY ON THE 700- QUERY BENCHMARK . Question type
LPSE
MLP
XGBoost
CPU Memory Disk Load Process Health Overall
80.00% 100.00% 88.00% 56.00% 73.00% 68.00% 69.00%
43.00% 45.00% 56.00% 44.00% 66.00% 51.00% 54.00%
73.00% 100.00% 68.00% 56.00% 81.00% 67.00% 72.00%
All types
76.29%
51.29%
73.85%
VI. C ONCLUSION LPSE replaces autoregressive decoding with single-pass codebook matching in latent space, reducing response time and confining outputs to a fixed operational inventory. On the evaluated multi-node Kubernetes cluster, the model achieved 82.42% rolling validation accuracy under changing node configurations. At 6.65 ms mean latency, it is 41× faster and 15× smaller than a deployable 4B LLM, fitting within the 50 ms control-loop budget with headroom for multi-query fan-out. Several limitations remain. Paraphrase robustness drops to 39% on reworded queries, identifying the frozen sentence encoder as the primary remaining gap to the LLM upper bound. The slot routing fixes the input dimension at 16 nodes, so larger clusters require retraining at a wider slot capacity. Supervision quality is bounded by the hand-crafted threshold ladders and by the K = 1 prediction horizon, which limits longer-horizon trend queries. Future work will address paraphrase generalisation through fine-tuning or paraphrase-augmented training, scale slot capacity to larger heterogeneous topologies, incorporate richer cross-modal context such as logs and events, and couple the model with multi-agent orchestrators for proactive autonomous control. ACKNOWLEDGMENT This work was supported by the UK Engineering and Physical Sciences Research Council (EPSRC) grant EP/Y037243/1, EP/X04047X/2 for the TITAN Telecoms Hub and the Federated Telecoms Hubs, grant EP/Y036514/1 for the JOINER project, and the NVIDIA Academic Grant program.
R EFERENCES [1] H. Li, H. Madhukumar, S. Yan, Y. Wu, and D. Simeonidou, “Multiagentic ai for fairness-aware and accelerated multi-modal large model inference in real-world mobile edge networks,” no. arXiv:2602.07215, Feb. 2026, arXiv:2602.07215 [eess]. [2] G. Jiang, K. Wang, X. Chen, and Y. Huang, “Agentic AI empowered intent-based networking for 6G,” arXiv preprint arXiv:2601.06640, 2026. [3] I. D. Martínez-Casanueva, D. González-Sánchez, L. Bellido, D. Fernández, and D. R. López, “Toward building a semantic network inventory for model-driven telemetry,” IEEE Communications Magazine, vol. 61, no. 3, pp. 60–66, 2023. [4] M. Jin, H. Y. Koh, Q. Wen, D. Zambon, C. Alippi, G. I. Webb, I. King, and S. Pan, “A survey on graph neural networks for time series: Forecasting, classification, imputation, and anomaly detection,” IEEE Transactions on Pattern Analysis and Machine Intelligence, vol. 46, no. 12, pp. 10 466– 10 485, 2024. [5] D. Saxena, J. Kumar, A. K. Singh, and S. Schmid, “Performance analysis of machine learning centered workload prediction models for cloud,” IEEE Transactions on Parallel and Distributed Systems, vol. 34, no. 4, pp. 1313–1330, 2023. [6] L. Zhang, T. Jia, M. Jia, Y. Wu, A. Liu, Y. Yang, Z. Wu, X. Hu, P. S. Yu, and Y. Li, “A survey of AIOps in the era of large language models,” ACM Computing Surveys, 2025. [7] Y. LeCun, “A path towards autonomous machine intelligence version 0.9.2, 2022-06-27,” Open Review, vol. 62, no. 1, pp. 1–62, 2022. [8] J.-B. Grill, F. Strub, F. Altché, C. Tallec, P. Richemond, E. Buchatskaya, C. Doersch, B. Avila Pires, Z. Guo, M. Gheshlaghi Azar et al., “Bootstrap your own latent-a new approach to self-supervised learning,” Advances in neural information processing systems, vol. 33, pp. 21 271–21 284, 2020. [9] M. Assran, Q. Duval, I. Misra, P. Bojanowski, P. Vincent, M. Rabbat, Y. LeCun, and N. Ballas, “Self-supervised learning from images with a joint-embedding predictive architecture,” in Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), 2023, pp. 15 619–15 629. [10] A. M. Girgis, A. Valcarce, and M. Bennis, “Time-series jepa for predictive remote control under capacity-limited networks,” no. arXiv:2406.04853, 2025, arXiv:2406.04853. [11] M. Monemi, M. Chinipardaz, M. Rasti, M. Bennis, and M. Latva-Aho, “Tutorial on joint embedding predictive architectures (jepa): Foundations, applications, and future directions,” Dec. 2025. [12] G. Skenderi, H. Li, J. Tang, and M. Cristani, “Graph-level representation learning with joint-embedding predictive architectures,” no. arXiv:2309.16014, Jan. 2025, arXiv:2309.16014. [13] M. Zaheer, S. Kottur, S. Ravanbakhsh, B. Póczos, R. R. Salakhutdinov, and A. J. Smola, “Deep sets,” in Advances in Neural Information Processing Systems 30 (NeurIPS). Curran Associates, Inc., 2017, pp. 3391–3401. [14] J. Lee, Y. Lee, J. Kim, A. R. Kosiorek, S. Choi, and Y. W. Teh, “Set transformer: A framework for attention-based permutation-invariant neural networks,” in Proceedings of the 36th International Conference on Machine Learning (ICML), ser. Proceedings of Machine Learning Research, vol. 97. PMLR, 2019, pp. 3744–3753. [15] N. Reimers and I. Gurevych, “Sentence-BERT: Sentence embeddings using Siamese BERT-networks,” in Proc. 2019 Conference on Empirical Methods in Natural Language Processing (EMNLP), 2019, pp. 3982– 3992.