Editor|Sia
Just as Cursor CEO Michael Truell revealed that OpenAI plans to block Cursor users from accessing its models in three months, causing a sudden tension in their relationship, OpenAI Codex suddenly made a new move.
Just now, these paying users suddenly received a wave of quota restoration – Codex lead Tibo announced on X (formerly Twitter) that they will reset usage quotas for all Codex and ChatGPT Work paying users.
This is not just a simple, brute-force addition of a bit more credit.
Tibo stated that they recently processed thousands of user feedback reports and almost completely overhauled the usage calculation mechanism behind Codex. The result revealed that users' previous feeling that the quota seemed to disappear too quickly wasn't entirely an illusion.
After a series of bugs were fixed, depending on different usage patterns, they estimate: the same Codex usage quota can now last 10% to 50% longer than before. The quota number might be the same, but the actual work it can accomplish has increased.
The list of issues disclosed this time almost reads like a "Compendium of How AI Agents Stealthily Burn Tokens." Some of these bugs, seemingly insignificant, could be remarkably voracious in consuming quota.
A Single Task Could Consume Up to 70% of a Week's Quota
OpenAI listed eight categories of issues that have been identified and fixed in one go.
The first is context compression (Compaction). When AI programming tools run for a long time, the context grows larger. Systems typically compress historical information to continue working.
The problem was that previously, when Codex performed context compression, it would keep old images in the context. As a result, while compression was intended to shrink the context, with old images not cleared, the context remained large—so large it could even immediately trigger another compression.
This led to a somewhat surreal situation: the compression meant to save context itself started consuming more context. After OpenAI fixed this, usage for users heavily utilizing images decreased by about 10%.
But this wasn't the most extreme. The real quota killer came from Codex's Goals mechanism.
OpenAI discovered that in some cases, a user-set /goal would be completed, but the Agent wouldn't stop as expected, instead continuing to execute.
Another scenario was that a tool might be broken, yet the model would keep retrying. A task might appear finished, but the AI was still working in the background repeatedly.
OpenAI stated that in some cases they observed, this single issue could consume 15% to 70% of a user's weekly quota. In extreme situations, one anomalous task could directly eat up seven-tenths of the weekly allowance. This issue has now also been fixed.
A Background Task Even Almost Ran 15,000 Times
Another issue appeared in the Memory system.
Codex's background Memory Worker, in some cases, would inherit certain Stop Hooks. In principle, Stop Hooks are used to control when a task stops. But with this bug, certain background tasks might run indefinitely because the stop condition couldn't be met.
This type of problem affected less than 1% of users. However, the long-tail cases were exceptionally extreme. OpenAI mentioned they even found a case where the action of checking if a task could end might be executed up to 15,000 times.
For the vast majority of users, this bug might be completely unnoticeable. But for those who encountered it, Tokens could silently evaporate in the background. The feeling is probably akin to a computer's fan suddenly spinning wildly with nothing visibly open.
Subagents Would Also Stealthily Upgrade Configuration
Another issue, characteristic of the Agent era, occurred with Subagent sub-agents.
Current Codex doesn't necessarily rely on a single model to complete a task. Complex tasks can be split and executed by multiple sub-agents working together. The problem arose here.
OpenAI discovered that some less capable models, like Luna, would sometimes autonomously choose more powerful (and more costly) auxiliary models without a user's explicit request.
Even more absurdly, even if the main model coordinating the task wasn't running in /fast mode, it might instruct the sub-agents below it to use /fast.
It's like the boss flying economy class while secretly buying business class tickets for several assistants. The task is the same, but the underlying resource consumption is a different story. This issue has also been fixed.
Automation Tasks: Set for Once a Day, Might Secretly Run More
Issues were also found in Automations.
OpenAI stated that some custom scheduled tasks previously could exhibit: an actual execution frequency higher than the user-set frequency. For example, a user might only want an automation to run periodically, but the system might wake the task more frequently than scheduled.
Looking at a single instance, it might not be much. But the characteristic of Agents is precisely that they can run autonomously without user operation. Running once isn't expensive. Running dozens of extra times, however, is a different matter. This issue has also been fixed.
Just Summarizing What It Did Could Also Consume 20% of Weekly Quota
Another typical issue came from Computer History.
To help the Agent understand what it previously did on the computer, the system needs to save, organize, and even summarize past operations. But in the old implementation, Codex might repeatedly summarize historical activities that were already highly overlapping. It's akin to re-sorting the same work log over and over.
OpenAI stated that in some cases, this extra overhead could account for about one-fifth, or 20%, of a user's total weekly usage.
A similar background consumption came from Rolling Task Summaries. Originally, even ordinary dialogue turns could trigger additional background requests to generate rolling task summaries.
The overhead per instance wasn't huge; OpenAI estimated it increased Token usage by about 1%. But again: 1% each time isn't much, but it adds up when it happens every time. OpenAI has directly disabled this mechanism.
MCP Didn't Escape Either: The Same Tool Result Might Be Encoded Twice
The final category of issues occurred with MCP tool calls.
OpenAI found that results returned by some tools might be encoded twice. Additionally, some tool descriptions could be accidentally truncated, forcing the system to retrieve them again.
Individually, these issues seem like minor engineering glitches. But when an Agent calls tools dozens, hundreds, or even more times a day, each duplicate transmission represents real Token consumption. Accumulated over time, it all reflects in the user's quota.
An Increasingly Hard-to-Calculate Bill
Looking at these fixes together, a clear change is emerging: In the past with ChatGPT, users could basically understand one dialogue as one model call.
But with Agent products like Codex, things are completely different.
You might only type one sentence on the interface, but what the system sees could be an entire Agent workflow. Understanding exactly how much quota is being used is becoming increasingly non-intuitive.
Some Tokens are used by the model to actually write code. Some Tokens are used to understand context. And some Tokens are even generated just by the background system maintaining memory, generating summaries, or scheduling Agents. If any part of this cycle experiences loops, repeated calls, or erroneous scheduling, what the user ultimately feels is just one thing: How did my quota run out when I didn't do anything?
OpenAI is clearly aware of this issue. Beyond fixing the aforementioned bugs, they stated they have made architectural-level adjustments to prevent similar problems from recurring. If related anomalies occur again, the team will automatically receive alerts.
More importantly, OpenAI is developing new usage display features. In the future, users will be able to see directly within the app where their quota is actually being spent, without having to guess.
From this perspective, this quota reset might just be surface-level goodwill. And it seems OpenAI isn't planning to stop here?
This article is from the WeChat public account "Almost Human" (ID: almosthuman2014), author: Following Scientific AI
