Papers for

cloud infrastructure managers

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.

Validation pipeline improves regulated AI inference decisions and audits

Inference Validation for Regulated AI: Building a Decision Pipeline on NVIDIA AIPerf

Abstract: Deploying large language models in regulated industries requires more than picking the fastest inference engine: it requires evidence that a configuration meets contractual and legal obligations before it serves a single customer request. We describe Runway, an internal validation harness built at MasterControl that builds a governed decision pipeline around NVIDIA AIPerf. The key insight is separating concerns: AIPerf provides the trusted measurement, while Runway provides the experiment design that comes before it and the compliance, cost, and audit decisions that come after. We describe the architecture and the storage model that makes caching and audit one mechanism. We report three findings from Runway sweeps: TensorRT-LLM and vLLM rankings invert with concurrency; a newer, pricier GPU instance can be the cheaper one per request; and speculative decoding behaves differently across engines under load, so engine configuration can outweigh engine choice.

Mon 9 NovSoftware EngineeringMachine LearningPerformance
The gist
Running large language models safely in industries with strict rules needs more than just speed. The paper describes how the researchers built a system called Runway that checks and records how AI is run before it serves customers. Their system separates measuring AI performance from making business and legal decisions, helping companies trust the AI they deploy. They also found that performance rankings between AI engines can change depending on workload and settings, affecting cost and choice.
Open → 2611.12737v1

Agentic AI strategies trade off accuracy and carbon emissions

Toward Sustainable Agentic AI: Carbon Tradeoffs Across Iterative Self-Refinement and Tool-Augmented Coding

Abstract: Agentic language model systems can improve performance either by iterating on their own outputs or by using external tools in grounded environments. While these strategies can reduce error rates and substitute for larger models in some settings, their environmental cost remains relatively underexplored. We present two complementary empirical studies that estimate the energy and carbon footprint of agentic AI across settings of increasing complexity. Study~1 evaluates iterative verbal self-refinement: GPT-4.1-mini at $k = 1$--$5$ steps versus a GPT-4.1 single-pass baseline on two MATH benchmark splits. Study~2 evaluates tool-augmented agentic coding: GPT-4.1-mini, Claude Opus~4.6, and GPT-5.3-codex on SWE-bench Lite, where agents operate inside Docker-isolated environments with access to code execution and file editing tools. In Study~1, $k=3$ refinements close a 16-percentage-point accuracy gap to within 1~point, but nearly triple the carbon footprint relative to the cheap single-pass baseline while remaining below the GPT-4.1 single-pass baseline under the current token-based carbon scenario. In Study~2, GPT-5.3-codex achieves the highest resolution rate in this sample (81.2\%), ahead of Claude Opus~4.6 (68.9\%) and GPT-4.1-mini (25.0\%), but resolved-task-normalized efficiency remains mixed: GPT-4.1-mini is lowest on estimated carbon and cost per resolved task, while GPT-5.3-codex delivers substantially higher task success. All carbon estimates cover output-token inference only; prompt tokens, which exceed 99\% of tokens in Study~2, and tool execution are not charged, so the figures are lower bounds on the full agentic footprint.

Mon 9 NovArtificial Intelligence
The gist
Agentic AI systems can improve their answers either by checking and refining their own responses multiple times, or by using external tools like code execution environments. The authors studied how these approaches affect the AI's accuracy and its carbon footprint, which measures environmental impact. They found that while iterative self-refinement can greatly improve accuracy, it also increases carbon emissions nearly threefold. Using more advanced AI with tool use improved success rates but sometimes at higher carbon costs. These results help understand the environmental effects of different ways to improve AI responses.
Open → 2611.12128v1

Migration cuts machines needed for job scheduling in half

The Power of Migration on Identical Machines is Two

Abstract: We study the power of migration in preemptive scheduling on identical parallel machines with time windows. If an instance admits a migratory schedule on $m$ machines, how many machines are needed to schedule it without migration? Kalyanasundaram and Pruhs (2001) showed that $6m-5$ machines suffice and gave a polynomial-time construction using $12m-5$ machines, whereas $2m-1$ machines may be necessary. We close this gap, which has been open for more than 25 years: $2m-1$ machines always suffice, and a corresponding non-migratory schedule can be computed in strongly polynomial time. Our proof has two main technical ingredients. First, we introduce supercanonical schedules and prove that the conflict graph of every such schedule on $m$ machines is $(2m-1)$-colorable. The key property is that whenever a job pauses, the jobs running alongside it just before and just after the pause separate the jobs processed entirely during the pause from the rest of the conflict graph. We use these separators and Kempe exchanges to compute a coloring in polynomial time. Second, we construct a supercanonical schedule with polynomially many processing blocks by shrinking job windows as far as possible while preserving feasibility and solving a min-cost flow problem.

