My token bill stopped hurting.
That is not a sentence I expected to write in 2026. For the past couple of years, every open source agent project I have contributed to has had the same unspoken tax line item: inference. Not compute for training, not GPU rentals, just the cost of an agent thinking out loud through a task. Agents are chatty by design. They read files, they reason, they retry, they read the same file again because they forgot. Every one of those steps is billed.
Then OpenAI cut GPT-5.6 Luna’s price by 80%, and a whole category of design decisions I had written off as impractical came back onto the table.
Why an 80% cut matters more to agents than to chat
If you are building a chat product, an 80% price drop is nice margin. If you are building an agent, it is structural. Agent workloads scale with the number of steps, not the number of user messages. A single “fix this failing test” request might burn through dozens of model calls: read the test, read the source, form a hypothesis, edit, run, fail, revise, run again.
That multiplier is why so many open source agent projects have quietly shipped with their loops clipped short. Not because short loops work better, but because long loops were expensive to run and expensive to test. I have reviewed pull requests where the actual justification for a design was “we cannot afford to iterate on this.” Nobody writes that in a commit message, but it is there in the diff.
With Luna at a fraction of its former cost, the calculus flips. You can let an agent take twelve steps instead of four. You can run the full regression suite against real model output on every pull request instead of mocking responses and hoping. You can afford to be wrong more often, which is the actual prerequisite for building something good.
The two-model pattern is now the obvious pattern
GPT-5.6 Sol sits at the other end of the family, faster processing at a higher cost. On its own, that is a straightforward tradeoff. Paired with a much cheaper Luna, it becomes something more useful: a routing decision.
Most work inside an agent loop is not hard. It is clerical. Summarizing a file, extracting a function signature, deciding whether a diff touched anything relevant, classifying an error message. These steps need to be correct, not brilliant. Sending them to your most capable, most expensive, fastest model is a habit left over from when there was only one model worth calling.
The shape I keep landing on looks like this:
- Luna handles the high-volume interior of the loop: file triage, summarization, routine classification, first-pass edits.
- Sol gets pulled in when latency actually matters to a human waiting, or when the reasoning is genuinely hard.
- The router itself stays dumb and readable, because a clever router is a debugging nightmare.
None of that is a new idea. What changed is the gap between the tiers. When the cheap model was only somewhat cheaper, routing added complexity for modest savings and most teams skipped it. At an 80% reduction, the savings justify the plumbing, and the plumbing is not that hard.
What this means if you work in the open
Open source agent projects have a specific problem that commercial ones do not: contributors pay their own inference costs. If a maintainer says “run the integration suite before opening a PR,” and that suite costs real money, contributions drop. People do not complain about it. They just do not show up.
Cheaper tokens lower that barrier directly. A first-time contributor can run the tests, see them pass, and open the PR with confidence instead of guessing. Maintainers can run larger evaluation suites in CI rather than sampling. The whole feedback loop tightens, which is where open source gets its actual advantage over closed development.
I would also flag the less comfortable side. When inference gets cheap, the temptation is to solve problems by throwing more model calls at them. That produces agents that work and nobody understands. Cheap tokens are not a substitute for good prompt design, clear tool boundaries, or knowing when to stop the loop. If anything, they remove the cost pressure that used to force those decisions.
Worth rethinking, not worth panicking about
The price-performance ratio across the GPT-5.6 family improved, and if your agent architecture was shaped by 2025 pricing, some of your constraints are now imaginary. Go find them. Look at the places where you capped retries, truncated context, skipped a verification step, or mocked a model response in tests. Some of those were correct engineering. Some were budget decisions wearing an engineering costume.
Sorting one from the other is a weekend of work, and it is probably the highest-value refactor available to most agent projects right now. My loop got longer, my tests got real, and my bill went down. That combination does not come along often.
🕒 Published: