Did OpenAI Quietly Shrink Codex's Context Window? Developers Are Building Their Own Watchdog

If you lean on an AI coding tool every day, you’ve probably felt this: yesterday it chewed through a sprawling codebase without blinking, and today it acts like it forgot the first half of the conversation. That nagging feeling is now a live debate in developer circles. The accusation: OpenAI quietly trimmed Codex’s context window from 372k down to 272k, without saying a word.

Let me be upfront. This one isn’t backed by a mountain of confirmed community data yet. Verified public discussion over the past 30 days is thin. So treat this less as a settled news report and more as a look at why the suspicion is spreading, and how developers are trying to prove or disprove it on their own.

Why 100k Tokens Is Not a Rounding Error

Think of the context window as an AI’s working memory — the total amount of information it can hold in its head at once. It’s measured in tokens, and 372k tokens is roughly 300,000 words in a single pass. That’s a small library.

For developers, the size is everything. A big window means you can hand the tool a dozen files at once and ask it to refactor across all of them. A small one means it sees your project in fragments and never grasps the whole. Dropping from 372k to 272k wipes out 100k tokens — the equivalent of dozens of files sliding out of view mid-task.

So no, 100k is not a rounding error. If the subscription price holds steady while the tool’s real-world capability shrinks, that’s a stealth price hike in everything but name.

The Word That Matters Is “Quietly”

Spec changes happen. That’s fine. The problem isn’t the change — it’s that it allegedly landed with no announcement.

AI products don’t behave like traditional software. There’s no clean version number stamped on the box. Instead, a model with the same name gets tuned, re-weighted, or throttled behind the scenes, and the label never moves. From the outside, yesterday’s tool and today’s tool wear identical badges, so you have no way to know what shifted. That’s information asymmetry in its purest form.

This is exactly where developers get twitchy. You feel the degradation in your gut, but there’s no official acknowledgment, so you’re stuck wondering whether you’re imagining it. And when people hit that wall, they do the one thing engineers always do: they measure it themselves.

How the Grassroots Tracking Started

Enter the DIY watchdog movement. The premise is simple. If the vendor won’t tell us, we’ll measure it and put it on the record.

The method is straightforward. Prepare a long input of known length, then repeatedly probe how far back the tool actually remembers. The moment it starts dropping the earliest content, that’s your real context ceiling. Get several people running the same test under the same conditions, pool the results, and an observation that would have died as “maybe it’s just me” becomes reproducible data.

This is a familiar pattern in the AI era. It rhymes with the recurring “GPT-4 got dumber” episodes on Hacker News and Reddit, where users swapped benchmarks and stacked up screenshots until the pressure forced a response. It’s the process of converting private hunches into collective evidence. And the more a company stays silent, the sharper this vigilante-style verification gets.

What This Fight Is Really About

Step back, and this stops being about one tool’s spec sheet. It’s about the trust architecture of AI services as a whole.

We are all paying a monthly fee for products whose performance can change at any time. Yet the dashboard that would let us detect those changes sits on the vendor’s side, not ours. Let that persist, and even a genuinely great tool carries a nagging doubt: is today’s version the same one I paid for yesterday? Trust isn’t built on raw capability alone. It needs predictability and transparency.

There’s a fair counterargument, of course. Maybe the cut was forced by infrastructure costs or stability concerns, and such calls aren’t inherently wrong. The issue was never the decision itself — it’s the way it’s communicated. When something a single line of release notes could have handled gets handled with silence instead, users feel burned.

To be clear one more time: the 372k-to-272k claim is not broadly verified yet. But it’s worth talking about anyway, because the real story is the movement itself — developers building their own dashboard because no one handed them one. So here’s the question worth sitting with: is the AI tool you used today really performing the same as it did yesterday? And would you even have a way to know?