Mon 9 NovData Structures and AlgorithmsDiscrete Mathematics
The gist
Scheduling tasks on identical machines can be tricky when jobs need to move between machines (migration). The authors found that if it's possible to schedule jobs with migration on a certain number of machines, then you only need about twice as many machines to schedule the jobs without any migration. They proved this precise number and provided a way to find such a schedule efficiently. Their discovery closes a question that was open for over 25 years in how much extra resource is needed if migration is not allowed.
Open → 2611.12034v1

Activation sparsity training improves efficiency of large language models

SGA-Sparse: Training Native SwiGLU Gates for Activation-Sparse and Low-Bit LLMs

Abstract: Activation sparsity can reduce FFN weight traffic during single-user LLM decoding, but active channels must be identified early enough to avoid fetching unused weights. In pretrained SwiGLU models, training-free routing with the native gate performs substantially worse than routing with the up activation at high sparsity. We show that this ordering reverses after sparsity-aware training. Based on this insight, we introduce SGA-Sparse, which converts pretrained SwiGLU LLMs into fixed-budget activation-sparse models by training the existing gate projection directly as a top-k router. SGA-Sparse updates all model parameters end-to-end while preserving the original SwiGLU activation and introducing no auxiliary router parameters. After approximately 30B training tokens, LLaMA models from 1B to 8B achieve uniform per-token 75-85% FFN channel sparsity while remaining within 0.2-2.7 pp of their original dense checkpoints in average zero-shot accuracy. Because post-training quantization degrades sparsity-trained checkpoints, we further study two complementary quantization-aware training (QAT) recipes: continued-QAT largely recovers performance at 4-bit weight quantization, while joint-QAT performs better for the more aggressive sub-4-bit target. To compare activation sparsity with dense low-bit quantization, we translate the sparsity-induced reduction in weight traffic into an equivalent bit-width. Under this unified weight-traffic metric, our 2.5- and 1.5-bit-equivalent models establish a new accuracy-traffic Pareto frontier: the 2.5-bit-equivalent models match dense 3-bit QAT accuracy, while the 1.5-bit-equivalent models approach dense 2-bit models and outperform dense ternary models by 1.3 pp on average. These results establish native-gate training as a practical approach for combining high FFN sparsity with low-bit weights.

Sun 8 NovMachine LearningArtificial IntelligenceComputation and Language
The gist
Large language models use a lot of computing power, especially in parts called feed-forward networks (FFNs). This paper shows a way to train models so that only a fraction of these FFN parts need to be active during use, saving resources. The authors train a model called SwiGLU to decide early which parts to activate, making the model both sparse and able to use low-bit weights to reduce memory use. Their approach keeps the models accurate while reducing how much data needs to be processed.
Open → 2611.11223v1

Deep reinforcement learning improves ioT task offloading with class-aware rewards

SLA-Aware Task Offloading in the IoT Edge-Cloud Continuum: Class-Weighted Deep Reinforcement Learning Against an Exact Optimum

Abstract: Deep reinforcement learning (RL) is often used to decide where Internet of Things (IoT) tasks with different latency limits run in the edge-cloud continuum, yet some methods give every missed task the same penalty and few compare their agents with an optimal policy. This benchmark study builds four offloading systems small enough to solve exactly by dynamic programming and measures reward and learner against the optimum. A bonus for a met limit makes each miss cost its penalty plus the bonus, which shifts the class weights of published per-class rewards. A class-blind penalty stays 65% to 118% above the optimal cost even with a perfect learner, while a corrected per-class penalty comes within 0.13% of the optimum. With a per-class reward, tuned proximal policy optimization (PPO) agents come within 9% to 11% of the optimum in the smallest system, and the corrected one beats a tuned reservation rule in 9 of 10 seeds. In larger systems the agents stay 41% to 76% above the optimum, and a tuned rule beats their mean. Training ten times longer does not close this gap, and a PPO-Lagrangian agent with reachable targets does no better than the per-class reward.

Sat 7 NovArtificial IntelligenceMachine LearningNetworking and Internet Architecture
The gist
Deciding where to run Internet of Things (IoT) tasks—on a nearby device or faraway cloud—needs to consider different speed requirements to avoid delays. The authors studied how deep reinforcement learning can better manage these decisions by giving smarter penalties to tasks that miss their deadlines. They show that using class-specific penalties helps these learning agents nearly match the best possible decisions in small setups. However, for bigger systems, the agents still make mistakes and don’t outperform simpler methods even with extended training.
Open → 2611.10638v1

Continuous maintenance improves reliability of coding benchmarks for ai models

Benchmarks as Software: Terminal-Bench and the Case for Continuous Benchmarks

