Build1 distinct publisher3 min readPublished
A cache hit answers 13 to 31 percent faster than a miss, and an ICML 2025 audit found seven of 17 live providers sharing that cache across users, though the one demonstrated 100 percent reconstruction ran against self-hosted vLLM and SGLang.
The Engineer · Build desk

Compiled by The EngineerSomething wrong?How this is made
The loop is mechanical. An attacker sends a prefix of candidate tokens, times the response, reads a fast answer as a prefix match and a slow one as a wrong guess, then extends one position with a local model proposing the next candidates [5]. Attention is deterministic, so a matching prefix means the server skips the computation and answers sooner [16]. Nothing privileged is involved: ordinary API calls plus a commodity local LLM for candidate generation [6].
The delta the whole attack rests on is 13 to 31 percent, measured end to end at the HTTP client, in a study of 500 agent sessions whose average system prompt ran 10,000 tokens [3][12]. Queueing, batching and network variance land in the same measurement. KV-Cloak tells you how much that matters: deliberately injecting noise into cache-hit timing raises the number of measurements an attacker needs by four, and reconstruction still succeeds [7]. Averaging beats injected noise, and it beats jitter for the same reason. A small delta is a sampling cost.
The cost side deserves the same arithmetic. A 41 percent reduction means paying 1/0.59, about 1.7 times, with caching off; an 80 percent reduction means paying 1/0.20, exactly 5 times [1]. The stated penalty for disabling caching is 2 to 5 times per session [13]. The top of that range checks out. The floor has been rounded up.
Per-user cache partitioning is the fix that most audited providers had not deployed when the ICML paper published [10], and it answers a narrower question than a SaaS team might assume. One provider API key per platform is the standard build, every customer request flows through it, and to the provider that key is a single user with a single cache namespace [9]. Partitioning by user separates your traffic from strangers, but it does not separate your tenants from each other. If your template interpolates per-tenant tool definitions or retrieval instructions into a cached prefix, the boundary is your own routing code, and tool definitions are the part that discloses the capability set and the probable credential structure [15].
The 100 percent reconstruction rate is the strongest number in this piece, and also the narrowest: it was measured against unprotected vLLM and SGLang deployments [4], which is a configuration you choose when you self-host the two dominant open-source serving frameworks [17]. Against a commercial endpoint, what arXiv:2502.07776 reports is thinner: timing analysis of OpenAI's shared cache yielded an undisclosed architectural fact about the embedding model, inferred from latency alone on the production endpoint [11]. That is cross-tenant leakage of an architectural fact inferred from latency, not a third party's system prompt read back token by token. The audit window closed in October 2024 [2], so seven of 17 is a snapshot rather than a current inventory.
The defensible position therefore splits by deployment. If you self-host vLLM or SGLang with the cache shared across tenants, treat the prefix as extractable, because that is the exact configuration reconstructed at 100 percent [4]. If you call a commercial provider, the evidence supports shared namespaces and a measurable timing signal, not demonstrated extraction of someone else's prompt. The design constraint holds either way, since any defense that keeps the latency benefit keeps the signal [8]. OWASP already lists cache timing as an indirect delivery mechanism under LLM07:2025 [14], so anything you would not hand a competitor does not belong in a prefix you want cached.
Ranked by verification strength, evidence, and original report placement.
arXiv:2502.07776, published at ICML 2025, audited 17 live production LLM API providers between September and October 2024; seven confirmed global cache sharing across users at the time of disclosure, including OpenAI.
A cache hit responds 13-31 percent faster than a cache miss (arXiv:2601.06007), and that difference is measurable at the HTTP client using standard latency measurement.
NDSS 2025 published 'I Know What You Asked' (PROMPTPEEK), an attack against vLLM and SGLang that achieved a 100 percent reconstruction success rate against unprotected deployments.
The PROMPTPEEK procedure: send a test prompt of candidate tokens, measure response latency for hit or miss, use a local LLM to generate plausible next-token candidates from what has been reconstructed, and iterate position by position.
The attack requires only standard API calls and a commodity local LLM for candidate generation.
KV-Cloak, the defense proposed in arXiv:2508.09442 ('Shadow in the Cache'), adds noise to cache hit timing; it increases the number of measurements an attacker needs by 4x but does not prevent reconstruction.
Distinct publishers with included, body-backed reporting in this cluster.
1 article · September 5, 2026
Follow any of these and your For You feed starts watching them — no settings page required.
build
Two buyers, one price: Patel says 2027's new compute is already half spoken for1 distinct publisher
build
Compaction that cut tool output 38.4% pushed the bill up 6.8%1 distinct publisher
build
Intel puts its Arc GPU operating knowledge inside the coding agent already installed1 distinct publisher
build
Peak-hour pricing pushes DeepSeek's new vision model past Gemini on the invoice test2 distinct publishers
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.
Solid citations, checked by only one reader
Every figure in this story traces to a single dev.to post reading four papers and an OWASP entry on our behalf. The citations are specific enough to verify (arXiv:2502.07776 at ICML 2025, NDSS 2025's PROMPTPEEK, arXiv:2508.09442) and none of them has been verified here. The two strongest results also describe different worlds: the seven-of-17 shared-cache finding is about hosted APIs as of October 2024, while the 100 percent reconstruction is against self-hosted vLLM and SGLang left unprotected. The OpenAI result is the weakest link, since the architectural detail it supposedly revealed is never named.
One 2024 audit, deployment scale unmeasured
The only counted deployment fact is seven of 17 providers sharing cache during a September-October 2024 window. On the exposure the headline rests on, how many multi-tenant products run every customer through one key and leave the user parameter unset, dev.to offers the assertion that most production deployments do not set it and no measurement behind it. OpenAI and Anthropic supporting the parameter tells us the fix exists, not that anyone has applied it.
Demonstrated on self-hosted, argued for SaaS
The mechanism and the reasoning are sound, and the leap is in the framing. A timing oracle proven against unprotected self-hosted servers becomes, by argument rather than measurement, every multi-tenant SaaS product with a shared key. The cost figures that open the piece do not reconcile with each other, the audit behind the shared-cache claim predates publication by almost two years, and the closing move is a link to a scanner for the problem just described.
The post sells the audit it recommends
This ends where vendor content ends: at intel.mago.team, a tool for detecting exactly the shared-key exposure the preceding argument establishes. The mechanism can be real and the framing still be sales-shaped, and the tell is what goes unmeasured: no figure for how often this has been exploited, and no cost put on the cache hit rate a team gives up by namespacing per tenant.
Clear shape, core claims still unproven
We can read the argument's structure with confidence: which parts are measured, which are inferred, and where the inference outruns the measurement. What we cannot do from one self-published source is confirm the papers say what they are said to say, or test the general principle that any speed-preserving defense preserves the leak, which the post's own PrefixWall example appears to contradict.