Just after Cursor CEO Michael Truell revealed that OpenAI plans to prevent Cursor users from continuing to access their models after three months, when the relationship between the two sides is suddenly strained, OpenAI Codex suddenly launches a new move.
Just now, these paid users have suddenly started a wave of quantitative feedback.Head of the CodexTibo announced in a tweet that it will reset the quota for all paid users of Codex and ChatGPT Work.
This time it's not a simple, rough, over-send.
Tibo said they recently focused on processing thousands of user feedback, almost overturning the utilization calculation behind Codex. The result was that it was not entirely an illusion how users had previously felt that the quota was not used.
After a series of bugs were fixed, depending on how they were used, they expected that the same Codex could now use 10%-50% more than before.
This published list of issues is almost as big as a bug in how an AI Agent smuggled Token. Some of the bugs, which don't look remarkable, burned up the quantity but were quite fierce.
One task can eat up to 70% of a week's allowance
OpenAI lists eight categories of problems that have been discovered and corrected.
The first is Compaction. AI programming tools run longer, the larger the context, and the system usually compresses the historical information in order to continue to work.
The problem is that the codex keeps the old image in the context when it has already been compressed. As a result, the original image was compressed to make the context smaller, but the old image was not removed, and the context is still large enough that it might even trigger a compression again immediately.
A slightly magical situation arose: Compression in order to save the context itself began to consume more context. After OpenAI fixed this problem, the use of images directly decreased by about 10% for those users who use images heavily.
But this is not the most exaggerated. The real quantity killer comes from Codex's mission target mechanism, Goals.
OpenAI has found that, in some cases, users set up/goalClearly the execution was completed, but the agent did not stop as expected, but continued to execute backwards.
The other scenario is that the tools are clearly broken and the model will continue to try again. The task seems to be over, but the AI is still working again in the background.
OpenAI said that in some of the cases they saw, the problem alone consumed 15% to 70% of users' weekly allowances. That is, in extreme cases, an unusual task could directly consume 70% of the weekly allowance.
There's a back-end mission, and it's been run almost 15,000 times.
Another problem is with Memory, the memory system.
In some cases, Codex's Background Memory Worker will inherit certain Stop Hooks. By default, the Stop Hook is used to control when the task stops. However, after the Bug occurs, some Background tasks may continue to run because the stop conditions cannot be met.
Less than 1% of users are affected by this type of problem. The problem is that long-tail cases are unusually exaggerated. OpenAI notes that they have even found a case where a system checks whether a task can be completed and can be performed up to 15,000 times.
For the vast majority of users, the bug may be completely nonsensical. But for users in a collision, the token may evaporate silently in the background.
Subagent will also stealthily upgrade the configuration.
There is also a problem that is very much a feature of the Agent era that is occurring in Subagent's sub-intelligence.
Today's Codex doesn't have to be a single model to complete a task. Complex tasks can be broken down and then called on multiple sub-agents to co-execut them.
OpenAI has found that some models with smaller capabilities, such as Luna, can sometimes choose stronger, more cost-effective support models on their own without explicit user requirements.
What's even more disgraceful is that even the main model responsible for the task of unification is not running./fastIn this mode, it may also require the following sub-Agent to be used:/fast。
It's like a boss sitting on an economic bench and stealing business cards from a few assistants. The task, of course, is that task, but the resource consumption behind it is no longer a thing.
Automated tasks, say, once a day, can actually steal more runs.
Automations is also getting into trouble.
According to OpenAI, some custom scheduling tasks may have occurred before: the actual execution frequency is higher than the frequency set by the user. For example, the user only wants a certain automated task to be executed regularly, but the system may wake up the task more often than the set time.
It may not be much to see at once, but the feature of Agent is that it can run on its own without user intervention. Running once is not expensive. Running more than a dozen times is not necessary.
You can eat 20% of your weekly portion just by summarizing what you've done.
Another relatively typical problem comes from Computer History.
In order for the agent to understand what he or she has done on the computer before, the system needs to save, organize, or even summarize past operations history. However, in older implementations, the codex may repeatedly summarize already highly overlapping historical activities.
According to OpenAI, in some cases, this extra cost could account for about one-fifth of users' total weekly usage, or about 20 percent.
There is also a similar backdrop consumption from Rolling Task Summaries. It may trigger additional backdrop requests to generate a rolling task summary.
One-time expenses are not large, and OpenAI estimates an increase of about 1% in Token usage. Or as the saying goes: less than 1% at a time, and it doesn't work every time. OpenAI has shut down this mechanism.
MCP didn't get away with it: the results of the same tool can be encoded twice
The last class of problems occurred with MCP tool calls.
OpenAI found that some tools returned results could be re-encoded twice. In addition, some tools indicated that they would be unintentionally intercepted and the system would have to retrieve them once again.
These types of problems, on their own, seem to be little bits of engineering implementation. But when the Agent calls dozens, hundreds, or even more tools a day, each repeated transmission means real Token consumption. After a smaller amount, it is finally reflected in the amount of users.
This is an increasingly difficult account.
Putting this correction together, a noticeable change is occurring: In the past with ChatGPT, users could basically understand a conversation as a model call.
But with Agent products like Codex, things are completely different.
You only type a word in the interface, and what the system sees is probably an entire Agent workflow, and how much of it is being used is becoming increasingly difficult to intuitively understand.
Some tokens are models that actually write code. Some tokens are used to understand the context. Some tokens are even generated by back-end systems to preserve memory, generate summaries, or schedule Agent. Here any link is looped, repeatedly called or mis-scheduled, and the end user feels only one thing: why is nothing done, and the quantity is gone?
OpenAI is obviously aware of this problem. In addition to fixing the above Bug, they also said that adjustments have been made at the architectural level to prevent similar problems from occurring again. If the relevant anomaly occurs again, the team will automatically receive alerts.
More importantly, OpenAI is developing new usage display functionality. Future users will be able to see directly within the application where their share is spent without having to guess.
From this point of view, this reset may just be a superficial benefit.
