Architectural Implications of Agentic AI Workflows

Architectural Implications of Agentic AI Workflows Jirong Yang† , Peizhe Liu† , Chaojie Zhang∗ , Jovan Stojkovic†

arXiv:2608.04458v1 [cs.AI] 5 Aug 2026

†

The University of Texas at Austin

∗

Microsoft Azure

tomation [29]. Projections place it among the fastest-growing consumers of datacenter capacity in the coming years [18]. Despite this popularity, the implications of agentic AI for server architecture remain underexplored. Researchers have been optimizing servers for traditional, CPU-centric services such as web serving, key-value stores, and data analytics [15], [21], [24], [27], [30], [32], [33], [37], [49], [60]–[64], [66], and, more recently, the inference of a single monolithic LLM, where dense tensor computation on an accelerator dominates while the host merely feeds it [3], [35], [41], [42], [53], [70], [81]. Agentic execution differs from both. A task no longer maps to a single tensor computation or a request-response service. Instead, it unfolds as a data-dependent graph of many model calls, tool invocations, and control decisions that orchestration software assembles on the host. Thus, execution spans the accelerator and multiple host-side components (CPU, memory system, network, and runtime) and grows complex as applications add agents and deepen their coordination. Although a nascent body of systems work has begun to build agentic frameworks [10], [11], [31], [36], [75], we lack fundamental architectural understanding of how these workloads exercise real hardware and whether servers designed for the two older targets are adequate. To reason systematically about such highly diverse workloads, we first develop a taxonomy along platform-relevant dimensions of agentic AI: how agents are orchestrated, how their workflows are structured, and how models are composed. Guided by the taxonomy, we perform the first architectural characterization of agentic AI through both a production study across the fleet of our hyperscaler, Microsoft Azure, and a controlled study of diverse open-source frameworks, spanning diverse use cases. Our main insight is that agentic AI creates highly fragmented execution, while the dimensions in our taxonomy determine how this fragmentation manifests as heterogeneous resource demand. Since host-side orchestration and tools separate successive model calls, the CPU enters the critical path and each task repeatedly crosses the CPU–GPU boundary. The orchestration mechanism governs how control passes among agents. Execution structure shapes the pattern of host load: long periods of low utilization can be punctuated by bursts toward saturation when workflow stages release groups of tool calls. Model composition determines how evenly a workflow utilizes the accelerator pool, potentially saturating some GPUs while leaving others idle. Even within the same taxonomy class, workloads vary substantially in offered load and the tasks they solve, further widening the range of resource needs. Consequently, conventional, uniformly provisioned servers are ill-suited to agentic AI in three ways. First, fragmentation

Abstract—Agentic AI, where LLMs autonomously plan, invoke tools, and coordinate across agents to solve complex tasks, is an emerging class of datacenter workloads. However, its architectural implications remain largely unexplored. To close this gap, we organize agentic workflows through a taxonomy and present the first architectural characterization of agentic AI using both a production study across the fleet of our hyperscaler and a controlled study of representative open-source frameworks. Our study shows that agentic execution is fundamentally fragmented and heterogeneous. Each request expands into a workflow of LLM inferences, tool invocations, and orchestration decisions that repeatedly crosses the CPU–GPU boundary. Our taxonomy explains how this fragmentation turns into resource demand. As orchestration and tools run on the host, the CPU sits on the critical path. The execution structure sets the load over time, which stays low with sudden bursts when a stage releases its tools. The model composition sets how evenly the workflow uses the GPUs, often saturating some while leaving others idle. Diversity in tasks and tools widens this range even further. These characteristics expose three architectural mismatches of conventional uniform servers. Fragmented execution strands CPU and GPU capacity despite bursty demand. Different software roles make homogeneous CPU provisioning inefficient. Finally, multiplexing many agents onto shared cores degrades microarchitectural locality and increases coordination overhead. Guided by these findings, we derive implications for agentic servers and examine them through Agora, our prototype for commodity servers. Agora dynamically harvests idle CPU cores for co-located throughput work, while protecting agentic tail latency against tool spikes. It also oversubscribes GPU memory by placing more agents on each GPU, prefetching the next agent’s state to hide swap latency. To match the machine to the heterogeneous roles, Agora pools cores by role and applies affinityaware scheduling to restore locality. Finally, Agora automatically tunes all of these mechanisms to the running workload. These techniques substantially improve CPU and GPU utilization and per-server throughput while preserving agent tail latency. Our insights also identify key directions for future server architectures for agentic AI.

I. I NTRODUCTION The way large language models (LLMs) are deployed is changing. Traditionally, LLM serving systems have optimized each model invocation as an independent request: the system consumes a prompt and produces a response [3], [16], [39], [47], [53], [74], [81], [84]. However, a growing class of applications now embeds one or more models in an iterative control loop. At each step, the application uses model inference to interpret the current state, select the next action, such as invoking a tool or delegating a subtask, observe the result, and continue until the task is complete. This agentic mode of execution powers applications in software engineering [22], deep research [13], scientific discovery [50], and enterprise au-

1

strands resources: CPUs and GPUs remain underutilized on average yet experience short bursts of near-saturation, leaving substantial capacity idle between bursts. Second, the three host roles (schedulers, orchestrators, and runners) exhibit sharply different resource profiles, so a single homogeneous pool of cores cannot serve all of them efficiently. Third, multiplexing many agents on shared cores degrades microarchitectural locality, as they evict one another’s cache lines and branchpredictor state, increasing pipeline stalls. As the nature and severity of these inefficiencies vary with the workflow, load, and task, no single static configuration suits them all; the server must instead adapt to each workload. Guided by these findings, we derive three design principles for servers running agentic AI. We examine each through a case study implemented in Agora, our prototype for commodity servers. First, on the host side, servers should reclaim the temporal slack from fragmented execution. Agora harvests idle CPU cores for co-located throughput work while protecting agents from sudden tool bursts. Second, on the accelerator side, servers should reclaim the idle capacity rather than dedicating exclusive GPU access to fixed agents. Agora harvests this capacity by consolidating agents onto fewer GPUs, exploiting agents that share model state or are never active at the same time so that busy and idle devices are balanced. Third, host cores should be partitioned by software roles and scheduled to preserve task locality, rather than managed as a single homogeneous pool. Agora isolates and right-sizes the control plane and the bursty runner pool, and pins tasks within the runner pool to preserve cache and branch-predictor locality. We implement the three case studies on open-source agentic frameworks and evaluate them on real hardware against static, workload-agnostic configurations. CPU harvesting recovers 95% of a co-located workload’s standalone throughput and increases host CPU utilization by 30% while limiting agent slowdown to under 3%. GPU harvesting frees a third of the GPUs while raising generation throughput by 82% and cutting tail latency by 2.5×. Role-aware pooling reduces the tools’ CPU demand by up to 46% and worst-case tool latency by 13%, while retaining 99% of serving throughput. Beyond today’s hardware, our insights also suggest optimizations for future hardware. Dedicated support could offload the frequent scheduling and context-management operations off the host cores. CPU cores could further match hardware capabilities to different host roles, combining energy-efficient cores for lightweight coordination with high-performance cores for compute-intensive tool execution. In summary, this paper makes the following contributions: • The first production architectural characterization of agentic AI, measured across the fleet of a hyperscaler. • A taxonomy that organizes the heterogeneous space of agentic AI workloads along platform-relevant axes, with a characterization of real use cases across its classes. • Three server-design implications, explored through case studies in Agora: harvesting idle CPU cores, harvesting idle GPU capacity by consolidating agents, and managing host cores by role and task locality.

GPU

Host Runner

Orchestrator

Turn start

Scheduler

1 Send request

4 Web search 5 Tool result

LLM Engine

2 Invoke LLM 3 Tool calls

Streamed responses

6

7 Edit files 8 Run/Test 9 Final output

Fig. 1. An example of agentic AI workflow execution.

II. BACKGROUND AND M OTIVATION Agentic AI Workflows. Traditional LLM serving treats model invocation as the primary unit of execution. A serving engine prompts the model with context, decodes output tokens autoregressively, and returns a response [68], [74]. The host prepares, schedules, and dispatches requests, while the accelerator, e.g., GPU, executes model computation [39], [51], [83]. An agent places an LLM inside a control loop. Given a goal, it invokes the model to interpret the current state, plan or reflect, and select a next step. The step may invoke an external tool, such as web search, code execution, or retrieval [4], [52], whose result is included in next model calls [72]. Tools run off the accelerator, on the host or a remote service [36], [72]. As each action depends on the previous one, a user request expands into a workflow: a data-dependent graph whose nodes are model inferences, tool invocations, and control decisions, and whose edges are their dependencies [40], [48]. The number, duration, and dependencies of these steps are determined dynamically at runtime, so execution alternates between accelerator-bound generation and host-bound work that tracks dependencies, marshals state, and invokes tools. Figure 1 shows this fragmented, host-orchestrated execution. Multi-agent applications distribute this workflow across cooperating agents. A coordinator may assign subtasks to specialized agents, e.g., researchers, programmers, reviewers [14], [28]. Agents may exchange results and claim work through messages or shared state. Each maintains its own logical control loop, while multiple agents may share the same model backend. Independent subtasks can execute concurrently, while dependencies and iterative feedback serialize others. Agentic Serving Systems. Researchers have been extensively optimizing LLM inference serving. Continuous batching [74], KV-cache management [39], optimized attention kernels [16], [83], disaggregated prefill and decode [53], all raise the throughput of the inference engine. These techniques optimize the inference-serving plane. Agentic workflows open a richer optimization space defined by dependencies among model invocations and tool calls. A growing body of systems work exploits this structure. Speculative agent execution runs likelynext actions ahead of time and discards mispredictions [73]. Programmable, software-defined serving lets applications express and co-optimize the workflow itself [1]. Agent-aware schedulers efficiently order workflow steps [31], [44], [75].

2

TABLE I TAXONOMY OF AGENTIC WORKFLOWS WITH EXAMPLES THAT FALL WITHIN DIFFERENT CATEGORIES AND THEIR IMPLICATIONS FOR PLATFORM DESIGN . Dimension Orchestration

