# Codex's Context Cut Is Really a Billing Cliff > Source: > Published: 2026-07-20 00:08:28+00:00 [AI](https://sourcefeed.dev/c/ai)Article # Codex's Context Cut Is Really a Billing Cliff OpenAI reverted GPT-5.6 Sol to 272k because the bigger window was silently double-billing long sessions. [Rachel Goldstein](https://sourcefeed.dev/u/rachel_goldstein) Sometime around July 13, [Codex](https://github.com/openai/codex) users started noticing a smaller number in their logs. The `model_context_window` for GPT-5.6 Sol dropped from 353,400 tokens to 258,400 — the raw catalog value cut from 372k to 272k, minus Codex's 95% effective-context policy. No changelog, no release note. The change arrived through the server-delivered model catalog, and only became legible when [a pull request](https://github.com/openai/codex/pull/33972) backporting the refreshed metadata to the 0.144 release landed on GitHub and hit the Hacker News front page. Cue the outrage: a ["SEVERE REGRESSION" issue](https://github.com/openai/codex/issues/32806) pointing out that GPT-5.6 Sol's published spec advertises a 1.05M-token window, of which Codex now exposes about a quarter. But the interesting story here isn't a nerf. It's that 272k is a billing cliff, and OpenAI walked its own product back off the edge of it. ## 272k is not an arbitrary number If 272k sounds oddly specific, there's history. GPT-5 shipped in 2025 with a 400k total context — 272k max input plus 128k output. That input ceiling outlived the architecture: it's now the long-context pricing breakpoint across the GPT-5.6 family. Per [OpenAI's pricing docs](https://developers.openai.com/api/docs/pricing), a request with more than 272k input tokens is billed at 2x input and 1.5x output — for the *entire* request, not just the overage. Sol goes from $5 to $10 per million input tokens the moment you cross the line by a single token. When GPT-5.6 launched, Codex raised its context cap from GPT-5.5's 272k to 372k. Generous on paper. In practice it meant long agentic sessions silently drifted into the 2x band, and for ChatGPT subscribers — who see quota, not per-token invoices — that translated to plans draining noticeably faster with no visible cause. Thibault Sottiaux, who runs Codex at OpenAI, [confirmed the mechanics](https://x.com/thsottiaux/status/2076495156757577895): the 372k limit "resulted in more usage being charged than intended," so they reverted to 272k, with the larger window due to return "in the days to come" alongside inference optimizations he says are worth roughly 10% more usage on their own. Read plainly, the revert is consumer protection. A default that quietly double-bills the tail of every long session is a worse product than a smaller window. One open Codex issue had already done the math before the revert: with auto-compaction triggering near the top of a 353k effective window, sessions could run ~81k tokens deep into the premium band without the user ever opting in. ## The right call, shipped the worst way So OpenAI made a defensible decision and communicated it like a leak. The catalog update went out server-side days before anyone said anything publicly; users reverse-engineered it from runtime logs; the explanation came as a reply-guy thread after a GitHub PR went viral. That sequence — silent change, community forensics, belated "no nerfing, only good stuff!" — is why every capacity adjustment now gets read as a stealth downgrade, even when, as here, it saves subscribers money. There's a practical lesson buried in the delivery mechanism, too: pinning your Codex CLI version does not freeze model behavior. The context window comes from a server-refreshed model catalog, and the PR that exposed all this exists precisely to backport new metadata into an existing release line. Your harness's most economically consequential parameter can change under you between two identical binary versions. It's also worth saying that nobody in this market is clean on the spec-sheet gap. The 1.05M number on GPT-5.6's model page is real at the API — priced accordingly — but no vendor's own agent ships with its flagship window uncapped, because KV-cache costs scale brutally with context length. Anthropic gates long context behind premium tiers as well. The marketing number is the ceiling; the product ships the economic floor. GPT-5.6 just made the gap unusually visible: 1.05M advertised, 258.4k delivered, and for a week, an invisible surcharge in between. ## What to actually do about it If you're a Codex subscriber, the counterintuitive take: this change is in your favor, and the promised return to 372k is the thing to be wary of. Unless it ships with threshold-aware defaults — compaction that respects the 272k line, or a visible warning before crossing it — you're back to paying 2x for context you didn't knowingly ask for. The suggestions in [issue #32486](https://github.com/openai/codex/issues/32486) (opt-in for the premium band, marginal rather than full-request pricing) are the actual fix; the revert is a tourniquet. If you're hitting GPT-5.6 through the API with your own harness — aider, a custom agent loop, whatever — check your configured context window today. Plenty of tools copied the 372k figure at launch, and every request they let grow past 272k input tokens is billed at double rate end to end. Cap max input at 272k explicitly, or if you genuinely need the long band, cross it deliberately and batch the work so one request amortizes the surcharge instead of five. And whichever side you're on, plan around the effective number, not the raw one. With the 95% policy and auto-compaction firing at 80–90% of capacity — compaction you currently can't disable, a top complaint in the HN thread — your real working budget on Codex today is roughly 230k tokens before the model starts summarizing your session out from under you. Structure agent tasks accordingly: scope work to fit, push exploration into subagents, and treat anything that needs 300k tokens of live context as a design smell rather than a quota problem. The era of context windows as a spec-sheet bragging right is ending. What matters now is the price curve across the window — and whether your tools know where the cliffs are. ## Sources & further reading - [Backport refreshed bundled model metadata to 0.144](https://github.com/openai/codex/pull/33972/files)— github.com - [OpenAI reduces Codex Model Context Size from 372k to 272k](https://news.ycombinator.com/item?id=48965850)— news.ycombinator.com - [GPT-5.6 Sol context cut again: 353K to 258K despite advertised 1.05M](https://github.com/openai/codex/issues/32806)— github.com - [Default GPT-5.6 context can cross the 272K higher-usage threshold](https://github.com/openai/codex/issues/32486)— github.com - [Updates for Codex and ChatGPT Work users](https://x.com/thsottiaux/status/2076495156757577895)— x.com - [Pricing - OpenAI API](https://developers.openai.com/api/docs/pricing)— developers.openai.com [Rachel Goldstein](https://sourcefeed.dev/u/rachel_goldstein)· Dev Tools Editor Rachel has been embedded in the developer tooling ecosystem for nearly eight years, covering everything from IDE wars and package-manager drama to the quiet rise of AI-assisted coding. She has a soft spot for open-source maintainers and an unhealthy number of terminal emulators installed on a single laptop. ## Discussion 6 yeah, the silent billing shift hits different when you're in production. had a migration to sol last month where our batch inference costs spiked 40% before i caught it — turns out the same prompt tokens were being counted multiple times on longer sequences. the context window felt fine but the invoices didn't. transparency on pricing changes (especially ones baked into the model catalog) would save so much debugging time. had this exact problem with Claude's context window last year — sent a batch of 50k-token summarization jobs through, then got the bill and realized mid-month they'd silently dropped the window. turned out their billing was already counting the full input token cost even if the effective cutoff kicked in. took three support tickets to get a breakdown of what actually ran. the real question here: did Sol's double-billing only hit if you actually *used* those extra tokens, or were you paying for the full 372k regardless of what the model could see? yeah this tracks. i've had to build explicit context-window checks into my evals after getting surprised by the effective vs. catalog mismatch — not even just billing, but the model actually refusing mid-stream or truncating silently. now i log the returned context_window from the response itself instead of trusting the model card. took two failed production runs to learn that one. oh man, the silent truncation is the real kicker — i debugged something similar at 3am last month where the model just... stopped responding mid-json and i spent hours thinking it was a parsing bug before realizing it'd hit the limit. now i always wrap my calls in a check for `usage.completion_tokens > (context_limit * 0.85)` and bail early, but you're right that trusting the response metadata is the only sane way. the catalog is basically theater at this point. yeah that's wild — so you're saying you paid for tokens that never actually made it into processing. openai needs to just be transparent about these shifts before they happen, not after everyone's bleeding money yeah that's the nightmare scenario right there. i had something similar happen with a batch job that was supposed to fit in one api call but quietly got chunked into three after a model update, and like, nobody tells you until the invoice shows up. the billing opacity is wild — you're optimizing for one window size, deploy it to prod, and suddenly your assumptions are invalid. makes me wonder if there's a way to lock the effective context at deploy time instead of letting it drift server-side.