← Back to AgentX

Field guide / AI infrastructure

AgentX Methodology

AgentX converts opt-in Claude Code proxy traces into deterministic AIPerf workloads. This page documents how collection metadata becomes a replay and which controls define a valid benchmark result.

published sessions
393
tokens per hash block
64
profiling window
1 hour
seeded start range
25–75%

Dataset collection

Participants opt in to an HTTP proxy that records request arrival and completion times, input and output token counts, conversation IDs, and subagent IDs. The published corpus does not contain prompts, source code, tool arguments, or tool results.

The proxy represents each input as session-scoped chained hashes in 64-token blocks. Matching block IDs preserve shared prefixes within a session. AIPerf replaces the blocks with deterministic synthetic coding and tool-use tokens before replay.

The client cannot see provider-side chat templates, proprietary tokenizers, server tools, encrypted reasoning content, or the exact token expansion of images and documents. Model-specific padding and deterministic placeholders approximate those fields. The placeholders and padding do not contain original prompts, code, or tool payloads.

Corpus dashboard showing 8,271 sessions, 3.41 million requests, 613.27 billion tokens, 99% cache-hit rate, and token-source shares.
Corpus snapshot used during dataset selection. The displayed cost is a list-price estimate for this snapshot; it is not a benchmark output.View full-resolution image
Median reconstructed-hash-token to provider-token ratio by sequence length, overall and split by model.
Across 135,282 requests from 393 sessions, the median reconstructed/provider token ratio is 1.004. Shaded bands report p25–p75, not a per-request bound.View full-resolution image

The v1.0 dataset

The v1.0 release contains 393 sessions built on June 21, 2026. Each selected session has at least 20 requests, uses Claude Code 2.1.139 or newer, and has no more than 10 concurrent subagents. Processing removes exact duplicates, short classifier calls used for security monitoring or title generation, and requests whose reconstructed input exceeds 990k tokens.

The full variant retains contexts up to 1M tokens. The 256k variant removes requests above its cap while retaining the relative timing and subagent overlap of the requests that remain. Both use the WEKA trace format consumed by AIPerf.

Annotated AgentX trace JSON showing session ID, 64-token hash blocks, request timing, input and output counts, and a subagent group.
An abridged WEKA record. Block IDs are local to one session; repeated IDs identify the prompt prefix shared by later requests.View full-resolution image
Log-scale distributions for inter-turn latency, input sequence length, and output sequence length in the v1.0 dataset.
Request distributions in the published v1.0 corpus. The median request has 142,016 input tokens and 444 output tokens.View full-resolution image
Log-scale inter-turn latency, input length, and output length distributions for the AgentX 256k dataset variant.
After requests above the 256k input cap are removed, the variant retains 68,266 requests. Median input length is 88,768 tokens; median output length is 376 tokens.View full-resolution image
Distributions of subagent wall-clock duration and number of subagent groups per session.
The 175 sessions with subagents contain 1,697 groups. Median group duration is 2.27 minutes, and the median participating session has four groups.View full-resolution image
Subagent group duration and groups-per-session distributions for the AgentX 256k dataset variant.
The 256k variant retains 1,697 subagent groups. Median duration is 2.27 minutes, and p95 duration is 18.5 minutes.View full-resolution image

From trace to replay graph

AIPerf converts each trace into a directed acyclic graph (DAG). Main-agent requests form a linear chain. Subagent requests form separate chains that spawn after an eligible parent request and join before the next dependent main-agent request. One-off auxiliary requests can run without a join edge.

The trace contains request timestamps and observed branch IDs, not the tool-level event that caused each branch. Replay therefore preserves recorded ordering, branch overlap, and inter-turn delays without claiming a provider-internal causal history.