Execution structure

Model composition

Option Hostorchestrated LLMorchestrated

Examples in the current corpus MetaGPT [25]; MAGE [82]; Paper2Code [59]

Sequential

AlphaEvolve [50]; Trae Agent [67]; AccelOpt [77]

Parallel

ReConcile [12]; CORAL [56]; DeLM [45]

Homogeneous

Most frameworks use the same base model by default ToolOrchestra [65]; AOrchestra [58]; AccelOpt [77]

Heterogeneous

OWL [26]; ToolOrchestra [65]; AOrchestra [58]

Agentic CPU. The aforementioned software optimizations still run on unchanged hardware. Agentic execution changes the demands placed on this hardware, particularly on the host CPU. In LLM inference the CPU fills a single role: a scheduler that dispatches inferences to the accelerator. Agentic execution keeps this role and adds two additional logical host roles: an orchestrator that routes messages and state among agents and enforces workflow dependencies, and a runner that executes agent logic and invokes tools [40], [48]. Thus, the CPU becomes far more than a front end for the accelerator. Figure 1 shows how these three roles interleave CPU and GPU work across a workflow. This expansion has led several vendors to advertise “agentic” CPUs and platforms [5], [7], [19]. Yet the architectural requirements of such platforms remain unclear. The research community has also begun to examine the CPU in agentic execution, but primarily at a coarse granularity, reporting aggregate host utilization and end-to-end latency [57], [76]. It remains unknown where the host bottlenecks lie, how they shift across the three roles, what microarchitectural challenges agentic workloads pose, and what server mechanisms these behaviors call for.

Implication for platform design The host exposes the control flow to the runtime, enabling scheduling and prefetching. The model selects or creates agents at runtime, adding inference-driven control decisions. Dependent steps form a critical path; a stalled step delays the whole workflow. Independent agents create concurrent inference and tool bursts, increasing batching and load. A common base model enables shared residency and larger cross-agent batches. Multiple model types must remain available within the workflow, complicating load balancing.

state machine specifies the agents and their dependencies, and the host advances execution according to this logic, as in MetaGPT [25] and later multi-agent systems [59], [82]. In an LLM-orchestrated workflow, a model makes routing decisions at runtime and forwards the decision to the host, so the control flow itself includes model inference, as in OWL [26], AOrchestra [58], and ToolOrchestra [65]. As hostside control logic is visible to the runtime, it exposes workflow dependencies and can enable earlier scheduling and prefetching [75]. LLM orchestration instead places a model inference in the control path: the next step depends on generated output, increasing inference demand and reducing predictability. Execution structure. The second dimension is how the nodes of the workflow graph are arranged over time. In a sequential workflow, each agent depends on the result of the preceding one: at most one node is active at a time, forming a chain [50], [67], [77]. A parallel workflow instead fans out independent subtasks that run concurrently and later synchronize, as in multi-agent debate [12], CORAL [56], and DeLM [45]. This structure shapes the temporal pattern of demand on the host and accelerators. A sequential workflow exposes little independent work, so a delayed inference, tool call, or handoff directly extends its critical path. A parallel workflow exposes multiple ready agents at once, creating opportunities for batching and overlap but also concentrating inference and tool activity into bursts that increase pressure on the system’s resources. Model composition. The third dimension is whether the agents run the same model or a mix. In a homogeneous workflow, all agents draw from the same base model, varying only the prompt, tools, or a lightweight adapter, as most opensource frameworks do by default. A heterogeneous workflow combines models of different kinds or sizes [58], [65], [77], e.g., a small model that plans or routes and a large one that writes code [8], [9], [17]. This distinction directly affects model residency and serving efficiency. A homogeneous workflow creates opportunities to share one resident model across agents and batch their requests, with only the peragent context stored separately, simplifying provisioning and placement. A heterogeneous workflow keeps several models resident, raising GPU-memory pressure, fragmenting batching, and complicating load balancing.

III. A TAXONOMY OF AGENTIC W ORKFLOWS Agentic workflows differ widely across deployments, making it difficult to reason about them as a single class. We take an agent, a multi-turn model–tool loop, as the primitive of analysis, and present a taxonomy of multi-agent workflows. Interactions among such primitives expose platformlevel choices and trade-offs. We organize the space along three orthogonal, platform-relevant dimensions, each placing a distinct demand on the server: who decides what runs next (orchestration), how the steps are arranged in time (execution structure), and how many model families are used in the workflow (model composition). Table I summarizes the taxonomy. These dimensions are not immutable labels, instead, a workflow may combine multiple options or move between them across stages [23], [43], [54], [55]. Thus, the taxonomy captures the dominant behavior that determines server needs. Orchestration. The first dimension is who decides what runs next. In a host-orchestrated workflow, such task is done by the host-side program logic. A programmatic graph or

3

IV. C HARACTERIZING AGENTIC AI W ORKLOADS To understand the architectural implications of agentic AI, we characterize it through two complementary lenses. First, we conduct a fleet study of production agentic services running in our hyperscaler, Microsoft Azure, capturing their real workload, tool mix, and resource usage at scale. Second, we perform a controlled study using four representative open-source frameworks covering representative points in our taxonomy, allowing us to isolate root causes and reproduce them. For the fleet study, we collect a 24-hour trace of production agentic requests and attribute time, tool activity, and CPU metrics to software roles (schedulers, orchestrators, and runners). For the controlled study, we evaluate SWE-Agent [71] (a single-agent, sequential, tool-intensive coding workflow), Trae [67] (a sequential coding workflow with long tool chains and three model endpoints), CORAL [56] (a four-agent, parallel, homogeneous-model evolutionary workflow), and Owl [26] (a heterogeneous workforce with a coordinator, six text roles, and vision and speech models). We run them on a server with a 96-core AMD EPYC 7V12 CPU and eight NVIDIA A100 GPUs. We deploy one vLLM instance per agent role while varying concurrency from 1 to 32 tasks. Our studies lead to two findings. First, agentic AI creates highly fragmented and heterogeneous execution across the CPU and GPU (Section IV-A). Second, this execution pattern stresses the server architecture in ways that differ from both traditional cloud services and monolithic LLM inference, manifesting as resource imbalance, poor microarchitectural locality, and increasing coordination overhead (Section IV-B).

$3,UHTXHVW //0FDOOV 7RRO([HFXWLRQ$ 7RRO,QYRFDWLRQ 7RRO6HDUFK 7RRO([HFXWLRQ%

V V

V

V

V





V

V

V

V

           (ODSVHGWLPHVHFRQGV

Fig. 2. Lifecycle of an example production request. Tool phases interleave with LLM calls, and the request repeatedly crosses the CPU-GPU boundary.

GPU activity while it waits for an upstream result. The finegrained host-orchestrated execution fragments every request into heterogeneous CPU and GPU phases. LLM (GPU)

bash

read

write

edit

eval

other

Agent 4 Agent 3 Agent 2 Agent 1 0

5

10

15

Time (s)

20

25

Fig. 3. A slice of a CORAL run. Agents alternate LLM inferences (GPU) with tool calls (CPU), colored by tool type; dependencies leave idle gaps.

This pattern extends across the fleet. Figure 4 summarizes the distribution of time agentic workflow requests spend in LLM inference and tool execution, and the fraction of request time spent in tools. Tool execution time has a heavy tail distribution, accounting for a large and highly variable share of request time, comparable to or exceeding the time spent in inference for more than 27% of requests. Thus, host-side tool work is a first-class contributor to end-to-end latency across the fleet, and the wide spread of the distribution means that no single CPU-to-GPU time ratio characterizes the workload. 







  //0LQIHUHQFH 7RROH[HFXWLRQ

 



     7RWDOWLPHVSHQWVHFRQGV

&')5HTXHVWV

&')5HTXHVWV

A. Agentic AI Creates Fragmented and Heterogeneous Work An agentic request unfolds as a graph of interleaved model inferences, tool invocations, and orchestration decisions distributed across CPU and GPU. This fragmented execution is diversified by workflow designs, application tasks, and tool behaviors, resulting in highly heterogeneous resource needs. Host orchestration fragments execution. Figure 2 shows the lifecycle of a representative production request. The request spans nearly a minute, alternating between multiple LLM calls, agent hand-offs, 3 tool-discovery operations, and 3 tool executions across 2 different tools. After each LLM call, host-side orchestration interprets the output and advances the workflow, while every tool result must be incorporated into workflow state before the agent resumes. Hence, the request repeatedly crosses the CPU-GPU boundary, and the host-side tool phases account for a substantial fraction of the end-to-end latency. The CPU therefore becomes part of the critical path for agentic requests instead of merely feeding the accelerator. Figure 3 shows the same behavior in our controlled study using CORAL. A single run expands into 580 LLM calls interleaved with 552 heterogeneous tool invocations, ranging from millisecond file system operations to multi-second compilations and evaluations. Each agent alternates continuously between GPU inference and CPU tool work, so execution ping-pongs between the two processors hundreds of times. Control and data dependencies create visible gaps in an agent’s



   

      )UDFWLRQRIWLPHVSHQWLQWRROFDOOV

Fig. 4. Fleet distribution of time spent in LLM inference versus tool execution, and the fraction of request time spent in tool calls.

Execution structure creates bursty load. Execution structure shapes host load at multiple granularities. At the agent level, sequential workflows expose one ready agent at a time, while parallel workflows expose multiple agents concurrently. Within an agent, a stage may further fan out into multiple tool invocations. Both agent-level parallelism and within-agent fanout can concentrate host activity into short bursts. Figure 5 shows the latter behavior through host CPU utilization over an entire Trae run. Although Trae is sequential at the agent level, some reasoning stages launch multiple builds and test runs in parallel. Host CPU utilization stays near its

4

Host CPU

Host CPU busy (%)

100

Spike

100 80 60 40 20 0 0

Median

75 50 25 200

400

600

Time (s)

800

1000

GPU 2

200

GPU 3

400

GPU 4

600

Time (s)

GPU 5

GPU 6

