Papers for

network operations teams

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

Online algorithms balance delay and network costs in service systems

Online Network Design with Additive Delays and Poisson Arrivals

Abstract: We study online service systems in which requests arrive at locations in a network. A service may open a facility and connect customers, buy a subtree linking them to a root, or send a mobile server to visit them. Combining requests can save opening, network, or travel costs, but each request pays its own waiting time. The objective is the sum of these spatial costs and individual delays. We assume independent Poisson arrivals of known rates. The algorithms know how often requests occur, but observe them only upon arrival. We show that these rates suffice to make fixed spatial choices that compete with an offline optimum free to adapt to the realized input. We obtain long-run ratios of expectations below $27.249$ for facility location in finite metrics, $94.415$ for multi-root aggregation on trees, and $24.326$ for online service on trees. All three algorithms are deterministic; the multi-root algorithm also has polynomial-time preprocessing on rational inputs. The proofs connect rate-based spatial choices with lower bounds on unavoidable purchase, movement, and waiting costs. All main proofs are self-contained, and every guarantee includes the full cost of completing finite inputs.

Tue 10 NovData Structures and Algorithms
The gist
The paper looks at how to serve people who request help from different places in a network, like cities connected by roads. The challenge is to decide where to open service points or send help so that both travel costs and waiting times are kept low. The authors use math models assuming requests arrive randomly but with known average rates. They develop fixed strategies that work nearly as well as ideal ones that know every request beforehand. Their approach works well for different kinds of network setups and is fully proven with clear performance guarantees.
Open → 2611.13859v1

Optimistic learning improves decision making in unknown path problems

OPSRL-SSP: Optimistic Posterior Sampling for Stochastic Shortest Path with Minimax-Optimal Regret

Abstract: We study online reinforcement learning for the stochastic shortest path (SSP) problem with unknown transition dynamics. Although existing posterior-sampling methods perform well empirically on SSPs, their regret guarantees do not achieve the minimax-optimal order. We address this limitation by proposing OPSRL-SSP, an optimistic posterior-sampling algorithm for the SSP setting. The algorithm operates in epochs and uses a logarithmic, time-dependent schedule for the number of posterior samples. To induce optimism, we augment the transition model with a pseudo-state assigned an optimistic boundary value. We establish a high-probability regret bound of $\tilde{O}(B_\star \sqrt{SAK} + B_\star S^2 A)$, where $B_\star$ is an upper bound on the expected cost of the optimal policy, $S$ and $A$ are the numbers of states and actions, respectively, and $K$ is the number of episodes. In addition, we extend the analysis to general zero-cost SSPs using a universal cost-perturbation argument. The leading term matches the minimax lower bound $Ω(B_\star \sqrt{SAK})$, thereby addressing the open problem raised by Jafarnia-Jahromi et al. [19] for posterior sampling in the SSP setting.

Sun 8 NovMachine Learning
The gist
This work looks at how computers can learn to find the best path in situations where the chances of moving from one place to another are not known. The authors propose a clever way for the computer to guess and explore these chances while being optimistic about the results, which helps the computer learn faster and make better decisions. Their method also comes with mathematical guarantees that it performs as well as the best possible approach in the worst cases. This solves a previously open question about how to do this type of learning efficiently.
Open → 2611.11337v1

Instruction tuning improves large model control of cloud edge resources

Continual Instruction Tuning for LLM-ased Management of Continuum Resources

Abstract: Large language models (LLMs) are increasingly explored for resource management across the Cloud-Edge continuum. However, embedding LLMs directly inside latency-sensitive control loops places inference latency, execution jitter, and hallucination risks on the critical path. This study argues for a different use of LLMs: a continually instruction-tuned intent compiler that runs once per management intent or declared context change, above a fast, deterministic tactical controller that handles all low-latency runtime actions. We formulate intent compilation as a continual instruction tuning problem, because management intents arrive sequentially and accumulate while infrastructure and workload contexts drift. Unlike recent LLM-based management frameworks, our design scores the model's outputs by execution, so that catastrophic forgetting can be measured in the executed objective of the underlying controller. On a continuum simulator with a 2B backbone and parameter-efficient adapters, preliminary results show that naive sequential tuning forgets earlier intents in the executed objective, that replay of stored examples nearly prevents this forgetting, and that the tuned compact compiler performs on par with simpler translators while being more robust than a grammar parser to rephrased intents.

Fri 6 NovDistributed, Parallel, and Cluster ComputingMachine Learning
The gist
Managing computer resources across cloud and edge devices can be complicated and slow when large language models are directly used for quick decisions. The authors suggest using these models instead as smart translators that prepare instructions just once when goals or situations change, leaving faster systems to handle immediate tasks. They show that continually updating this translator with new instructions can forget old ones unless previous examples are replayed during training. This approach helps maintain good performance and is more flexible than simple grammar-based methods.
Open → 2611.10292v1

Robots improve actions by switching vision models based on failure prediction

VLA Handover: Failure-Prediction-Based Switching from On-Robot to Server VLA Models

Abstract: Large vision-language-action (VLA) models generalize well but are difficult to run in real time on a robot, and small VLAs that run there fail more often. Remote inference over beyond-5G and 6G networks lets a robot use a large VLA on a server, but querying the server for every action chunk limits the number of robots per server. We propose VLA handover: the robot runs a small VLA (S-VLA) and switches to a large VLA (L-VLA) on a server only when the S-VLA is likely to fail. We formulate the switching as minimizing the request cost under a required success probability and, since this problem cannot be solved directly, propose a heuristic framework that retrains neither VLA. In simulation with SmolVLA and $π_{0.5}$ on three of the four LIBERO suites, VLA handover raised the success rate by 11-22 percentage points over the S-VLA alone and sent 49-77% fewer requests than server-only control at a 2-4 percentage-point lower success rate, and its completion time grew less with the network latency.

Fri 6 NovRoboticsMachine LearningNetworking and Internet Architecture
The gist
Robots can run small vision-language-action (VLA) models onboard quickly but sometimes fail to act correctly. Larger models on remote servers work better but are slower and costly when used for every action. The authors propose having the robot use the small model most of the time and switch to the big model only when failure is likely. This approach raises success rates and reduces how often the robot needs to ask the server, improving speed and efficiency.
Open → 2611.08987v1

Optimistic algorithm improves online learning with dynamic constraints

Dynamic Optimistic Constrained OCO with Memory via Delay Equivalence

Abstract: Online Convex Optimization with memory and time-varying constraints (COCO-M) is a recently-introduced framework that captures the dynamics of stateful online learning and non-stochastic control with budget constraints. Despite its expressive power, COCO-M remains largely understudied. In this work, we tackle this problem in its full scale, providing an optimistic algorithm that incorporates untrusted predictions to tame universal dynamic regret and cumulative constraint violation. Our analysis leverages a potent reduction from memory to delay and treats state-dependent gradients as delayed feedback. We establish the first bounds that adapt to both environment non-stationarity (path length $P_T$) and prediction accuracy, while lifting previous restrictive assumptions such as functional separability. En route to these results, we derive findings of independent interest for the memory-to-delay reduction, and for delayed OCO with time-varying constraints. The proposed framework ensures sublinear worst-case guarantees that improve with prediction accuracy, reaching $\mathcal O(1)$ regret under perfect predictions, with cumulative constraint violation (CCV) $\mathcal O(\sqrt{T})$ for unknown $P_T$ and $\mathcal O(\log T)$ for known or online observable $P_T$ , while recovering the optimal COCO rates when memory disappears.

