September 25, 2026. The biggest AI story of the week was a price cut. On September 22 OpenAI released GPT-6 Sol and GPT-6 Luna at half the per-token price of the GPT-5.6 models they replace: Sol at $2 per million input tokens and $10 per million output, Luna at 10 cents and 50 cents. Every launch write-up quoted those four numbers. Almost none quoted the second half of OpenAI's own pricing table, where the same models have a second column of prices that apply the moment a request passes 272,000 input tokens. Cross that line and the whole request, not the overflow, is billed at double the input and cache rates and one and a half times the output rate. For an agency running agents that stuff CRM histories, call transcripts or document piles into the prompt, that second column is the one that decides the invoice.
What the pricing table actually says
The facts below are read from OpenAI's pricing page and the three GPT-6 model pages on September 25, 2026. Each model page carries the same sentence: prompts with more than 272K input tokens are priced at 2x input and cache rates and 1.5x output for the full request.
- GPT-6 Sol costs $2.00 input, $0.20 cached input, $2.50 cache writes and $10.00 output per million tokens on the short context tier. Past 272K input tokens the same request bills at $4.00, $0.40, $5.00 and $15.00.
- GPT-6 Luna moves from $0.10, $0.01, $0.125 and $0.50 to $0.20, $0.02, $0.25 and $0.75.
- GPT-6 Astra, released September 3, moves from $10.00, $1.00, $12.50 and $50.00 to $20.00, $2.00, $25.00 and $75.00.
- The threshold is not new, the models are. The GPT-5.5 and GPT-5.4 rows on the same table are labelled "under 272K context length" with a long context column beside them. What changed this week is that the half-price models everyone is migrating to inherit the same cliff, and GPT-5.6 and later also add cache writes at 1.25x the input rate, which the cliff doubles too.
- The cliff applies to every processing tier. Batch and Flex halve both columns, Fast mode doubles both, so a Fast mode Sol request over 272K tokens pays $8.00 per million input and $30.00 output.
- The window is far bigger than the cliff. All three GPT-6 models list a 1,050,000 token context window and 922,000 maximum input tokens, so a request can run to 3.4 times the threshold without an error. The API will not stop you. The bill will.
Why one extra document doubles the bill
Because the higher rate covers the full request, the last few thousand tokens before the line are the most expensive tokens OpenAI sells. Take a GPT-6 Sol call with 2,000 output tokens. At 272,000 uncached input tokens it costs about $0.56. At 275,000 input tokens it costs $1.13. Those 3,000 extra tokens, about one page of a contract, cost 57 cents, which works out to roughly $189 per million tokens against a list price of $2. On Astra the same shape is worse in dollars: a 272K request with 4,000 output tokens is $2.92, a 300K request is $6.30. On Luna it is 2.8 cents against 5.75 cents, small per call and large across a batch of ten thousand.
Caching does not rescue you, because the cached input rate doubles as well. A Sol request that reuses a 250,000 token cached prefix and adds 30,000 new tokens costs about $0.13 under the line. The same request with the same cache hit costs $0.25 over it. Writing the cache is dearer too: a 300K prefix written on the long context tier costs $1.50 on Sol, against 68 cents for a 272K prefix written on the short tier. OpenAI's prompt caching guide is explicit that writes cost 1.25x the uncached input rate and reads 0.1x, and both multiply by two past the threshold.
What a month of it looks like
Agencies rarely make one call. An agent that handles 1,000 requests a day at 280,000 input tokens each, with 2,000 output tokens, costs about $1,150 a day on GPT-6 Sol. Trim the same agent to 272,000 tokens and it costs $564 a day. Over thirty days that is $34,500 against $16,920, a difference of $17,580 for 8,000 tokens per request that most operators never notice they are sending. Cloud cost tracker CloudZero flagged the same mechanism on Astra's launch: any prompt past 272K reprices the entire request, not just the overflow.
Where SMB agents cross the line without meaning to
272,000 tokens is roughly 200,000 words of English text, using the usual three quarters of a word per token estimate. That sounds enormous until you look at what agent builders actually put in a prompt. A CRM export of one account's full activity history, pasted whole. A quarter of call transcripts for a coaching client. A property file with every inspection report attached. A multi-step agent that appends each tool result to the conversation and never compacts it, so request forty carries the output of requests one to thirty-nine. Each of these drifts upward, and none of them throws an error at 272K. A legal intake flow is the clearest example: an AI intake agent for a law firm that loads the prospective client's uploaded documents to run a conflict check can pass the threshold on a single large matter, and if it does, that one intake bills at double the rate the firm was quoted.
How to use this
First, measure. Every OpenAI response carries usage figures for input, cached and output tokens. Log them per request and alert at 250,000 input tokens, not at the error boundary that never comes. Second, retrieve instead of stuffing. Pull the ten relevant records into the prompt, not the account's entire history; a retrieval step on Luna costs a fraction of a cent and keeps the main Sol call on the cheap tier. Third, compact long-running agents. Summarise completed steps and drop raw tool output once it has been used, so the conversation stops growing. Fourth, if a job needs more than 272K tokens, split it into two calls under the line: two 200K requests on Sol cost about $0.80 in input tokens, one 400K request costs $1.60. Fifth, put the threshold in the client's pricing. Our agent cost guide and the cached input pricing analysis both assume short context rates; a quote built on them should say so, and should say what happens if the client's documents blow past the line.
What it means for operators
The headline this week is that frontier intelligence got 50% cheaper, and for most SMB workloads that is simply true. The trap is that the pricing page now has two columns and the cheaper column has a hard edge at 272,000 input tokens. An agent that sails past it does not fail, it just costs twice as much per input token and half again per output token, and it does so for the whole request. Operators who build with retrieval, compaction and a usage alert keep the discount. Operators who treat a million token window as a licence to paste everything pay the 2026 equivalent of a roaming charge. If you want an AI automation build where the token budget is designed rather than discovered on the invoice, that is the work our engineers do before the first prompt is written, and you can hire an AI engineer who prices the cliff into the architecture from day one.
Frequently Asked Questions
272,000 input tokens. OpenAI's GPT-6 model pages state that prompts with more than 272K input tokens are priced at 2x the input and cache rates and 1.5x the output rate, and the higher rate applies to the full request, not only the tokens above the line.
On the standard tier GPT-6 Sol bills $4.00 per million input tokens, $0.40 cached input, $5.00 cache writes and $15.00 output once a request passes 272K input tokens, against $2.00, $0.20, $2.50 and $10.00 below it. Batch and Flex halve both columns and Fast mode doubles them.
No. The cached input rate doubles past the threshold as well, from $0.20 to $0.40 per million on GPT-6 Sol, and cache writes go from $2.50 to $5.00. Caching still cuts the bill, but it does not move the request back to the short context tier.
No. GPT-6 Astra, Sol and Luna list a 1,050,000 token context window and 922,000 maximum input tokens, so a request can be 3.4 times the pricing threshold and still succeed. The only signal that you crossed the line is the price.
Log input tokens per request and alert at about 250,000; retrieve the relevant records instead of pasting whole histories; summarise and drop used tool output in long-running agents; and split jobs that genuinely need more context into two requests under the threshold, which costs half as much in input tokens as one request over it.
The threshold appears on the GPT-5.5 and GPT-5.4 rows of the same table, so it predates GPT-6. What is new this week is that the half-price GPT-6 Sol and Luna models released on September 22, 2026 carry the same cliff, and that GPT-5.6 and later add cache write charges that double past it.