Let’s start with three pieces of news from the AI industry last week. OpenRouter released a set of statistics showing that token consumption by AI agents has surpassed that of humans, and the gap continues to widen. Next, OpenAI dropped the initial benchmark results for its in-house inference chip, Jalapeño, beating current Nvidia products across several metrics. Meanwhile, GitHub Next published a prototype tool called Knowledge Compressor, capable of halving the length of documents repeatedly read by agents. Each of these three developments comes with its own numerical pitfalls—let’s go through them one by one. As an aside, a key player runs through all three ledgers: model providers offer discounted rates for repeatedly read context, a mechanism known as prompt caching—we’ll set that aside for now.
In mid-August, Peter Walker, head of data at OpenRouter, shared a dataset showing that February 6, 2026, marked the last time human token consumption surpassed that of agents. Seven-day moving average data as of August 10 indicates that agents burn 7.3 trillion tokens weekly, compared to 1.4 trillion for humans. Based on these two numbers, nominal agent usage reached 5.2x that of humans. Over the past six months, agent token usage surged 14x, while human usage grew only 2.8x. This dataset circulated through five independent reporting chains including The Decoder and a16z, with the cited figures aligning across every source. This cross-verified dataset forms the baseline for assessing the recent token economy.
This 5.2x volume actually comes under two different accounting metrics. Looking at total token usage as reported by Walker himself, roughly 70% of agent usage consists of cached reads; when a16z relayed the figures in their newsletter, they switched to the token burn metric, putting the share at over 85%+. The two metrics measure distinct quantities, landing at roughly 70% and 85%+ respectively. a16z also noted that the surplus agent volume is almost entirely driven by cached tokens. Model providers typically charge significantly lower rates for cached reads. Based on this caching share and a rough estimate assuming cache pricing at ~10% of base rates, the actual bill multiple generated by agents over humans is ~2x (rough estimate). This estimate lacks empirical testing to back it up; where the actual figure lands will depend on the real caching ratios on both sides and specific discount rates.
When extrapolating from this platform data, two strict boundaries must be maintained. First, this reflects data from OpenRouter alone. The platform notes that its traffic represents only about 1% of global inference volume, roughly 28 trillion tokens weekly. Users here are predominantly developers, and the models lean toward open weights with lower token efficiency. OpenRouter separates humans from agents via a weighted estimate of seven behavioral signals; the exact weights are unpublished and cannot be independently reproduced. Furthermore, August coincides with summer vacations, which naturally depresses human usage. Even more striking is the extreme single-point concentration: Hermes Agent alone burned 1.5 trillion tokens in a single week—nearly matching the aggregate of the other 49 tracked applications combined, accounting for roughly 20% of total agent traffic.
Second, this figure is prone to systematic overestimation. Reported case studies frequently show agents downloading irrelevant files or querying useless information. Even more typical is falling into retry storms: where an agent should halt after the initial failure, it loops repeatedly instead, ballooning token counts without accomplishing additional work. In addition, while the platform’s aggregate cache hit rate is indeed high, individual applications still suffer from cache invalidation—such as issue #20957 in hermes-agent. These pitfalls, alongside dynamic prompts and separate fees for cache writes, are steadily eroding the on-paper cost savings.
On August 24, GitHub Next researcher Alex Gorischek published a prototype tool named Knowledge Compressor. The tool automatically shortens knowledge documents that agents read repeatedly. In the official example, synthetic text was compressed from 996 tokens down to 480 tokens. It operates by first auto-generating 24 Q&A questions, followed by closed-book filtering and iterative compression. A forced-failure mechanism requires at least one question to fail, which then triggers a failure feedback loop and minimal recovery step until all tests pass green. The acceptance process is described in the official blog post. The team provided an economic calculation: compression costs $2 per run, saving $0.001 per uncached read, breaking even at around 2,000 runs of the same document. In the footnotes, the team acknowledged that the breakeven threshold is affected by pricing and caching, though no specific numbers were provided.
There is a mismatch in this breakeven math. The official calculation assumes every read is a full-price uncached read, yet repeatedly loading documents across multi-turn interactions is precisely where cache hits deliver the most value. Factoring in cache discounts causes the tool’s economic return to fluctuate. The official implied unit price is $1.94/M ($1.94 per million tokens), compared to Sol’s list price of $4-5/M. The largest discrepancy lies in cache pricing, where major providers differ drastically. OpenAI and Anthropic charge 10% of base price for cached reads, 25% for Gemini (save 75%), and DeepSeek charges just 2%. Empirical testing shows that long-session caching can save 78-81% of costs. Assuming a 50% cache hit rate, breakeven requires approximately 3,640 runs. At a 90% hit rate, it takes roughly 10,500 runs. Under a full-cache scenario, the breakeven threshold surges all the way to 20,000 runs. The 2,000 runs is merely an optimistic estimate under full-price assumptions; an honest breakeven range spans 2,000 to 20,000 runs, with a 5,000+ median expectation.
Extrapolating this to a 10k-token document makes the picture clearer: compression alone costs $20, plus another $25 for verification running 240 questions in fresh contexts, bringing the starting cost of a single run to $45. The prototype is not open-sourced, and neither external reproductions nor community feedback have matched the ideal state shown in the official demo. Furthermore, using Q&A metrics to validate compression carries hidden risks: relational and connective knowledge lost during compression does not show up in Q&A scores. The remaining irreplaceable value of this tool lies solely in context window capacity. Moreover, achieving this breakeven threshold requires documents to remain virtually unmodified while repeatedly feeding the entire text into context. In real-world enterprise settings, massive collections of business documents rarely see 5,000+ unmodified reads across their lifecycle.
On August 25, OpenAI shared the first benchmark results for its in-house inference chip, Jalapeño. In a fixed-length single-turn benchmark with an 8,000-token input / 1,000-token output, they evaluated three models: GPT-OSS 120B, DeepSeek R1 670B, and open-weight Kimi K2.5. Benchmarked against Nvidia’s GB200 and GB300 chips, Jalapeño achieved 1.5-1.9x per watt throughput and 1.7-3.6x latency end-to-end. These unilaterally published figures demonstrate the new hardware’s on-paper performance. Third-party research firm SemiAnalysis conducted on-site spot checks on a subset of inference runs in the lab without executing the full benchmark suite. Current critiques do not allege fabricated numbers—they acknowledge the real lead—but point out missing dimensions in the test methodology instead.
SemiAnalysis favors benchmark methodologies that simulate real-world agent workloads with long contexts and multi-turn dialogues, such as AgentX. In such workload scenarios, a critical variable is the repetitive reading of identical, long prefix contexts—that is, heavy prefix caching. Across all results released this time, AgentX figures were completely absent. The analysts noted that frameworks performing well in fixed-length 8k/1k target testing frequently falter under realistic AgentX workloads. Being optimal on a single fixed-length benchmark does not necessarily translate to equal performance on complex agent workloads.
The tech community on Hacker News added two critiques regarding asymmetric testing conditions. First, the comparison data for Nvidia Rubin factored in speculative decoding, whereas Jalapeño did not utilize it. Second, Jalapeño remains an engineering sample available only in negligible volumes by late 2026 before ramping in 2027, whereas Rubin is already shipping commercially. Moreover, the direct comparison was made against GB200 and GB300 rather than Rubin in head-to-head testing, and single-user decoding scenarios offer weak representation for production workloads. Evaluated on a per-total-cost basis, media outlet wallstengine relayed the assessment that Jalapeño and Rubin are on par. Examining this third ledger closely reveals a structure remarkably similar to the first two: fixed-length 8k/1k benchmarks fail to measure real agent workloads because the largest portion of real-world work consists of discounted repetitive reads. In this ledger, discounted reads directly caused the absence of real-world evaluation metrics.
These three news stories originate from three separate sources, each carrying a pitfall to steer clear of. When citing OpenRouter’s usage figures, remember that the vast majority consists of discounted cached reads: nominally 5.2x, but translating to an actual bill rough estimate of ~2x. When hearing cost-saving claims for compression tools, verify first whether the breakeven math is calculated at full price or at discounted cache rates. When reviewing chip benchmarks, keep in mind that synthetic target scores and real-world workload performance are two very different matters today. Behind all three developments lies the single variable of prompt caching—a leverage point we explored in our June KV Cache article. We won’t rehash that here, but keep it in mind.