Filed the original issue documenting reproducible reasoning-token clustering where GPT-5.5 Codex emits low-entropy loops like 'the the the' inside reasoning blocks, followed by degraded answers. Argues this is a sampling-path problem — not prompt-related — since temperature, top-p, and system prompt variations don't fix it, and identical prompts work cleanly on GPT-5 Codex.
Frames the failure as a classic long-context autoregressive decoding pathology that shouldn't reach production — likely a KV-cache eviction bug, mis-tuned repetition penalty in the serving stack, or a quantization regression on a specific inference tier. None of these are visible or workaroundable from the caller's side, which is what makes the incident acute.
Highlights that Codex is a rolling alias with no way for API callers to fall back to the previous checkpoint, meaning a silent server-side regression instantly breaks every downstream agent loop with no escape hatch. The lack of version pinning turns a routine inference bug into a platform-wide outage for anyone building on top.
Engineers running agent loops posted side-by-side traces showing clean chain-of-thought on GPT-5 Codex degenerating into repeating tokens on GPT-5.5 Codex for identical prompts. For them, retrying sometimes working is cold comfort — non-determinism in a coding agent that silently produces truncated or off-target answers is worse than an outright failure, because it corrupts downstream automation without a clear signal to stop.
On July 3, an OpenAI Codex user filed [issue #30364](https://github.com/openai/codex/issues/30364) titled *"GPT-5.5 Codex reasoning-token clustering may be leading to degraded performance."* Within 48 hours it hit 328 points on Hacker News, and the comment thread filled with engineers posting their own traces: long, visible runs of the same reasoning token — sometimes the literal string `the the the` or a repeating punctuation glyph — appearing inside the `
The pattern isn't random hallucination — it's clustering: the model gets stuck emitting the same low-entropy token for dozens or hundreds of steps, then recovers into a truncated or off-target answer. Multiple reporters showed side-by-side runs where the identical prompt produced clean chain-of-thought on GPT-5 Codex and degenerate loops on GPT-5.5 Codex. Temperature, top-p, and system prompt variations didn't fix it. Retrying sometimes did, which is the giveaway that this is a sampling-path problem, not a prompt problem.
OpenAI hasn't publicly acknowledged the issue at time of writing, though a staff engineer left a `thanks, we're looking` comment on the thread. There's no mitigation shipped, no version pin available, and no way for API callers to fall back to the previous checkpoint — Codex is a rolling alias.
Reasoning-token clustering is a known failure mode in long-context autoregressive decoding, but it isn't supposed to happen on a shipped production model. When it does, the usual suspects are a KV-cache eviction bug, a mis-tuned repetition penalty in the serving stack, or a quantization regression on a specific inference tier — none of which are visible to the caller and none of which you can work around from the outside.
The community reaction split cleanly. One camp — mostly people running agent loops — treated this as a five-alarm fire. Their argument: if the model degrades mid-trajectory, an agent doesn't just produce a bad answer, it produces a bad *plan* and then executes it. One commenter posted a trace where a Codex agent stuck in a reasoning loop kept calling the same `read_file` tool 40 times before the framework's own retry limit killed it. That's real money and real side effects.
The other camp pointed out that OpenAI has rolled silent updates before — GPT-4-turbo shifted underneath users at least four times in 2024 with no version bump — and the correct posture is to assume the model is a moving target. If your evaluation harness doesn't run nightly against a fixed benchmark suite, you have no way to detect a regression like this until a customer files a ticket. That's not a Codex problem, that's a you problem.
Both camps are right, and the intersection is what makes this story useful. The failure mode is specific enough to be diagnosable (token-level repetition inside the reasoning trace) and universal enough to catch anyone who assumed a shipped model wouldn't regress in production. The Anthropic Claude and Google Gemini equivalents have shown milder versions of the same clustering behavior at long context lengths — this isn't an OpenAI-specific problem, it's a class of bugs the whole industry is going to keep hitting as reasoning traces get longer and the KV cache gets more aggressive about eviction.
Worth noting: the HN thread produced one genuinely useful diagnostic. Several users found that setting `reasoning_effort: "low"` sidestepped the clustering entirely — the shorter reasoning traces don't give the pathological state room to develop. That's a workaround, not a fix, and it defeats half the reason you're paying for a reasoning model in the first place, but it will keep production pipelines running until OpenAI ships a rollback.
Three concrete things to do this week if you have Codex in the loop.
First, add a repetition guard on the reasoning trace before you trust the final output. A rolling window that flags any n-gram appearing more than ~10 times in the last 200 tokens catches the clustering pattern reliably. If it triggers, retry once with a different seed or fall back to a non-reasoning model. This is 20 lines of Python and it will save you from shipping degraded output to users who won't file a bug — they'll just leave.
Second, if you're running agent loops, put a hard cap on identical consecutive tool calls. The Codex agent stuck calling `read_file` 40 times wasn't a bug in the agent framework — it was the agent framework doing exactly what it was told, which is exactly the problem. Two identical calls in a row is a signal; three is a state you need to break out of.
Third, if you don't have a nightly eval against a fixed prompt set, build one before the end of the sprint. Ten prompts covering your actual workload, scored against a rubric or a stronger model as judge, run every night, results tracked in a two-column table. The whole setup takes an afternoon. When your provider silently swaps a checkpoint underneath you — and they will, again — you'll know within 24 hours instead of finding out from a Twitter thread.
The Codex regression will get patched, probably quietly, probably this week. The larger pattern is that the reasoning-model era has put us in a place where model behavior changes are no longer just about output quality — they're about the shape and stability of the trace, and traces are what agent frameworks depend on. Providers are going to have to start versioning reasoning modes the way they version fine-tunes, and callers are going to have to start treating the reasoning trace as a first-class output that deserves its own monitoring. Neither of those things is happening yet. Until they do, the load-bearing infrastructure of every agent product you're building is a model alias that can shift at any time, and the only defense is your own eval loop.
Top 10 dev stories every morning at 8am UTC. AI-curated. Retro terminal HTML email.