800

1000

GPU 7

Workload diversity amplifies heterogeneity. A workflow’s taxonomy class alone does not determine its resource demand. Even within the same taxonomy class, resource demand varies with the tasks an application solves and the tools it invokes. Figure 8 holds the CORAL framework and workflow configuration fixed while varying the task set. The same framework stresses opposite resources depending on the task: research problems saturate the host CPU at 99% while leaving the GPU at 44%, whereas algorithmic problems exhibit the opposite balance, using only 31% of the CPU but 55% of the GPU.

Fig. 5. Host CPU over time for Trae. Stage-based execution keeps the CPU near its median, then drives sharp bursts toward saturation.

Execution structure also shapes how host demand is divided between scheduler and tool work. Under high concurrency, Figure 6 decomposes host CPU demand over time into scheduler and tool components. Scheduler demand remains relatively steady while an agent is active, whereas tool demand fluctuates as tools start and finish. The observed patterns align with each workflow’s execution structure. Owl activates only a subset of its roles at a time, so aggregate scheduler demand remains low but fluctuates as different roles become active and idle. CORAL runs its four agents in parallel, keeping aggregate scheduler demand steadily high. Trae advances in stages, causing tool demand to alternate between quiet intervals and extended, near-saturating bursts. 20 Owl (sequential) CPU (cores)

GPU 1

Fig. 7. Per-GPU power consumption (% of peak) over time for Owl.

0 0

Scheduler Tools CORAL (parallel) 100

Median (%)

100

500

1000 1500

Time (s)

0

500

1000 1500

Time (s)

0

500

GPU SM

GPU power

50 0

Research

Algorithms

Across applications, Figure 11 shows the distribution of tool calls across functional categories in the fleet. The workload spans a broad variety, from code execution, which is the single largest category, to DevOps, search and retrieval, databases, and communication services, each exhibiting a distinct resource signature. Variation appears not only across categories but also across requests within a category. Figure 12 shows the number of concrete tool calls per active request in each category, reported as the average and the 99th percentile. On average, a single request issues many tool calls, and the tail is far heavier than the average and behaves distinctly across functional categories. Consequently, diversity from tasks, applications, and tools further amplifies the heterogeneity and stresses the underlying hardware. No single CPU-to-GPU operating point characterizes the workload. These results show the architectural challenges of running agentic workflows. Host orchestration fragments execution, execution structure introduces bursty load, model composition creates resource imbalance, and task and tool diversity further broadens the operating space. We next examine how such heterogeneous work interacts with server architecture.

Trae (staged)

50

25

Host CPU

Fig. 8. Resource utilization of CORAL on research vs. algorithmic task sets.

50 10 0

GPU 0

GPU power (% of peak)

11% median during the sequential portions, but rises rapidly to nearly 100% at these stage boundaries. This contrast between average and peak demand makes static provisioning inefficient.

1000 1500

Time (s)

Fig. 6. Host CPU over time split into scheduler cores (the per-agent serving engines) and tool cores for three different frameworks.

Model composition complicates imbalances across devices. Model composition shapes how execution is distributed across accelerators. In a homogeneous workflow, multiple roles may share one serving instance or use role-dedicated instances of the same model, whereas a heterogeneous workflow distributes execution across models of different types or modalities. Figure 7 shows the power draw of all eight GPUs during an Owl run at high concurrency. As each role is served by a separate serving instance and the roles differ widely in activity, this fine-grained mapping translates role-level skew into uneven demand across GPUs. Four GPUs serving the busiest text and vision roles repeatedly approach peak power, while the remaining GPUs spend most of the execution near idle ∼20%. Under this static role-to-GPU mapping, lightly loaded devices retain substantial unused capacity. Reclaiming this capacity requires collocating roles with complementary activity on fewer GPUs. Differences in model size and modality further constrain which roles can share a deployment or be efficiently collocated, making the imbalance harder to eliminate.

B. Heterogeneous Work Stresses the Server Architecture The fragmentation and heterogeneity of agentic execution challenge two assumptions underlying today’s server architectures: resource demand remains relatively stable over time, and host work can be managed as a uniform pool. Conventional CPU-centric services primarily stress the host, whereas monolithic LLM inference is largely accelerator-bound. Agentic

5

2UFK 6FKH 5XQQ &38XWLOL]DWLRQ

2UFK 6FKH 5XQQ 1HWZRUN,2

2UFK 6FKH 5XQQ &RQWH[W6ZLWFKLQJ

    

'LVN2SV0%V

    

0HP3UHVVXUH

    

93GLVSDWFKV.

1HWZRUN,2*%V

&38XWLOL]DWLRQ

    

2UFK 6FKH 5XQQ 0HPRU\3UHVVXUH

    

3 3

3 $YJ

2UFK 6FKH 5XQQ 'LVN2SV

,3&

5HWLULQJ

)URQWHQG% %DG6SHF %DFNHQG%



%UDQFK03.,

    

&DFKH03.,

    

70$/

,3&

Fig. 9. Per-role host metrics for schedulers, orchestrators, and runners in the fleet. The three roles have fundamentally different resource signatures.

  

/03.,

/03.,



3 3 2UFK 6FKH 5XQQ

  

/03.,

%UDQFK0LVS 0DFKLQH&O

Fig. 10. PMU measurements (top-down, cache, and branch) for the three host roles in the fleet. Low IPC, pipeline stalls, and high cache MPKI dominate.

&RGH$3,H[HFXWLRQ *LW+XE'HY2SV 6HDUFKUHWULHYDO 2WKHU 'DWDTXHU\ &RPPSURGXFWLYLW\ %XVLQHVVZRUNIORZ

Host CPU

Median (%)

100





  RIREVHUYHGWRROFDOOV

$YJ 

   1XPEHURIWRROFDOOVSHUUHTXHVW

GPU power

50 0

SWE-Agent

Trae

CORAL

Owl

Fig. 13. Median host CPU utilization, GPU SM-activity, and GPU power across frameworks on a single server.



of an agentic system contains three distinct roles: schedulers that dispatch model requests, orchestrators that manage workflow state and routing, and runners that execute tools. Figure 9 shows the resource signatures of production hosts dedicated to these roles. The roles differ not only in their overall utilization, but also in which resources they stress. For instance, a role that is CPU-heavy is light on the network, and a role that dispatches at a high rate is light on disk. No single metric therefore captures their provisioning needs. Mapping these roles onto a single homogeneous core pool leads to inefficient provisioning, and simply adding more identical cores does not resolve the underlying mismatch. Such a pool treats the roles as interchangeable despite their distinct demand patterns and latency requirements. Reserving enough cores for bursty runners wastes capacity while tools are idle, whereas sharing those cores with the control path allows tool bursts to delay inference dispatch and agent handoffs. Agentic servers therefore require role-aware resource allocation that isolates latency-critical coordination from bursty execution and sizes each role’s pool independently. Agent multiplexing impacts microarchitectural locality. The mismatch extends below resource utilization into the microarchitecture itself. A host-wide PMU snapshot from production nodes provides fleet-scale evidence that these workloads can be microarchitecturally inefficient. Figure 10 shows PMU measurements for cores serving the three host roles, including IPC, the top-down breakdown of pipeline slots, cache misses per kilo-instruction, and branch mispredictions. While IPC is low, the pipeline is dominated by backend and frontend stalls rather than retiring instructions, and cache MPKI is high, especially at the deeper levels of the hierarchy, with non-trivial branch mispredictions on top. The host is thus starved on the memory subsystem and the instruction front

Fig. 11. Fleet distribution of tool calls across functional categories.

&RGH$3,H[HFXWLRQ *LW+XE'HY2SV 6HDUFKUHWULHYDO 2WKHU 'DWDTXHU\ &RPPSURGXFWLYLW\ %XVLQHVVZRUNIORZ

GPU SM

3 

Fig. 12. Per-request tool-call frequency by category (average and P99).

execution fits neither pattern. It alternates between CPU and GPU phases, distributes work across roles with distinct resource profiles, and multiplexes many short-lived tasks. Thus, static provisioning strands capacity, while shared, role-agnostic scheduling introduces interference and coordination overhead. Fragmentation Strands CPU/GPU Resources. Fragmentation causes CPU and GPU demand to alternate over time. Figure 13 shows the median host CPU utilization, GPU SM activity, and GPU power per framework. Both processors remain underutilized on average: host CPU utilization ranges from 6% (Owl) to 31% (CORAL), while GPU SM activity stays below 55%. GPU power runs higher at up to 50–70% of peak, but still leaves the accelerators far from saturated. The time-series show that low medians do not reflect an absence of instantaneous demand. Instead, CPU demand falls during accelerator-bound phases, while GPU activity drops during host-side orchestration and tool execution. Provisioning for peak wastes capacity between bursts, while provisioning for the average leaves insufficient headroom when bursts arrive. Agentic workloads strand capacity: neither the CPU nor GPU is fully utilized in aggregate, yet each can become a transient bottleneck on the workflow’s critical path. Host roles break homogeneous provisioning. The host side

6

end, so its cores spend most of their cycles stalled rather than doing useful work. Our controlled study provides further evidence consistent with microarchitectural interference under agent multiplexing. Figure 14 shows the top-down pipeline-slot breakdown for the four frameworks. SWE-Agent, CORAL, and Owl are primarily backend-bound, losing 43–47% of pipeline slots to backend stalls, while Trae is split more evenly between frontend and backend stalls. IPC stays low, 1.2–1.6. L1-data MPKI reaches 14–20, while L2 and branch-misprediction MPKI also remain elevated. This behavior is consistent with interference in stateful microarchitectural structures as many agent tasks timeshare the same cores, displacing one another’s cache lines and branch-predictor state. These results motivate bounding each task’s contention domain and preserving affinity, rather than freely multiplexing all agent work across a shared core pool. Frontend

Pipe. slots (%)

100

Backend

Retiring

Bad-spec

Trae

CORAL

Owl

V. S ERVER D ESIGN P RINCIPLES AND C ASE S TUDIES Our characterization yields concrete design principles for servers that run agentic AI. We examine each through a case study in Agora, our prototype for commodity servers. Agentic execution is fragmented, bursty, and heterogeneous, whereas today’s servers allocate resources statically and manage their cores as a uniform pool. Agora closes this gap in two ways: it harvests the CPU and GPU capacity stranded by fragmentation, and it pools and pins cores to match the differing demands of the scheduler, orchestrator, and runner. Agora tunes each principle to where the workload sits in the taxonomy, and to its current load and task characteristics. A. Harvesting Stranded CPU and GPU Cycles 1) Harvesting Idle CPU Cores: The goal of CPU harvesting is to maximize per-server throughput while guarding the latency of the agentic workflow. The characterization showed that runner cores exhibit substantial idle periods punctuated by sudden tool bursts. Agora reclaims the idle cores by colocating CPU-intensive traditional workloads, which we call harvesters, on the same runner cores that the agent tools use. The difficulty is that the idle capacity is not stable. A harvester that simply takes the idle cores steals them during a tool burst and slows the agent workflow. Agora thus lets harvesters share the runner cores, harvesting aggressively while the runners are idle and retreating when sustained runner demand appears.

50 0 SWE-Agent

Fig. 14. Top-down pipeline-slot breakdown across frameworks. The host is stalled on the memory subsystem or the instruction front end.

Ctxt-sw / s

Coordination overhead limits scalability. Finally, increasing agent concurrency creates additional host-side coordination pressure. Unlike conventional inference, where higher concurrency primarily improves accelerator utilization, adding concurrent agents also increases host-side scheduling, dispatch, and context-management activity. Figure 15 shows involuntary context switches, the signal of cores being preempted under contention, as concurrency grows from 1 to 32 tasks. For SWE-Agent, context switches grow from 71 to 660 per second, even though aggregate CPU utilization remains low. The system therefore spends increasingly more effort coordinating agents rather than executing useful work. This behavior suggests that general-purpose operating system scheduling becomes insufficient at high agent concurrency and motivates dedicated hardware or runtime support for agent scheduling and context management. Owl

2

4

8

16

Agent Orchestrator Knows graph and tool type

Orchestrator

Never Harvested

Shared Runner Cores R

H

H

R

R

H

H

R

R

H

H

R Run.

H Harvester

(c) Adaptive Retreat Grace period Tool activity Harvester High allocation Low

High Runner capacity Low

Hint

Compute-bound tool Hint Compute

Harv. capacity

Time

Hints

I/O-bound tool Hint Harv. capacity

No hint

Detected burst

I/O wait

Time

Harvest Controller

Harv. capacity

Time

Recovery period

Time

Time Time

Fig. 16. Agora harvests idle runner cores in agentic workflows by collocating harvester workloads and introducing three working mechanisms: a) role-based isolation, b) orchestrator hints, and c) adaptive retreat.

