The 48-Hour Ledger
According to monitoring by Dongcha Beating, OpenCode co-founder Dax Raad shared a client-side cache hit rate report for DeepSeek traffic over the past 48 hours. The top spot was not his own OpenCode. Zhipu's ZCode delivered 98.60%. OpenCode V2 followed at 97.86%. Claude Code / CLI came in at 89.31%. Dax's response was candid enough to become the market's most valuable artifact: 'I don't know what ZCode is, but it's doing a really good job.'
That reaction is the trade signal. In a market obsessed with agent benchmark leaderboards, the metric that actually sets the cost structure is not pass rate. It is cache hit rate. DeepSeek's cache-miss input cost is roughly 50 times its cache-hit price. A seven-point gap is not a footnote. It is a structural cost advantage that changes the default choice for teams running agent workloads at scale.
Why This Number Is Not a Dashboard Curiosity
Cache hits are the hidden dividend of the LLM economy. When an agent sends the same system prompt, the same tool schemas, and the same file context, the inference provider does not recompute the entire prefix. It reuses the stored key-value state and bills the client as if the computation were nearly free. On DeepSeek, the difference is extreme: an input token that misses the cache can cost fifty times more than one that hits. In traditional finance terms, the hit rate is a payout ratio; the miss rate is the tax.
ZCode is an agentic development environment launched by Zhipu for GLM-5.2. It can also connect to other models, which is exactly why it appears in DeepSeek traffic at all. Zhipu did not need to campaign in Western developer communities. It simply shipped a harness that made DeepSeek's pricing model work in the user's favor. Dax's admission of ignorance is the most honest competitive intelligence we have seen in months: an 'unknown' agent from a Chinese lab is outperforming the most famous CLIs on a cost-critical operating variable, without a press release, without a leaderboard campaign, and without a logo redesign.
This is a ledger in the DeFi sense. Token fees are paid on every operation, and the fee difference between a hit and a miss is the equivalent of a 50x gas price spike. An agent builder who ignores cache layout is the same as a DeFi trader who ignores gas optimization while executing a cross-platform arbitrage. The winner is not the one with the better idea; it is the one with the lower marginal cost per repeated operation.
For over a week, the crypto side of my feed was quiet. Sideways markets make traders anxious. The AI infrastructure side, though, is not quiet. This data shows exactly where the next cycle of institutional attention will flow: toward tools that reduce recurring input costs without sacrificing output quality. The institutions that entered through Bitcoin ETFs are already asking the same question that Dax asked, in a different accent: 'Who is doing the work even when nobody is watching?'
The Method Behind the Number
One thing I want to verify before buying into any number is the source. Dax shared the data from his own client-side monitoring over 48 hours, not from DeepSeek's internal dashboard. That distinction is vital. Client-side hit rates are what users actually experience. Server-side caching logs can miss the effect of shared prefixes across sessions. When I built a real-time dashboard for Bitcoin ETF inflows in 2025, I learned that the market reacts more to traceable, externally verifiable data than to self-reported exchange numbers. This cache report has the same quality: it is independently observable by any user who instruments the client.
Cache hit rate is not a static property of a model. It is a flow characteristic of the traffic mix. The same ZCode harness could see a 70% hit rate in a group of users who are loading entirely novel codebases. The 98.60% number belongs to a specific 48-hour sample. That is why this is a signal, not a law. But it is a remarkably consistent signal across millions of tokens, and the width of the gap is large enough to survive measurement noise.
Most teams evaluate agents by benchmark scores. They run the same prompt set once and conclude that a model is good. That is like evaluating a DEX by one swap on a quiet Saturday. The real metric is what happens under repeated, high-frequency load. In an agentic IDE, the same workflows repeat constantly. Refactoring, test loops, error fixing, documentation updates. These are prime cache material. The teams that design for repetition will always outperform on cost, even if they lose on the first attempt in a generic benchmark.
Converting Hit Rate into Effective Input Cost
Let me do what I did during the 2020 DeFi summer: stop staring at the headline rate and convert the metric into an arbitrage. If h is the cache hit rate, and a cache miss costs 50 units for every 1 unit of a cache hit, then the effective input cost factor is h times 1 plus (1 minus h) times 50. The result simplifies to 50 minus 49h. This factor tells you how many units of fully cached input cost each input token actually costs on average, all else equal.
Plug in ZCode's 98.60%: effective cost factor equals 50 minus 49 times 0.986, which is 50 minus 48.314, or 1.686. OpenCode V2 at 97.86%: 50 minus 49 times 0.9786 equals 50 minus 47.9514, or 2.049. Claude Code at 89.31%: 50 minus 49 times 0.8931 equals 50 minus 43.7619, or 6.238. These three numbers belong to different asset classes. ZCode is spending less than 1.7 units of cost per effective cached token. Claude Code is spending more than 6.2 units. The spread is not a decimal point; it is a multiple.
Now compare ZCode with Claude Code in the terms that a fund would use. Divide 1.686 by 6.238. The answer is 0.270, or 27.0%. Under the same token structure, ZCode pays about 27% of Claude Code's input cost to move the same number of tokens. On a per-token basis, Claude Code is 3.7 times more expensive than ZCode. That is the kind of asymmetry that spreads across a portfolio of ten thousand developer seats and turns into a seven-figure yearly delta.
Compare ZCode with OpenCode V2. Divide 1.686 by 2.049. That is 82.3%. ZCode cuts OpenCode's effective input cost by 17.7%. OpenCode is already a disciplined open-source agent, but ZCode is still cheaper. If your product is an agent that sells clicks per task, starting with ZCode's cache profile is the equivalent of starting with a 17.7% lower unit cost than the second-place market leader. In a mature market, that kind of edge is usually reserved for scale. Here, it exists before the fifth user.
Let me walk through a concrete session to make the cost difference real. Imagine a coding agent that executes 2,000 tool calls per day. Each tool call sends a prefix of 20,000 input tokens. With a 98.6% hit rate, roughly 1,972 calls are billed at cached rates and 28 are billed at full miss rates. With an 89.31% hit rate, only 1,786 calls are cached and 214 are full misses. The difference of 186 miss events leads to nearly 3.7 million extra uncached tokens per day for the same nominal workload. Under a 50x multiplier, that is not a rounding error. It is a blowup in the monthly invoice.
Cache hit rate also shapes user experience, not just the invoice. High hit rates imply lower latency, because the prefix is already in memory. ZCode's result tells me that its average request is hitting memory-resident context, which means the first token arrives faster. The same math that lowers cost lowers response time. This is why I call cache hit rate the speed-to-ledger metric. It is the closest thing the agent economy has to an on-chain block time for recurring workflows.
Why is ZCode so good? The answer is architecture, not magic. ZCode is likely generating a highly deterministic prefix structure: a stable system prompt, a fixed tool set, a consistent ordering of files, and a small library of workflow templates. Every session starts from the same byte sequence. When the provider sees that byte sequence in its prefix cache, it returns a hit on the first step. The agent effectively learns to reuse state, the same way a smart contract uses storage slots to avoid re-executing the same event log.
Markets don't reward raw compute. They reward the ability to reuse it. Based on my years auditing token distribution mechanics, I have learned to judge a network by its marginal cost under load. ZCode's hit rate tells me that Zhipu has built an agent as a stateful machine, not as a stateless prompt wrapper. The engineering choice is invisible in headline benchmarks, but it is fully visible in the operating statement.
Claude Code's 89.31% hit rate is not a proxy for intelligence. It is a proxy for flexibility. A general-purpose CLI invites users to write bespoke prompts, load arbitrary file trees, and mix domains. Every new user workflow creates a different prefix. Different prefixes miss the cache. That is the invisible tax on open-ended design. In DeFi terms, Claude Code is paying the gas for full state verification on every new route; ZCode is reusing a pre-approved state root.
OpenCode V2's result sits in the middle: strong enough to prove that open-source agents can be designed for cache discipline, but still leaving 17.7% of cost reduction on the table. I suspect OpenCode's issue is not capability. It is defaults. If the harness standardizes its system prompt and file-loading order further, it can close the gap. But closing the gap is not free: it may require constraining user workflows to the same degree that ZCode does. The same constraint that creates the hit rate may also create the game plan.
DeFi teaches us that trust is code, not character. The agent economy is learning a similar lesson: cost is cache, not compute. When I ran the Aave-Compound arbitrage in 2020, a 15% yield spread did not look exciting until I multiplied it by transaction frequency. The same principle applies here. A 7.5-point hit-rate advantage does not look exciting until you multiply it by the number of tool calls in a million active developer sessions. Then it becomes the difference between sustainable unit economics and a subsidy-fueled burn.
Speed is the only currency that never depreciates. In the agent market, speed is measured in cache hits. Every prefix that avoids recomputation is a cost rebate. The reason ZCode can be unknown and still win is that it optimized the number that compounds: the probability that the next byte is already paid for.
The Verdict for Builders
For a builder, the takeaway is operational, not philosophical. Instrument your own cache hit rate before choosing a default agent. Run the same month of pull requests through ZCode, OpenCode, and Claude Code. Calculate the effective input cost factor with the current provider pricing. If your workflow is highly repetitive, the model with the highest hit rate will be the cheapest. If your workflow is exploratory, a lower hit rate may be the price of freedom. Do not let a leaderboard choose your stack. Let the ledger choose it.
The Cult of Cacheability
Now comes the angle I have not seen anyone write about. The mainstream interpretation of this data will be: higher cache hit rate equals better agent. I think the opposite deserves serious attention. A 98.6% hit rate may signal a highly constrained workflow. Agents that score that high are often optimizing the user experience around a template, not around agency. If every session is designed to look like the previous session, the agent is not really exploring. It is checking the same ledger entries over and over without re-executing them.
Sentiment is the invisible ledger of value. Right now, sentiment says cache hit rate is efficiency, and efficiency is alpha. But this creates an incentive to engineer for cacheability at the expense of novelty. If every agent vendor starts to standardize context shapes, all agents will converge to the same low-cost, low-risk architecture. The savings are real, but the differentiation dies. A coding assistant that can only solve problems that have been solved before is not an agent; it is an autocomplete machine.
Claude Code's lower hit rate may become its moat. The metric penalizes variety. Variety is the precondition for frontier work. When a developer is probing a deprecated codebase, or a compiler with unfamiliar syntax, or a repo with no conventional structure, the cache will miss. That miss is the price of actually going off the map. If I am running a team that needs to do hard, non-repetitive work, I might choose Claude Code precisely because it does not force my prompts into a rigid template.
Also, the 50x cache multiplier is not a permanent law. It is a pricing curve published by DeepSeek. Providers can change it tomorrow. They may introduce shorter cache windows, semantic caching, or dynamic discounts that narrow the miss-to-hit spread. Anyone who builds a business model on a 73% cost advantage is extracting alpha from a pricing table, not from protocol innovation. That alpha is the first thing to be arbitraged away.
What to Watch
The next 48 hours matter more than the last. I will be watching three things. First, whether Zhipu publishes a repeatable methodology for cache-adjusted cost. If it does not, the 98.6% number will remain an anecdote. Second, whether Anthropic quietly adjusts its caching prices or whether its team decides to measure cache hit rate as a product KPI. Third, whether the OpenCode community starts treating cache layout as a first-class feature, the way early Ethereum users treated gas optimization.
This is a sideways market for crypto, but it is not a sideways market for agent economics. The winning signal is the one nobody has priced. Cost efficiency is now the most important feature in agent infrastructure. The next agent leaderboard will be written by the ledger, not by the benchmark. And when the ledger starts to speak, the market will listen. The only question is who will be listening first.