Hook
72 hours ago, Codex's average token consumption per request spiked 40%. No user behavior change. No new feature launch. Just a silent, systemic bleed. The headlines screamed "OpenAI throttling users." The data whispered something else: a compression algorithm gone rogue.
Context
Codex is OpenAI's flagship coding assistant. It charges users a monthly subscription—tiered by usage limits (measured in tokens). Think of it as a gas metering system. Each prompt, each image, each auto-generated title draws from a shared pool. The economics are simple: the pool must cover inference costs. But when the pool drains faster than expected, the system breaks.
Last week, users reported accelerated quota depletion. The complaints were scattered—some noticed after a long chat with multiple images, others after short queries. OpenAI's Tibo confirmed three root causes: context compression inefficiency, cache hit rate degradation, and auto-title generation overconsumption. A fourth was hinted: the new Computer History feature.
Core
Let me decompose this like an on-chain audit. I trace anomalies to their source. Here, the source is the context management layer.
1. Context Compression: The Silent Inflation
Context compression is supposed to reduce token usage by summarizing or pruning historical context. But when multiple images are repeatedly compressed, the process creates extra waste. This is not a theoretical bug—it's an engineering failure. The compression algorithm likely uses a full re-compression strategy: every time the context grows, it re-processes the entire history. For text, this is cheap. For images, each re-compression expands the token footprint. The result: a positive feedback loop. More images → more compression → more waste → faster quota depletion.
2. Cache Hit Rate: The Missing KV Cache
Tibo admitted cache hit rates degraded. In transformer inference, caching (KV cache) avoids recomputing previous tokens. Lower cache hit rates force full inference paths, burning tokens. The cause? Likely a prefix caching design that fails to match compressed contexts. If compression introduces noise (e.g., timestamp-dependent tokens), the cache key changes. The system can't reuse prior computations. This is like a blockchain where each transaction hash changes based on block time—no state reuse.
3. Auto-Title Generation: The Hidden Fixed Cost
Every conversation generates a title automatically. This seems trivial, but it invokes a separate model call per conversation. For short-lived chats (e.g., 10 queries), the title cost becomes a significant percentage of total usage. OpenAI didn't account for this overhead in the token budget. It's a classic off-by-one error in resource allocation.
4. Computer History: The Unbounded Context Injection
The new feature streams Mac screen captures into the context. This is a continuous data flow—screenshots, app states, web content. If tokenized as high-resolution images, the consumption scales linearly with duration. No token budget pre-allocation. No throttling. The system just appends. This is the equivalent of a smart contract that accepts unlimited calldata without gas limits.
Evidence Chain
I cross-referenced user reports with OpenAI's public statements. The pattern is clear: all three issues stem from the same root—context representation uncertainty. The compression algorithm is non-deterministic, the cache relies on deterministic keys, and the injection is unbounded. The system lacks a unified budget controller.
Contrarian
The narrative is that OpenAI is deliberately throttling users to push more subscriptions. The data says otherwise. The reset—restoring all users' quotas—is a costly move. OpenAI absorbs the inference cost of the reset period. This is a loss-mitigation strategy, not a profit grab. The real problem is engineering debt. Codex was built on a context management architecture that didn't scale to multi-modal, multi-session workflows. The "new optimization plan" Tibo mentioned is not a marketing gimmick; it's a necessity.
But here's the contrarian twist: this event may actually benefit Codex long-term. The exposure of these flaws forces OpenAI to invest in context compression technology. In the crypto world, we see the same pattern: a hack exposes a smart contract bug, the protocol patches, and emerges stronger. The same logic applies here. The next version of Codex will likely feature a deterministic compression scheme, a cache-aware budget manager, and a per-feature token allocation. The unit economics will improve.
Takeaway
Watch the next week's data. If the cache hit rate recovers past 90% and the average token per request drops below the pre-event baseline, the optimization is real. If not, expect a pricing model shift—likely a per-feature billing structure. The hash doesn't lie. The usage patterns will reveal the truth.