SWE-Agent

Concurrent tasks

(b) Orchestrator Hints

Scheduler Orchestrator Cores Scheduler

500 250 1

(a) Role-based Isolation

Harvesting resources is well studied in datacenters, where prior systems reclaim spare CPU cycles or memory from latency-critical services using historical utilization prediction and safe throttling [20], [64], [69], [78], [79]. Agentic workloads challenge the assumptions behind these systems, because their idle capacity can disappear abruptly during overlapping tool bursts, so history-based controllers may react too late. Agora differs in three ways that are specific to agentic execution: it isolates cores by their role so that harvesting never touches the latency-critical scheduler and orchestrator cores, it takes hints from the orchestrator to anticipate bursts and to distinguish compute-bound from I/O-bound tools, and it adapts its retreat policy to the workflow’s position in the taxonomy and to its load. Figure 16 illustrates the mechanism.

32

Fig. 15. Involuntary context switches versus agent concurrency. Coordination cost grows steeply with the number of agents.

These results show that agentic AI stresses servers through a combination of temporal fragmentation, resource heterogeneity, microarchitectural interference, and growing coordination overhead. This is a poor match for static CPU/GPU partitioning and undifferentiated core pools. Instead, agentic systems require architectures that dynamically reclaim stranded resources, match hardware to software roles, preserve locality under multiplexing, and reduce the cost of coordination.

7

additional throughput. Agora also raises host CPU utilization by 31%, at a cost of only 3.3% higher agent latency. Policy trade-off. Figure 17 shows, for two frameworks at high load, the harvested throughput and the agent slowdown of three policies: never retreating, pausing the harvester whenever a tool runs, and the gradual retreat with a grace period. Never retreating delivers the most throughput but the largest slowdown. Always pausing gives the least slowdown but the least throughput. The gradual policy avoids most of the slowdown caused by no retreat while delivering more throughput than always pausing. Agora thus uses the gradual, grace-guarded retreat at high load and the no-retreat policy at low load. Two cases bound the technique. A parallel, tool-saturated workflow keeps its cores busy almost continuously, so little is harvestable and the delivered throughput is low, as CORAL shows at high load. A workflow like Owl whose tools mostly wait on the network is over-protected by tool-triggered retreat, which is the case that the orchestrator’s tool-type hint is designed to fix. Without type information, an all-tool retreat policy retains only 37.7% standalone throughput; with tooltype hints, it retains 80% at 0.2% average agent slowdown.

TABLE II H ARVESTED THROUGHPUT AND AGENT SLOWDOWN UNDER CPU HARVESTING AT LOW AND HIGH LOAD . VALUES NEAR 100% MEAN THE HARVESTER APPROXIMATELY DELIVERS ITS STANDALONE THROUGHPUT.

Low load

High load

Framework

Harvest (%)

Slow. (%)

Harvest (%)

Slow. (%)

SWE-Agent Trae CORAL Owl

101.5 100.1 94.7 83.6

2.5 1.4 1.0 6.2

63.6 73.3 1.0 76.9

1.2 4.3 9.9 0.2

Average

95.0

2.8

53.7

3.9

Role-based isolation. Agora lets harvesters share the oftenunderutilized runner cores while isolating the latency-critical control cores. These include scheduler cores that dispatch inferences to the accelerators and orchestrator cores that route work and state among agents; Agora never places harvesters on either. This keeps the part of the host that most directly affects agent latency free of interference.

Agent slowdown (%)

Adaptive retreat. When Agora detects a burst of tool executions on the runner cores, it first enters a grace window. If the execution episode ends within the grace window, the harvester continues unchanged, preserving harvester throughput when retreat would provide little benefit to the agent. If the burst persists, Agora gradually throttles the harvester and eventually pauses it, limiting contention while avoiding an abrupt loss of harvester throughput. After the episode ends, Agora also waits for a short recovery window before resuming the harvester, merging closely spaced tool calls into one adjustment and preventing repeated throttling and resumption.

6

No retreat

Gradual + grace

Always pause

SWE-Agent

Trae

4 2 60

65

70

75

80

85

Harvested throughput (% of standalone)

90

Fig. 17. Harvested throughput versus agent slowdown at high load for three policies, with two different agentic frameworks.

Orchestrator hints. A reactive controller must observe a burst before it acts, leaving a short window in which tools and harvesters contend. Agora closes this window when the workflow is host-orchestrated: the orchestrator knows the workflow graph and warns Agora that a burst is about to start, so it takes action before the tools run. The orchestrator also knows the tool types. When a tool is compute-bound, Agora reduces the harvester’s allocation. When a tool is I/Obound and primarily waits on an external service, Agora keeps harvesting, because the tool consumes little CPU.

Adapting to the taxonomy and load. How much and how early Agora retreats depends on the workload’s taxonomy and on the load. Along the execution-structure axis, a sequential workflow issues isolated, well-separated tool bursts, so most bursts end within the grace period and the harvester keeps most of its throughput. A parallel workflow can issue concurrent bursts across multiple agents, so the bursts overlap and leave little idle time. In the extreme, a parallel and tool-saturated workflow (e.g., CORAL at high load) leaves almost no idle capacity, so Agora disables harvesting entirely. Along the orchestration axis, a host-orchestrated workflow supplies the proactive and typed hints above, so Agora retreats selectively for compute-bound tools, whereas an LLM-orchestrated workflow gives no hints and Agora falls back to reactive detection with a conservative grace period. The load sets the operating point: at low load, the interference is small and Agora harvests aggressively, and at high load, Agora applies the gradual, grace-guarded retreat to bound the agent’s latency. 2) Harvesting Idle GPU Capacity: The goal is to serve the same agents on fewer GPUs, so that each accelerator does useful work instead of idling. The characterization showed that the accelerator pool is underused and imbalanced under a static, role-dedicated deployment. Some devices approach saturation while others sit near idle, because roles differ in

Reclaimed throughput. We evaluate CPU harvesting on the four frameworks, each co-located with a DCPerf [66] harvester at low and high-loads. The low-load setting runs a few concurrent agents and a light harvester, while the high-load setting runs many concurrent agents and an intense harvester. We report two metrics: the agent slowdown, which is the increase in the agent workflow’s makespan relative to running alone, and the harvested throughput, which is the fraction of the harvester’s standalone throughput that it delivers while colocated. Table II shows the results. At low load, the harvesters deliver 95% of their standalone throughput at under 3% agent slowdown, and at high load, they deliver 53.7% on average at under 4% slowdown. Averaged over the two operating points, the co-located harvesters deliver 74% of their standalone throughput, effectively recovering 0.74 server-equivalents of

8

load and are often not active at the same time. Agora reclaims this stranded capacity in two steps. It first consolidates agents by co-locating several on a shared serving instance, so that one instance serves many agents, raising each GPU’s utilization at a fixed GPU count. It then harvests by reducing the GPU count itself, returning the freed GPUs to a shared pool for other work. The challenge is that the agents’ combined memory footprint may exceed device capacity, while roles that are active simultaneously can contend for GPU compute. Figure 18 illustrates the mechanism. (a) Stranded GPU Capacity

TABLE III GPU CONSOLIDATION ( CON .) AND HARVESTING ( HAR .) UNDER HIGH LOAD , RELATIVE TO A ROLE - DEDICATED DEPLOYMENT BASELINE . Framework Owl (con.) Owl (har.) CORAL (con.) CORAL (har.)

