The Ninety-Eight Point Six Percent: How ZCode Beat Claude Code at DeepSeek's Cache Game

The data shows a two-day window, three clients, one inference provider, and a 9.29-percentage-point gap that rewrites the unit economics of AI coding agents by a factor of 3.7. OpenCode co-founder Dax Raad published 48 hours of client-side cache hit rates for DeepSeek traffic on his public feed. The leaderboard contains no mid-table finish. ZCode, an agentic development environment Dax admitted he had never heard of, posted 98.60%. OpenCode V2 posted 97.86%. Claude Code / CLI posted 89.31%. His reaction, verbatim: "I don't know what ZCode is, but it's doing a really good job." The professional instinct, the one that has guided my reporting through ICO audits, DeFi post-mortems, and provenance verification, says: trust the surprise, but audit the telemetry. A 98.6% cache hit rate is not a compliment. It is a claim — a claim about how a client orders tokens, persists context, and manages a conversation before it ever touches a model weight. Claims like this get verified, or they get corrected. This article is the verification pass. Let us establish exactly what we are looking at, because the headline numbers will be misunderstood without the layer beneath them. DeepSeek prices its input tokens along two lanes. Cache hits — tokens that match a cached prefix — enter a cheap lane. Cache misses, which require a full forward pass through the network, are priced at roughly fifty times the cost of a hit. The client-side hit rate measures the fraction of input tokens the client successfully steered into that cheap lane. The higher the fraction, the lower the effective cost per token. This is not a model benchmark. No one here is measuring reasoning accuracy, code generation pass@k, or human preference. This is ledger observation — the kind I have built my career on. It is the difference between asking a chef whether the dish tastes good and auditing the kitchen's procurement receipts. The taste is subjective. The receipts are arithmetic. Here is the arithmetic, stated without smoke. Set a cache hit token at price 1 and a cache miss token at price 50. ZCode, at 98.60% hits, pays 1.686 per 100 tokens. OpenCode V2, at 97.86%, pays 2.049. Claude Code, at 89.31%, pays 6.238. Divide. ZCode's effective input cost is 27.03% of Claude Code's — the exact figure Dax's rough calc produced. OpenCode V2 lands at 32.84%. Against the same token structure, the anonymous tool is 18% cheaper on input than the open-source darling that publicly wondered who it was. The ledger does not lie, but it forgets. And what it appears to have forgotten, at first glance, is that Claude Code is not the obvious laggard here on intelligence. It is merely the obvious laggard on cost discipline. The actors in this story matter. OpenCode is an open-source, terminal-first AI coding agent with a loyal developer following; V2 is its rebuilt core. Claude Code / CLI is Anthropic's own agentic coding tool, distributed with the same mindshare as the Claude models. ZCode is an Agentic Development Environment (ADE) launched by Zhipu for GLM-5.2, though it accepts connections to other models — a fact the telemetry confirms, because it clearly generated a substantial volume of traffic against DeepSeek's API over the sampled 48 hours. A note on sampling before we go deeper. Dax shared a 48-hour slice. I do not know the sample size, the number of unique sessions, or whether the traffic was weighted by heavy users. The source data is not public in full. That would normally disqualify an analyst from drawing conclusions. But the server-side counters in DeepSeek's API response make the share itself trustworthy: DeepSeek returns two counters per completion — prompt_cache_hit_tokens and prompt_cache_miss_tokens — and the client merely tallies them. The aggregation happened on the client. The raw counts were issued by the provider. Unless a client fabricates its usage response, this data is DeepSeek's own testimony about how each client behaved. What makes a cache hit rate high or low is not magic. In 2020, I wrote Python scripts to monitor YieldFarm Alpha's pool balances, then published a breakdown showing that its advertised APY was an emission mirage rather than genuine trading fees; the pool could not survive a 5% withdrawal without catastrophic slippage. The same instinct applies here. I spent part of last week mentally reconstructing the request flows implied by these three numbers. There is no proprietary SDK involved. The mechanism is public knowledge, and the engineering discipline required to game it favorably is hard but not secret. The loading mechanism in question is prefix caching. A transformer's attention computation is a function of input token sequences; the expensive activations for earlier tokens can be stored and reused if the suffix of a new prompt matches an earlier prompt's prefix. In practice, the system prompt — the tool definitions, the file tree, the framework rules — dominates the first few thousand tokens of any agentic session. If those tokens are byte-identical across requests, the provider can return the cached computation for the prefix and only compute the new tail. The twist is the word identical. Token caching is not fuzzy or semantic. A single token difference early in the prompt invalidates the cache for the entire suffix. Insert a timestamp at the top of the system prompt, and you have just paid the miss price on every subsequent token — every tool result, every file read, every line of context. The ledger is unforgiving at the token level. This is where client engineering reveals itself: not in prompt aesthetics, but in prompt hygiene. I have reverse-engineered enough vesting schedules to know that the place to look is the schedule, not the whitepaper. The equivalent schedule here is the message-ordering logic. Let me enumerate the disciplines that separate 89% from 98%. Each one is a choice an engineering team makes, and each choice leaves fingerprints in the telemetry. First, system-prompt stability. A client that locks its system prompt to a canonical byte string, appends no observation timestamps, no user IDs, no session UUIDs, and no random seeds will hold the prefix cache alive across an entire conversation. A client that injects dynamic values into the prologue will not. The data strongly suggests that Claude Code's prompt assembly is not prefix-stable under typical use, or its hit rate would be closer to 97%. Second, session continuity. Agentic coding tools loop: call the model, receive tool calls, execute them, append tool results, call again. If the client reuses the same message array and appends the new tool result, the cacheable prefix grows naturally. If the client serializes, reserializes, or converts message formats between turns — say, moving tool results into a different role field — the token IDs shift. The prompt looks the same to a human. The tokenizer disagrees. The cache breaks. Third, truncation policy. Context windows are finite, and long agentic sessions ultimately exceed them. The manner of truncation determines the cache outcome. A client that truncates the tail of old messages while preserving the system prompt and the earliest turns will retain a long cached prefix. A client that slides a floating window — dropping the first exchange to make room for the newest — destroys the prefix cache on every slide. The difference is not a matter of intelligence; it is a matter of respecting the byte-boundary discipline. Fourth, tool-schema ordering. Many clients assemble tool definitions procedurally, and procedural ordering can vary between calls based on nondeterministic iteration or registration order. Any change in the order of two tool schemas is a change in the token stream. A client that sorts its tool schemas lexicographically and never emits unstable headers will keep the prefix cached. A client whose tools are ordered by map iteration order will, on occasion, silently reorder and pay the full price. The hits take the toll. Fifth, context-relevance placement. The most aggressive cache-optimized clients place volatile content — timestamps, ephemeral state, current git status — at the tail of the prompt, preserving the stable prefix. Some providers even offer prompt-caching-specific guidance: put dynamic content after static content. ZCode's 98.60% suggests its engineers treat that guidance as law. Claude Code's 89.31% suggests its engineers treat it as a suggestion. Now the uncomfortable questions. The first: is ZCode's number too clean? A 98.60% hit rate over 48 hours is close to the theoretical ceiling. My 2021 provenance work taught me to be suspicious of perfection: the CryptoArt deployer's wallet was linked to three banned addresses, and the collection's origin story was a fabrication that took me a week of ledger tracing to expose. In token usage, there is an analogous way to manufacture a beautiful hit ratio: send a static prefix repeatedly, keep conversations short, and let the model do trivial work that does not disturb the cache. If ZCode's users mostly run identical linting loops or repetitive file reads, the hit rate will look sublime while the actual utility per session is modest. The second question is whether the hit rate is being measured fairly across tools. The sample was drawn from DeepSeek traffic, not from a controlled benchmark. Users of Claude Code who route through DeepSeek are a self-selected population; they might be configuration-heavy users, experimenters, or developers who switched a one-line config and ran the same workflow. Users of ZCode against DeepSeek are, by definition, users who chose a Chinese-ecosystem ADE and pointed it at another Chinese-provider API. The workloads are likely different in structure. I cannot verify the equivalence of tasks from here. What I can verify is the arithmetic of the penalty: given a fifty-to-one miss penalty, a nine-point hit-rate gap is not noise. It is a 3.7-fold cost differential. Let me extend the comparison into a realistic operating scenario. Assume a small engineering team issues one million input tokens per day against DeepSeek — a plausible volume for a team of eight running agentic loops. At Claude Code's 89.31%, the team pays approximately 6.238 cost units per thousand tokens, or 6,238 units daily. At ZCode's 98.60%, the same volume costs 1,686 units. The annualized difference approaches four times the working budget. No amount of model cleverness justifies that leak if the task output is equal. This is the exact lesson I documented in 2020: headline yield is a marketing artifact; the sustainability of an APY is a mechanical artifact. Here, the headline intelligence is the marketing artifact, and the cache architecture is the mechanical truth. I want to address the fifty-to-one miss penalty directly, because I have spent years writing about arbitrary pricing parameters in crypto. Aave's interest rate curve and Compound's borrow spread are policy choices calibrated by governance, not discoveries made by markets. They are parameters selected to shape behavior. DeepSeek's fifty-to-one miss penalty is the same species of policy instrument: memory is not fifty times more expensive than computation in any honest physics of silicon. The price gap exists to steer clients toward prefix-aligned traffic, to reward client implementations that batch and reuse, and to penalize sloppiness. It is a behavioral tax dressed as an infrastructure cost. That is a design choice, and it has consequences. Clients that engineer for cache discipline effectively receive a subsidy. Clients that do not — or that deliberately prioritize prompt dynamism over cost — pay the full freight. In a market where model intelligence is converging commodity to commodity, the cache discipline is the margin. The data from Dax's feed is the first public polling showing that margin at the client layer. There is a crypto parallel worth stating, because my readers will recognize the shape. In 2022, I did not write about Terra-Luna's collapse as a crisis of confidence; I analyzed the reserve audits from 2019 to 2021 and documented the mathematical instability of the peg under stress. The death spiral was inevitable once the burn-rate discrepancies were quantified. Here, the death spiral is milder but analogous: a client with a low cache hit rate compounds its own cost disadvantage in every agentic loop. Higher cost per task disincentivizes usage. Lower usage disincentivizes optimization. The client becomes progressively less competitive without ever making a single visibly bad decision. The ledger does not lie, but it forgets the decisions that led to the deficit. Now let me turn to the contrarian case, because a Cold Dissector who only confirms the leaderboard has stopped dissecting. The bulls — who, in this case, are Anthropic's defenders and Claude Code loyalists — have a legitimate retort. Cache hit rate is not a measure of model quality. It is a measure of request pattern. Claude Code may score lower precisely because it takes on harder problems: larger repositories, more file mutations, richer tool-call graphs, deeper multi-step edits. Difficult tasks mutate state. Each mutation is a potential cache break. A tool used predominantly for trivial browsing will preserve its prefix. A tool used for destructive refactoring will invalidate its cache with every file write. If ZCode's 98.60% reflects a user base doing relatively shallow tasks, the comparison is apples to hallucinated oranges. The second counterpoint: Dax's sample is an accident, not an experiment. The 48-hour window overlapped no benchmark, no controlled workload, no standard prompt suite. It is a moment in time from a provider's usage counters, filtered through whatever sessions happened to run. A separate 48 hours, with different users and different repositories, could move the numbers by several points. The cost ratio would likely survive — the gap is too large to be pure noise — but the precise ranking could reorder. The third counterpoint is the one I find most technically serious: high cache discipline can degrade output quality. The most aggressive cache-optimizing strategy is to keep volatile context out of the model entirely — to omit current working state, recent terminal output, or environment noise — because that volatility destroys the prefix. But that same volatility is often the signal the model needs to produce correct edits. A client that wins the cost-accounting war by starving the model of dynamic context may lose the correctness war. ZCode's engineers may have decided that the cold prefix is sacred and the live tail is optional. That trade can look great in an API bill and terrible in a code review. I cannot resolve that counterpoint from telemetry alone. No one can. The client-side counters tell us what tokens hit the cache; they do not tell us what tokens should have been sent but were not. This is the blind spot of every pure cost analysis, and I flag it here with the same force I used in my 2024 ETF work, where 70% of retail investors misunderstood the difference between holding an ETF share and holding the underlying asset. Cost efficiency is a shadow of quality; the shadow tells you where the light is, not what the object is made of. But here is what the contrarian case does not explain. It does not explain why OpenCode V2 — a client built for the same class of hard agentic tasks — lands at 97.86%, a hair behind ZCode. If difficult tasks inevitably broke the cache, OpenCode V2 would share Claude Code's fate. It does not. A nine-point gap separates OpenCode V2 and Claude Code on the same provider, on the same days, under the same fifty-to-one penalty. At some point, the workload-defense collapses into engineering-defense: Claude Code's prompt assembly simply treats the cache as expendable. There is also a distribution lesson wrapped inside ZCode's dominance, and it reads like a page from my NFT provenance files. In 2021, I verified a collection whose deployer had fabricated its ownership story; the floor price contracted 40% when the provenance was published. The pattern that repeated across every case: exceptional technical execution is worthless if the market cannot find it. ZCode is winning the efficiency ledger while its existence is a surprise to one of the most prominent builders in the agentic coding space. Dax's public confession is not an indictment of ZCode's engineering. It is an indictment of ZCode's distribution. The best cache hit rate in the industry is, at this moment, a secret handshake — a genuinely unexported insight. There is one more dimension worth unpacking, because it ties this story back to a sector I know well. The crypto industry spent 2023 and 2024 arguing that rollups need dedicated data availability layers. I have been on record that the DA layer is overhyped; most rollups do not generate enough data per block to justify a parallel market. The same reasoning applies here. The most expensive asset in the agentic world is not the model — it is the volatile tail of a fragmented prompt. The tool that minimizes the tail wins. That is not a blockchain problem. It is an engineering problem with a blockchain-shaped solution: auditability, provenance, and byte-level accountability. When ZCode and OpenCode V2 both approach a 98% hit rate, they are effectively building an internal DA layer inside the prompt — a static, reusable record of context that never needs to be re-priced. The takeaway from this weekend's telemetry is not that ZCode is smarter than Claude Code. It is that cost discipline in agentic systems has become a first-order competitive variable, and the public data showing that is a 48-hour spreadsheet from a founder who was too honest to hide his own surprise. The cache is the new liquidity pool. Hit rate is the new utilization rate. Token providers already price the two lanes; serious clients will now be forced to disclose where their traffic actually lands. I am making a prediction, with the same caution I used when I flagged unsound vesting schedules in 2017: within two quarters, cache hit rate will be printed in every serious AI coding tool's README, benchmark table, or competitive comparison. It will be the carbon label of the agentic economy. And when it is, the question will shift from "which model is strongest" to "which client wastes the least token volume." The ledger does not lie, but it forgets — and it will forget the tools that stop optimizing the prefix. Watch ZCode. Watch its funding, its roadmap, its open-source posture. Ask whether a distributed, standards-compliant client can hold a 98.6% rate under adversarial, multi-repo workloads, or whether the number is an artifact of limited traffic. And ask, equally, whether Claude Code's engineers will treat this weekend as a wake-up call or as noise. The difference between the two answers is the difference between 89.31% and a future where no one can afford to run at 89.31% at all.