Jan Sverre Bauge

Codex Quality Decline: Why Do My AI Agents Act Like “Addicts”?

Local logs document Codex quality decline, 1.152 billion processed context tokens and a costly repair loop - without proving a single technical cause.

Codex AI agents caught in a costly cycle of failures, repairs and new regressions
Across 41 local session files, repairs too often became the starting point for the next Codex failure.

Codex quality decline is not just the feeling that an AI agent gave me one bad answer. In my local logs, I see a recurring pattern: fresh sessions break simple contracts, corrections swing to the opposite extreme, and the repair becomes the start of the next failure.

I have started calling agents that behave this way “addicts.” It is my metaphor for an agent that seems disoriented and inconsistent – not a medical or technical diagnosis. It can be brilliant one moment, then do the exact opposite of an instruction it had just repeated back correctly.

From July 4 to July 17, 2026, 41 local session files recorded approximately 1.152 billion processed context tokens, 10,288 tool calls, 43 automatic compactions and 26 interruptions. That huge number needs an important qualification: Around 1.102 billion were cached input. These were not 1.152 billion new tokens, and the number is not a bill. It measures how much context passed through the agent work while I tried to get actual deliverables over the line.

Codex quality decline: What do the logs show?

The documented finding is instability in the agent service as a whole, not a proven downgrade of one base model. Every one of the 10 active production days I examined had at least one specific deviation, retry, missing final status or faulty quality gate. Some deliverables emerged after an automatic retry or manual rescue, but not one of those days produced a clean end-to-end run.

That distinction matters. An article that eventually gets delivered after hours of diagnosis, code changes and another run is not evidence of a working autopilot. The whole point of an agent is that I should not have to sit there as an on-call operator and discover every failure myself.

On some days, I spent up to roughly 10 hours on diagnosis, checks and repairs. About $100 is a rough estimate for the entire Codex period, not an audited bill for a single video.

The failures were not confined to one stage, either. They appeared in scoring, argument transport, metadata, link validation, scheduling, the runtime environment and persistent code changes. On one day, a large request stopped with Argument list too long, after which the pipeline presented the technical failure as if no stories had scored highly enough. On another, a valid article was blocked by an incorrect requirement for more internal links. The following day, the batch crashed after a WordPress draft had already been created because a time variable had not been carried through the function contract.

An endless AI workflow repeats failures, fixes and regressions in the same loop
A fix often lasted only until the next session, when the workflow started the same dance all over again.

Why can’t context rot explain everything?

OpenAI itself describes context pollution and context rot in the Codex manual: Useful information can drown in logs, intermediate results and other details as a main thread grows. That is a real risk, and it probably explains some failures late in long sessions. It does not explain failures that arrive before a session has had time to become long.

I found four fresh sessions from July 14 to July 17 that ran the same established media workflow with the same visible model family and effort level. In all four, the first serious problem appeared within the first three user actions and before automatic compaction. The output drifted from missing details to incorrect framing, unnatural movement and, finally, a character that stopped talking and did something completely different.

I need to be precise here: Image and video generators are stochastic. Not every bad image or video clip can be blamed on Codex. Codex did, however, control the instructions, prompts, file changes and the choice of what to run. The series therefore documents instability in the complete agent pipeline, not proof that the language model alone created every visual failure.

The clearest moment came when a correction went from chaotic movement to a completely static camera, a lifeless character and mechanical body movements. Codex itself described how it had overcorrected from chaos to lifeless mechanics. In the same response, it broke a simple naming instruction that was plainly present in the fresh session. The naming error is measurable, but it is not the main point. What matters is that the agent could understand the complex overcorrection while simultaneously losing a simple, explicit rule.

When the repair becomes the next day’s regression

The most expensive class of failure is not a badly worded answer. It is when the agent saves a repair into the persistent system, declares the job finished and lets the next ordinary production run become the real test. At that point, the failure moves out of the conversation and into the workflow.