Thu 5 NovMachine Learning
The gist
Online learning systems often have to make decisions over time while remembering past information and following changing rules or limits. The authors developed a new method that uses predictions to improve performance and reduce mistakes, even when the environment changes or predictions are imperfect. Their approach turns challenges caused by memory into a simpler problem related to delays and provides guarantees that get better with prediction accuracy. This work also relaxes previous strict assumptions and improves on existing methods for these kinds of problems.
Open → 2611.08302v1

Self supervised learning improves encrypted traffic classification accuracy

Understanding Self-Supervised Representation Learning for Encrypted Traffic

Abstract: SSL has been adopted for encrypted traffic classification to learn representations from unlabeled traces and reduce reliance on manual feature engineering. However, recent studies show that data leakage can inflate reported performance and that pretrained models can underperform shallow classifiers once leakage is controlled. These findings raise questions about what information SSL can learn from encrypted traffic and how different pretraining mechanisms exploit this information. In this paper, we systematically investigate these questions by examining the sources of learnable information, the effectiveness of contextual pretraining, alternative self-supervision mechanisms, and the limits of representation learning. We first find that visible protocol fields retain contextual dependencies that are strongest between adjacent bytes, while payload interventions establish the classification value of retained plaintext structure. Guided by these insights, we investigate byte-level contextual learning through ByteBERT and TrafficDCNet, showing that aligning prediction granularity with local dependencies produces more discriminative representations. We further examine cross-view contrastive learning through AlignTraffic and find that complementary supervision improves representation quality beyond contextual prediction alone. Across four public classification tasks, AlignTraffic outperforms shallow learning by 5.97% to 30.70%, with additional evaluations on industrial traffic demonstrating its effectiveness in broader settings. Finally, evaluations on Tor traffic and individual packets reveal limitations when application information is concealed or unevenly distributed. These findings provide a systematic understanding of how observable information and self-supervision mechanisms shape the effectiveness and scope of representation learning for encrypted traffic.

Thu 5 NovNetworking and Internet Architecture
The gist
Encrypted internet traffic is hard to classify because its contents are hidden. The authors investigated how self-supervised learning (SSL) methods can learn useful patterns from such encrypted data without needing labeled examples. They found that some visible parts of the data still carry clues that SSL can use, especially when predictions focus on local byte relationships. They also showed that combining different SSL techniques leads to better results across various tasks, but the method struggles when important application information is hidden. This work helps clarify what encrypted traffic data can reveal and how best to teach models to understand it.
Open → 2611.07452v1

UniFlow improves speed and quality of multiscale time series generation

UniFlow: Unified Multi-Scale Flow Matching for Time Series Generation

Abstract: Real-world time series exhibit complex dynamics across multiple temporal resolutions, yet effectively incorporating multi-scale information into generative modeling remains challenging without increasing generative complexity. We propose UniFlow, a unified framework that integrates multi-scale representation learning with efficient non-autoregressive generation through a shared-semantic discrete interface. Specifically, a multi-scale tokenizer employs shared-index voting to consolidate complementary temporal information into a single public-ID sequence, while scale-specific codebooks preserve the information required for reconstruction. Building on this unified representation, we develop geometry-aware categorical flow matching, which initializes transport from learned low-rank anchors and generates public identities non-autoregressively. This design captures multi-scale temporal structure without requiring multiple generative token streams or sequential token decoding. Experiments across four benchmarks and both short- and long-term settings demonstrate improved generative fidelity, strong cross-scale consistency, and substantial inference speedups over representative autoregressive and diffusion-based baselines. Code is available at https://github.com/William-Liwei/uniflow

Tue 3 NovArtificial Intelligence
The gist
Time series data, like weather or financial records, change in complicated ways over different time scales. The authors propose UniFlow, a new method that learns these different time scales together through a shared representation, making it easier and faster to generate realistic data. UniFlow avoids slow step-by-step prediction by generating sequences all at once, while keeping details consistent across time scales. Tests show it produces better and faster results than some existing methods.
Open → 2611.04825v1

Agentic AI enabled network twins check dependencies to avoid errors

Can Agentic AI Undermine Its Own Assurance Loop? Closed-Loop Dependency Assurance for Cognitive Network Digital Twins

Abstract: Agentic Artificial Intelligence (AI) and Network Digital Twins (NDTs) are increasingly combined to form Cognitive Digital Twins (CDTs) that translate operational intents into network changes and support closed-loop management. However, a network change may achieve its intended objective while disrupting the monitoring or recovery mechanisms needed for subsequent decisions. For example, a service may be rerouted while its latency-monitoring traffic continues along the original path, producing measurements that no longer reflect the service's performance. We propose Closed-Loop Dependency Assurance (CLDA), an assurance mechanism that augments agentic AI-enabled NDTs with dependency-aware validation. In our framework, an agentic AI planner generates and refines network plans, while the NDT evaluates the projected network outcomes of these plans. CLDA extends this analysis using a Loop Dependency Graph (LDG) that connects service requirements to monitoring mechanisms, forwarding paths, failure domains, and recovery prerequisites. CLDA projects candidate actions onto these dependencies, checks intermediate states of multistep plans, and supports deterministic make-before-break repairs using temporary monitoring mechanisms. Unlike the Large Language Model (LLM)-based planner, CLDA uses explicit, deterministic rules for assurance decisions and repair. We evaluate CLDA through controlled reconfigurations, a 240-trial LLM-based planning campaign, and live network execution. A separate synthetic study examines deterministic assurance scalability across network models representing up to 1,024 routers.

Sat 31 OctArtificial IntelligenceEmerging TechnologiesNetworking and Internet Architecture
The gist
Sometimes when a smart AI changes a computer network, it can accidentally mess up the ways we check if those changes worked. For example, a service might be rerouted but the monitoring data still comes from the old path, giving wrong results. The authors propose a way to make sure these changes don’t break the tools that keep an eye on the network. Their method uses a special graph to connect service needs with network monitoring and recovery tools, ensuring every step is checked before moving on. This helps AI plans avoid causing issues while managing networks.
Open → 2611.00838v1

Telecom language models combine broad and specialist networking knowledge

Building Telecom Language Models with RSOD: Domain Data, Specialist Post-Training, Memory-Conscious Distillation, and Networking Evaluation