Abstract: Coding agents are among the most economically consequential deployments of LLMs to date, making reliable evaluation increasingly important. Yet even benchmarks that are carefully validated at release can become stale. As models improve, they can discover valid solutions that existing verifiers reject, while changes to evaluation infrastructure can invalidate assumptions embedded in tasks and tests. We call the resulting accumulation of defects benchmark maintenance debt: a growing gap between benchmark scores and the capabilities they are intended to measure. We introduce a continuous-validation workflow for agentic benchmarks that combines community reports, task artifacts, agent traces, automated oracle checks, and human-gated repairs. We apply this workflow to Terminal-Bench 2.0, a benchmark that underwent extensive human and LM-assisted review and red-teaming before release. Our audit identifies issues in roughly 30% of the benchmark, and we release the resulting repairs as Terminal-Bench 2.1. These repairs change evaluation results: accuracy increased by over 10 percentage points and leaderboard positions move by up to three ranks, even as the overall ranking remains highly correlated (Spearman rho = 0.958). We evaluate how resource allocation shapes benchmark conclusions. We show that fixed wall-clock can materially change agent performance: For example, extending the time limit closes a 20pp harness gap on GPT 5.4 and shrinks a 30 pp gap on GPT 5.4 mini to 5 pp. Benchmark maintenance is therefore not only about repairing task artifacts: resource budgets are part of the measurement specification and must be validated alongside the tasks themselves. More broadly, benchmark maintenance debt is not just accumulated implementation bugs: our results show that as models improve, both evaluation assumptions and resource settings may need to be revalidated.

Thu 5 NovArtificial Intelligence
The gist
Benchmarks measure how well AI coding agents perform, but over time, these tests can become outdated or flawed as models get better. The authors show that frequent checking and fixing of these tests, including adjusting resource limits, helps keep benchmark results accurate and meaningful. They applied this to a coding benchmark called Terminal-Bench, fixing many issues and showing how performance rankings can change as a result. Their work highlights that benchmark upkeep involves more than bug fixes—it also means rechecking assumptions and timing rules.
Open → 2611.08417v1

LLM defenders lure attacks into isolated honeypots to protect real targets

A Gingerbread House for LLM Agents: Source-Planned Honeypots That Lure Autonomous Attackers into an Isolated Shadow

Abstract: LLM agents can exploit web vulnerabilities fast enough that patching may come too late. Deception against such agents has mostly lured them away from a real target that stays reachable. We study a different arrangement: an LLM defender plans a static honeypot from the application's source, and a router sends every later request of a client it confirms as an attacker, including a working exploit, to an isolated shadow copy. We compare no defence, this static plan, and an augmented configuration with a runtime LLM responder and further router rules, graded by the benchmark's own grader on the real target and, for ARTEX, also on the shadow. On the 40 critical CVE-Bench tasks the static plan cut real compromise from 26/40 to 5/40 for Claude Opus 4.8 and from 20/40 to 0/40 (31 valid runs) for the ARTEX attack framework. On 20 new tasks not used in the design, ARTEX went from 15/20 to 0/20. In about half of the deception-arm runs ARTEX's exploit succeeded on the shadow while the real target stayed intact: the defence moved a working exploit rather than stopping it, and the remaining risk lies in requests that reach the real target before confirmation. ARTEX reported a planted fake secret as genuine on 30 of the 120 deception-arm tasks, five times in a report that labelled another item a decoy. With ARTEX's real compromise at zero in both deception configurations, they did not differ significantly on the remaining outcomes, a comparison that does not isolate the responder.

Thu 5 NovCryptography and Security
The gist
Large language model (LLM) agents can find and exploit web security weaknesses very quickly, sometimes before fixes are made. To stop real damage, the authors tested a trick where a fake vulnerable system called a honeypot is created from the app’s actual source code, and attackers are redirected there once identified. This way, hackers' attacks still succeed—but only on the fake copy, leaving the real site safe. Tests showed this method greatly reduced successful attacks on real systems, though hackers might reach the real site before being caught.
Open → 2611.07611v1

Randomization limits truthful scheduling accuracy on unrelated machines

Tight bounds for fractional and randomized truthful scheduling

Abstract: We resolve one of the longest-standing open problems in algorithmic mechanism design by showing that randomization cannot yield a sublinear approximation for truthful scheduling on unrelated machines, even when truthfulness is required only in expectation. Our main technical result concerns fractional scheduling, where tasks may be split among machines. We prove that every deterministic truthful fractional mechanism on $n$ unrelated machines has worst-case approximation ratio at least $(n+1)/2$, even against the optimal integral makespan. This matches the known upper bound exactly and settles the optimal approximation ratio of truthful fractional scheduling. Since the expected allocations and payments of a truthful-in-expectation mechanism define a truthful fractional mechanism, the same lower bound applies to all truthful-in-expectation mechanisms and, in particular, to all universally truthful mechanisms. On the positive side, we give a universally truthful mechanism with approximation ratio $n/2+o(n)$. Together, these results establish the optimal leading constant $1/2$ for randomized truthful scheduling. Thus, randomization improves on the optimal deterministic approximation ratio by an asymptotic factor of two, and no more.

Wed 4 NovComputer Science and Game Theory
The gist
The paper looks at how well we can schedule tasks fairly and truthfully among different machines that all work differently. It shows that even if we allow random methods and only ask for truthfulness on average, we cannot do much better than a certain approximation ratio. Specifically, the best possible truthful scheduling that splits tasks fractionally has a known lower bound, and the authors prove it cannot be improved. They also provide a method that nearly matches this limit, showing random methods only improve the approximation by about twice compared to deterministic methods.
Open → 2611.06642v1

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

