Searcharxiv⌕ Search
Home/Archive/arXiv

arXiv · 2610.41672

Understanding the Energy Cost of Quantized Agents on Shared GPUs

Stephen Abkin·Alex Flesher·Aldric Yang·Nitheesh Kodarapu·Deepak Panigrahy·David Kebo Houngninou
View original source ↗Read source document ↗Export metadata ↓

Abstract

Quantization can lower the energy of language-model calls and free memory for serving more agents, but its benefit per completed task remains unclear when agents share a GPU. Measurements of fixed requests or isolated agents leave open how the agents' generated work interact with competition for compute and cache. We present a systematic study of precision and admission limits for two agent models on A100 deployments with 40 or 80 GB of memory, using coding and data-analysis tasks with independently verified outcomes. We replay recorded calls across precisions to isolate execution energy and cap the cache to test the value of freed memory. For both models with four admitted agents where requests fit in the cache, 4-bit weights with 16-bit activations execute the same calls with 10-25% less energy than 8-bit weights and activations. Despite this saving, extra work and fewer completions in live runs raise their energy per verified completion by 49%. Where requests compete for cache on the 40 GB deployment, 4-bit weights cost less, and capping their cache raises energy per verified completion by 34% with 16 agents. These results show how generated work and cache demand change the energy benefit of quantization, providing a practical basis for choosing precision and admission limits together.

Explore related subjects

cs.PF

Keep this discovery

Explore connections, maps & timelines

BibTeXRIS

Stephen Abkin, Alex Flesher, Aldric Yang, Nitheesh Kodarapu, Deepak Panigrahy, David Kebo Houngninou. 2026-11-02. Understanding the Energy Cost of Quantized Agents on Shared GPUs. https://arxiv.org/abs/2610.41672

Cite the original work for its findings. Save a collection to share your selection of sources.

KEEP EXPLORING

Related papers

arXiv2026

The Unreported Variable:Collector Selectivity in Data Placement Evaluation

A solid-state drive cannot overwrite data in place, so it cleans full blocks by copying out still-valid data, costing speed and lifetime. Interfaces such as NVMe Flexible Data Placement (FDP) let the host label data by expected lifetime so data dying together is stored together, and published schemes report cutting these copies by 20--75%. Those studies rarely state which blocks the drive chooses to clean. Varying only this choice in simulation, we show it decides how much a label is worth: label value peaks when the drive searches moderately for blocks holding little valid data, falls when it always takes the block with the least, and turns negative when it ignores how much valid data blocks hold. This holds in 47 of 48 synthetic configurations, and one real mail-server trace shows the same shape at about half the magnitude. Priced as spare capacity, a two-class label is worth 65% more spare when each scheme runs at its best setting, but becomes a net loss at 20% label error, typical of learned classifiers. Labels stating which data die together keep most of their value at 16 FDP handles and gain as cleaning improves. Evaluations must report the drive's cleaning policy.

cs.PF↗
arXiv2026

Warpline: Binary-Level Tracing and Unified Evidence for Agentic GPU Kernel Optimization

LLM agents are becoming GPU kernel engineers, but they still tune kernels without seeing where the time goes. Hardware profilers report how busy each unit was, not where each warp's time went; intra-kernel tracers can show it, but only with hand-placed probes and a recompilation that alters the very kernel being measured. We present Warpline, which gives agents this view automatically while leaving the kernel essentially unchanged. Warpline analyzes the binary to decide which events to record and inserts probes into the binary itself without recompilation or any manual step. It then aligns the trace with hardware profiling data on one unified timeline. Because it needs only the binary, it can regenerate this evidence for every new version of the kernel at whatever level the agent edits it (source, IR, or PTX), closing the optimization loop without human intervention. On NVIDIA B200, across 35 kernels in Triton, CuTe DSL, and CUDA C++, Warpline adds a median overhead of 1.2% and leaves a median 99.9% of executed instructions unchanged, whereas existing tracers have median overheads of 1.6% to 13.2% and leave only 4.6% to 32.7% unchanged. Warpline also traces closed-source kernels, which these tracers cannot. On 10 SOL-ExecBench problems, agents using Warpline spend less time and fewer model requests than a bare coding agent and NVIDIA's Kernel Design Agents (KDA), yet lead both after every round in geometric mean and reach a 7.69$\times$ geometric-mean speedup, against 6.94$\times$ and 6.13$\times$. Two case studies further demonstrate that Warpline reveals hidden bottlenecks and provides actionable optimization insights.

cs.PF↗
arXiv2026

Trustworthiness as a Measurement Structure for Task Conformance in 6G Service Chains

A 6G service crosses a chain of stages from different vendors, and its contract binds class-conditioned guarantees at the terminal interface: in the packet relay chain studied here, a priority class is owed a timely-delivery rate and a loss ceiling. We define trustworthiness as conformance of the delivered per-class distribution of outcomes to the contract and develop the measurement structure this forces. Two results fix its form: a discrepancy that treats outcomes interchangeably cannot express contract preferences, and no single expectation-valued score that determines the contracted terminal expectations can be carried from stage to stage once two or more contracted indicators remain independent at some stage. The minimal record is one signed number per independent contracted indicator, which the downstream design data carry to the terminal exactly; classical scalar trust models are the single-indicator case. The terminal deviation splits exactly into per-stage contributions. Transition logs at a stage estimate its contribution without reconstructing its full deployed behavior, a stage at its design behavior is flagged at most at a declared rate whatever traffic it receives, and the estimates bracket each stage's share of the terminal deviation at explicit confidence. In the three-relay chain, a relay that either deprioritizes premium traffic or has degraded capacity violates the same clause with identical contracted evidence: the transition audit localizes the relay in 300 of 300 windows and brackets its share of the deviation, and a diagnostic separates the causes.

cs.PF↗