Abstract: Telecom language models must combine broad networking knowledge with specialist behavior across routing, broadband services, access technologies, and operational diagnostics while remaining practical to deploy as a single model. We present an end-to-end framework that builds source-grounded synthetic training data from structured networking taxonomies and expert graphs, materializes 212,559 routed training records across fourteen networking routes, trains six frozen specialist LoRA teachers over one shared continued-pretrained backbone, and consolidates their behavior into one deployable student adapter using Routed Specialist On-Policy Distillation (RSOD). In RSOD, the committed student generates each trajectory, the route-assigned specialist teacher-forces the exact native token sequence, compact teacher hidden states are reconstructed through the shared frozen output head, and only the student LoRA is updated. A controlled reconstruction validation shows mean absolute logit error of 7.26 x 10^-6 with 100% top-1 agreement between native and reconstructed teacher logits. On four RTX 6000 Ada GPUs, the completed 2,000-step run produced 16,000 trajectories with zero observed student-version or token- ID mismatches. Under the primary route-conditioned evaluation over 2,850 held-out questions, the raw Meta-Llama-3.1-8B-Instruct model scores 12.8661/25 micro (13.0172/25 macro), the combined routed six-teacher system scores 21.7641/25 micro, and the consolidated RSOD student, released as Llama-CalixCLM v1, reaches 21.7112/25 micro (21.8006/25 macro) on the same five dimension LLM-judge rubric. Under a separate neutral deployment-like prompt, the same student reaches 20.0028/25 micro (20.0778/25 macro). The consolidated student remains within 0.0529 micro-score points of the combined routed-teacher system while retaining a numerically validated and auditable train-serve execution path.

Tue 20 OctArtificial IntelligenceComputation and LanguageMachine Learning
The gist
Language models for telecom need to understand many areas like routing and broadband while still fitting into one system. The authors created a way to train these models using expert networks and lots of example data, then combined smaller expert models into one through a special training method called RSOD. This combined model performs nearly as well as the separate experts but is easier to deploy and check. They tested it with thousands of questions and found it works well in real-world scenarios.
Open → 2610.27993v1

Minimal swarms balance exploration and use to approach resource sharing optimum

Self-organizing reinforcement learning: a swarm approaches the explore-exploit optimum

Abstract: The explore/exploit trade-off is the core problem of reinforcement learning (RL). We show that a minimal foraging swarm approaches its optimum - the ideal-free / Nash allocation of a multi-agent resource-sharing game (an equilibrium, not a return maximum) - with no learner and no reward signal. Agents explore by heavy-tailed (Levy) flights, recruit neighbours to a discovery through a threshold cascade on their proximity network, and disperse as a patch crowds; this cascade cycle balances exploration and exploitation and drives foragers toward the ideal free distribution. The swarm attains the shape of this optimum (committed foragers track richness with slope 0.94) but not its exact equilibrium - it stays measurably exploitable - reaching it dynamically (~150 steps) through the coupling of recruitment to movement: remove the coupling and matching collapses (0.94 -> 0.08). The RL sits at the level of the problem and the allocation reached, not the micro-rule: no step evaluates payoff (reward-free by construction, though the crowd signal is informationally tied to payoff), and the swarm reaches the allocation without learning it (quality plateaus and re-settles after resources move, no cumulative gain). Against a trained baseline the comparison is two-sided: in an easier, disembodied game a learner is more precise, while in the same embodied environment the reward-free swarm reaches ~65% of a validated oracle ceiling at zero training and leads until trained PPO and centralised-critic (CTDE) learners overtake it (~74-75%, 16 seeds, all above the swarm mean) after ~4,000 of 15,000 training steps - its advantage is in budget, not asymptote. In this one setting we read it not as beating RL but as a strong zero-shot, reward-free operating point: a demonstration that the self-organizing physics of a minimal swarm can carry a collective close to the optimum RL seeks, with none of RL's machinery.

Sun 18 OctMachine LearningArtificial IntelligenceSocial and Information Networks
The gist
Balancing trying new things and using what works best is a big challenge in teaching computers to learn. This paper shows that a simple group of agents, or 'swarm,' can get close to the best way to share resources without any learning or reward signals. The swarm explores by moving in a specific pattern, shares discoveries with neighbors, and spreads out when places get crowded, naturally balancing looking around and sticking to good spots. Although it doesn’t reach the perfect balance exactly, it performs well without the usual trial-and-error learning methods.
Open → 2610.25113v1

Temporal graph training made faster by skipping redundant events

RAFT: Redundancy-Aware Input Filtering for Temporal Graph Neural Network Training

Abstract: Temporal graph neural networks (TGNNs) have shown strong performance on dynamic graph learning tasks by continuously updating node memories from evolving interactions (i.e., events) and leveraging these memories for downstream predictions. As graphs grow rapidly in modern applications, training requires processing an increasing number of events; meanwhile, each event can update node memories used by later events, creating dependencies that constrain parallel execution and limit the benefits of additional computing resources. These costs motivate an upstream question: Are all events, and the dependencies they introduce, necessary for learning? We investigate this question through two roles of temporal events: prediction targets and historical events sampled as inputs. We observe that targets involving stable node memories tend to exhibit lower prediction loss, while filtering historical events associated with stable memories can retain similar training-loss trajectories in several evaluated settings. Together, these observations suggest an opportunity to identify input redundancy through changes in node memories. Building on this opportunity, we propose RAFT, a redundancy-aware input-filtering framework for TGNN training. RAFT tracks memory changes during training and uses them to guide two filters: a root-event filter removes selected prediction targets before training, and a support-event filter excludes selected historical context during sampling. Filtering inputs before their downstream preparation and processing reduces the work they trigger. Across three TGNN models and five datasets, RAFT reduces training inputs by 35.23% on average and up to 97.11%, while reducing recorded training time by up to 52.56\% with negligible changes to model precisions.

Sat 17 OctMachine LearningArtificial Intelligence
The gist
Graphs that change over time are tricky to teach computers to understand because every new event can affect how previous information is used. The authors found that not all these events are needed to learn well—some bring redundant information. They created a method called RAFT that watches how much information changes and skips the less useful events during training. This speeds up training by over half while keeping the accuracy about the same.
Open → 2610.24875v1

Graph neural networks learn new classes without forgetting old ones

MAEM: Mitigating Recency Bias via a Replay-Free, Capacity-Controlled Dynamic Mixture of Experts for Class-Incremental Graph Learning

Abstract: Graph Neural Networks (GNNs) excel on graph-structured data but suffer catastrophic forgetting when classes arrive sequentially. In class-incremental graph learning, predictions are often dominated by recently learned classes, causing severe recency bias. Dynamic expansion can isolate knowledge across sessions, but many methods assume task-incremental settings and require task identities at test time to select branches or heads---information unavailable in class-incremental learning. Learnable routers offer an alternative, yet continual fine-tuning the router on new data can bias routing toward recent components. We propose MAEM, a replay-free, capacity-controlled dynamic mixture-of-experts framework for class-incremental graph learning. MAEM builds representations with Simplified Graph Convolution (SGC) and trains a dedicated expert for each new session, then freezes it to protect prior knowledge. For routing without task IDs or a shared trainable router, each expert uses a masked autoencoder (MAE); test nodes are assigned to the expert with the lowest reconstruction error, reducing routing-level recency bias. When the expert pool reaches a fixed capacity, MAEM merges the least-used experts via Git Re-Basin alignment and further distills them into a fused expert using topology-aware pseudo data synthesized from MAE distributions (DeepInversion-style), without storing or revisiting historical graph data. On four class-incremental graph benchmarks, MAEM mitigates recency bias, outperforms strong continual graph learning baselines, and keeps model capacity bounded under strict replay-free learning.