Host Memory

GPU Memory GPU 1

GPU 2

Evict Prefetch

GPU 3 GPU 4

Profiling

GPU 2

Evict Prefetch

GPU 5 GPU 6

MILP

GPU 3

T-put.

Tasks/h

Tail lat.

– 33% – 50%

+106% +82% +15% −71%

+36% 3.8× +22% 2.5× +28% 5.3× −55% 16× worse

Energy eff. KV hit +42% +51% +20% −53%

+68% +75% +8% −17%

its own GPUs. For Owl, Agora frees a third of the GPUs while raising generation throughput by 82%, completing 22% more tasks per hour, cutting tail latency by 2.5×, and improving energy efficiency by 51%. The benefit holds across the load range, so the harvested layout is safe as a static choice. At a fixed GPU budget, the same consolidation mechanism instead improves performance, raising throughput by 106% and cutting tail latency by 3.8×. Consolidation improves throughput even as it frees GPUs because collocated agents that run the same model share a single copy of its weights. This removes the duplicate weight copies that a role-dedicated deployment keeps, freeing memory for a larger KV cache. Together with cross-agent prefix reuse, this additional capacity increases the measured KV-cache hit rate and serving capacity. Higher tensor parallelism can improve throughput by amortizing weight reads, but introduces a synchronization–communication tradeoff, e.g., in CORAL, TP8 does not outperform the rolededicated baseline, while two TP4 instances do. Adapting to the taxonomy and load. How much Agora can harvest depends on where the workload sits in the taxonomy, and the execution structure sets the headroom. When agents run at different times rather than in parallel, their busy periods do not overlap, so many GPUs sit idle at any instant. Agora can then time-share those agents onto fewer devices and reclaim whole GPUs. Owl behaves this way, as its agents activate unevenly and leave much of the pool stranded, so harvesting frees a third of the GPUs. A parallel workflow such as CORAL instead keeps its agents active concurrently, leaving little capacity stranded, and harvesting GPUs there costs throughput that can exceed the fraction of GPUs removed. Such a workflow should therefore not be harvested. It still consolidates the agents at a fixed GPU budget, where sharing weights and cache raises throughput by 15% and cuts tail latency by 5.3× at high load. Load sets the operating point: the gains are largest at high concurrency, where stranding and contention are worst, and shrink at low load. Agora thus harvests GPUs where the taxonomy and load leave them stranded, and otherwise consolidates only to raise throughput.

(b) GPU Harvesting with Agent Collocation

GPU 1

GPUs red.

Evict Prefetch

Fig. 18. GPU layout: a) a static role-dedicated deployment that strands GPU compute, and b) Agora’s GPU harvesting, which consolidates agents onto shared serving instances and frees GPUs.

Oversubscribing GPU memory. Agora oversubscribes a GPU by assigning it more agent state than can reside simultaneously. It keeps the active agents resident and stages the rest in host memory. Swapping this state in on demand would stall the accelerator, so Agora hides the cost when it can. When the workflow is host-orchestrated, the orchestrator knows which agent runs next, and Agora prefetches that agent’s state from host memory before it is needed, overlapping the transfer with the current agent’s work. Taxonomy-guided collocation. Which agents to place together depends on the taxonomy and how much state they share. Agents that share large amounts of state, including model weights and cached prompt prefixes, are efficient to collocate, because the shared portion stays resident only once. A homogeneous workflow is the ideal case, where every agent uses the same base model and only the smaller per-agent state must be managed separately. Agents that are never active at the same time can share a device without contending for compute, which a sequential workflow guarantees since it activates one agent at a time. Agora also pairs a heavily used agent with a lightly used one rather than stacking two hot agents on the same device, so that collocated agents fill each other’s idle periods instead of competing. Solving the allocation. The best layout depends on the models, the workflow, and the load, all of which shift over a run, so Agora recomputes it dynamically. It casts the placement as a mixed-integer linear program over profiling data. The program decides, for each agent, how many GPUs it receives and its tensor-parallel configuration, and which agents to collocate, subject to the memory and contention constraints above. The result is a GPU assignment that tracks the workload and keeps the accelerators busy without slowing the agents. Reclaimed capacity. Table III reports GPU harvesting on two workflows, Owl and CORAL, relative to serving each agent on

B. Role-Aware CPU Core Pooling and Pinning In a conventional role-agnostic deployment, the scheduler, orchestrator, and runner share one CPU pool, despite performing different kinds of work. The scheduler and the orchestrator are latency-critical: they gate every inference and handoff, so response time matters. The runner instead has highly variable demand: its tools sit idle, then burst. These demands pull in opposite directions, so the roles cannot be scaled as one bundle. A shared pool sized for bursts wastes cores when

9

the runner is idle. A pool sized for the common case has no room for a burst. The tools then steal cores from the control roles the agent is waiting on. Sharing a pool also reduces the effectiveness of microarchitectural structures: many tasks and tools crowd onto the same cores and switch in and out constantly, polluting the caches and branch predictors. Agora responds by giving each role its own pool. It separates the control roles from the runner, so the two no longer compete and each is sized on its own. Within the runner, it pins each task to a narrow set of cores, limiting tool migration and cache thrashing. The challenge is that the layout cannot be fixed once, unlike with the traditional datacenter services [61]. The runner swings between idle and saturation, so the partition that fits one workload is wrong for the next. To solve this, Agora builds on its harvesting mechanism and extends its roleawareness inward to the agent’s cores, dynamically resizing the pools. Figure 19 shows the mechanism. S

R R

O

R

(c) Per-task pinning

(b) Role-aware pools

(a) Shared CPU pool

O S

R

Scheduler

Orchestrator

S

O

S

R S

O

Task 1

H

Task 2

R

O

R

Migration and Interference

Edit

Shell

Test

Edit

Shell

Test

R

CACHE

Runner Pool

R

R

H

R R

R

coding workloads, over its lifetime it runs a whole sequence of tools against the same files and repository state (e.g., editing a file, running a shell command, and executing a test). Pinning by task keeps that entire sequence on a set of cores. Pinning by tool type would instead gather every edit across all tasks onto one set of cores and every test onto another. The mix of active tools shifts continuously over a run, so a static per-tool partition cannot track demand and leaves some tool classes starved while others sit idle. A per-task partition instead follows the work, as each task carries its own tools with it. It also preserves locality, as the tools within a task operate on the same working set. Adapting to the taxonomy and load. The pool layout follows where the workload sits in the taxonomy. Along the modelcomposition dimension, a homogeneous workflow can share one scheduler pool, whereas a heterogeneous workflow requires one per serving backend. Along the execution-structure dimension, a parallel, high-concurrency workflow gains the most from fine-grained per-task pinning, because many tool bursts overlap and contend, while a sequential workflow contends little and needs coarse pinning at most. The load sets the pool sizes, so Agora widens the runner pool as concurrency rises and returns cores to harvesting when the runner is quiet. Evaluation setup. We increase load by the number of concurrent agent tasks, C ∈ {1, 8, 32}, on a fixed core budget: C=1 and C=8 use one 24-core NUMA node, and C=32 uses 48 cores across two nodes. Compaction confines tools to a bounded runner pool rather than the full core budget. We compare Shared, which places the tool and serving planes in one CPU set; Split, which assigns them separate pools on the same node; and Isolate, which moves the serving plane to another NUMA node while preserving the total core budget. Within the runner pool we sweep pinning from one wide shared pool to a few tasks per pool, one shared neighbor, and private per-task cores. We report reclaimed CPU as CPU-seconds relative to the unpartitioned baseline. For performance, we report batch completion time—the wall-clock time of the whole run—and perlane metrics. We break performance down per lane, which is one task’s execution timeline: its full-lane span is the task’s end-to-end time, and its tool sum is the cumulative execution time of its tool calls. We report per-lane metrics as the median and maximum across lanes. To size the scheduler pool, we separately run a pure-serving microbenchmark that shrinks the serving core budget while measuring output throughput. Right-sizing the scheduler pool. The serving plane’s host demand is small and stable. It uses 10.3 cores in total across its control processes, and this holds across frameworks. Throughput then saturates sharply with the core budget: a pool of 11 cores already retains 98.5% of standalone throughput, while 16 or more cores add almost nothing. Agora therefore sizes the scheduler pool just above this measured demand. Doing so retains 99% of serving throughput and frees the rest of the machine for the runner and for harvesting. Compacting the runner pool. Table IV reports runner com-

R

R

Runner

H

CACHE

H

Harvester

Warm cache and branch state

Fig. 19. CPU core layout: a) a shared pool where all roles contend for cores, causing interference and migration, b) role-aware pools, and c) pertask pinning within the runner pool.

Right-sizing the role pools. Agora places the scheduler and the orchestrator on small, dedicated pools of a few cores each. Both roles are latency-critical but with low and stable demand, so isolation keeps inference dispatches and handoffs off the contended runner cores. Thus, a tool burst cannot directly contend for their cores. Profiling the scheduler plane shows that its footprint is small and stable and grows with the serving configuration rather than with the agent load, so Agora sizes each control pool just above its measured demand. The remaining cores form the bounded runner pool for bursty, mostly idle tools. Compaction therefore reduces scheduling overhead because the runner role incurs the most context switches. On a wide set of cores, the OS repeatedly migrates the many short-lived tool processes, and each migration reschedules the process and reloads its state on a new core, whereas a bounded pool holds them on a limited set of cores. Compaction also keeps the runner’s bursts from spilling into the control pools, and the cores left outside it become clean, contiguous capacity that harvesting can reclaim. Pinning to restore locality. Sizing the runner pool is not enough, as many agents still share the same cores. Agora therefore pins each task, or a small group of tasks, to a narrow set of cores within the runner pool. A narrow contention domain restores the cache and branch locality that the agents would otherwise destroy, and it bounds how far one task’s burst can interfere with its neighbors. Agora pins by task rather than by tool type. A task is one agent’s assignment, such as resolving a single issue. In our

10

