Quick Summary
OpenAI’s Codex has cut its context window from 372k tokens down to 272k tokens. Anyone using it for large projects will likely feel this right away — the context you used to be able to cram in has now gotten noticeably tighter.
OpenAI hasn’t put out an official explanation for the reduction yet. From what’s generally observed, changes like this usually come down to server-side resource management or the cost of running the model.
Who does this hit hardest? People working with large codebases, reading lots of files, or running long sessions will notice first, since there’s now less room left for code plus conversation history.
Developers using Codex for big projects should start thinking about breaking work into smaller chunks, or using mid-session context summarization instead of dumping everything in at once. That will help avoid running out of tokens mid-task.
What Changes When You Open Codex Today
Open Codex today and you might notice warnings popping up faster than before. Sessions that used to run long and smooth are now hitting prompts telling you to trim files or summarize before continuing.
An easy way to spot it: if you open a project with a lot of files at once, you’ll hit the “context exceeded” error faster than you’re used to. For anyone who hasn’t been tracking the changelog, it can be confusing — a workflow that used to run fine suddenly stalls partway through. That’s not a bug — that’s the sign the context window got cut.
The Day Context Ran Out Mid-Task
I remember it clearly — I was refactoring an old project with a dozen interlinked files, working through Codex, going layer by layer through the dependencies. It was flowing well, then suddenly an error popped up mid-session. An hour’s worth of accumulated context vanished, and I had to re-explain the entire project structure from scratch.
At first I thought I’d hit my own usage quota. Checked — that wasn’t it. Codex really had cut its context window from 372k down to 272k tokens. Work that used to fit in a single conversation was now spilling over.
Honestly, this isn’t just a number in some changelog — it’s hitting the day-to-day workflow of anyone actually using Codex for serious work. This article looks at why the cut happened and how developers need to adapt.
Where Codex Sits in OpenAI’s Model Lineup
Codex is a specialized coding model, split off from the main GPT line that’s built for general conversation. Since launch, its selling point has been a large context window — able to handle long codebases, read entire files or whole repos in one go, without needing to chop things into pieces.
Cutting context from 372k to 272k tokens shakes that “handles more than anyone else” image. Codex used to be positioned as the choice for enterprise work — large codebases where you need to see the whole system at once — distinct from general GPT models built for short, fast-turnaround tasks.
So this cut isn’t just about internal performance — it’s a positioning shift. From “the largest context in the coding-tool category” to a point where Codex needs a new answer for what actually differentiates it, now that the headline number it used to advertise has lost half of its previous edge.
372k vs. 272k — Just a Number, or a Real-World Impact?
The core context figure that changed is clear: 372k tokens down to 272k tokens. Other numbers — like price per token or response speed — haven’t been officially disclosed by OpenAI, so we can only speak qualitatively there.
| Factor | Codex (372k) | Codex (272k) |
|---|---|---|
| Context size | 372,000 tokens | 272,000 tokens |
| Handles long code / multiple files | Wider (estimated) | Narrower (estimated) |
| Price per token | Not officially disclosed | Not officially disclosed |
| Response speed | No confirmed data | No confirmed data |
| Long-context work (large repos) | Lower risk of context loss | Higher risk of context loss |
The lost context capacity directly affects work that requires reading long code or multiple files at once. Price and speed will need real benchmarks to confirm — can’t call it either way yet.
Which Coding Tasks Get Hit Hardest by a Smaller Context
Large codebase refactors: More files means more risk of getting cut off mid-task. Break work into smaller chunks — don’t dump an entire module in at once.
Whole-repo code review: Instead of asking for one sweeping review, go file by file or PR by PR for more accurate results.
Debugging across multiple files: This gets hit hardest, since you need to trace stack traces across files. If context runs out, the model may “forget” the first file it read — paste only the relevant sections instead of whole files.
Generating docs from a long codebase: Summarizing/generating docs from an entire system’s code needs to be split into per-module rounds, then merged afterward.
Bottom line: workflows that used to cram everything into a single context may need to shift toward smaller, chunked tasks instead.
If Not Codex, What Has a Bigger Context Window?
| Factor | Codex | Claude Code | Gemini Code Assist |
|---|---|---|---|
| Context window | 272k tokens (down from 372k) | No reduction announced | No reduction announced |
| Coding strength | Tied to ChatGPT ecosystem | Continuous cross-file code reading | Tied to Google Cloud/Workspace |
| Current risk | Just cut context mid-stream | No changes announced | No changes announced |
There’s no confirmed, directly comparable context figures for Claude Code or Gemini Code Assist right now. All we can say is neither has announced a context cut the way Codex just did.
What’s really changing isn’t just “a smaller number” — it’s the workflow. What used to be loading an entire project in one go may need to shift toward smaller chunks of work, regardless of which tool you’re using.
Pros and Cons of the Direct Context Cut
Cutting context from 372k to 272k doesn’t automatically mean things got worse — there are upsides and downsides depending on what kind of work your team does.
Pros
- +Less context to load means a chance at faster responses and lower cost per request
- +Forces work into smaller chunks, reducing noise from unrelated files bleeding into the task
Cons
- −Tasks that need to read an entire large repo in one continuous pass no longer work the same way — must be split into multiple rounds
- −Teams that relied on long context to have the AI remember full history now have to redesign their own workflow
Simply put: if your work is already made up of small, well-defined tasks, this barely affects you. But if you’re doing cross-file refactoring, you may need an extra layer of task planning.
The Hidden Cost of Managing Context Yourself
The cost that’s not obvious at first is time — having to re-trim prompts, decide what stays and what gets cut, instead of just throwing a long task in and letting it finish in one pass.
Scarier still is the risk of the AI “forgetting” old context. Once a session gets split, code you just edited might silently conflict with logic written earlier without you realizing it — and now you’re stuck debugging backward.
And when you need to resend context more often just to avoid losing continuity, the tokens used per task can keep climbing even though the price per token stays the same. So the real cost isn’t just the number on the bill — it’s the extra workflow overhead you now have to manage.
What Teams Relying on Codex for Long-Context Work Should Do
The question now isn’t “is Codex still good?” — it’s “how much does our team’s work actually depend on long context?” Start by breaking large tasks into smaller, self-contained pieces that don’t need to carry context across sessions.
If your team has a large codebase and constantly needs to reference old logic, that’s a signal to start looking at alternatives in parallel — don’t wait until work grinds to a halt.
The question worth asking before deciding: which part of your team’s work “loses logic” most often — and does that part genuinely depend on long context, or is it just poorly designed prompts? Sometimes the problem isn’t really the smaller window — it’s that we haven’t yet adjusted how we break up work to fit this new constraint.