Wed 14 OctMachine Learning
The gist
Graph neural networks struggle to remember old knowledge when learning new classes one after another. The authors introduce MAEM, a method that assigns each group of new classes to a separate expert model that is then frozen to protect past knowledge. Instead of storing old data, MAEM uses a smart way to pick the best expert for new inputs and merges less-used experts when needed to keep the model size manageable. This approach helps reduce the problem of recent classes overshadowing older ones, improving performance on graphs without needing to review old data.
Open → 2610.20238v1

Hawkes background estimation improved by projected Wasserstein-Fisher-Rao flows

Projected Wasserstein-Fisher-Rao Flows for Hawkes Background-Intensity Estimation

Abstract: We consider the problem of estimating the background intensity of a Hawkes process when the triggering mechanism is known, treating the background as an unknown finite positive measure with a regular density. We propose a likelihood-based variational approach based on the Wasserstein-Fisher-Rao geometry. In this setting, the relevant first variations are naturally distribution-valued and therefore fall outside the classical gradient-flow formulation. We develop a distributional framework for the resulting dynamics and give them a finite-dimensional meaning through projections onto statistical manifolds. We identify the true background as the unique zero of a limiting generalized gradient and, under suitable stability, compactness, integrability and approximation conditions, establish a conditional consistency theorem for measurable estimators satisfying the empirical projected equations on events whose probabilities tend to one. Finally, we specialize the construction to Gaussian-mixture manifolds and obtain an explicit finite-dimensional scheme.

Wed 14 OctMachine Learning
The gist
Estimating the background activity in Hawkes processes, which model events triggering other events, is challenging when the causing mechanism is known but the baseline rate is unknown. The authors develop a new mathematical approach using Wasserstein-Fisher-Rao geometry to estimate this background intensity more accurately. They translate complicated mathematical dynamics into a finite-dimensional framework, make the solution uniquely identifiable, and prove that their estimator is consistent under certain conditions. The method is then specified explicitly for Gaussian mixture models, making it computationally practical.
Open → 2610.19588v1

Autonomous training gym boosts cyber defence AI with realistic simulations

Autonomous Cyber Operations Gym for Training and Evaluating AI Models for Defence

Abstract: This paper proposes an Autonomous Cyber Operations (ACO) gym, a unified framework integrating high-fidelity network emulation, realistic user behaviour modelling for benign network traffic and adversarial profiles, and the generation of cybersecurity scenarios through open toolkits. By supporting live and deferred feature extraction at the packet and flow levels, the gym facilitates the creation of labelled synthetic datasets for training Deep Neural Network (DNN)-based Intrusion Detection Systems (IDSs), as well as developing and evaluating modular components for autonomous defence agents through emulated interactions. While evaluation of a DNN classifier within the gym shows high in-domain performance, achieving near-perfect recall on adversarial network flows, our experiments reveal a significant sensitivity to domain shift, showing that even minor changes in network composition, such as variations in traffic protocol distribution, can lead to a catastrophic collapse in model transferability and detection performance.

Tue 13 OctCryptography and SecurityMachine Learning
The gist
Detecting cyber attacks with AI requires realistic data, but real network traffic is hard to get and simulate. The authors created a virtual gym that mimics real network actions and attacker behaviors to train and test AI models for spotting intrusions. Their tests show AI can detect attacks well within the simulated setting, but struggles when networks change slightly, revealing challenges for making AI that works widely in real life.
Open → 2610.18594v1

Calm-5g controls risk for 5g service alarms with guaranteed reliability

CALM-5G: Event-Level Conformal Risk Control for Predictive Service-Assurance Alarms

Abstract: Predictive service assurance converts forecasts of key performance indicators into alarms, and that conversion decides whether the assurance function is deployable. We present CALM-5G, an assurance layer that operates above any forecasting backbone and issues alarms with distribution-free, finite-sample guarantees. It calibrates on service-level violation events, scores violation onset directly, selects its calibration scheme out of sample, and reports the alarm duty cycle with every certified miss rate. Four corpora are evaluated separately, namely a production cellular network, commercial 5G traces, an open radio access network testbed and our 5G standalone testbed. Risk control on the regression-derived score yields duty cycles of 0.24 to 0.91. Onset targeting with cross-validated calibration reduces time-in-alarm by 56.3% to 89.7% on three corpora, with no significant change on the fourth. The realised miss rate stays within a two-standard-error tolerance on three corpora and within one standard error of it on the fourth. Under label shift, pooled batch calibration exceeds that tolerance structurally, by 10.9 standard errors on the production corpus. Online calibration restores compliance. Calibration schemes cannot be ranked on the split that fits their thresholds. Miss rate and duty cycle are certified jointly where within-entity dependence leaves sufficient calibration units.

Tue 13 OctNetworking and Internet ArchitectureMachine Learning
The gist
Predicting when mobile networks might have problems can help fix issues before users notice, but turning predictions into alerts can be tricky. The authors created CALM-5G, a system that triggers alarms on 5G networks with reliable, math-backed guarantees, even with limited data. They tested it on multiple real-world network datasets and showed it reduces false alarms while keeping missed issues low. Their method adapts online to changes in network behavior to stay accurate.
Open → 2610.17962v1

Transformer-based network intrusion detection improved by session-based sequences

Beyond Model Scaling: Rethinking Sequence Construction for Transformer-based Network Intrusion Detection

Abstract: Transformer-based network intrusion detection systems (NIDS) have shown strong potential for detecting multi-stage cyberattacks, yet most methods construct input sequences using fixed temporalization schemes rather than treating sequence construction as a systems design decision. In flow-based intrusion detection, timestamp-based windowing often fragments related attack activities while merging unrelated communications, reducing the behavioral context available to transformers. We present a unified pipeline abstraction that decomposes transformer-based NIDS into four design dimensions (traffic representation, temporalization, transformer backbone, and prediction aggregation) and propose session-coherent temporalization, which constructs sequences from communication sessions instead of fixed time windows. Experiments on three complementary intrusion detection datasets show that temporalization is the dominant factor governing transformer performance: session-coherent temporalization more than doubles Macro-F1 over timestamp-based windowing, enabling lightweight transformers to achieve up to 0.95 Macro-F1 at substantially higher inference throughput than pretrained models. We further vary the transformer size from 0.65M to 3.38M parameters and find that larger transformer models provide no measurable accuracy improvement despite substantially higher computational cost, while zero-shot cross-dataset evaluation shows only modest gains under domain shift. These results indicate that preserving communication-session semantics, rather than scaling transformer capacity, is the key to accurate and efficient transformer-based intrusion detection.

Tue 13 OctCryptography and SecurityNetworking and Internet Architecture
The gist
Network intrusion detection systems try to spot cyberattacks by looking at network data sequences. Most systems divide data into fixed time windows, which can mix unrelated activities or split related attack steps, making detection harder. The authors show that organizing data based on communication sessions, rather than time, greatly improves detection accuracy for transformer models. They also find that making transformers bigger doesn't help much once good session-based data organization is used.
Open → 2610.17725v1

Rapidly detect unknown distribution shifts without tuning parameters

Monitoring for Shifts at Unknown Times: Parameter-Free Conditional Conformal Martingales