is smaller than for SWE-Agent, the tighter layout cuts peak runner usage from 70.1 to 14.1 cores, reducing interference with co-located workloads. Harvesting and role-aware pooling complete Agora’s CPU management. Harvesting fills idle cores with useful work, while pooling lays out the agent’s own roles so that the control path stays fast, the tools keep their locality, and the reclaimed capacity forms clean pools for the harvester to use.

TABLE IV RUNNER - POOL COMPACTION RELATIVE TO THE UNPARTITIONED BASELINE (%). P OSITIVE MEANS LESS CPU WORK OR FASTER EXECUTION ( MEDIAN / MAX ACROSS LANES ). C

Placement

Tool CPU

Serve CPU

Tool time

Batch

8 8 8

Shared Split Isolate

40.1 44.2 46.0

-0.2 1.4 1.0

-2.4 / -1.2 2.3 / 4.2 1.7 / 5.6

-0.3 0.2 1.0

32 32 32

Shared Split Isolate

25.2 29.7 33.7

0.9 1.8 0.5

3.6 / 17.0 7.0 / 20.1 4.4 / 21.1

0.6 0.2 0.3

C. Implications for Future Hardware Our characterization also points to where future silicon could help agentic AI most. We highlight three directions. Hardware support for scheduling and context switching. Coordination is a first-class cost: context switches grow with concurrency despite low utilization, and the runner incurs the most context switches among the three roles. Agora’s pooling and pinning bound but cannot eliminate this cost, since the OS scheduler still dispatches every short-lived tool and handoff. A dedicated engine that offloads agent scheduling and context switching from the OS [63], [80], holding agents and their state in hardware queues, would turn concurrency into throughput. Hardware partitioning of microarchitectural structures. The host’s low IPC comes from contention for stateful structures: many similar agents on shared cores can evict one another’s cache lines and branch history, raising MPKI. Agora recovers some locality by pinning tasks to narrow core sets, but this is coarse, dedicating whole cores and wasting capacity when a task underuses them. Partitioning the shared structures directly [2], [61], such as way-partitioned or agent-tagged caches, TLBs, and branch predictors, would isolate agents within a core more finely than software affinity. Heterogeneous and morphable cores. The three roles have different needs: the scheduler and orchestrator are latencycritical and coordination-bound, and the runner is throughputoriented and compute-heavy, so a uniform core serves all three poorly. Heterogeneous per-server cores [6], [37], [38] would fit each better, pairing energy-efficient cores for orchestration with high-performance cores for tool execution, with the scheduling engine above. As the role mix dynamically shifts, static heterogeneity is a compromise; morphable cores [34], [49] that reconfigure their resources could track these shifts, extending Agora’s software adaptation to hardware.

paction at two concurrency levels. Compaction reclaims a large share of the tool footprint while leaving the serving plane untouched. It cuts tool CPU-seconds by 25 to 46% and changes serving CPU by under 2%, lowering runner usage from 15.6 to 11.5 cores at high concurrency. Separating the roles matters: the split and isolated layouts save 4.1–8.5 more points of tool CPU than a shared pool, and they avoid the cross-role contention that slows the shared pool at C=8. The reclaimed capacity comes at no end-to-end cost, since batch completion changes by under 1%. Overall, compaction turns scattered tool cores into clean harvestable capacity. Locality from pinning. Table V reports the effect of narrowing each task’s contention domain at high concurrency, relative to a wide shared runner pool. The benefit shows up most on the slowest lanes. The best layout, two tasks per pool, shortens tool time by up to 12.8% on the tail, cuts tool CPUseconds by 34%, and speeds up batch completion by 4.7%. Partitioning helps because a narrow contention domain bounds how far one task’s burst spills into its neighbors, so the tasks that would otherwise suffer the worst interference recover the most. Narrowing too far backfires, e.g., fully private cores do worse than the shared pool on batch time, because they remove the slack a task needs to absorb its own bursts. Partitioning by tool class instead of by task gives no benefit, which confirms that the layout must follow the shifting per-task tool mix. TABLE V E FFECT OF NARROWING EACH TASK ’ S CONTENTION DOMAIN AT HIGH CONCURRENCY, RELATIVE TO A WIDE SHARED RUNNER POOL (%). P OSITIVE VALUES INDICATE FASTER EXECUTION . F ULL - LANE AND TOOL - SUM ARE MEDIAN / MAXIMUM ACROSS LANES . Contention domain

Batch

Full lane

Tool sum

16 tasks / pool 4 tasks / pool 2 tasks / pool 1 neighbor (ring) Private cores

2.58 2.39 4.73 -0.65 -1.01

1.52 / 11.49 2.38 / 11.19 3.30 / 11.58 3.29 / 12.76 1.53 / 11.47

1.69 / 11.47 2.63 / 12.15 3.24 / 12.81 2.43 / 13.11 2.79 / 12.26

VI. C ONCLUSION Agentic AI is becoming a major datacenter workload, yet its architectural implications have remained largely unexamined. This paper took a first step by systematically characterizing the agentic workflows at production scale. We found that agentic execution fragments tasks into short, interdependent, hostorchestrated steps. They leave CPU and GPU underutilized on average yet bursty and imbalanced at any instant, while placing heavy pressure on the host microarchitecture. Guided by these findings, we designed Agora, an agent-native server runtime that reclaims the stranded compute on both the host and the accelerator, provisions and schedules cores by role, and adapts to the diversity of agentic workloads.

Adapting to the workloads. Tool workloads exhibit diverse resource profiles and differ both in how aggressively they can be compacted and in how much they benefit from compaction. Owl on GAIA [46] spends most of its tool time waiting on network I/O and has low baseline CPU demand. In a separate Owl experiment at C=32, reducing its total core budget from 96 to a 24-core isolated layout preserves performance and reduces average runner usage by 4.8%. Although this reduction

11

R EFERENCES

[22] GitHub, “The world’s most widely adopted AI developer tool,” https: //github.com/features/copilot, 2024. [23] J. Gottweis, W.-H. Weng, A. Daryin, T. Tu, P. Sirkovic, A. Myaskovsky, G. Glowaty, F. Weissenberger, A. Orlandi, D. Popovici et al., “Accelerating scientific discovery with co-scientist,” Nature, pp. 1–3, 2026. [24] U. Gupta, C.-J. Wu, X. Wang, M. Naumov, B. Reagen, D. Brooks, B. Cottel, K. Hazelwood, M. Hempstead, B. Jia, H.-H. S. Lee, A. Malevich, D. Mudigere, M. Smelyanskiy, L. Xiong, and X. Zhang, “The Architectural Implications of Facebook’s DNN-Based Personalized Recommendation,” in Proceedings of the IEEE International Symposium on High Performance Computer Architecture (HPCA’20), 2020. [25] S. Hong, M. Zhuge, J. Chen, X. Zheng, Y. Cheng, C. Zhang, J. Wang, Z. Wang, S. K. S. Yau, Z. Lin, L. Zhou, C. Ran, L. Xiao, C. Wu, and J. Schmidhuber, “MetaGPT: Meta Programming for A Multi-Agent Collaborative Framework,” 2024. [Online]. Available: https://arxiv.org/abs/2308.00352 [26] M. Hu, Y. Zhou, W. Fan, Y. Nie, B. Xia, T. Sun, Z. Ye, Z. Jin, Y. Li, Q. Chen, Z. Zhang, Y. Wang, Q. Ye, B. Ghanem, P. Luo, and G. Li, “OWL: Optimized Workforce Learning for General Multi-Agent Assistance in Real-World Task Automation,” 2025. [Online]. Available: https://arxiv.org/abs/2505.23885 [27] S. Ibanez, A. Mallery, S. Arslan, T. Jepsen, M. Shahbaz, C. Kim, and N. McKeown, “The nanoPU: A Nanosecond Network Stack for Datacenters,” in Proceedings of the 15th USENIX Symposium on Operating Systems Design and Implementation (OSDI’21), 2021. [28] IBM, “What is a multi-agent system?” https://www.ibm.com/think/ topics/multiagent-system, 2026. [29] A. Jain and A. Biazetti, “Agentic AI in enterprise workflow automation,” https://developer.ibm.com/articles/agentic-ai-workflow-automation/, 2026. [30] S. Kanev, J. P. Darago, K. Hazelwood, P. Ranganathan, T. Moseley, G.-Y. Wei, and D. Brooks, “Profiling a warehouse-scale computer,” in Proceedings of the 42nd Annual International Symposium on Computer Architecture (ISCA’15), 2015. [31] H. Kang, Z. Li, X. Yang, W. Xu, Y. Chen, J. Wang, B. Chen, T. Krishna, C. Xu, and S. Arora, “Thunderagent: A simple, fast and program-aware agentic inference system,” arXiv preprint arXiv:2602.13692, 2026. [32] S. Karandikar, C. Leary, C. Kennelly, J. Zhao, D. Parimi, B. Nikolic, K. Asanovic, and P. Ranganathan, “A Hardware Accelerator for Protocol Buffers,” in Proceedings of the 54th Annual IEEE/ACM International Symposium on Microarchitecture (MICRO’21), 2021. [33] S. Karandikar, A. N. Udipi, J. Choi, J. Whangbo, J. Zhao, S. Kanev, E. Lim, J. Alakuijala, V. Madduri, Y. S. Shao, B. Nikolic, K. Asanovic, and P. Ranganathan, “CDPU: Co-designing Compression and Decompression Processing Units for Hyperscale Systems,” in Proceedings of the 50th Annual International Symposium on Computer Architecture (ISCA’23), 2023. [34] Khubaib, M. A. Suleman, M. Hashemi, C. Wilkerson, and Y. N. Patt, “MorphCore: An Energy-Efficient Microarchitecture for High Performance ILP and High Throughput TLP,” in Proceedings of the 45th Annual IEEE/ACM International Symposium on Microarchitecture (MICRO ’12), 2012. [35] H. Kim, N. Wang, Q. Xia, J. Huang, A. Yazdanbakhsh, and N. S. Kim, “LIA: A Single-GPU LLM Inference Acceleration with Cooperative AMX-Enabled CPU-GPU Computation and CXL Offloading,” in Proceedings of the 52nd Annual International Symposium on Computer Architecture (ISCA ’25), 2025. [36] J. Kim, B. Shin, J. Chung, and M. Rhu, “The cost of dynamic reasoning: Demystifying AI agents and test-time scaling from an AI infrastructure perspective,” arXiv preprint arXiv:2506.04301, 2025. [37] J. Kim, C. Zhang, I. Goiri, C. Rossbach, and J. Stojkovic, “PhaseWeave: Phase-Aware Execution on Heterogeneous Chiplet Architectures for Datacenters,” in Proceedings of the 53rd Annual International Symposium on Computer Architecture (ISCA ’26), 2026. [38] R. Kumar, D. Tullsen, P. Ranganathan, N. Jouppi, and K. Farkas, “Single-ISA heterogeneous multi-core architectures for multithreaded workload performance,” in Proceedings of the 31st Annual International Symposium on Computer Architecture (ISCA’04), 2004. [39] W. Kwon, Z. Li, S. Zhuang, Y. Sheng, L. Zheng, C. H. Yu, J. E. Gonzalez, H. Zhang, and I. Stoica, “Efficient Memory Management for Large Language Model Serving with PagedAttention,” in Proceedings of the 29th Symposium on Operating Systems Principles (SOSP ’23), 2023.

