When GPT-5.6 Sol landed on 9 July 2026 at half the price of Claude Fable 5, most of the coverage treated it as a scoreboard update. It isn't. A 50% price cut doesn't make the same projects cheaper — it makes a whole category of projects exist that didn't before.
I've spent two weeks re-costing my own pipelines against the new numbers. Here's what actually moved.
The four prices that matter (not one)
Everyone quotes the headline in/out rate and stops. There are four rates, and the two nobody quotes are where the money is:
input output cached in batch in/out
GPT-5.6 Sol $5 $30 $0.50 $2.50 / $15
Claude Fable 5 $10 $50 $1.00 $5.00 / $25
per 1M tokensCached input is 10× cheaper than fresh input on both providers. Batch is 50% off again on both. Stack those two discounts against the cheaper base rate and the spread between a naive integration and a tuned one is roughly 20× — far bigger than the gap between the two vendors.
Which means the interesting question was never "which model is cheaper". It's "am I paying the fresh-input, real-time rate for work that could be cached and batched".
The workload that just flipped
Concrete example from this site. I wanted every one of ~880 blog posts audited for a weak meta description, a missing FAQ block, and a heading structure that doesn't match the target keyword. Call it 4k input tokens per post and 800 output.
880 posts x 4,000 in = 3.52M input tokens
880 posts x 800 out = 0.70M output tokens
Fable 5, real-time: 3.52 x $10 + 0.70 x $50 = $70.20
Sol, real-time: 3.52 x $5 + 0.70 x $30 = $38.60
Sol, batch: 3.52 x $2.50 + 0.70 x $15 = $19.30$70 versus $19. At $70 I think about it, scope it down to the top 100 posts, and do it once. At $19 I run it every month and stop thinking about it. That's not a discount — it's a different habit.
And this is a small corpus. Scale it to a real content operation, a support-ticket backlog, or a product catalogue and the same flip happens at every size.
The money pattern: a provider adapter you write once
You cannot exploit any of this if your model choice is hard-coded across forty files. The single highest-ROI thing in your AI stack is a boring adapter with one job: make the model a config value.
// lib/ai.ts — one seam, two providers, zero call-site churn
type Job = { system: string; user: string; batch?: boolean };
const ROUTES = {
cheap: { provider: 'openai', model: 'gpt-5.6-luna' },
default: { provider: 'openai', model: 'gpt-5.6-sol' },
careful: { provider: 'anthropic', model: 'claude-fable-5' },
} as const;
export async function run(tier: keyof typeof ROUTES, job: Job) {
const { provider, model } = ROUTES[tier];
return provider === 'openai'
? openai(model, job)
: anthropic(model, job);
}Now a price change, a new release, or a bad week from one vendor is a one-line edit. I've re-pointed this seam twice in 2026 and neither move touched a single call site.
The second half of the pattern is tiering by task, not by vibe. Most calls in a real system are not hard:
- cheap — "did anything in this log look like an error?", classification, tagging, extraction. A small model nails these and costs a rounding error.
- default — the actual work. Drafting, refactoring, multi-step agent turns.
- careful — irreversible or expensive-if-wrong. Migrations, money, anything customer-facing that ships unreviewed.
I audited my own usage and found I'd been running the flagship on tasks a small model handles perfectly — watching a dev-server log for the strings error|failed|cannot|undefined. That's a grep with opinions, and it belongs on a cheap always-on watcher. It does not need a frontier model, and paying frontier rates to stare at a file is the most common waste I see in AI stacks.
Prompt caching is the discount you're probably leaving on the table
Agentic sessions re-send an enormous, near-identical prefix every turn: system prompt, tool definitions, project rules, repo context. Fresh, that prefix is full price on every single turn. Cached, it's a tenth.
Two rules to actually get the hit rate:
Put the stable stuff first, the volatile stuff last. Caches match on prefix. One changing token near the top invalidates everything after it. So: system prompt → tool defs → project rules → retrieved docs → then the user's turn. If you're injecting a timestamp or a request ID at the top of your system prompt, you have a 0% cache hit rate and a very expensive bug.
Keep the prefix byte-identical. Rebuilding the prompt with a different key order, a re-serialised JSON blob, or a trailing-whitespace difference reads as a different prefix. Serialise it once, deterministically, and reuse the string.
The catch: cheaper tokens invite more tokens
Here's the trap, and I walked straight into it. When the marginal cost of a model call drops, the discipline to not make the call drops with it. I caught myself spinning up parallel sub-agents for work that was one grep, and leaving verbose agents running because "it's only a few cents".
Two guardrails that fixed it for me:
Compress the comms. My default output mode is deliberately terse — abbreviations, arrows for causality, fragments, one word where one word does, full technical accuracy preserved. It cuts roughly 75% of output tokens, and output is the expensive side of the ledger at 6× input. The biggest single win is right before dispatching parallel sub-agents, because their output flows back into the main context and gets re-billed as input on every subsequent turn.
Cap the loop. An agent with a cheap model and no iteration ceiling is a subscription to nothing. Hard-limit turns per task and make the model report what it couldn't finish, rather than discovering the spend afterwards.
There's a structural version of this too: inference is a variable cost that scales with usage. More success means more GPU spend. That's a utility's margin profile, not a software company's — which is why the price war has further to run and why nobody's premium is safe.
The verdict
Half-price frontier tokens don't make your existing AI features cheaper so much as they change your threshold for what's worth automating at all. The corpus-wide audit, the nightly content pass, the "re-check every record" job you shelved on cost — go back and re-run the numbers, because a lot of shelved ideas are now $20 jobs.
Then do the three unglamorous things: put a provider adapter behind your calls, route by task tier instead of habit, and order your prompts so the cache actually hits. Those three outlive whichever model is winning this quarter — and something will be winning next quarter.
Cheap tokens are only cheap if you're not paying flagship rates to watch a log file.
Want your AI spend audited and a provider-agnostic layer wired in so you can swap models on a config change? Get in touch, or browse the work first.