Abstract: Conditional conformal test martingales provide sequential tests for detecting distribution shifts, using a fixed reference dataset to avoid contamination from test-time samples. Prior work used a penalized betting function via online optimization with smoothing, clipping, and other hyperparameters, which can adapt slowly when a shift occurs after a long stationary period. In this work, we introduce an approach that requires no hyperparameters and provably adapts quickly to shifts occurring at unknown times. Our key idea is to frame the penalized betting problem as portfolio selection in a three-asset market. Then, we use a restarting universal portfolio, with a heavy-tailed wealth allocation over time. We establish anytime false-alarm control and derive optimal finite-sample bounds on detection delay under detectable alternatives. We also develop an FFT-based implementation that computes the portfolio sequence over $T$ rounds in $\mathcal{O}(T^2\ln T)$ time, instead of $\mathcal{O}(T^3)$ of the naive implementation. Synthetic and real-world experiments suggest that the proposed approach adapts rapidly after long periods of null samples, with detection delays depending substantially less on shift time than prior baselines.

Mon 12 OctMachine Learning
The gist
Detecting when data changes unexpectedly is important but can be hard if you don’t know when the change will happen. The authors developed a method that spots these changes quickly without needing any tricky setup or tuning. They use ideas from investing to manage how they detect changes, helping them adapt faster than older methods. Their approach is backed by math guarantees and works well on both made-up and real data.
Open → 2610.17343v1

Gpu takes control to speed up network ai without cpu delays

Toward Intelligent Networks via AI-Aware GPU-Native Packet Processing

Abstract: The integration of inline Artificial Intelligence (AI) models into critical network infrastructure is fundamentally bottlenecked by the high latency and synchronization overhead of CPU-mediated packet processing. While legacy GPU offload and recent CPU-bypass frameworks attempt to bridge this gap, they remain trapped in proprietary ecosystems or still rely on the host CPU and coarse-grained batching to coordinate stateful telemetry and AI pipeline execution. In this paper, we propose AGP, a novel framework that promotes the GPU from a passive accelerator to a primary data-path controller, answering what changes architecturally when the GPU autonomously owns the complete packet-to-inference pipeline. By enabling GPU-native packet processing, contention-free in-GPU stateful aggregation, and a persistent mega-kernel for continuous AI inference, AGP removes the CPU from the critical path. Our evaluation demonstrates that native in-GPU packet processing sustains line-rate throughput while being over 6.1x more power-efficient. Furthermore, our integrated Intrusion Detection System (IDS) stress test eliminates the legacy CPU-GPU synchronization tax, reducing end-to-end latency by 7.9x (up to 35x p99) and accelerating whole-system inference throughput by 9.3x using only ~2% of the GPU's thread capacity.

Thu 8 OctNetworking and Internet Architecture
The gist
Network systems often slow down because CPUs have to handle every packet before AI can analyze it, causing delays. The authors present AGP, a new method that lets GPUs directly process network packets and run AI models without waiting for the CPU. This setup greatly reduces delays and uses less power while keeping up with high-speed data. The authors showed that their system can detect threats much faster with lower resource use compared to traditional methods.
Open → 2610.12139v1

Machine learning improves operating system detection from network data

Machine Learning Optimization for Enhanced OS Fingerprinting

Abstract: Operating System (OS) Fingerprinting is a technique that can be used to identify a network's operating systems by evaluating network traffic in the form of TCP/IP packets. This research will explore the effectiveness of passively identifying operating systems on the CIC-IDS2017 dataset, a collection of over 47 gigabytes of pcap files with their corresponding operating systems. This research also proposes a new command line interface, OsirisML, which uses nPrint to preprocess the data into tabular data and XGBoost to apply ML to the data to generate, retrain, and test ML models. When packets are split randomly between training and testing, OsirisML models reach an accuracy of 97.66% on a down-sampled subset of the Friday capture and 84.69% on the entire capture. On the entire Monday capture, which contains no attacks, OsirisML reaches an accuracy of 73.83% and an F-1 score of 79.38%.

Thu 8 OctMachine Learning
The gist
Identifying the operating systems running on devices in a network helps protect and manage those devices. This paper shows how machine learning can analyze network packets to recognize operating systems with good accuracy. The researchers built a tool called OsirisML that processes data and applies a popular machine learning method called XGBoost to identify systems. Their tests show it works well in different network traffic scenarios but with varying accuracy depending on the data.
Open → 2610.11133v1

PairAudit improves error detection in intrusion reviews with graph tokens

PairAudit: Guiding Human Review with Graph Tokens under Distribution Shift

Abstract: Intrusion detectors can confidently misclassify attacks that were not seen during training. Human review can correct these errors, but only a limited number of cases can be checked. Uncertainty-based review may overlook confident errors, while anomaly scores alone do not show whether changing the review plan will correct more errors. We introduce PairAudit to find overlooked errors and improve review under a fixed budget. Its graph tokens capture prediction patterns across connected nodes. Rather than building another predictor through feature aggregation, PairAudit uses unusual relational patterns to uncover potential errors in existing predictions. Human feedback then helps decide whether these findings justify changing review priorities. Experiments across security tasks show that PairAudit corrects more errors on average than uncertainty-based review, including more errors on unseen attacks. These gains account for all review costs and do not require retraining the detector.

Wed 7 OctMachine LearningCryptography and Security
The gist
Intrusion detection systems can confidently make mistakes when encountering attacks they haven't seen before. The authors introduce PairAudit, a tool that helps human reviewers find these hidden errors by looking at unusual patterns in how predictions relate to each other. Instead of only focusing on how uncertain a detector is, PairAudit uses relationships between data points to suggest which cases should be reviewed. This approach lets reviewers fix more errors without needing to retrain the original detection system.
Open → 2610.10260v1

Graph wave state space models improve weather and temporal graph forecasts

WaveGSSM: Graph Wave State Space Models for Propagating Spatio-Temporal Patterns

Abstract: Spatio-temporal graph models typically encode each snapshot with a GNN and then connect the resulting representations through a temporal module. This space-then-time design is effective, yet it does not explicitly represent how a pattern moves across the graph. We show empirically that, for a propagating process, the same present field can lead to different futures when its recent rate of change differs, motivating an explicit representation of motion in the predictive state. We introduce WaveGSSM, a second-order graph state-space model that maintains two coupled latent states at each node, one for the current pattern and one for its temporal rate of change. A graph-wave transition updates the motion state through graph interactions and uses it to advance the pattern state, coupling spatial propagation and temporal evolution within a single rollout. We evaluate WaveGSSM on four temporal-graph benchmarks and global weather forecasting. It consistently achieves the best mean performance across the temporal-graph benchmarks and reduces the geopotential RMSE by 20.2% on average for 1- to 5-day weather forecasts relative to a backbone-matched snapshot model, while better preserving large-scale atmospheric patterns.

Mon 5 OctMachine Learning
The gist
Predicting how things change over time in networks like weather systems can be tricky because it's not just the current state that matters, but also how that state is changing. The authors created a new model called WaveGSSM that keeps track of both the current pattern and its rate of change at every point in a graph. This helps the model better predict future states by explicitly capturing the motion of patterns over time and space. They tested WaveGSSM on different datasets and found it outperformed existing methods, especially in weather forecasting where it reduced forecasting errors and preserved important large-scale patterns.
Open → 2610.06540v1

