Why OpenAI's 80% Price Cut Won't Move Your Agent Bill

OpenAI cut the price of two of its three current models today. Luna, the cheapest of them, dropped 80 percent, from $1 per million input tokens and $6 per million output tokens to 20 cents and $1.20. Terra, the middle one, dropped 20 percent, from $2.50 and $15 to $2 and $12.^[1]

Sol, the model at the top of the family, costs exactly what it cost yesterday: $5 per million input tokens and $30 per million output tokens, unchanged on OpenAI's own pricing page.^[2]

That third line is the one that decides most invoices. Agent loops reach for the strongest model available, so the workload generating the largest bills is the workload this cut does not touch.

None of that makes the cut fake. It makes it narrow, and the difference matters if you are the one paying.

What did OpenAI change on July 30?

OpenAI reduced the published price of GPT-5.6 Luna by 80 percent and GPT-5.6 Terra by 20 percent, effective July 30, 2026. Sol, the most capable model in the family, kept its price. The lower rates also change how usage is counted in Codex and ChatGPT Work, so subscription quota goes further too.

The company framed it as passing on efficiency gains, and the wires framed it as a response to cost-sensitive buyers and cheap open-weight rivals.^[1] Both readings are fair. Neither tells a buyer whether their own invoice moves.

The announcement is worth reading closely for what it does offer the top tier. Sol did not get cheaper. It got a faster option, and that option is listed at $10 and $60 per million tokens, double the standard rate.^[2]

So the only new thing on the expensive tier costs more per token and buys speed.

Will an 80 percent price cut cut your bill by 80 percent?

Probably not, for two reasons. The cut applies to the cheap and middle models, and long agent runs go to the top one. And per-token price and total spend have been moving in opposite directions for years, because each task now consumes far more tokens than it used to.

Running these models got roughly 280 times cheaper between late 2022 and late 2024, according to Google's DORA research program, and bills went up anyway. That gap has a name and a mechanism, both of which we worked through in why metered AI coding bills are usage drift coming due.

This week supplied a fresh demonstration, and it came from OpenAI.

On July 29, the day before the price cut, the company reset usage limits for every ChatGPT Work and Codex customer, shipped efficiency fixes worth about 18 percent more usage, and explained why quota had been draining faster than people expected.^[3]

That is not a complaint. It is an operating description, and it is the cleanest statement of the mechanism anyone has published this year: same task, more tool calls, longer runs, more tokens.

The bill is the product of price per token and tokens per task. One of those two numbers fell 80 percent today, on two of three models. The other has been climbing on all of them.

Put a plausible shape on it. A coding agent works a ticket on Sol, makes 40 tool calls, and carries its context along the way, so the run consumes something like 400,000 input tokens and 60,000 output tokens. At Sol's unchanged rates that is $2 of input and $1.80 of output, about $3.80 for the task.

That was the number yesterday. It is the number today.

Now let the same agent get a little more willing, in exactly the way OpenAI described this week, and make 48 tool calls instead of 40. The task lands near $4.56. The price per token never moved, and the cost of the task went up 20 percent.

A price that moves 80 percent three weeks after launch was also never a cost floor. It was a positioning choice, which is the reading we gave the pricing side of the AI bubble two weeks ago and would give again today.

Where the price cut is real

On high-volume, low-complexity work, this cut is worth every bit of what it says. Classification, extraction, routing, tagging, summarization, first-pass triage. Any workload made of many short calls rather than a few long agent runs sees the full 80 percent, with no code change at all.

Work the numbers on a support-ticket classifier running on Luna at 5 million input tokens and 500,000 output tokens a month. Yesterday that was $5 plus $3, so $8. Today it is $1 plus 60 cents, so $1.60.

Run a hundred jobs of that shape and the saving stops being a rounding error.

OpenAI made the same call on its own product: automatic code review moved to Luna at roughly a tenth of the previous cost. That is a real workload, moved to a cheaper tier because the work fit the tier.

The test is not whether you use AI heavily. It is whether your heaviest spending is many small calls or a few long runs. If it is the first, today is a genuinely good day, and the move is to go find every job still sitting on a bigger model that never needed one.

There is a middle case worth naming, because it is where most real systems live.

An agent run is rarely one model doing everything. It summarizes a file, classifies a diff, picks which test to run, drafts a commit message, and only some of that needs the strongest model in the family.

Every one of those sub-steps you can route to the cheap tier just got 80 percent cheaper, inside a run whose headline model did not change price at all.

So the thing that got more valuable today is routing discipline. The gap between a well-routed run and a lazy one just widened by a factor of five on every step that fits the cheap tier.

Why does the harness decide the bill, not the token price?

Because most of what an agent spends is set by the loop around the model: how many times it calls a tool, how much context it carries forward, how often it retries, how long it keeps going. The token price sets the unit. The harness sets the count, and the count is where the growth is.

OpenAI's developer account was unusually specific about where the new prices came from.

Four activities are named there. Three of them, request routing, tool use, and context management, belong to the harness rather than the model, and only token generation is really about the model itself. That is our own argument described from the supply side: the harness is where the tokens go, so the harness is where the cost got squeezed out.

It is also where switching costs accumulate, which is the dynamic behind better models arriving inside worse tools. And it is what decides who absorbs the overage when a run goes long, the split we mapped in the metered-versus-included pricing divide.

What should teams do about AI costs?

Four moves, none of which require guessing at the next price change. Measure cost per completed task. Know which tier each workload runs on. Put a hard ceiling on agent runs where the platform offers one. And treat every published price as provisional.

• Cost per completed task is the metric. Cost per token is an input to it and moves independently of it, which is exactly how a cheaper token and a bigger invoice coexist.
• Tier your workloads deliberately. The cut reaches two models out of three, so the answer to "which tier is this job on" decides whether today changed anything for you.
• Cap the run, not just the model. Google's Gemini API now takes a hard total-token ceiling for a managed agent run, so a loop that goes sideways stops at a number you chose instead of a number you discover.^[4]
• Treat published prices as provisional. This one moved 80 percent three weeks after the model launched, and the next one will move on someone else's schedule.

The industry keeps announcing lower prices, and builders keep opening invoices that are flat or higher. Both of those are true at once, and the space between them is the harness. Until you measure the task, you are not measuring the thing you actually pay for.