MemX cuts time and balances memory in mixed GPU training clusters

MemX: Memory-Aware Automatic Parallelism for Cross-Vendor Heterogeneous GPU Training

Abstract: Cross-vendor heterogeneous GPU clusters are increasingly used for large-scale model training. However, their GPUs differ substantially in compute power, memory capacity, and interconnect characteristics. Existing automatic parallelism training systems usually minimize iteration time while treating memory as a hard constraint, almost failing in resolving the compute--memory asymmetry of cross-vendor clusters regardless correlation between memory and throughput. In this paper, we present MemX, a new memory-aware automatic parallelism system that jointly optimizes iteration time, peak memory usage, and cross-GPU memory balance. MemX consists of a weighted-product objective function, heterogeneous recomputation strategies, a minimal-set profiler, interpolation-based data augmentation, a dual-output XGBoost predictor, and a hash-signature prediction cache, in order to accelerate search of large-scale auto-parallel best configurations at lower cost. We implement MemX on Megatron-LM and evaluate it against four automatic parallelism baselines on two heterogeneous clusters. MemX achieves the lowest prediction Mean Absolute Percentage Error (MAPE) of 12.17% and is the only method that identifies the real Top-1 configuration under both time-based and memory-balance rankings. In terms of search cost and search space, MemX searches 31,240 configurations in 26.5 seconds, while an end-to-end profiling baseline is extrapolated to require about 17 days at the same scale. The simulation study that extends the measured 20-GPU data to 40-GPU and 60-GPU clusters further illustrates the effectiveness of MemX at larger scales.

Fri 30 OctDistributed, Parallel, and Cluster Computing
The gist
Training large AI models requires many GPUs, which can be different in power and memory. This makes it hard to split work fairly and efficiently. The authors created MemX, a system that finds the best way to divide tasks across different GPUs by considering both their memory and speed. MemX works much faster and more accurately than previous tools, even on bigger GPU clusters.
Open → 2610.41525v1

Efficiently finding profitable AI model inference mixes despite complexity

Circumventing the Computational Hardness of Computational Arbitrage

Abstract: AI model marketplaces host providers with heterogeneous costs and capabilities. These differences create an opportunity for computational arbitrage (Olmedo et al., 2026), in which an intermediary purchases inference from a portfolio of models and resells it to users at a profit. Beyond creating profit opportunities for the arbitrageur, computational arbitrage offers financial value to both consumers and providers and could therefore significantly influence AI model markets. While prior work empirically demonstrates the feasibility of computational arbitrage for small model pools, scaling it to large marketplaces requires arbitrage strategies that are both computationally tractable and inexpensive to identify and deploy. In this work, we formalize computational arbitrage as an allocation problem and prove that it is generally NP-hard. However, we show that the optimal allocation can be computed efficiently under a natural diminishing-returns condition on how model performance scales with inference spending. We further develop a sample-efficient method for estimating model performance from limited data, reducing the upfront cost of identifying arbitrage strategies. Our analysis also yields several economic insights: at the optimum, every funded model delivers the same marginal utility per dollar; arbitrage directs revenue away from providers offering little utility relative to their prices; and it rewards complementary specialization.

Thu 29 OctArtificial Intelligence
The gist
Buying AI model predictions from multiple providers at different costs can create a chance to resell combined services for profit, but figuring out the best way to do this is usually very hard. The authors showed that while the problem is generally tough to solve, under realistic conditions it can be handled efficiently. They also developed a way to estimate models’ performance with less data. Their findings explain how arbitrage benefits users and providers by favoring models that provide more value per dollar spent.
Open → 2610.40831v1

Peak-aware online strategies cut costs in energy buying

Peak-Aware One-Way Trading: Competitive and Learning-Augmented Algorithms for Energy Procurement

Abstract: We introduce peak-aware one-way trading ($\texttt{PA-OWT}$), an online problem in which a player must purchase a fixed quantity of an asset by a deadline, minimizing its total cost plus a charge proportional to the largest single purchase at any time. The model is motivated by electricity procurement, where the cost of energy rewards buying at low prices, but peak demand charges discourage concentrating purchases in short periods. Balancing these incentives is challenging when future prices are unknown: a large purchase can establish a peak that later decisions cannot undo. We develop a peak-aware online algorithm that balances price and peak control with deadline feasibility and achieves the order-optimal competitive ratio. We further extend our results to a learning-augmented algorithm that uses predictions of optimal purchasing decisions to achieve an order-optimal consistency-robustness tradeoff, exploiting accurate advice while retaining worst-case guarantees in the face of arbitrary prediction errors. Finally, we evaluate our algorithms in a case study on electricity procurement using historical electricity price traces to understand the benefits of peak-aware purchasing.