Anlu improves time series anomaly detection using counterfactual reference signals

Anlu: Enabling In-Context Time Series Anomaly Detection in Foundation Models via Counterfactual Supervision

Abstract: Whether a time-series pattern is anomalous often depends on the operating regime of the monitored process. A missing event can signal a fault in one regime and be routine in another, and the query alone may not reveal which regime applies. We study in-context learning (ICL) for time series anomaly detection (TSAD) through reference-conditioned detection, where a reference record provides evidence about expected behavior and model parameters remain fixed at inference. Supplying the reference is not enough: when training anomalies are recognizable from the query alone, the detector can fit its targets while ignoring the reference. We therefore introduce counterfactual supervision, which pairs one query with two references that support different normal rules and labels the query under each. At positions where the two labels disagree, no detector that ignores the reference can fit both targets. Anlu learns from this supervision by adding a reference memory and zero-initialized gated adapters to a frozen time-series foundation model (TSFM) pretrained for anomaly detection. On the 350 TSB-AD-U evaluation sequences, Anlu raises the mean VUS-PR of the frozen TSFM from 0.542 to 0.607. Replacing the reference with zeros lowers Anlu's score to 0.499.

Mon 5 OctMachine LearningArtificial Intelligence
The gist
Detecting unusual patterns in time series data can be tricky because whether something is normal or abnormal depends on the context or operating conditions. The authors studied how to help large pretrained models spot anomalies better by showing them examples of normal behavior alongside the data. They introduced a special training method where the model sees one data example paired with two different normal contexts and learns to detect anomalies differently depending on the context. This method improved detection accuracy on a large evaluation dataset compared to using the pretrained model alone.
Open → 2610.06180v1

Finite state machines improve traffic routing for multiple analysis engines

Finite State Machine-Based Traffic Orchestration for Multi-Engine Analysis Platforms

Abstract: Modern application-security platforms route live traffic from a single proxy into several independent analysis engines -- behavioral anomaly detection, authentication analysis, resource discovery, access-control inspection, among others. Each engine's appetite for traffic changes on its own schedule, yet the proxy can honor only one forwarding instruction per resource. We present a traffic-orchestration method that models the combined needs of all engines as a single composite finite state machine (FSM) whose state space is the Cartesian product of per-engine states. Every reachable composite state pre-maps to one forwarding configuration, so runtime reduces to a lookup rather than a negotiation. We add two refinements: time-based expiry treated as a first-class FSM transition enabling declarative traffic decay, and per-state multi-tier outputs that let one machine serve every service level. The design is fully declarative, engine-agnostic, and scales to N engines without re-architecture.

Mon 5 OctSoftware Engineering
The gist
The problem is how to send network data to different analysis tools that each want different amounts of data at different times. The authors present a way to combine all these needs into one big machine that decides where to send the data instantly using simple lookups. They also add features to handle timed changes and different service levels automatically. This method works without needing to rebuild the system as more tools are added.
Open → 2610.05788v1

Quantum networks improve data quality by routing with priority delays

Priority-Aware Routing for Quantum Networks:Integrating Coherence-Time Constraints into Scheduling

Abstract: Quantum networks face a fundamental challenge absent in classical networks; finite memory coherence times mean that queuing delay directly degrades information quality, causing decoherence that has no classical analog. Existing routing protocols optimize for hop count or channel fidelity while treating scheduling delays as a secondary concern, leaving fidelity vulnerable to congestion-induced decoherence. We present a coherence-aware routing protocol that integrates decoherence constraints into path selection via a priority-modulated aging model derived analytically from Weighted Fair Queueing theory, where high-priority traffic receives compressed effective queue delay. We build a custom discrete-event simulator verified against NetSquid (across 104 states), and evaluate across two structurally diverse topology classes under identical physical parameters, isolating topology structure as the sole independent variable. In all experiments, our protocol is benchmarked against loss-only Dijkstra routing and FIFO scheduling as baselines. On topologies, P2 traffic achieves 96.08% fidelity under a 9x load increase with only 0.04 percentage point degradation, versus a 13.51 percentage point collapse for the loss-only baseline; P2 tail latency holds stable at 0.055 ms while Dijkstra degrades 5.5x. On Barabasi-Albert scale-free topologies, our protocol delivers a +4.12 percentage point fidelity advantage with 97.8% higher aggregate throughput at operational loads over the baseline, with a clearly characterized hub-saturation boundary at 160k QPS. FIFO scheduling provides negligible priority differentiation on both topology classes, providing strong evidence that coherence-aware routing-not scheduling alone is responsible for the observed QoS gains.

Tue 29 SeptNetworking and Internet Architecture
The gist
Quantum networks have a problem that normal networks don't: the memory holding the quantum data loses quality the longer it waits. The authors created a way to pick network paths that consider how long data waits, so important messages lose less quality. They tested their method with computer simulations that matched real quantum network models and found it keeps data clearer and faster even when the network is busy. Their approach works well on different network designs and beats usual routing methods that ignore waiting time effects.
Open → 2609.38380v1

Simple method selects useful data fields for AI analysis

SAIVE: Selecting AI Valuable Entities

Abstract: Data lakes store large amounts of telemetry, with logs from network sensors, hosts, and applications containing possibly hundreds of fields for every event. Large enterprises are then left with data lakes that cannot be analyzed efficiently with AI. Aggregate analysis looks at persistent shifts in behavior over time. Many of the fields and columns in data lakes are not useful as they do not contain information that is sufficiently diverse or concentrated to support AI analysis. SAIVE is a simple method for examining a few rows in a large table and applies a histogram of histograms filtering criterion to select the fields that for AI analysis is more likely to yield useful results. This paper provides a principled foundation for the SAIVE heuristics by assuming of a Zipf-Mandelbrot power-law distribution of the underlying data. Constraining the Zipf-Mandelbrot exponent alpha to a reasonable range provides a a practical, cheap, expert-free filter for selecting AI valuable entities in large data sets.

Tue 29 SeptDatabases
The gist
Large companies collect huge amounts of data from computers and networks, but not all information is useful for AI analysis. The authors developed SAIVE, a simple way to pick which pieces of data are likely to help AI work better by looking at a small sample of the data. They base their method on a mathematical pattern called Zipf-Mandelbrot distribution to filter out unhelpful data without needing experts. This helps make AI analysis more efficient and focused.
Open → 2609.36512v1

Modeling uncertainty and dependency improves multivariate time series anomaly detection

GT-PSSM: Unified Probabilistic Framework for Stochastic Dynamics Modeling and Dependency Learning in Multivariate Time Series Anomaly Detection

