On August 24, 2026, a spike in usage limit consumption hit OpenAI Codex users. Not from a surge in coding activity, but from a silent failure in the system’s own context management. The anomaly was consistent: longer conversations with multiple images burned through the allowance at double the normal rate. Community reports flooded in. Official acknowledgment came from Tibo, a Codex team lead, citing three causes: image compression inefficiency, cache hit rate degradation, and auto-title generation overhead. This is not a demand-side problem. It is a supply-side engineering debt.
Context
Codex is OpenAI’s flagship AI coding assistant, integrated into the ChatGPT ecosystem. It operates on a token-based usage limit model, where each interaction consumes a predefined budget. The system relies on two critical mechanisms: context compression to fit long conversations into the model’s context window, and caching to reuse computation across similar requests. The recent update introduced a new feature, Computer History, which streams Mac screen data into the conversation. The combination of these three elements created a perfect storm.
Core: The On-Chain Evidence Chain (or Rather, the System Evidence Chain)
Tibo’s admission reveals a forensic trail. First, context compression inefficiency: when multiple images are compressed repeatedly, the token count inflates non-linearly. This is not a model architecture issue—it is an engineering flaw in the compression algorithm. In my years auditing smart contracts, I’ve seen the same pattern: a function that works in isolation fails under load. The fixed cost of re-compressing the entire history each time creates a “compression-expansion” loop. Based on my experience building liquidity stress tests for DeFi pools, this is akin to a recursive rebalancing algorithm that generates more overhead than the original state.
Second, cache hit rate degradation. Tibo explicitly stated that “some users experienced worse cache hit rates yesterday.” A drop in cache hits means more requests go through the full inference path, accelerating token consumption. The root cause likely lies in the interaction between compression and caching. If the compressed output is non-deterministic—due to timestamps, session IDs, or random seeds—the cache key becomes unique for each request, rendering the cache useless. This is a classic prefix caching design flaw I encountered when auditing AI-agent trading bots in 2026. The agents’ dynamic context made caching ineffective, leading to 12x cost overruns.
Third, auto-title generation overhead. Every conversation generates a title by calling the model independently. For short chats, this fixed cost becomes a significant percentage of total consumption. The hidden information: these three causes are not isolated. They share a common root—lack of deterministic context representation. The compression algorithm introduces entropy, the cache cannot match non-deterministic keys, and the title generation is a redundant call that could be batched or deferred. The system’s architecture treats context as a mutable variable, not a constant. Trust is a variable, not a constant in AI.
Contrarian: Correlation ≠ Causation
The natural narrative is that the feature update caused the issue. But the real cause is the rate of engineering iteration outpacing the robustness of the control plane. OpenAI prioritized shipping Computer History and image support over hardening the context management layer. The anomaly is a symptom of innovation debt, not a simple bug. The reset strategy—resetting usage for all paid users—is not a customer-friendly move; it is a unit economics crisis. Each reset costs OpenAI millions in inference compute, but the alternative—losing users to Cursor or GitHub Copilot—is worse. The correlation between the reset and the optimization plan is misleading. The optimization plan may not fix the root cause; it may only patch the symptom. History repeats not by fate, but by flawed code.
Takeaway
The next-week signal is not the restoration of normal usage limits. It is whether OpenAI’s “new optimization plan” addresses the deterministic context representation or merely tweaks the compression algorithm. If the root cause remains, expect a recurrence within the next two months. Watch for the cache hit rate recovery—if it does not return to historical levels, the debt is structural. Code is law, bugs are crime. The forensics are clear.