From July 15 to July 17, I followed one such chain. First, a transport error was interpreted as a valid empty result. The repair changed several contracts. The next day, a faulty quality gate rejected content that was actually valid, while metadata and link search required more rounds of work. On the third day, a time-related change crashed the batch, and the first repair exposed yet another variable error.

This is more than ordinary variation in language. These were Codex-generated changes that persisted and affected the next run. The observation is solid: The repair merry-go-round happened. The hypothesis about why the agent did not catch the side effects before declaring itself finished remains open.

The same error of proportion can hit content. In another test, the main finding was a local 27B model of roughly 7.2 GB running at approximately 83-85 tokens per second while still being capable of practical work. Yet a minor installation detour hijacked the article angle, social media copy and image concept. When I corrected course, the agent first swung to another oversimplified extreme. It found the most dramatic detail, not the center of gravity in the complete research.

When retrieval finds the answer but cannot enforce it

The Grok 4.5 case shows a different class of failure. On July 17, the authoritative case package contained an internal link to my published July 9 article, “Grok 4.5 is out – price, API and OpenRouter access.” The writer model used that link in the draft, yet still rewrote the launch story. Retrieval found the right information, but the match had no binding effect on the decision to stop.

The editor stopped the story before publication, but only after a complete article, three new images and a WordPress draft had been produced. The final safety net worked, just far too late. The distinction matters: A system can be good at retrieving relevant information and still be bad at allowing that information to govern what the agent is permitted to do.

This must be kept separate from one limited Grok 4.5 experience in another project. There, I used the model through OpenRouter in one call for one part of a media workflow, and the result was worse than GPT-5.6 Terra for that specific task. It was not a broad Grok test or an overall verdict on the model. In that project, the problem was failure to capture the memory. In the launch story, the knowledge had been retrieved but had no controlling force.

What do 1.152 billion tokens actually tell us?

The 1.152 billion figure is processed model context in local logs, not 1.152 billion unique or equally billed tokens. Approximately 1.149 billion were input, of which around 1.102 billion were cached. Non-cached input was approximately 47.3 million, while output was roughly 3.08 million and recorded reasoning output about 798,000.

Cached input may have different pricing and quota weighting from new input. Converting the total into a dramatic API bill would therefore be misleading. The figure still matters because a cache does not make processed context disappear. It shows the scale of the agent work that passed through the system.

The most interesting part is the change between the two periods. From July 4 to July 10, approximately 362.6 million tokens were processed, with five interruptions. From July 11 to July 17, that rose to approximately 789.5 million tokens and 21 interruptions. The interruption rate climbed from roughly 0.85 to 2.53 per 100 user messages. The heaviest observed day, July 15, accounted for approximately 219 million processed tokens.

This does not prove that high token use caused the quality decline. The direction of causality may run the other way: More failures produce more corrections, restarts, file reviews and new runs. Heavy use can be both a possible stress factor and a result of the agent failing to finish. That is exactly why tokens per completed deliverable are more interesting than the total alone.

Paid image and video jobs repeat while time, tokens and money disappear
Repeated keyframes, video generations and assembly runs turned poor agent judgment into a direct cost.

Why does this remind me of Claude?

The uncomfortable part is that I recognize the pattern. Claude gave me about a year of useful agent work before I started seeing the same visible behavior: Instructions lost their force, corrections did not stick, working code was changed, and the agent swung between extremes. I have previously written about Claude, token problems and declining quality at Anthropic.

With Codex, some symptoms appeared on the first day, while the broader quality wall became obvious after a few days of intensive use. That does not make Codex and Claude technically identical. Similar visible behavior across two providers proves neither a shared backend, the same compaction system nor identical account handling.

The parallel is still too strong to dismiss. An open Anthropic report analyzes 6,852 Claude Code sessions, while an open Codex report analyzes 2,702 user prompts and 56,717 tool calls. Both describe a growing need for correction, more restarts and a loss of autonomy. These are user analyses, not official confirmations of a cause, but they point to a bigger question: Do today’s agent services have a stability limit that users cannot see?