Thu 22 OctData Structures and Algorithms
The gist
Buying energy is tricky because you want to pay less while avoiding big spikes in how much you buy at once, which can lead to extra charges. The paper tackles this problem when prices change over time and future prices are unknown. The authors created smart buying plans that balance buying cheaper energy and keeping peak amounts low, even when predictions about prices are imperfect. They tested these plans using real electricity prices to show how they save costs.
Open → 2610.31447v1

Reinforcement learning improves scheduling on heterogenous accelerators for real time dnn inference

Hard and Soft Real-Time DNN Inference Scheduling on Heterogeneous Multi-Accelerator Systems via Reinforcement Learning

Abstract: We present a scheduling framework for heterogeneous multi-accelerator systems executing both hard real-time and soft real-time QoS-aware DNN inference workloads. The framework combines an online reinforcement learning (RL) scheduler with a deterministic runtime safety layer. The RL scheduler dynamically generates candidate schedules by jointly selecting sub-job priorities and accelerator assignments, while runtime certification guarantees that all HRT deadlines remain satisfied independently of the learned policy. To enable runtime certification in heterogeneous precedence-constrained systems, we introduce a schedulability-preserving prefix replacement criterion based on machine-wise cuts. The proposed criterion guarantees that runtime-generated schedule prefixes preserve the existence of a feasible continuation without requiring complete finish-time dominance with respect to a feasible reference schedule. Experimental results on heterogeneous DNN accelerator platforms show that the proposed framework preserves HRT schedulability while improving QoS-aware deadline satisfaction, client-level service quality, and accelerator utilization compared to state-of-the-art scheduling approaches.

Wed 21 OctHardware ArchitectureDistributed, Parallel, and Cluster Computing
The gist
Scheduling tasks in systems with different kinds of AI accelerators is tricky, especially when some need strict timing and others can be more flexible. The authors created a new system that uses reinforcement learning to decide which tasks to prioritize and where to run them, while also making sure the most urgent tasks always meet their deadlines. They introduced a way to check schedules on the fly, ensuring that the system stays stable even with complex task orders. Tests showed their method keeps hard timing tasks on track while improving overall task quality and hardware use.
Open → 2610.29503v1

HydraPoT routes attacker commands to cut honeypot costs and keep realism

HydraPoT: A Configurable Multi-Agent Framework for Cost-Aware LLM-Assisted Honeypots

Abstract: Large language models (LLMs) can improve honeypot realism by generating dynamic, context-aware responses, but powerful cloud models incur substantial cost and latency, while lightweight models may provide weaker deception. This forces practitioners to choose between operational efficiency and interaction fidelity. In this work, we present HydraPoT, a configurable multi-agent honeypot framework that integrates traditional emulation, lightweight LLMs, and powerful cloud LLMs. HydraPoT routes each attacker command to an appropriate agent according to a configurable complexity-based policy, while maintaining shared session state to preserve consistency across agent transitions. We evaluate HydraPoT through an architectural-overhead analysis, a cross-agent context-preservation benchmark, and a three-agent case study. HydraPoT introduces less than 5% runtime overhead, preserves context across heterogeneous agents, and achieves fidelity close to a cloud-LLM-only honeypot. Under our case-study policy, it reduces cloud-processed tokens by 72.6% and operational cost by 3.7x. These results demonstrate that configurable multi-agent routing can make realistic LLM-assisted honeypots more practical under limited operational budgets.

Tue 20 OctCryptography and Security
The gist
Honeypots are traps set up by security teams to catch hackers by pretending to be real computer systems. Using powerful language AI helps make these traps feel real, but it can be slow and expensive. The authors made a system called HydraPoT that mixes simple and powerful AI to respond just right, saving money and speeding up responses. This system keeps the trap believable while cutting down on expensive AI calls by over 70%, making it easier to run honeypots on a budget.
Open → 2610.27722v1

Memory-bound CFD runs faster and cheaper with smart AMD EPYC settings

Data-Driven Prediction of Optimal MPI Rank Placement and Node Count for Memory-Bound CFD on AMD EPYC Clusters

Abstract: Users who run a memory-bound OpenFOAM case on an AMD EPYC cluster must decide how many nodes to use and how many MPI ranks to place on each core complex. The fastest choice is often not the cheapest one. This paper revisits our earlier analytical model of this performance and energy trade-off with 560 measured configurations of the motorBike case on five Zen 4 and Zen 5 EPYC processors, including socket power from processor telemetry. On up to four nodes, small meshes are both fastest and cheapest on a single node on most processors. For the largest mesh the largest node count is both the fastest and the cheapest option, because its speedup is superlinear. A genuine trade-off arises only for medium meshes, where full speed costs a median of 20 to 97% more node hours than the cheapest option. The L3 miss rate and the halo traffic per cell are consistent with this pattern. For a new mesh of the same case, the configuration that was optimal on the nearest measured mesh is near optimal in 75 to 85% of the decisions. Running the two configurations it recommends for speed and for cost raises this share to 85 to 90% for runtime and node hours and determines the trade-off with median errors of 3 to 5 percentage points. Neither gradient boosted trees trained on the same data nor the earlier polynomial model improves on this simple procedure.