[1] S. Agarwal, M. Laju, J. Srinivasa, M. Lee, and A. Akella, “Software-Defined Agentic Serving,” 2026. [Online]. Available: https: //arxiv.org/abs/2601.03197 [2] J. Ahn, C. H. Park, and J. Huh, “Micro-Sliced Virtual Processors to Hide the Effect of Discontinuous CPU Availability for Consolidated Systems,” in Proceedings of the 47th Annual IEEE/ACM International Symposium on Microarchitecture (MICRO ’14), 2014. [3] K. Alizadeh, I. Mirzadeh, D. Belenko, K. Khatamifard, M. Cho, C. C. D. Mundo, M. Rastegari, and M. Farajtabar, “LLM in a flash: Efficient Large Language Model Inference with Limited Memory,” arXiv preprint arXiv:2312.11514, 2024. [4] Amazon AWS, “Agentic AI with AWS Databases,” https://aws.amazon. com/products/databases/agentic-ai/, 2026. [5] AMD, “Agent Computers. Powering the Future of Agentic AI.” https://www.amd.com/en/products/processors/consumer/agentcomputers.html, 2026. [6] ARM, “Processing Architecture for Power Efficiency and Performance,” 2025. [Online]. Available: https://www.arm.com/technologies/big-little [7] Arm, “Arm AGI CPU: The world’s most efficient agentic CPU,” https: //www.arm.com/products/cloud-datacenter/arm-agi-cpu, 2026. [8] Z. Asgar, M. Nguyen, and S. Katti, “Efficient and Scalable Agentic AI with Heterogeneous Systems,” 2025. [Online]. Available: https://arxiv.org/abs/2507.19635 [9] P. Belcak, G. Heinrich, S. Diao, Y. Fu, X. Dong, S. Muralidharan, Y. C. Lin, and P. Molchanov, “Small Language Models are the Future of Agentic AI,” 2025. [Online]. Available: https://arxiv.org/abs/2506.02153 [10] Z. Bian, F. Wu, C. Zhang, H. Dong, Y. Liang, and Y. Zhuo, “Tokendance: Scaling multi-agent llm serving via collective kv cache sharing,” arXiv preprint arXiv:2604.03143, 2026. [11] G. I. Chaudhry, E. Choukse, H. Qiu, I. Goiri, R. Fonseca, A. Belay, and R. Bianchini, “Murakkab: Resource-Efficient Agentic Workflow Orchestration in Cloud Platforms,” in 20th USENIX Symposium on Operating Systems Design and Implementation (OSDI ’26), 2026. [12] J. C.-Y. Chen, S. Saha, and M. Bansal, “ReConcile: Round-Table Conference Improves Reasoning via Consensus among Diverse LLMs,” in Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers). Association for Computational Linguistics, 2024, pp. 7066–7085. [Online]. Available: https://aclanthology.org/2024.acl-long.381/ [13] A. Cheng et al., “Barbarians at the Gate: How AI is Upending Systems Research,” 2025. [Online]. Available: https://arxiv.org/abs/2510.06189 [14] crewAI, “Fast and Flexible Multi-Agent Automation Framework,” https: //github.com/crewaiinc/crewai, 2026. [15] A. Daglis, M. Sutherland, and B. Falsafi, “RPCValet: NI-Driven TailAware Balancing of µs-Scale RPCs,” in Proceedings of the TwentyFourth International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS ’19), 2019. [16] T. Dao, D. Y. Fu, S. Ermon, A. Rudra, and C. Ré, “FlashAttention: Fast and Memory-Efficient Exact Attention with IO-Awareness,” arXiv preprint arXiv:2205.14135, 2022. [17] D. Ding, A. Mallick, C. Wang, R. Sim, S. Mukherjee, V. Ruehle, L. V. S. Lakshmanan, and A. Awadallah, “Hybrid LLM: Cost-Efficient and Quality-Aware Query Routing,” in Proceedings of the International Conference on Learning Representations (ICLR ’24), 2024. [18] Fortune Business Insights, “Agentic AI Market Size,” https://www. fortunebusinessinsights.com/agentic-ai-market-114233, 2026. [19] S. Fowler, J. Segovia, L. Leung, L. Fordham, and S. Holt, “Agentic AI Requires More CPUs,” https://www.intel.com/content/www/us/en/ content-details/916705/agentic-ai-requires-more-cpus.html, 2026. [20] A. Fuerst, S. Novakovic, I. Goiri, G. I. Chaudhry, P. Sharma, K. Arya, K. Broas, E. Bak, M. Iyigun, and R. Bianchini, “Memory-Harvesting VMs in Cloud Platforms,” in Proceedings of the 27th ACM International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS ’22), 2022. [21] Y. Gan, Y. Zhang, D. Cheng, A. Shetty, P. Rathi, N. Katarki, A. Bruno, J. Hu, B. Ritchken, B. Jackson, K. Hu, M. Pancholi, Y. He, B. Clancy, C. Colen, F. Wen, C. Leung, S. Wang, L. Zaruvinsky, M. Espinosa, R. Lin, Z. Liu, J. Padilla, and C. Delimitrou, “An Open-Source Benchmark Suite for Microservices and Their Hardware-Software Implications for Cloud & Edge Systems,” in Proceedings of the Twenty-Fourth International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS’19), 2019.

12

[40] LangChain, “langgraph: Low-level orchestration framework for building stateful agents,” https://github.com/langchain-ai/langgraph, 2026. [41] J. Lee, H. Kim, S. Oh, M. Chun, M. Kim, and J. Kim, “AiF: Accelerating On-Device LLM Inference Using In-Flash Processing,” in Proceedings of the 52nd Annual International Symposium on Computer Architecture (ISCA ’25), 2025. [42] C. Li, Y. Yin, X. Wu, J. Zhu, Z. Gao, D. Niu, Q. Wu, X. Si, Y. Xie, C. Zhang, and G. Sun, “H2-LLM: Hardware-Dataflow CoExploration for Heterogeneous Hybrid-Bonding-based Low-Batch LLM Inference,” in Proceedings of the 52nd Annual International Symposium on Computer Architecture (ISCA ’25), 2025. [43] G. Liao, H. Qin, Y. Wang, A. Golden, M. Kuchnik, Y. Yetim, J. J. Ang, C. Fu, Y. He, S. Hsia et al., “Kernelevolve: Scaling agentic kernel coding for heterogeneous ai accelerators at meta,” arXiv preprint arXiv:2512.23236, 2025. [44] M. Luo, X. Shi, C. Cai, T. Zhang, J. Wong, Y. Wang, C. Wang, Y. Huang, Z. Chen, J. E. Gonzalez, and I. Stoica, “Agentix: An Efficient Serving Engine for LLM Agents as General Programs,” in Proceedings of the 23rd USENIX Symposium on Networked Systems Design and Implementation (NSDI ’26), 2026. [45] Y. Mao and A. Mirhoseini, “Decentralized Multi-Agent Systems with Shared Context,” 2026. [Online]. Available: https://arxiv.org/abs/2606. 10662 [46] G. Mialon, C. Fourrier, C. Swift, T. Wolf, Y. LeCun, and T. Scialom, “GAIA: A Benchmark for General AI Assistants,” in International Conference on Learning Representations, 2024. [Online]. Available: https://arxiv.org/abs/2311.12983 [47] X. Miao, C. Shi, J. Duan, X. Xi, D. Lin, B. Cui, and Z. Jia, “SpotServe: Serving Generative Large Language Models on Preemptible Instances,” in Proceedings of the 29th ACM International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS ’24), 2024. [48] Microsoft, “AutoGen: A programming framework for agentic AI,” https: //github.com/microsoft/autogen, 2026. [49] A. Mirhosseini, A. Sriraman, and T. F. Wenisch, “Enhancing Server Efficiency in the Face of Killer Microseconds,” in Proceedings of the IEEE International Symposium on High Performance Computer Architecture (HPCA’19), 2019. [50] A. Novikov, N. Vũ, M. Eisenberger, E. Dupont, P.-S. Huang, A. Z. Wagner, S. Shirobokov, B. Kozlovskii, F. J. R. Ruiz, A. Mehrabian, M. P. Kumar, A. See, S. Chaudhuri, G. Holland, A. Davies, S. Nowozin, P. Kohli, and M. Balog, “AlphaEvolve: A coding agent for scientific and algorithmic discovery,” 2025. [Online]. Available: https://arxiv.org/abs/2506.13131 [51] NVIDIA, “TensorRT-LLM’s Documentation,” https://nvidia.github.io/ TensorRT-LLM/, 2024. [52] Open AI, “Web Search,” https://developers.openai.com/api/docs/guides/ tools-web-search, 2026. [53] P. Patel, E. Choukse, C. Zhang, A. Shah, I. Goiri, S. Maleki, and R. Bianchini, “Splitwise: Efficient generative LLM inference using phase splitting,” in ISCA, 2024. [54] H. Ping, A. Bhattacharjee, P. Zhang, S. Li, W. Yang, A. Cheng, X. Zhang, J. Thomason, A. Jannesari, N. Ahmed et al., “Verimoa: A mixture-of-agents framework for spec-to-hdl generation,” arXiv preprint arXiv:2510.27617, 2025. [55] A. Prabhakar, R. Ram, Z. Chen, S. Savarese, F. Wang, C. Xiong, H. Wang, and W. Yao, “Enterprise deep research: Steerable multi-agent deep research for enterprise analytics,” arXiv preprint arXiv:2510.17797, 2025. [56] A. Qu, H. Zheng, Z. Zhou, Y. Yan, Y. Tang, S. Y. Ong, F. Hong, K. Zhou, C. Jiang, M. Kong, J. Zhu, X. Jiang, S. Li, C. Wu, B. K. H. Low, J. Zhao, and P. P. Liang, “CORAL: Towards Autonomous Multi-Agent Evolution for Open-Ended Discovery,” 2026. [Online]. Available: https://arxiv.org/abs/2604.01658 [57] R. Raj, H. Wang, and T. Krishna, “A CPU-Centric Perspective on Agentic AI,” 2025. [Online]. Available: https://arxiv.org/abs/2511.00739 [58] J. Ruan, Z. Xu, Y. Peng, F. Ren, Z. Yu, X. Liang, J. Xiang, B. Liu, C. Wu, Y. Luo, and J. Zhang, “AOrchestra: Automating SubAgent Creation for Agentic Orchestration,” 2026. [Online]. Available: https://arxiv.org/abs/2602.03786 [59] M. Seo, J. Baek, S. Lee, and S. J. Hwang, “Paper2Code: Automating Code Generation from Scientific Papers in Machine Learning,” 2025. [Online]. Available: https://arxiv.org/abs/2504.17192

