If you've been living under a rock: OpenAI shipped GPT-5.6 "Sol" on 9 July 2026, the flagship of a three-model family (Luna < Terra < Sol). Anthropic's Fable 5 was the thing to beat. Two weeks later the benchmark blogs have settled into a tidy split, and my actual experience contradicts most of it.
So this is not a leaderboard recap. This is what happened when I pointed both at real production work — a multi-tenant Astro site, a Supabase auth flow, an ads-to-BigQuery pipeline, and a render farm — and paid for every token out of my own pocket.
The part nobody argues about: the price
Sol is roughly half the cost of Fable 5. Not 10% cheaper. Half.
input / output cached in batch
GPT-5.6 Sol $5 / $30 $0.50 $2.50 / $15
Claude Fable 5 $10 / $50 $1.00 $5.00 / $25
per 1M tokensRead that batch row again. If your workload is asynchronous — nightly content generation, bulk classification, a migration sweep across 800 files — you're paying $2.50 in / $15 out versus $5 / $25. On a job that burns 40M input and 8M output tokens, that's $220 versus $400. Same job. Same afternoon.
And the cached-input line matters more than it looks. Long agentic sessions re-send an enormous prompt prefix on every turn. At $0.50 per 1M cached versus $1.00, a day of heavy agent work with a fat system prompt and a large repo context quietly halves again. I've broken the full cost model down in the token price collapse — including the batch maths that turns a $70 job into a $19 one.
The benchmark split, and why it misled me
Here's the honest state of the published numbers, because I'm not going to pretend they all point one way:
- Sol led terminal/agentic benchmarks, general knowledge, cost-per-task, and token efficiency.
- Fable 5 led SWE-bench Verified and SWE-bench Pro, the aggregate intelligence indices, and safety evals.
If you'd shown me only that split, I'd have picked Fable for coding and Sol for everything cheap. That's exactly what I did, and it was wrong.
The problem is what SWE-bench measures: a well-specified patch against a known repo with a passing test as the oracle. That's a closed task. Almost none of my day is closed tasks. My day is "the login works locally but not on the deployed site, figure out why" — an open task with no oracle, where the model has to choose what to look at, notice when its own theory is wrong, and stop.
On open tasks, token efficiency and terminal competence turn out to matter more than patch accuracy on a curated set. Which is precisely the axis Sol won and I discounted.
Where Sol actually pulled ahead in my work
1. It asks the disambiguating question first. The single most expensive failure I get from an agent is confidently building the wrong thing. I asked for a responsive-grid previewer and got a full-screen ad previewer, plus a watcher, plus a livereload server, plus a launcher — a beautifully engineered answer to a question I never asked. Sol asks the one clarifying question up front and then builds. One question kills an hour-long detour.
2. It gets terse under pressure. When something goes sideways I want the fix or silence. What I usually get is apology scaffolding: three paragraphs of "you're absolutely right, let me reconsider my approach" before a single command runs. Sol shuts up and acts. That's not a personality preference — the verbose recovery is billed output tokens, and it's the mode you're in precisely when you're already behind.
3. It stops. "Rebuild on change" means rebuild on change. Not a rebuild pipeline, a file watcher, a stub server, and a launch script. Over-building is the failure mode that looks like effort, and it doubles the surface area you then have to verify.
4. Token efficiency compounds into wall-clock time. Fewer tokens for the same work means fewer turns, less context pressure, and fewer compactions mid-task. Compaction is where agents lose the thread — and every one you avoid is a bug you don't get.
Where Fable 5 is genuinely still the better call
I'm not writing a hit piece. Two things I'd still hand to Fable:
Long, self-directed refactors inside one large codebase. The SWE-bench lead isn't fictional — it reflects something real about holding a big mental model of an unfamiliar repo and producing a patch that doesn't break the neighbours. On a 1M-context window with a gnarly legacy codebase, Fable is the safer bet.
Anything where a wrong answer is expensive and irreversible. The safety and calibration edge shows up as fewer confidently-wrong assertions in domains where I can't immediately verify. For DNS changes, migrations, and money-touching code, I'll pay the premium.
The catch: your switching cost is one line
Here's the thing that should worry Anthropic more than any benchmark. The entire cost of me changing my mind is this:
// before
const client = new Anthropic({ apiKey: env.ANTHROPIC_API_KEY });
const model = 'claude-fable-5';
// after
const client = new OpenAI({ apiKey: env.OPENAI_API_KEY });
const model = 'gpt-5.6-sol';One SDK, one base URL, one model string. If you've built anything resembling a provider layer — and you should have — it's a config value. I keep a thin adapter in every project for exactly this reason, and it has paid for itself twice this year.
That's the real story of 2026: tokens are converging on a spot commodity, and when the buyer's switching cost is a string literal, nobody holds pricing power for long. Premium pricing survives on a capability gap. The gap now resets roughly every quarter, and it doesn't always reset in the same direction.
The verdict
Sol is my default. It's half the price and, on the open-ended work that makes up my actual week, it's better — it asks first, it stops when it's done, and it doesn't narrate its feelings at me while the build is broken. Fable 5 stays wired up for big-repo refactors and anything irreversible, because the safety and long-context edge is real.
But the honest conclusion is less exciting than a tier list: run both, behind an adapter, and re-evaluate every quarter. The model is the engine. The harness you build around it — the verification gates, the cheap always-on watchers, the deterministic hooks — is the car, and it's the part that keeps paying you back on every upgrade for free.
Pick your model on this quarter's evidence, not last quarter's brand. Do not @ me.
Want a provider-agnostic AI layer wired into your own stack so you can swap models on a config change? Book a call or see the work.