Agentic applications are shifting AI serving from isolated model inference to long-running workloads in which LLMs coordinate tools, environments, and persistent state. However, the system behavior of these workloads---where latency, cost, and bottlenecks arise---remains poorly characterized, leaving serving systems to rely on assumptions built for conventional inference. We present AgentSysBench, a benchmark suite and measurement toolkit with ten representative agentic applications and unified systems-level instrumentation. Across controlled deployments and production traces, we identify six properties that distinguish agentic workloads from conventional LLM serving: (1) execution is heavyweight and stateful, with non-LLM components dominating latency in 5 of 10 applications and sandbox working-set memory peaking at 28 GB per session; (2) applications compose components with heterogeneous resource affinity---GPU-bound inference, memory-bound retrieval, CPU-bound sandboxes---whose task latencies diverge by up to 32x; (3) bottlenecks shift across requests, models, and deployments; (4) production sessions hold state idle for minutes to hours between active steps; (5) a control-plane tax---auxiliary LLM calls and context overhead from tool schemas and observations---crowds out productive compute and context; and (6) production traces from three applications reveal heavy cross-request redundancy in search queries and web fetches, exposing a large caching opportunity. Four design explorations demonstrate that these findings are actionable: task-aware serving reduces latency by 29--40%, communication-aware placement by up to 4.5x, state offloading reduces memory usage by 4.6x, and tool-result caching removes 35.2% of redundant search calls and saves 19.3% of aggregate search latency.
Figures & tables
Domain
Application
Domain
Application
QA
RAG ( Gao et al., 2024 )
AI search
DeepResearch ( AI, 2024 )
Multimodal processing
HuggingGPT ( Shen et al., 2023 )
Software engineering
Mini-SWE ( Team, 2025b )
Terminal use
Codex ( OpenAI, 2025 )
Browser use
WebAgent ( Research, 2025 )
Computer use
GUIAgent ( Xie et al., 2024 )
Tool-rich assistants
Claude Code ( Anthropic, 2025 )
Office work
Openclaw ( WW-AI-Lab, 2025 )
AutoResearch
Pi-AutoR ( Barcelona, 2025 )
Table 1. Compact overview of the AgentSysBench suite.
Figure 1. Agentic workload, serving system, and system behavior illustrated with a coding agent.
Application
Domain
Datasets
Key Tools/Envs
Major Orch.
Model
RAG ( Gao et al., 2024 )
Retrieval QA
WQA ( Yang et al., 2015 ) , MS-MARCO ( Nguyen et al., 2016 )
VecDB, embed
Pipeline
Qwen2.5-7B
HuggingGPT ( Shen et al., 2023 )
Multimodal
TaskBench ( Shen et al., 2024 )
Specialized models
Plan-Exec
DS-V4-Pro
OpenDR ( AI, 2024 )
AI Search
YDC ( Su-Sea, 2024 ) , GAIA ( Mialon et al., 2023 ) , HLE ( Phan and Alice Gatti, 2025 )
Search, VecDB, embed
Parallel, Plan-Exec,
Qwen3.7-Max;
Branching, Loop
DS-V4-Pro, V4-Flash
Mini-SWE ( Team, 2025b )
Coding
SWEBench Verified ( Jimenez et al., 2023 )
FS, shell
ReAct
DS-V4-Pro
Codex ( OpenAI, 2025 )
Terminal
Terminal Bench ( Shaw et al., 2025 )
FS, shell
ReAct
DS-V4-Pro
Table 2. Systems-oriented overview of the benchmarking suite in AgentSysBench.
Figure 2. Suite Overview.
Figure 3. Distribution of end-to-end latency across requests for all ten AgentSysBench applications.
Figure 4. Decomposition of end-to-end execution time by component type.
Figure 5. Token consumption breakdown across characterized applications.
Figure 6. Distribution of KV-cache performance state (a), active sandbox working-set memory (b), and persistent vector-database state (c) across representative sessions.
Figure 7. Average and total data volume serialized, transmitted, and received per component type.
Figure 8. Estimated per-request pay-as-you-go cost breakdown under public cloud pricing.
Figure 9. Execution time of tasks in the DeepResearch.
Figure 10. Workload of tasks in the DeepResearch.
Figure 11. LLM-invocation latency across iterations for ten Mini-SWE traces.
Figure 12. Invocation-level heterogeneity in a single Mini-SWE execution: per-iteration input and output length, decomposed prefill and decode latency, and sandbox latency. Decode latency tracks output length, while prefill latency tracks the newly appended observation rather than the monotonically growing (cached) context. Per-iteration input (context), output, and latency across a single Mini-SWE-Agent execution. Input grows monotonically, yet latency fluctuates with output length rather than with the accumulated context.
Figure 13. Three mechanisms of performance interference: HOL blocking in an embedding service (a), degradation of a short-context LLM request under increasing long-context background load (b), and shared-resource contention among sandbox operations (c). Mean embedding-query latency under increasing background document-embedding load; mean time per output token of a short-context LLM request when served alone or with one or two background 128K-context requests; and mean execution time of eight concurrent Codex sandboxes with isolated or shared CPU sets.
Figure 14. Effects of request type (left) and input-document size (right).
Figure 15. Effects of Tool set selection. Latency breakdown of WebAgent under different observation-format configurations. Adding more observation formats increases LLM cost and shifts the bottleneck from browser interaction to LLM inference.
Figure 16. Token usage (left) and execution-time breakdown (right) of DeepResearch under three writer–summarizer configurations. The planner uses Qwen3.7-Max in all configurations. Input and output token usage by the planner, writer, and summarizer, together with absolute execution time and its component breakdown, for three DeepResearch writer–summarizer model configurations.
Figure 17. Orchestrator of RAG and RAG*.
Figure 20
Figure 20. Idle-but-live behavior in production coding-agent sessions. (a)~CDF of the ratio of active execution time to total session lifetime. Most sessions spend only a small fraction of their lifetime executing. (b)~Distribution of idle-interval lengths across production sessions.
Figure 21. Composition of the LLM input context over one production session. Stacked context composition across the LLM calls of one production session, separating system messages, user instructions, and accumulated history.
Figure 22. Context compaction: post-/pre-compaction context ratio (a), latency (b), input tokens (c), and output tokens (d). The lower log-scale tail summaries show the off-axis p99 values of 775 s and 438K input tokens. (a)~Distribution of post-compaction to pre-compaction context ratios. (b–d)~Latency, input tokens, and output tokens per compaction event. Log-scale tail summaries expose the latency and input-token p99 values.
Figure 23. Token and monetary-cost impact of prefix-cache eviction. Token and monetary-cost breakdowns by cache-read, cache-create, output, and temporal-input categories, with cache-create cost attributed to normal operation and cache eviction.
Figure 24. Cross-session redundancy in search queries and URL fetches. Distribution of within-day invocation frequencies for distinct search queries and fetched URLs, showing substantial reuse across sessions.
Figure 25. Effectiveness of task-aware serving, communication-aware placement, and state offloading
Figure 26. Effectiveness of tool-result caching. Latency reduction from tool-result caching.
Agentic workflows are composed of sequences of interdependent Large Language Model (LLM) calls, and they have become a dominant workload in modern AI systems. These workflows exhibit extensive redundancy from overlapping prompts and intermediate results due to speculative and parallel exploration. Existing LLM serving systems, such as vLLM, focus on optimizing individual inference calls and overlook cross-call dependencies, leading to significant inefficiencies. This paper rethinks LLM and agent serving from a data systems perspective and introduces Helium, a workflow-aware serving framework that models agentic workloads as query plans and treats LLM invocations as first-class operators. Helium integrates proactive caching and cache-aware scheduling to maximize reuse across prompts, KV states, and workflows. Through these techniques, Helium bridges classic query optimization principles with LLM serving, achieving up to 1.56x speedup over state-of-the-art agent serving systems on various workloads. Our results demonstrate that end-to-end optimization across workflows is essential for scalable and efficient LLM-based agents.
As LLM applications grow more complex, developers are increasingly adopting multi-agent architectures to decompose workflows into specialized, collaborative components, introducing structure that constrains agent behavior and exposes useful semantic predictability. Unlike traditional LLM serving, which operates under highly dynamic and uncertain conditions, this structured topology enables opportunities to reduce runtime uncertainty\unicodex2015yet existing systems fail to exploit it, treating agentic workloads as generic traffic and incurring significant inefficiencies. Our analysis of production traces from an agent-serving platform and an internal coding assistant reveals key bottlenecks, including low prefix cache hit rates, severe resource contention from long-context requests, and substantial queuing delays due to suboptimal scaling. To address these challenges, we propose Pythia, a multi-agent serving system that captures workflow semantics through a simple interface at the serving layer, unlocking new optimization opportunities and substantially improving throughput and job completion time over state-of-the-art baselines.
The optimization of LLM serving engines, such as vLLM and SGLang, is largely benchmark-driven: optimizations, scheduling policies, hardware and system designs are all selected based on representative workloads. However, a significant mismatch has emerged in the agentic era. Existing benchmarks primarily focus on simple single-turn chatbot workloads. LLM applications are increasingly agentic: coding agents, terminal execution systems, and tool-use agents issue multi-turn requests with growing context lengths. We introduce AgentPerfBench, a benchmark suite for agentic inference. It uses real traces from agentic benchmarks, such as SWE-Bench and TerminalBench, alongside standard chat baselines. This enables benchmarking of models on multi-turn tasks involving tool calling, skill utilization, and increasing context lengths. AgentPerfBench also samples from empirical distributions of input length, output length, and turn count derived from the real traces, generating representative synthetic profiles for cheap and accurate measurements on new hardware. In addition, we further find that several existing benchmarks fail to accurately reflect real hardware performance for two key reasons: 1) they do not account for realistic context-length growth, and 2) they measure inference performance without operating at hardware saturation. We discuss these issues in detail and provide rich kernel-level Nsight Compute (NCU) traces to construct a new multi-dimensional roofline model that captures hardware-system limitations in both memory bandwidth and memory capacity footprint. The benchmarking suite then includes automated scripts to identify potential bottleneck conditions on emerging hardware when evaluated with diverse agentic traces. Together, these contributions quantify the chat-to-agentic gap in current inference benchmarks and characterise per-kernel GPU resource utilisation via roofline analysis.
Cheuk Hang Lau, Zeyu Cao, Kevin Wong Cheuk Yin +6
Imperial College London · University of Cambridge · University of Oxford