[60] A. Sriraman and A. Dhanotia, “Accelerometer: Understanding Acceleration Opportunities for Data Center Overheads at Hyperscale,” in Proceedings of the Twenty-Fifth International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS’20), 2020. [61] J. Stojkovic, E. Choukse, E. Saurez, I. Goiri, and J. Torrellas, “Mosaic: Harnessing the Micro-Architectural Resources of Servers in Serverless Environments,” in Proceedings of the 57th IEEE/ACM International Symposium on Microarchitecture (MICRO’24), 2024. [62] J. Stojkovic, A. Farrell, Z. Gong, C. J. Hughes, and J. Torrellas, “AccelFlow: Orchestrating an On-Package Ensemble of Fine-Grained Accelerators for Microservices,” in Proceedings of the IEEE International Symposium on High Performance Computer Architecture (HPCA ’26), 2026. [63] J. Stojkovic, C. Liu, M. Shahbaz, and J. Torrellas, “µManycore: A Cloud-Native CPU for Tail at Scale,” in Proceedings of the 50th Annual International Symposium on Computer Architecture (ISCA’23), 2023. [64] J. Stojkovic, C. Liu, M. Shahbaz, and J. Torrellas, “HardHarvest: Hardware-Supported Core Harvesting for Microservices,” in Proceedings of the 52nd Annual International Symposium on Computer Architecture (ISCA’25), 2025. [65] H. Su, S. Diao, X. Lu, M. Liu, J. Xu, X. Dong, Y. Fu, P. Belcak, H. Ye, H. Yin, Y. Dong, E. Bakhturina, T. Yu, Y. Choi, J. Kautz, and P. Molchanov, “ToolOrchestra: Elevating Intelligence via Efficient Model and Tool Orchestration,” 2025. [Online]. Available: https://arxiv.org/abs/2511.21689 [66] W. Su, A. Dhanotia, C. Torres, J. Gandhi, N. Gholkar, S. Kanaujia, M. Naumov, K. Subramanian, V. Andrei, Y. Yuan, and C. Tang, “DCPerf: An Open-Source, Battle-Tested Performance Benchmark Suite for Datacenter Workloads,” in Proceedings of the 52nd Annual International Symposium on Computer Architecture (ISCA’25), 2025. [67] T. R. Team, P. Gao, Z. Tian, X. Meng, X. Wang, R. Hu, Y. Xiao, Y. Liu, Z. Zhang, J. Chen, C. Gao, Y. Lin, Y. Xiong, C. Peng, and X. Liu, “Trae Agent: An LLM-based Agent for Software Engineering with Test-time Scaling,” 2025. [Online]. Available: https://arxiv.org/abs/2507.23370 [68] A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, Ł. Kaiser, and I. Polosukhin, “Attention is All You Need,” Advances in Neural Information Processing Systems (NeurIPS), 2017. [69] Y. Wang, K. Arya, M. Kogias, M. Vanga, A. Bhandari, N. J. Yadwadkar, S. Sen, S. Elnikety, C. Kozyrakis, and R. Bianchini, “SmartHarvest: Harvesting Idle CPUs Safely and Efficiently in the Cloud,” in Proceedings of the Sixteenth European Conference on Computer Systems (EuroSys ’21), 2021. [70] Z. Xu, D. Kong, J. Liu, J. Li, J. Hou, X. Dai, C. Li, S. Wei, Y. Hu, and S. Yin, “WSC-LLM: Efficient LLM Service and Architecture Coexploration for Wafer-scale Chips,” in Proceedings of the 52nd Annual International Symposium on Computer Architecture (ISCA ’25), 2025. [71] J. Yang, C. E. Jimenez, A. Wettig, K. Lieret, S. Yao, K. Narasimhan, and O. Press, “SWE-agent: Agent-Computer Interfaces Enable Automated Software Engineering,” 2024. [Online]. Available: https: //arxiv.org/abs/2405.15793 [72] S. Yao, J. Zhao, D. Yu, N. Du, I. Shafran, K. Narasimhan, and Y. Cao, “React: Synergizing reasoning and acting in language models,” 2023. [Online]. Available: https://arxiv.org/abs/2210.03629 [73] N. Ye, A. Ahuja, G. Liargkovas, Y. Lu, K. Kaffes, and T. Peng, “Speculative Actions: A Lossless Framework for Faster Agentic Systems,” 2026. [Online]. Available: https://arxiv.org/abs/2510.04371 [74] G.-I. Yu, J. S. Jeong, G.-W. Kim, S. Kim, and B.-G. Chun, “Orca: A Distributed Serving System for Transformer-Based Generative Models,” in OSDI, 2022. [75] S. Yu, J. Shu, Y. Ni, K. Qian, X. Li, Y. Wang, J. Zhang, Z. Xu, S. Yang, L. Zhu et al., “Pythia: Exploiting workflow predictability for efficient agent-native llm serving,” arXiv preprint arXiv:2604.25899, 2026. [76] Y. Yuan, A. Nayak, S. Kundu, and N. Talati, “Agentic AI workload characteristics,” arXiv preprint arXiv:2605.26297, 2026. [77] G. Zhang, S. Zhu, A. Wei, Z. Song, A. Nie, Z. Jia, N. Vijaykumar, Y. Wang, and K. Olukotun, “AccelOpt: A Self-Improving LLM Agentic System for AI Accelerator Kernel Optimization,” 2025. [Online]. Available: https://arxiv.org/abs/2511.15915 [78] Y. Zhang, I. Goiri, G. I. Chaudhry, R. Fonseca, S. Elnikety, C. Delimitrou, and R. Bianchini, “Faster and Cheaper Serverless Computing on Harvested Resources,” in Proceedings of the International Symposium on Operating Systems Principles (SOSP ’21), 2021.

13

[79] Y. Zhang, G. Prekas, G. M. Fumarola, M. Fontoura, I. Goiri, and R. Bianchini, “History-Based Harvesting of Spare Cycles and Storage in Large-Scale Datacenters,” in Proceedings of the 12th USENIX Symposium on Operating Systems Design and Implementation (OSDI ’16), 2016. [80] J. Zhao, I. Uwizeyimana, K. Ganesan, M. C. Jeffrey, and N. E. Jerger, “ALTOCUMULUS: Scalable Scheduling for Nanosecond-Scale Remote Procedure Calls,” in 2022 55th IEEE/ACM International Symposium on Microarchitecture (MICRO ’22), 2022. [81] Y. Z. Zhao, D. W. Wu, and J. Wang, “ALISA: Accelerating Large Language Model Inference via Sparsity-Aware KV Caching,” in Proceedings of the 51st Annual International Symposium on Computer Architecture (ISCA ’24), 2024. [82] Y. Zhao, H. Zhang, H. Huang, Z. Yu, and J. Zhao, “MAGE: A Multi-Agent Engine for Automated RTL Code Generation,” arXiv preprint arXiv:2412.07822, 2024. [Online]. Available: https: //arxiv.org/abs/2412.07822 [83] L. Zheng, L. Yin, Z. Xie, C. Sun, J. Huang, C. H. Yu, S. Cao, C. Kozyrakis, I. Stoica, J. E. Gonzalez, C. Barrett, and Y. Sheng, “SGLang: Efficient Execution of Structured Language Model Programs,” 2024. [Online]. Available: https://arxiv.org/abs/2312.07104 [84] Z. Zhou, X. Wei, J. Zhang, and G. Sun, “PetS: A unified framework for parameter-efficient transformers serving,” in Proceedings of the USENIX Annual Technical Conference (USENIX ATC ’22), 2022.

14

Related documents

• From Review to Reuse: How Post-Task Workflow Can Support Human-AI Agent Interaction#1070628
• Towards Agentic Cloud Engineering: Graph and Loop Engineering with a Zero-Trust Agent Harness#819534
• Towards Agentic Cloud Engineering: Graph and Loop Engineering with a Zero-Trust Agent Harness#809538
• Scepsy: Serving Agentic Workflows Using Aggregate LLM Pipelines#1105012
• Correct Is Not Governed: Provenance Integrity in Agentic Workflows#451245