Abstract: Multivariate time series anomaly detection (MTAD) is crucial for ensuring the safe and reliable operation of complex systems. Many existing methods learn normal patterns by training reconstruction or forecasting models on predominantly normal data. However, a large portion of these approaches rely on deterministic models and their associated point-wise output errors for anomaly scoring. Since real-world multivariate time series are inherently stochastic due to measurement noise and intrinsic system randomness, purely error-based scores can be unreliable, as large errors may arise from benign fluctuations rather than true anomalies. Probabilistic approaches address this limitation by quantifying uncertainty in model outputs. In particular, probabilistic state-space models (PSSMs) provide a principled framework by modeling stochastic system dynamics through latent state transitions and measurement noise via emission models. Despite this advantage, existing PSSM-based MTAD methods often struggle to capture long-range temporal dependencies and inter-variable dependencies, as they typically rely on noise-sensitive recurrent architectures and lack explicit cross-variable structure modeling. To address these limitations, we propose Graph-Transformer-Enhanced Probabilistic State-Space Model (GT-PSSM), a novel PSSM-based MTAD method that tightly integrates PSSM-based probabilistic modeling of stochastic dynamics with Graph Transformer-based learning of temporal and inter-variable dependencies. By jointly modeling stochasticity, long-range temporal dependence, and variable interactions within a unified probabilistic framework, GT-PSSM enables more robust anomaly detection.

Mon 28 SeptMachine Learning
The gist
Finding unusual events in data that changes over time and across many parts is important for safety. The authors point out that usual methods often treat these data as predictable and may mistake normal random changes for problems. They created a new approach that combines a way to handle randomness with a method to understand both how things change over time and relate to each other. This combined approach helps detect true problems more reliably.
Open → 2609.34161v1

Local checks improve safety and accuracy in network automation

Can You Check That? The Checkability Boundary for Local LLM Network Automation

Abstract: Sending every network-automation input to a third-party frontier LLM exports sensitive artifacts such as production configurations, topologies, and logs. Querying small language models (SLMs) locally avoids this egress, but SLM outputs can be error-prone for direct use. This work introduces checkability as a criterion for determining which tasks are suitable for local inference. A task is checkable when it exposes a cheap, deterministic test - an intrinsic check - that rejects outputs violating a necessary correctness condition. We instantiate this idea in Touchstone, a local-first pipeline that uses seven off-the-shelf SLMs (1-8B parameters) to generate candidates, uses task-specific intrinsic checks to reject responses, and escalates unresolved inputs to a frontier LLM. On conflict detection and intent translation tasks, Touchstone reaches 98.6% and 93.8% end-to-end accuracy while escalating only 16% and 17% of inputs, respectively. On TeleQnA, a knowledge-only control that has no task-specific intrinsic checks, Touchstone is unable to match the accuracy of the frontier baseline. Our results support a simple deployment rule: keep inference local when task semantics support precise, low-cost checks; escalate the rest.

Fri 25 SeptNetworking and Internet ArchitectureArtificial Intelligence
The gist
Sending sensitive network data to big online language models can risk privacy, so running smaller models locally is safer but less reliable for some tasks. The authors introduce the idea of 'checkability,' meaning a task is suitable for local models if there is a fast and clear way to check if the answers are correct. They build a system called Touchstone that first tries local small models and checks outputs before asking a big model for help only when needed. Their approach works well on tasks like detecting conflicts or understanding commands while keeping most data local, but it doesn't perform as well on tasks without clear checks.
Open → 2609.31540v1

Graph dynamics model predicts changing networks in uncertain settings

Beyond Static Graph World Models: Learning Stochastic Latent Dynamics over Evolving Topologies

Abstract: Graph-based world models have recently emerged as a means of learning transitions over relational state representations. However, existing approaches are largely limited to fixed-topology graphs or deterministic, fully observable environments. We propose the Graph Dynamics Model (GDM), a world model for graph-structured observations that is designed to handle the more general setting of evolving topologies in stochastic and partially observable environments. The GDM uses a sparse recurrent adjacency matrix to model topology updates and perform message passing, together with a recurrent state-space architecture for modelling stochastic transitions. Furthermore, we identify a gap in the evaluation of graph-based world models, as existing methods do not provide a means of comparing predicted and true distributions over the joint graph state comprising the interdependent topology, node features, and graph features. We therefore introduce the Graph Distribution Distance (GDD) metric, which uses maximum mean discrepancy with a graph kernel to comprehensively compare joint next-state distributions. We evaluate the GDM across several environments, including stochastic and partially observable settings. We demonstrate that GDM outperforms baseline models and displays zero-shot generalisation on large graphs.

Wed 23 SeptMachine LearningArtificial IntelligenceSocial and Information Networks
The gist
Many models assume networks (graphs) don’t change over time, but real-world situations often involve networks that evolve unpredictably. This paper presents the Graph Dynamics Model (GDM), which can learn and predict how both the structure and attributes of a network change in environments that have randomness and only partial observations. The authors also introduce a new way to measure how well these models capture the true behavior of evolving networks. Their experiments show that the GDM produces better predictions and can handle larger networks than previous methods.
Open → 2609.28670v1

CacheDyG speeds up learning on dynamic graphs with less memory

CacheDyG: Decoupling Temporal Propagation for Efficient Dynamic Graph Learning

Abstract: Dynamic graphs are widely used to model time-evolving relational systems in real-world applications. Dynamic graph neural networks provide an effective framework for capturing both structural dependencies and temporal dynamics in such data. However, they typically intertwine temporal graph propagation with every optimization epoch and often maintain large trainable representations for each node-time pair. This design repeatedly recomputes largely unchanged historical structures, leading to substantial training and parameter overhead. To address this critical issue, we propose CacheDyG, a Cache-refine framework for efficient Dynamic Graph learning. Specifically, it decouples temporal propagation from routine parameter updates by constructing a time-ordered temporal dependency cache that stores graph-aware node-time representations in non-trainable buffers. During standard training epochs, CacheDyG reads from the cache and updates only a lightweight cache refiner, an adaptive residual gate, and the link predictor. Selective cache refresh further keeps cached representations aligned with the supervised objective while avoiding epoch-wise sparse propagation. Experiments on five dynamic graph benchmarks show that CacheDyG adopts substantially fewer trainable parameters and lower runtime to obtain more competitive predictive performance than baselines. These results demonstrate that cache-based decoupling provides an effective principle for scalable dynamic graph learning.

Tue 22 SeptMachine Learning
The gist
Dynamic graphs represent things that change over time, like social networks or traffic patterns, and analyzing them takes a lot of computing power. The authors found that current methods waste time recalculating parts of the graph that don't change much between training steps. Their solution, CacheDyG, keeps a special memory bank of past computations and only updates small parts needed for learning. This makes training faster and uses fewer parameters while still making good predictions.
Open → 2609.25814v1

Scalable algorithm finds tight communities around many nodes fast

Improved Methods for k-core Community Search

Abstract: Community search based on user-specified query nodes is complementary to community finding or graph clustering. Prior work in community search is divided into optimizing for external separate- ness or internal cohesiveness, which does not scale well networks of over a billion edges. We present SteinerKCore, a new scalable k-core based community search algorithm for multi-vertex queries. We also present Par-ShellStruct, a parallel algorithm for building the ShellStruct data structure used for k-core community search. We show that our implemen- tations in Icebug, an open-source toolkit for large-scale network analysis, are both more efficient and more scalable than comparative tools, being able to perform on a benchmark network of 273M and 5.1B edges using just 64GB RAM and under 4 hours runtime with 16 CPUs.

