Build1 distinct publisher3 min readPublished
An arXiv tracing study of Claude Code agents on Gemma and Qwen measured prefix-cache hit rates between 84.6 and 99.5 percent, which moves the serving bottleneck to how long you can keep KV blocks resident between tool calls.
The Engineer · Build desk

Compiled by The EngineerSomething wrong?How this is made
Follow any of these and your For You feed starts watching them — no settings page required.
build
Cloudflare moves durable execution under the harness, and the platform starts choosing it1 distinct publisher
product
Four leaderboards, four denominators: what you buy when you standardize on a coding agent1 distinct publisher
product
A billion downloads, and nobody will say what a download is1 distinct publisher
build
A 27B Apache-2.0 model in 17GB makes local inference a wiring decision, not a demo1 distinct publisher
A ReAct turn arrives at the server looking almost exactly like the previous one. Same system block, same tool schemas, same transcript of earlier thoughts and observations, with one tool result appended at the end. Prefix caching keeps the KV blocks up to the point where the two prompts diverge, and that point sits near the very end. Prefill only pays for that tail, while generation carries the rest of the work, and that split is why the traced runs put nearly all LLM time in decode [4]. The paper's framing is that this is a different animal from conventional long-prompt serving [13], and the mechanism backs that up: the long prompt is already in memory.
The arithmetic across the two ends of the measured hit range is worth doing, using SWE-bench Pro's average accumulated context as the stand-in [3][5]. At a 99.5% hit ratio, an 80K-token prompt needs roughly 400 tokens of fresh prefill per turn [14]. At 84.6%, the same prompt needs about 12,300 [15]. That is thirty times the prefill work for an identical context, decided by whether the blocks were still resident [16]. A fully cold prefix is worse, because the whole 80K gets recomputed, 200 times the best case [17]. Mixing a per-benchmark context size with an across-configuration hit rate makes that illustrative rather than measured, but the shape holds at whatever context size you substitute.
For the numbers to transfer to your stack, the prompt prefix has to be byte-stable turn over turn. A clock in the system prompt will do it. So will a tool list serialized in map iteration order, or a retrieval block prepended above the transcript, because each moves the divergence point to the top and takes the hit ratio with it. The state also has to survive the gap while the tool runs, which is dead time the blocks spend holding memory without producing tokens.
The paper flags the practical limit itself. Achieving decode-dominated execution is hard because concurrent agents with long multi-turn contexts can exceed GPU capacity, and the sentence in the copy I have stops at "can exceed GPU" [9], so I will not put a number on the ceiling.
Re-entry count multiplies the exposure. On ADE-Bench, Gemma Thinking averaged 18.0 turns while Gemma Instant averaged 108.8, with one trajectory reaching 786 [6]. Six times the turns is six times the number of moments the session's state has to still be there when the model comes back [18]. A 786-turn trajectory is something only a benchmark harness would sit through.
The instrumentation that follows from this is per-session rather than per-fleet: prefix hit ratio, and the interval between an eviction and the next re-entry that needs the evicted blocks. Aggregate tokens per second will look healthy while individual agents quietly re-prefill their entire history.
Ranked by verification strength, evidence, and original report placement.
The paper characterizes ReAct-style agents from both the LLM-serving and tool-execution perspectives using an end-to-end tracing infrastructure across reasoning and non-reasoning Gemma and Qwen configurations on five agentic benchmarks.
The tracing infrastructure runs Claude Code agents through Harbor, serves Gemma and Qwen models with vLLM, and correlates agent trajectories with request-level serving traces.
Decode dominates 91.0 to 98.6 percent of LLM time in the traced agentic runs.
Tool use has a clear temporal structure, with agents shifting from read/explore behavior early in execution to execute/write behavior later.
The paper states that achieving decode-dominated execution in practice can be challenging because concurrent agents with long multi-turn contexts can exceed GPU capacity; the source text breaks off mid-sentence at "can exceed GPU".
The authors focus on ReAct-style agents because they are simple, widely used, and closely match the serving loop of systems such as Claude Code, Codex and OpenClaw.
Distinct publishers with included, body-backed reporting in this cluster.
1 article · August 29, 2026
Evidence-backed comparisons of source perspectives and observed adoption signals. Read the methodology
Which Builder, Operator, and Investor concerns the observed source mix emphasized—not a truth score.
Evidence, demonstrated adoption, hype gap, incentives, and confidence are assessed independently, each on its own current evidence. How these are measured.
Precise numbers, one notebook
The 84.6-99.5 percent hit range, the 91.0-98.6 percent decode share and the 69K-80K contexts all come from a single arXiv preprint's own instrumentation, and the copy available stops inside the contributions list, before any table a reader could check the ranges against. Specificity and internal consistency count for something; the absence of anyone reproducing them caps how far the figures should travel. The thirty-fold and two-hundred-fold multipliers in our reporting are arithmetic we performed on the authors' ranges, not findings they published.
One harness, no fleets
What exists is a research rig, not a deployment: Claude Code driven through Harbor, Gemma and Qwen on vLLM, five benchmarks, one lab. The paper's premise is that this loop resembles how Claude Code, Codex and OpenClaw are served in production, but no operator of those systems has published a hit rate or a decode share to hold it against, and the models under trace are open-weight stand-ins rather than the ones those products run.
Scope runs slightly ahead
The framing travels a little further than the paper does. Ninety-one percent is the floor of the decode range and it holds only under effective context caching, a condition the authors state plainly before warning that concurrent agents with long contexts can exhaust GPU memory, at which point retention, offloading and recomputation add costs they never measure. Our two-hundred-fold eviction figure turns that unquantified risk into a hard-looking number the study does not claim. The overstatement is one of scope rather than substance.
Nobody named
We cannot see who paid for this work. The text available opens at the abstract and ends mid-contributions with no authors, no institutions and no funding or compute acknowledgement. The study leans on Google's Gemma, Alibaba's Qwen, Anthropic's Claude Code and the vLLM project without saying whose GPUs produced the traces, and an affiliation with any serving-stack vendor would matter for a paper whose conclusion is essentially buy memory residency rather than prefill throughput. Nothing in front of us settles it in either direction.
Confident in the shape, not the constants
That ReAct turns reuse nearly all of their prefix, and that this pushes the bottleneck onto cache residency, follows from how these loops are built and is easy to believe. Whether reuse is 84.6 percent or 99.5 percent is a property of five benchmarks, two open-weight model families and one harness, and the engineering answer flips inside that range: thirty times the per-turn prefill work separates the ends of it. Unreplicated and unattributed, so the direction earns trust well before the digits do.