Just now, OpenAI is set to offer collective refunds to paid subscribers of Codex and ChatGPT Work.

Edited by Sia  

Right after Cursor CEO Michael Truell revealed that OpenAI plans to block Cursor users from accessing its models in three months, which has suddenly strained the relationship between the two sides, OpenAI Codex has suddenly rolled out a new move.

Just now, these paid users have suddenly received a usage quota reset — Head of Codex Tibo announced on X that all paid users of Codex and ChatGPT Work will have their usage quotas reset.

This is not a simple, crude move to give users a little extra quota.

Tibo said that they have recently processed thousands of user feedback submissions, and completely overhauled the usage calculation mechanism behind Codex. It turns out that the users' previous feeling that the quota was being used up too quickly was not entirely an illusion.

After a series of bugs are fixed, depending on different usage patterns, they estimate that the same Codex usage quota can now last 10%-50% longer than before. The number of quota points may not change, but the actual amount of work that can be done has increased.

The list of issues announced this time is almost a complete guide to how AI Agents secretly burn tokens. Some of these bugs look insignificant, but they consume a huge amount of quota.

One single task can consume up to 70% of the weekly quota

OpenAI has listed 8 types of discovered and fixed issues at one go.

The first one is context Compaction. When AI programming tools run for a long time, the context keeps growing, and the system usually compresses the historical information to continue working.

The problem was that when Codex performed context compression before, it would keep old images in the context. As a result, compression that was originally meant to reduce the size of the context did not clear old images, so the context remained very large, to the point that it might immediately trigger another compression.

This led to a rather absurd situation: the compression intended to save context itself started to consume more context. After OpenAI fixed this issue, the relevant usage volume for users who heavily use images dropped by about 10% directly.

But that is not the most extreme case. The real quota killer comes from Codex's task Goals mechanism.

OpenAI found that in some cases, when the /goal set by the user had already been completed, the Agent did not stop as expected, but kept executing further steps.

In another scenario, even when the tool was already broken, the model would keep trying to retry. The task appeared to be finished, but the AI was still running over and over in the background.

OpenAI said that in some cases they observed, this single issue alone could consume 15%-70% of a user's weekly quota. That means in extreme cases, one abnormal task could directly eat up 70% of the weekly quota. This issue has now been fixed.

One background task almost ran 15,000 times

Another issue was found in the Memory system.

The Codex background Memory Worker would in some cases inherit certain Stop Hooks. The Stop Hook was originally designed to control when a task should stop. But after the bug occurred, some background tasks could keep running because the stop condition could never be met.

Less than 1% of users were affected by this issue. But the edge cases were extremely exaggerated. OpenAI mentioned that they even found a case where the action of the system checking whether a task could be ended ran as many as 15,000 times.

For the vast majority of users, this bug may be completely unnoticeable. But for the few users who encountered it, tokens could be silently consumed in the background. It feels like the fan of your computer suddenly starts spinning at full speed even when no programs are open.

Subagents will also secretly upgrade their configuration

Another very characteristic issue of the AI Agent era occurs with Subagents.

Current Codex does not necessarily complete tasks with only one model. Complex tasks can be split up, and multiple subagents are called to execute in collaboration. The problem arises here.

OpenAI found that some smaller, less capable models such as Luna would sometimes choose more powerful and higher-cost auxiliary models on their own, without explicit requests from users.

Even more absurdly, even if the main model coordinating the task was not running in /fast mode, it could still require the subagents below to use /fast mode.

It is like the boss flies economy class, but their assistants secretly buy business class tickets. The task remains the same, but the resource consumption behind it is completely different. This issue has also been fixed now.

Automation tasks that are supposed to run once a day may secretly run multiple extra times

Problems were also found in Automations features.

OpenAI said that some custom scheduled tasks previously could run more frequently than the frequency set by users. For example, if a user only wanted an automation task to run periodically, the system might wake up the task far more often than the scheduled time.

A single extra run may not cost much, but the defining feature of Agents is that they can run on their own without user intervention. One run is not expensive, but dozens of extra runs can add up quickly. This issue has also been fixed now.

Summarizing what you have done alone can also consume 20% of your weekly quota

Another typical issue comes from Computer History.

To let the Agent understand what it has done on the computer before, the system needs to save, organize and even summarize past operation history. But in the old version of the implementation, Codex could repeatedly summarize highly overlapping historical activities. It is like reorganizing the same work log over and over again.

OpenAI said that in some cases, this extra overhead could account for about one fifth, or roughly 20% of the user's total weekly usage.

There is another similar background consumption from Rolling Task Summaries. Ordinary conversation turns could also trigger extra background requests to generate rolling task summaries.

The overhead per instance is not large, OpenAI estimates it adds about 1% to total token usage. But as the saying goes: 1% per time is not much, but it adds up when it happens every time. OpenAI has completely shut down this mechanism.

MCP did not escape either: the same tool result could be encoded twice

The last type of issue occurred in MCP tool calls.

OpenAI found that some tool return results could be encoded twice. In addition, some tool descriptions could be accidentally truncated, forcing the system to retrieve them again.

These issues individually look like tiny flaws in engineering implementation. But when an Agent calls tools dozens, hundreds or even more times a day, every extra transmission means real token consumption. The total adds up and is eventually reflected in the user's quota usage.

An increasingly hard-to-calculate bill

Looking at all these fixes together, a clear change is taking shape: in the past when using ChatGPT, users could roughly understand one conversation as one model call.

But for Agent products like Codex, things are completely different now.

You only enter one sentence in the interface, but the system may run a whole Agent workflow. It is becoming increasingly difficult to intuitively understand how much quota has actually been consumed.

Some tokens are truly used by the model to write code. Some tokens are used to understand the context. Other tokens are even generated by the background system to maintain memory, generate summaries, or schedule Agents. If any of these links has loops, repeated calls or wrong scheduling, the only thing users will feel in the end is: why is my quota used up even when I barely did anything?

OpenAI is clearly aware of this problem. In addition to fixing the bugs mentioned above, they said they have also made adjustments at the architecture level to prevent similar issues from happening again. The team will also automatically receive alerts if such anomalies occur again.

More importantly, OpenAI is developing a new usage display feature. In the future, users can directly see in the application where their quota has been spent, instead of having to guess.

From this perspective, this quota reset may only be a superficial benefit. And it seems that OpenAI does not plan to stop here.

This article is from the WeChat public account "Almost Human" (ID: almosthuman2014), authored by AI science followers, republished with authorization from 36Kr.