Fri 16 OctPerformanceMachine Learning
The gist
Running computer simulations for fluid flow on AMD EPYC clusters needs decisions about how many nodes and processor cores to use. The authors studied hundreds of tests to find that for small problems, using one node is fastest and cheapest, while big problems benefit most from many nodes, being both faster and cheaper. Medium-sized problems show a real trade-off between speed and cost. They also found a simple way to predict nearly optimal settings without complex models. This can help users save time and money when running these simulations.
Open → 2610.23383v1

Tandem queues with partial job abandonment behave predictably in heavy traffic

Tandem Queues with Hybrid Abandonment in Heavy Traffic

Abstract: Hybrid-abandonment systems, where jobs abandon from certain stages of service but not others, occur frequently in medical, service, and computing systems. Abandonment affects the heavy-traffic behavior of both the stages with and without abandonment. In contrast to existing heavy-traffic works that focus on cases where there is abandonment at either all stages or no stages, we focus on the heavy-traffic behavior for these hybrid-abandonment systems. We provide the first heavy-traffic characterization of the second queue length in a two-stage tandem queue with abandonment only in the first stage. We characterize the scaled mean of the second stage queue length and prove that the scaled second queue length is asymptotically exponentially distributed and asymptotically independent of the first stage queue length. We derive our results by analyzing Markovian arrival process queues with countably infinite phases. We do this by extending techniques used to analyze queues with Markov-modulated arrivals to the broader class of infinite Markovian arrival process queues. We prove asymptotic results for a more general infinite phase process condition, an infinite birth-death phase process, and the hybrid-abandonment tandem case. We also empirically demonstrate that our heavy-traffic approximations are good approximations across various system settings.

Thu 8 OctPerformance
The gist
Many systems like hospitals, call centers, or computers have jobs or customers that may give up waiting at certain stages but not others. This paper studies what happens when such systems are very busy, focusing on two connected queues where only the first one allows people to leave early. The authors find formulas describing how many jobs queue up in the second stage and show that the queue sizes become independent and follow simple patterns. They also show their math works well in different situations by running computer experiments.
Open → 2610.12716v1

Algorithm learns to schedule jobs efficiently without knowing time limits

Learning While Scheduling Jobs under Context-Dependent Service Rates: An Anytime Rate-Optimal Algorithm

Abstract: We study contextual queueing bandits, where a learner schedules jobs while learning unknown service rates modeled by logistic functions of job-server features. Performance is measured by queue length regret, the expected excess queue length at round $t$ relative to an oracle that knows the service rates. Existing decaying-regret guarantees either have a suboptimal decay rate or require a known fixed horizon. They also assume context-wise slack and a strictly positive minimum eigenvalue of the feature covariance. In this paper, we propose WISE (Widest Interval Selection with Elimination), achieving rate-optimal $\widetilde{\mathcal O}(t^{-1/2})$ queue length regret at every sufficiently large time without knowing the horizon. We assume capacity slack, meaning that expected incoming workload under best-server service is below service capacity, and impose no covariance lower bound. Our analysis uses a workload potential measuring the expected service attempts needed by waiting jobs on their best servers. Its drift on nonempty rounds combines a negative term ensured by capacity slack with errors from suboptimal service choices. Then an elliptical potential count bounds how often WISE selects wide confidence intervals, thereby limiting the number of rounds with large service errors. We also sharpen the arrival-rate dependence of an existing lower bound and make its dependence on feature dimension and server count explicit. We prove another lower bound that quantifies the increase in regret as the normalized capacity slack decreases; to our knowledge, this is the first such lower bound for CQB. Simulations show small regret even when context-wise slack fails.

Mon 5 OctMachine Learning
The gist
This paper looks at how to schedule jobs on servers when the speed of each server depends on job features and is initially unknown. The authors propose an algorithm called WISE that learns these speeds over time and schedules jobs to keep queues short, even without knowing in advance how long it will run. Their method improves on previous approaches by achieving the best possible rate of reducing delay and works under more realistic assumptions. The authors also provide mathematical guarantees and show simulations where their algorithm performs well.
Open → 2610.06006v1

Language models produce different results on different GPU brands

Measuring and Reducing Cross-Vendor Mismatch in Language Models

Abstract: Running the same language model on different graphics processing unit (GPU) vendors can produce different logits, even when the model weights and inputs are the same. We analyze cross-vendor mismatch in two dense and two mixture-of-experts (MoE) models with five metric families, namely bitwise equality, logit differences, top-K consistency, token agreement, and task accuracy. We trace one source of the mismatch to accumulation order inside vendors' matrix instructions. Upcasting to FP32 reduces the dense model's logit error by 43% at three times the runtime, yet keeping only the MLPs in BF16 retains 94% of this gain at 1.3 times the runtime, so most of the cost of full upcasting buys little. In the MoE models, FP32 and FP16 both lower the probability error but raise the logit error and change expert selection, and FP16 fails in the dense model. An output-head low-rank adapter (LoRA) does not help either, since the final hidden state does not predict the mismatch. The mismatch also carries into training. With every seed fixed, a student distilled from a teacher running on AMD answers 431 MMLU questions differently from one distilled from the same teacher on NVIDIA. Under FP32 upcasting, bitwise equality barely changes while the output distributions move most of the way to the reference, so judging cross-vendor agreement by a single measure misreads both its cost and its gains. Code is available at https://github.com/crova-project/crova.