A linear four-request trace converted from recorded timing into a replay dependency chain.
A session without subagents becomes a linear dependency chain with recorded inter-turn delays.View full-resolution image
A main-agent trace with one two-request subagent converted into a dependency graph with a join gate.
One subagent branch spawns after the first main request and joins before the next dependent main request.View full-resolution image
Two subagent chains branching from a main agent and rejoining at one dependency gate.
Two subagent chains spawn after the same main request and share one join gate before the main chain resumes.View full-resolution image
Two parallel subagents joining the main agent and a one-off auxiliary request that does not rejoin.
Parallel subagents share a join gate. The auxiliary request runs independently and has no join edge.View full-resolution image
Two subagent chains and one auxiliary request running in parallel before a three-way join.
A flat-spawn group runs two subagent chains and one auxiliary request in parallel, then joins all three before the main chain resumes.View full-resolution image
Two subagent chains and two plain sidecar requests running in parallel before one join gate.
Two plain sidecar requests without duration metadata run beside two subagent chains. Replay waits for all four at one join.View full-resolution image
Four parallel subagents grouped by two join points, plus an auxiliary request, shown as a replay dependency graph.
Multiple subagent groups retain their separate join points, while the auxiliary branch remains detached.View full-resolution image

Concurrency and reported metrics

Concurrency is the number of live agent clients. It is not a fixed HTTP request batch because one client can fan out into several subagent requests. The server can have more in-flight requests than the configured client concurrency.

AgentX runs closed loop: a client submits its next eligible request after dependencies complete. Faster systems progress farther through their sampled sessions during the same hour, so the exact request mix can vary, especially at low concurrency. Results should report throughput with time to first token (TTFT) and interactivity. A single latency value does not describe the run.

Request queue depth over about one hour, separating running, waiting, and total requests for a concurrent AgentX replay.
A 50-client replay produces a changing number of running and waiting HTTP requests as session graphs fan out and join.View full-resolution image
B200 vLLM MiniMax-M3 throughput per chip versus p90 interactivity curve across client concurrency levels.
Each labeled point is a client-concurrency setting. Higher concurrency raises throughput while reducing per-client interactivity.View full-resolution image

Warmup, timing, and determinism

A fixed seed selects each replay start uniformly from 25% to 75% of the recorded session duration. A max_tokens=1 primer materializes the active main-agent and subagent prefixes. Each replay lane then completes 10 additional warmup requests before the measurement barrier opens.

Only the following one-hour profiling window contributes reported metrics. The seed fixes session sampling, start points, and synthetic payloads. A unique cache-bust marker is added to each recycled play so unrelated replays cannot accumulate a shared prefix.

Four replay trajectories showing seeded 25–75% warmup points and primer requests for active main-agent and subagent streams.
The fixed seed chooses t* within the shaded 25–75% interval. Primers establish the active prefix state before profiling.View full-resolution image

Synthetic payloads and speculative decoding

Synthetic tokens preserve input length and prefix structure, but their draft-token acceptance does not match natural model output. AgentX therefore uses a measured acceptance length from the coding category of SPEED-Bench for each model, speculative method, draft length, and thinking mode.

The serving engines expose a forced-acceptance control, and InferenceX records the selected values in versioned golden acceptance-length files. This separates serving-system performance from acceptance variation caused by the synthetic payload. AgentX does not evaluate model answer quality.

Merged SGLang, TensorRT-LLM, vLLM, and ATOM pull requests adding forced speculative-decoding acceptance controls.
Merged engine changes expose the controls required to apply the same acceptance assumption across serving stacks.View full-resolution image

DRAM offload rules

KV-cache offload changes the capacity available to long-running sessions. Servers without a standardized DRAM configuration are capped at 3 TB. Standard GB200 NVL72, GB300 NVL72, and TPUv7 systems may use their installed capacity.

A benchmark configuration can access only the fraction of host DRAM proportional to its GPU allocation. This prevents a small GPU partition from claiming the memory budget of the entire server.

Scope and reproducibility

The replay preserves client-visible request lengths, timing, branch structure, and KV-prefix reuse. It cannot reproduce provider-hidden transformations or the semantic content of the original session. Use the published corpus and locked scenario settings when comparing systems.

Primary sources