Tue 15 SeptSocial and Information Networks
The gist
Finding groups of connected friends or items around specific people in huge networks is hard. Past methods struggled with very large networks or only worked well for certain group shapes. The authors created SteinerKCore, a new method that quickly finds strong, tightly connected groups including many chosen people. They also made Par-ShellStruct, a fast way to prepare necessary network information using multiple computers. Their tools work well on extremely large networks using reasonable memory and time.
Open → 2609.17822v1

Network traffic classification improved with human guided semantic validation

Beyond Measurement Metrics: A Human-Centered Framework for Semantic Validation of Network Traffic Classification

Abstract: Machine learning (ML) has become the dominant approach for network traffic classification, achieving very high predictive performance. However, a model is only valuable if it learns semantically meaningful and trustworthy patterns rather than exploiting spurious correlations. Conventional evaluation practices predominantly assess predictive performance. Consequently, whether the model relies on semantically meaningful patterns remains unknown. To address these challenges, we adapt the knowledge generation framework for network traffic classification. The adapted framework combines data, ML models, explainability, visualization, and expert reasoning to support the iterative exploration, verification, and refinement of model behavior and data preprocessing. The framework is grounded in findings from the literature, benchmark dataset analyses, practical experience with XAI-based traffic classification, and expert feedback, providing practical guidance for semantic model validation. By complementing predictive performance with semantic validation and human expertise, the proposed framework supports the development of network traffic classification models that are not only accurate but also robust and trustworthy.

Tue 15 SeptNetworking and Internet ArchitectureHuman-Computer InteractionMachine Learning
The gist
High accuracy in identifying types of network traffic using machine learning is common, but it is unclear if the models learn meaningful patterns or just tricks. The authors propose a new framework that brings together data, machine learning models, explanations for those models, visual tools, and expert judgment to better understand and improve model behavior. This approach helps ensure that the models work in a trustworthy way and are robust, not just accurate. It encourages combining human feedback with machine performance to make smarter network traffic classification.
Open → 2609.17014v1

Signals improve safety checks for network operation agents

Safety Signals to Verify NetOps Agents with Action-Level Granularity

Abstract: Agentic Network Operations (NetOps) are an emerging paradigm promising to enable workload-aware, self-adjustable, and reliable autonomous networks. While agents have proven their value in incident summarization and telemetry signal extraction, their effectiveness as autonomous control-loop engines heavily relies on their long-horizon reliability. One such setting is the datacenter fabric, where an agent must respond to alarms and operator intents while abstaining from high-risk actions that may cause or extend downtime. Abstention, however, presupposes that an action's impact is known pre-execution, which necessitates a per-action ground truth that NetOps agent benchmarks do not provide. We construct such a ground truth for the network repair task of NetArena. A symbolic replay of the emulated network, validated against the environment at every turn, yields the exact value of every action. From the action-level value, we derive two pre-execution targets, namely whether an action reduces the repair distance (progress) and whether it increases it (harm). We show across 10 agent models, that agent verifiers leveraging internal signals predict both harm and progress more reliably than a baseline using observable signals only. Perspectively, we aim to use these signals as safety feedback to an agent harness to abstain from risky actions and protect the target system.

Sun 13 SeptArtificial Intelligence
The gist
Managing computer networks automatically is tricky because some agent actions can cause problems or downtime. The authors created a way to precisely judge every action an agent might take before it happens, using a detailed replay of network conditions. They showed that by analyzing the agent's internal signals, they can better predict if an action will help fix the network or cause harm. This approach could help agents avoid risky moves and keep networks running smoothly.
Open → 2609.14422v1

Benchmark compares cloud-edge scaling and placement strategies under deadlines

ContinuumBench: Benchmarking Joint Autoscaling and Placement Across Evaluation Regimes in the Cloud-Edge Continuum

Abstract: Cloud-edge controllers coordinate service placement, replica scaling, and resource pre-warming to keep end-to-end latency within application deadlines. But evaluations often obscure the source of a reported gain: placement and scaling are studied separately; workload, connectivity, and calibration assumptions remain implicit; and metrics over completed tasks hide unfinished work. We present ContinuumBench, a benchmark that controls these factors. Its completion-aware accounting treats late, unfinished, and discarded tasks as deadline misses. A common protocol compares placement-only and scale-capable controllers under declared regimes and stressors. Built on the ECLYPSE simulator, ContinuumBench adds arrivals, worker elasticity, intermittent transport, buffering, and failures to close the control loop. We evaluate nine controllers across four scenarios and two regimes. The studied regimes are capacity-bound: elastic capacity, not placement sophistication, drives completion, and once capacity suffices, the choice of autoscaling policy decides how much of that work arrives on time. Placement re-planning has no measurable effect without relocation, while cost-free migration defines the observed exception. Consequently, scale-capable controllers approach an over-provisioned reference while placement-only controllers degrade with load; and placement quality separates controllers only once capacity is exhausted. Finally, the accounting choice itself changes the reported result: completion-only and completion-aware scoring can rank controllers differently.

Tue 8 SeptDistributed, Parallel, and Cluster Computing
The gist
Coordinating where and how much computing power to use in cloud and edge systems is tricky, especially to keep tasks finishing on time. The authors created ContinuumBench, a tool that fairly compares different controllers that decide service placement and scaling, making clear when tasks miss deadlines or fail. They found that scaling capacity often matters more than placement choices until resources are very tight, and different ways of counting task completion can change which controller looks best. This helps clarify how to better manage computing across clouds and edges for time-sensitive applications.
Open → 2609.08946v1

Network fault effects predicted with uncertainty using new model

Information-Entropy-Driven Fault Propagation Modeling for Probabilistic Network Performance Prediction

Abstract: Network faults can trigger cascading effects that cause abrupt and nonstationary performance degradation. Existing learning-based performance predictors mainly focus on normal operation or treat fault-induced topology and routing changes as static inputs, and typically produce deterministic point estimates. They overlook fault-propagation dynamics and uncertainty in performance evolution. The predefined-rule and purely data-driven propagation models lack a unified representation of fault definition, propagation mechanism, and impact quantification. Additionally, generic denoisers in conditional diffusion models fail to incorporate fault propagation into uncertainty modeling. To address these limitations, we propose an information-entropy-driven fault propagation paradigm (IEFP) that characterizes fault propagation via relative entropy, mutual information and transfer entropy. We then design a fault-aware graph message-passing mechanism that propagation contexts modulate network representation learning. We further develop FEMNet, which employs this mechanism as a tailored denoiser within a conditional diffusion model to enable probabilistic network performance prediction under complex fault scenarios. Compared with the strongest baselines, IEFP improves fault-prediction performance, while FEMNet reduces errors in both point and probabilistic KPI prediction.

Tue 8 SeptNetworking and Internet Architecture
The gist
Networks can experience faults that cause complicated and unexpected problems as issues spread through them. Existing prediction methods often treat faults as fixed changes and give only one guess about how the network will perform. The authors present a new way to understand and model how faults spread by measuring the information shared and transferred between parts of the network. They use this idea to build a tool called FEMNet that can predict not only the likely network performance during faults but also the uncertainty around those predictions.
Open → 2609.08143v1