I have also examined what Codex CLI actually adds. This analysis does not change the fact that Codex can be extremely good. It changes how much responsibility I believe the tool should receive without supervision.

What could the technical explanation be?

The honest conclusion is that I do not know. Variation in the backend or runtime environment behind the same visible model name is the most interesting hypothesis, because two sessions can have different task capabilities despite displaying the same settings. It is a plausible explanation, but it remains a hypothesis.

Runtime variation is documented locally. Two near-simultaneous, read-only tests used the same project, model, effort level and almost identical prompts. The first was blocked by a sandbox or network failure and could not read the files. The second got access and delivered correctly. The first agent did the right thing by refusing to make anything up, but from the user’s perspective, the sessions looked dramatically different.

Context pollution and automatic compaction are also real mechanisms, especially in long threads. Self-reinforcing instruction pollution is another plausible amplifier: If the agent first breaks a rule and then writes the incorrect form into a persistent project file, the next session can inherit a conflict the agent created itself.

Account-dependent restrictions are technically possible, but the local evidence is weak. The visible weekly quota was 29 percent used, no rate limit was logged, and the sessions still showed the selected model. OpenAI had, however, confirmed that some accounts were incorrectly rate-limited by its abuse- and fraud-prevention systems in June. The company also wrote that it had not observed a broader decline in Codex quality.

I therefore cannot claim that OpenAI punishes heavy users, routes me to a hidden mini model or lowers quality as the quota is consumed. Task mixing, difficult media models and my own frustration are also sources of error. They have to be taken seriously. But they do not explain away the overall pattern across fresh sessions, production logs and persistent regressions.

What does a reliable AI agent need?

Codex can deliver extremely good work in a controlled session. In good sessions, it follows instructions, qualifies claims and stays with the main finding instead of chasing the most dramatic detour. The problem is that I cannot know in advance when that quality will be there.

As an autonomous control layer for long production tasks, Codex was therefore too unstable during this period. That does not mean GPT is only useful for chat. It means the agent currently needs closer supervision, lower-risk areas of responsibility and explicit quality gates before it is allowed to change persistent systems or order paid external work.

An agent product also needs a visible stop mechanism. If capacity, context, account state or runtime makes normal quality uncertain, I would rather get a clear warning than see an unchanged model name while the agent continues spending time, quota and money. OpenAI’s own status pages note that aggregate availability can hide differences between subscriptions, models and features. Users need more telemetry, not less.

It is a bit like a car with fantastic steering on nine out of 10 trips. That does not help if, on the 10th trip, you cannot tell whether the problem is in the steering, the brakes or the engine – while the dashboard still says everything is normal. An agent that can change code, create drafts and order paid jobs needs warning lights and a safe stop.

I am not left with proof of one hidden technical explanation. I am left with something more practical: 41 session files, 10 production days with deviations, 1.152 billion processed context tokens and a pattern in which the repair too often becomes the next problem. The numbers do not lie, at least. The open question is which layer does.

Frequently asked questions

Does this mean Codex always gives bad answers?

No. Codex can deliver extremely good work in a controlled session. This analysis concerns stability in long, multi-step agent tasks where the tool changes files, uses tools and must preserve contracts over time. The problem is the variation and the lack of clear warnings when quality fails.

Are 1.152 billion tokens the same as billed tokens?

No. The number is processed context from local logs. Approximately 1.102 billion were cached input, while roughly 47.3 million were non-cached input. They can be priced and counted against quotas differently, so the total should not be read as an API bill.

Could a full context window be causing the Codex problems?

A full or noisy context can explain some later failures, and OpenAI documents the risk as context pollution and context rot. It cannot, by itself, explain the selected failures that occurred within the first user actions of completely fresh sessions and before automatic compaction.

Has OpenAI downgraded the model for heavy users?

There is no evidence of that here. The visible weekly quota was 29 percent used, no rate limit was logged, and the sessions showed the selected model. Backend or account-dependent variation is a hypothesis for OpenAI to investigate, not a technical conclusion from the local logs.

Leave a Reply

Your email address will not be published. Required fields are marked *