Sun 4 OctMachine LearningDistributed, Parallel, and Cluster Computing
The gist
Running the same language model on different GPU brands can give slightly different answers, even with the same inputs and weights. The authors found this is partly due to how math operations are handled differently by GPU vendors. They tested methods to reduce these differences and found some improve accuracy at a cost to speed, while others don’t help. Also, models trained on different GPUs show differences, meaning this mismatch affects training too. Their work helps understand and partly fix why identical models behave differently on various hardware.
Open → 2610.05458v1

Agentic large language models trade higher costs for limited accuracy gains

Engineering Sustainable Agents: A Systematic Comparison of Agentic LLMs for Developer Workflows

Abstract: Large language models (LLMs) are increasingly used in software engineering, including agentic systems that coordinate multiple agents, but impose higher computational and environmental costs. In this paper, we present a comprehensive empirical study of agentic LLM systems across five software engineering tasks: code generation, technical debt identification, code vulnerability detection, log parsing, and log analysis. For each task, we compare LLM configurations that range from a non-agentic single-query baseline to multi-agent workflows, using six open-weight LLMs, two prompt strategies, and three hardware platforms. We assess each configuration in terms of accuracy, inference latency, and energy consumption. Our results reveal substantial trade-offs between agentic complexity and energy efficiency: multi-agent designs consume on average 6.36$\times$ as much energy and run 6.07$\times$ as long as the non-agentic baseline, with worst-case slowdowns of up to 160$\times$ for individual task--hardware pairs. Accuracy gains from additional agents are limited and task-specific: multi-agent improves average vulnerability-detection accuracy, but lightweight non-agentic and single-agent configurations still dominate the Pareto front, accounting for 59 of 66 Pareto-optimal configurations. Model and prompt choice act as task-specific levers whose effective direction varies between tasks rather than as global defaults. We translate these findings into design guidelines for sustainable, task-aware LLM-based development tools.

Fri 2 OctSoftware EngineeringMultiagent Systems
The gist
Using many AI agents working together in software development tasks uses much more energy and time than using just one or none. The authors compared different setups of AI models doing coding tasks like finding bugs or understanding logs. They found that having multiple AI agents often doesn't improve accuracy enough to justify the big extra costs. Instead, simpler setups with one or no agents usually perform best when balancing accuracy, speed, and energy use. The findings help guide developers to pick AI tools that work well without wasting resources.
Open → 2610.03010v1

CadenceRL improves reinforcement learning rollout speed on mixed hardware

Reshaping Rollout Workloads for Asynchronous RL Post-Training on Heterogeneous Accelerators

Abstract: Reinforcement learning (RL) post-training increasingly relies on long-horizon, multi-turn rollouts. As post-training jobs outgrow a single cluster, rollout pools assembled across clusters introduce hardware heterogeneity. Rollout scheduling must serve two stakeholders: the hardware needs high aggregate decode throughput, while each trajectory needs to finish quickly. The tension arises from the memory-bandwidth-bound nature of autoregressive decoding. A large active batch amortizes weight reads for high throughput but leaves each trajectory a smaller bandwidth share and a longer completion time. The scheduling objective is therefore specialization, letting different workers serve different roles. Heterogeneous hardware further enables this specialization. High-bandwidth accelerators favor long-context work, while cost-efficient accelerators sustain large batches. Workload evolution makes this specialization difficult to sustain, and dynamic reassignment faces a circular dependency because a move's benefit depends on subsequent placement decisions. We present CadenceRL, which bypasses this dependency through structural workload reshaping rather than per-move benefit estimation. Pacing replaces long-context trajectories with shorter ones, providing a structurally positive transformation that sustains large active batches for high throughput. When accumulated staleness demands faster completion, concentration directs the residual long-context tail onto high-affinity workers. Late-bound KV preparation stages accumulated prefixes before a destination is selected. On heterogeneous rollout pools, CadenceRL improves decode throughput by up to 48% and reduces P95 trajectory latency by up to 64%. Adding high-bandwidth accelerators reduces tail latency, while adding cost-efficient accelerators increases throughput, without manual routing configuration.

Tue 29 SeptDistributed, Parallel, and Cluster Computing
The gist
Reinforcement learning often needs to run many long tests, or rollouts, that are slow and use different types of computer hardware. The authors show that balancing the workload better across different machines can make these rollouts faster and more efficient. They created CadenceRL, a method that reshapes workloads by breaking long tasks into shorter ones and sending the hardest parts to the fastest machines. This approach improves overall processing speed and reduces delays without needing manual configuration.
Open → 2609.36899v1

Energy saving methods reduce neural operator costs in virtual sensing

Energy-efficient operation of neural operators for virtual sensing

Abstract: Virtual sensing repeatedly reconstructs physical fields from changing observations, often on a fixed geometry. We investigate how shared spatial computation reduces the energy of these updates while retaining the selected checkpoint and its evaluated predictions. In a heat-exchanger service, standard compiler freezing and explicit trunk reuse give similar operating energy reductions relative to graph replay: approximately 1% at one request per second and 20% at forty requests per second. In 15 W mode with fixed clocks, reuse with graph replay completes the same request sequence with 22.0 to 22.5% less energy than eager execution, including preparation and waiting. DeepONet and Fourier neural operator (FNO) controls distinguish the effects of reusable arithmetic and launch overhead. Preparation, artifact construction, and worker replacement add costs outside repeated inference. These results connect operator structure to operating energy and show how update frequency and execution lifetime govern the benefit of computation reuse in physical-field virtual sensing.

Thu 24 SeptMachine LearningPerformance
The gist
Virtual sensing is a way to recreate physical fields (like temperature or flow) using changing measurements on a fixed setup. The authors show that reusing parts of the neural network’s spatial calculations lowers the energy used for updates while keeping prediction accuracy. In their tests on a heat exchanger, energy savings ranged from about 1% to over 20% depending on how often updates happened. They found that reusing computation is more effective at higher update frequencies and is influenced by overhead costs like setup time. This helps understand when and how to save energy in repeated virtual sensing tasks.
Open → 2609.30580v1

Deep reinforcement learning improves one-dimensional bin packing efficiency

Deep Reinforcement Learning on Item-Compatibility Graphs for One-Dimensional Bin Packing

Abstract: The one-dimensional bin packing problem (1D-BPP) is a classical NP-hard combinatorial optimization problem with applications ranging from logistics and manufacturing to cloud resource management. Although deep reinforcement learning (DRL) has become a competitive paradigm for data-driven optimization, most learned packing methods target 2D and 3D variants, and intelligent learned solvers for 1D-BPP remain scarce. In this paper, we present a novel end-to-end, size-agnostic graph reinforcement learning framework for 1D-BPP. We formulate the packing process as a Markov decision process on an item-compatibility graph, serving as a structural knowledge representation in which every action merges two partial bins that fit together. A graph neural network actor-critic policy extracts relational features from this representation and is trained through reinforcement learning and decoded by stochastic beam search, enabling a single trained model to generalize zero-shot to instances of any size. We conduct a systematic empirical study across graph encoders, DRL algorithms, reward functions, training distributions, and hyperparameters. Evaluated zero-shot on the full BPPLIB benchmark against a constructive heuristic, a grouping genetic algorithm, and recent learned methods, our data-driven policy lowers the mean optimality gap of the constructive heuristic from 2.66\% to 2.31\%, with the largest gains on structured instances. Against learned baselines evaluated on the same benchmark, it attains a lower gap on most of the nine families and is far more stable across instance distributions. On the hardest benchmark family, it outperforms a state-of-the-art learned solver that relies on column generation and integer programming, while using no solver at all. A grouping genetic algorithm remains ahead overall, and we analyze where and why the residual gap arises.

Mon 21 SeptMachine LearningArtificial Intelligence
The gist
Packing items efficiently into fixed-size containers is a tough problem that many businesses face. The authors developed a method using deep reinforcement learning to decide which items to pack together by representing items as nodes in a graph. This model learns to combine items in ways that fit well, improving packing efficiency better than some traditional methods. Their approach works well right away on different sizes of packing problems without needing extra training.
Open → 2609.25397v1

Probabilistic forecasting improves resource allocation in 5G networks

Goal-oriented probabilistic forecasting for dynamic PRB allocation in 5G networks

Abstract: Efficient physical resource block (PRB) allocation in 5G networks requires accurate demand forecasting. Conventional methods minimize symmetric error metrics (MAE, RMSE), ignoring the operational cost asymmetry where under-provisioning (service degradation) is far costlier than over-provisioning (wasted capacity). We propose a goal-oriented probabilistic forecasting framework that aligns model training with the operator's decision-making objectives. Specifically, we train DeepAR and Temporal Fusion Transformer (TFT) models using the Pinball Loss function and derive the optimal allocation quantile from the operator's cost matrix. Evaluation on a real beam-level 5G traffic dataset shows that the proposed approach reduces operational cost compared to MSE-trained baselines while maintaining calibrated uncertainty estimates. The framework enables dynamic PRB allocation that explicitly balances service reliability against resource efficiency.

Tue 15 SeptMachine Learning
The gist
Allocating resources in 5G networks can be tricky because running out of capacity hurts service more than having a bit too much. The authors study better ways to predict future demand by focusing on these real-world costs rather than just average errors. They use special forecasting methods trained to reduce costly under-provisioning. Tests on real data show their approach lowers operational costs while keeping reliable uncertainty estimates, helping balance service quality and efficient resource use.
Open → 2609.17297v1

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