GPT-5.6 vs Grok 4.5 vs Fable 5: The Creative Test

GPT-5.6 vs Grok 4.5 vs Fable 5: The Creative Test

The model that supposedly won this comparison doesn't exist. Neither do two of the three names people keep repeating.

That's not a nitpick — it's the whole reason I sat down to write this. A creator ran a genuinely interesting experiment: hand three frontier models the same creative brief, build a GTA-style open world, a Minecraft clone, and a 30-second iPhone ad, all in browser-native Three.js, then see who wins. Good test. Better than another SWE-bench chart, honestly. But the write-up called them "GPT 5.6," "Codeex," and "Claude's Fable," and by the time that framing gets three shares deep, people are making real budget decisions on model names that aren't real and a cost ranking that's flat-out inverted.

So this is a GPT-5.6 vs Grok 4.5 vs Fable 5 comparison with the receipts checked. Same creative angle — because it's the right angle, and page one for this query is nothing but benchmark tables — but with the actual product names, the actual July 2026 rates, and the actual math on what a creative build costs you.

Fair warning on one of those numbers: the "cheapest" model in that test is not the cheapest model. It's not close. I'll get to it.

Let me be straight about whose test this is

Before I analyze a single frame of anyone's Minecraft clone, the disclosure — because I've watched too many people launder a YouTube demo into "I tested this" and I'm not doing it.

I did not run the game builds. I didn't build Neon Burrow, Apex City, or Metro Rush. Those are a creator's outputs from a creator's prompts on a creator's machine, and I have exactly what you have: the footage. What I can't tell you is what the prompts said, how many iterations ran before the take that made the cut, what effort level was set, or what the token bill looked like. Those four unknowns happen to be the four variables that decide the outcome of a test like this. Keep that in your pocket.

What I can speak to first-hand is the part that survives the demo: the models themselves, the rates, and what they cost when you run them for real. I run multi-model agent pipelines most days. I've already done the painful version of the Fable 5 cost lesson — I watched a single task burn $22 and had to rebuild my whole effort-level strategy around it, which I wrote up in detail in my breakdown of cutting Fable 5 usage costs. I've slotted Grok 4.5 into my stack and mapped out why the efficient model beats the smart one more often than anyone admits. That's my ground truth. The builds are someone else's.

So read this as what it is: an analysis layer over a third-party test, plus the verified numbers the test left out. That's less exciting than "I tested all three!" It's also true, and the true version is more useful to you, because the corrections are where the money is.

Starting with the names.

GPT-5.6 vs Grok 4.5 vs Fable 5: the real names and the real rates

Here's the correction table. Everything below is from vendor and pricing documentation as of July 2026, not from the video.

A few of these matter more than spelling.

GPT-5.6 is a family, not a model. The whole Sol/Terra/Luna split went GA on July 9, 2026 with a 1M-token window across all three tiers — the tail end of a gated, geopolitically messy rollout I traced in my read on the GPT-5.6 series and the gated AI frontier. When the test says "GPT 5.6 built a clean open world," the only question that matters is which tier — because that's a 5x price spread between Sol and Luna, and it's the difference between a build that costs pennies and one that doesn't. The video's "three brains you pick from" framing isn't wrong, exactly. It's just missing the names you'd need to actually order one.

Fable 5's effort levels aren't "extra." The API takes low, medium, high, xhigh, max. If you're wiring this into anything, "extra" throws an error. Small thing. Costs you twenty minutes.

@Sites isn't a slash command. It's a plugin you call in a Codex thread when a task should end in a deployment. Codex builds the project, runs it, deploys to OpenAI infrastructure, and hands back a live URL. It launched June 2, 2026, and it's since gone GA for paid subscribers, with Business and Enterprise workspaces still in preview behind admin toggles. Typing /sites gets you nothing.

Now — the correction that actually changes a decision.

The cost ranking in that test is inverted

The video's summary table puts Grok 4.5 at "Cost: Lowest" and calls it the cheapest entry-level access. That is the single most repeated claim about this comparison and it does not survive contact with the price sheet.

Grok 4.5 is $2 in / $6 out. GPT-5.6 Luna is $1 in / $6 out.

Luna is half the price on input and identical on output. There is no reading of those two rows where Grok is "the cheapest." If your workload is input-heavy — long context, big files, lots of re-reading, which describes basically every agentic build — Luna is meaningfully cheaper than the model the test crowned as the budget pick. Even Terra at $2.50/$15 sits within a rounding error of Grok on input.

How did the test get this backwards? Almost certainly by comparing Grok against Sol and calling it a day. Against Sol's $5/$30, sure, Grok looks cheap. But that's comparing the budget model to the other guy's flagship and declaring a pricing win, which is like calling a Civic cheaper than a 911 and concluding Honda is the value brand. Compare tier to tier and the story flips.

Grok's actual pricing edge is elsewhere, and it's real — it's just not the sticker rate:

• Cached input at $0.50/M (a 75% discount) — strong if you're hammering the same context repeatedly.
• Up to $175/month in free API credits through xAI's data-sharing program, the most generous free tier any major provider ships right now.
• Token efficiency. This is the one that actually matters and the one nobody puts on a chart. xAI reported Grok 4.5 using roughly 4.2x fewer output tokens than Opus 4.8 on long coding tasks — about 15,954 average output tokens per task against 67,020. Sticker rate is the tax rate. Token count is the income. A model that's nominally pricier per token can lose to one that simply says less.

There's a catch on the free credits worth knowing before you get excited: it's a data-sharing program. Your traffic trains their model. For a throwaway Three.js game, who cares. For client work under an NDA, that's a conversation with legal, not a free lunch.

And Grok's context window went the wrong direction — 500K, down from the previous generation's 1M. Reports point to xAI expanding back toward 1M, but architect on 500K, because that's what ships today.

So: cheapest input is Luna. Cheapest effective cost on verbose agentic work is probably Grok, once token efficiency compounds. Cheapest for repeated identical context is Grok with caching. "Cheapest" was never one number, and the test flattened three different questions into one wrong answer.

Which brings up the more interesting thing about this experiment — the part I think it got right.

Why building a game exposes what benchmarks hide

Page one for this comparison is a wall of SWE-bench Pro and Terminal-Bench numbers. Here's the reported state of play, and I'll say up front these are largely vendor figures on vendor harnesses, which means treat them as marketing with a methodology section:

Look at that table and try to answer the question you actually have: which one makes a better ad?

You can't. Nothing in there measures it. SWE-bench asks whether a model can resolve a real GitHub issue. Terminal-Bench asks whether it can plan and drive a shell. Both are genuinely useful and both are completely silent on whether a model knows that a sunset needs warm rim light, that an iPhone's chamfer catches a specular highlight along one edge, or that a world without ambient sound feels dead even when every mechanic works.

That's the case for the creative test, and it's why I think the creator was onto something real. A GTA clone in Three.js is a brutal single prompt. It demands, simultaneously: 3D spatial reasoning, physics, state management for a wanted system, a render loop that doesn't collapse, and taste. Miss any one and it shows in about four seconds of footage. There's no partial credit and no way to fake it in the write-up. A benchmark gives you a percentage. A playable build gives you a verdict you can see.

Here's what was observed across the three briefs, reported as observation — not my measurement:

The GTA-style open world. Grok's Metro Rush had the skeleton — cars, police, a wanted level — but ran laggy and felt incomplete. GPT-5.6's Neon Burrow delivered a genuinely stable open world with walk/drive mechanics and a five-star wanted system; clean and playable, no dynamic mood lighting. Fable's Apex City took it on atmosphere — dynamic sunset lighting, better car handling, a world that felt inhabited — at a heavier resource cost and only a two-star wanted system.

Read that last pairing again, because it's the tell. Fable shipped better light and fewer features. GPT-5.6 shipped more system and flatter light. That's not one model being smarter. That's two models making different bets about what "build a GTA-style game" means when the brief doesn't say. Fable optimized for the screenshot; GPT-5.6 optimized for the spec. Both defensible. Neither is a benchmark result.

The Minecraft clone. Grok's Vauilcraft looked correct and was hollow — mobs present but limited, no water. GPT-5.6 nailed the core loop: walking, chopping trees, a working weather system with real-time rain control. Fable was the only one that shipped sound — mobs reacting audibly, plus water and sand.

Sound is the sleeper result of the entire test. Nobody's brief said "add audio." Every scoring rubric in every model eval I've seen ignores it. And it's the single thing that most separates "tech demo" from "game" in the first three seconds. If you want to know what a model believes the job is, look at what it does when nobody asked.

The iPhone ad. Grok distorted the body and reshaped the port — a decent attempt, not an Apple ad. GPT-5.6 landed close: lens and body closely replicated, frames synchronized, recognizably the real thing. Fable produced reflections, lighting, and materials that read like motion-studio work.

Consistent pattern across all three: Fable wins on fidelity, GPT-5.6 wins on mechanics and stability, Grok gives you a foundation to iterate on. That's a coherent finding. It matches the models' general reputations. And it's worth exactly as much as your trust in four unknowns — prompts, iteration count, effort level, and cost — none of which were disclosed.

Especially that last one.

The number the test never showed you

Every one of those builds has a bill attached and not one of them was mentioned. So let me do the arithmetic the demo skipped, because it changes the verdict.

Take a realistic single-shot creative build: a complex Three.js game from a detailed brief. Call it 15K input tokens (brief, context, maybe some reference code) and 40K output (a large single-file build plus reasoning). Rough, but directionally honest.

Fable 5 costs roughly 8x what Luna costs for the same build. And here's the thing the demo can't show you: nobody gets the GTA clone in one shot. Not Fable, not anyone. Real creative work is iterative — you build, you look, you say "the lighting's flat," you go again. Multiply that table by eight iterations and Fable's single-build $2.15 becomes $17, while Luna's is $2.

Now factor in what I learned the expensive way: effort level is a token multiplier, not a pricing tier. Fable 5's per-token rate is fixed at $10/$50 regardless of effort. What effort changes is how many tokens it burns thinking before it answers — and every one of those thinking tokens bills as output, at the most expensive token class Anthropic ships. Crank max on a task that didn't need it and you're paying $50/M for reasoning you threw away. That's how a single task hits $22.

The video's advice is to run Fable at "extra or max" for complex builds. Setting aside that those aren't both real values — that advice, applied by someone who just watched an exciting demo, is how you wake up to a bill you didn't model. Anthropic's own documentation notes that Fable 5's lower effort levels often exceed the xhigh performance of prior models. Blanket max is not a quality strategy. It's a tax you volunteer for.

So the honest cost read: Fable's fidelity win is real and it is expensive, and whether it's worth 8x depends entirely on whether the output ships to a client or dies in your downloads folder. The test declared a winner on a dimension where price wasn't a variable. Price is always a variable.

If you want the full lever-by-lever version of getting that bill down without dropping to a dumber model, the five changes that cut my Fable 5 costs up to 80% is the piece I'd point you at first.

What about deployment — does @Sites decide it?

The test gives GPT-5.6 a real edge here and I think it's the most underrated finding in the whole thing.

@Sites means Codex can build a Three.js game, host it, and hand back a live shareable URL — no hosting account, no deploy pipeline, no DevOps ticket. It runs on OpenAI infrastructure using Cloudflare Workers-compatible tech. For creative work, that loop is genuinely different: prompt → playable link you can send someone. The feedback cycle collapses from hours to minutes.

That's not a model capability. That's a product capability, and it's worth being precise about the distinction, because it's the thing most likely to decide your actual choice. Fable 5 might render a better sunset. If GPT-5.6 gets your build in front of a client in ninety seconds while you're still figuring out where to host Fable's masterpiece, the better sunset lost.

Access reality as of July 2026: GA for paid ChatGPT subscribers with publicly viewable sites; preview for Business and Enterprise, on by default for Business, admin-gated behind RBAC for Enterprise. "Publicly viewable" is doing quiet work in that sentence — check it before you deploy client material.

On the Anthropic side, Cowork covers the workflow half — file access, multi-step execution, MCP connectors, plugins, now with full parity on Windows and running cloud tasks from mobile. I've been running my own morning briefing pipeline on it and wrote up what actually works and what breaks in the Cowork cloud update. It's a strong work system. It is not a one-command public deploy target, and pretending those are the same feature helps nobody.

GPT-5.6 vs Grok 4.5 vs Fable 5: which should you actually use?

No universal winner — the test got that part right, even if it got there partly by luck. Here's the framework I'd actually apply, with price in it:

Reach for GPT-5.6 Luna when you're iterating. Early exploration, throwaway prototypes, twelve variations of the same scene. At ~$0.26 a build it's the cheapest way to find out whether your idea is any good. It is also — say it again — cheaper on input than the model that test called cheapest.

Reach for GPT-5.6 Terra when it's real work with a budget. The everyday workhorse, competitive with GPT-5.5 at half the cost, and the default I'd start from for most production loads. Move up only when you can name what Terra failed at.

Reach for GPT-5.6 Sol when you need mechanics that hold together and a deploy at the end. Best stability-plus-shipping combo in the test, ~91.9% on Terminal-Bench 2.1 via ultra mode's parallel subagents, and @Sites closes the loop. Roughly a third of Fable's cost.

Reach for Grok 4.5 when the work is verbose and repetitive — long agent runs, cached context, the stuff where token efficiency compounds. Its 4.2x output-token efficiency does more for your bill than any sticker rate. Just plan around 500K context and read the data-sharing terms.

Reach for Fable 5 when the output is the product. Client-facing, portfolio-grade, the ad that has to look like a studio made it. When peak quality genuinely beats price — and be honest about how often that's true. Then run it at medium or high first and make it prove it needs more.

The meta-move, and the one that's served me better than any single-model loyalty: iterate cheap, finish expensive. Find the idea on Luna. Build the structure on Terra or Sol. If it's shipping to someone who's paying, run the final pass on Fable. The test's framing — pick your fighter, one wins — is the wrong shape for how this work actually goes. You're not choosing a model. You're choosing a model per stage, and the stage where you need $50/M output tokens is usually the last one.

What I'd need to see before I trusted any of this

Let me point the skepticism at my own analysis too, since I've spent 2,000 words aiming it at someone else's.

Everything above rests on observations I didn't make. Four disclosures would change my read, and until they exist, calibrate accordingly:

1. The exact prompts. A model that "lost" on a vague brief may just have interpreted it differently. Fable's two-star wanted system versus GPT's five-star isn't obviously a capability gap — it might be a prompt-reading gap.
2. The iteration count. One-shot versus best-of-five is a completely different claim. If Fable's sunset took four tries and GPT's flat lighting took one, the ranking inverts on any axis that includes your time.
3. The effort level. If Fable ran at max and GPT-5.6 at default, that's not a model comparison. That's a settings comparison with a model-comparison headline.
4. The token bill per build. Without it, "Fable wins" means "Fable wins at unknown cost," which is not a finding. It's a preference.

I'd also want a re-run on a fresh brief. Every model in this class has been trained on a planet's worth of Minecraft clones and GTA discussion and Apple ad frames. "Build a Minecraft clone" is very close to a memorization probe. Ask for a game that doesn't exist — some mechanic with no Stack Overflow answer — and I suspect the gaps look different. Possibly much smaller. Possibly much larger. That's the test I'd actually want to see, and it's the one I'd have to build myself before I put my name on a verdict.

The three-way creative comparison I'd trust hasn't been run yet. This one is a good sketch of it.

The part worth taking with you

Go back to where we started: the model that won didn't exist, and neither did the price ranking.

That's not a shot at one creator. It's the texture of this entire moment. Models ship weekly now. Names blur. A demo gets clipped, the clip gets a headline, the headline gets a nickname, and three weeks later people are picking infrastructure based on a chain of telephone that started with someone eyeballing a sunset. The creative test underneath was a genuinely good idea — better than the benchmark tables it competes with, because it measured taste, and taste is the thing benchmarks structurally cannot see. It just got published without the four numbers that would make it a finding instead of a vibe.

So here's the thing I'd actually ask you to do, and it takes ten minutes. Before your next model decision, open the pricing page — the real one, the vendor's — and write down the input rate, the output rate, and the context window for every model you're considering. Tier for tier. Not flagship-versus-budget. Then ask what your work is actually made of: is it input-heavy or output-heavy? Iterative or one-shot? Does it ship to a client or die in your downloads folder?

Ten minutes of that beats ten hours of demos. It would have caught the Luna thing instantly.

The models are extraordinary. All three of them. The GTA clone in a single prompt would have been science fiction eighteen months ago and we're now bored by it. But the gap between "this is amazing" and "this is what I should run on Tuesday" is filled entirely with arithmetic, and nobody's clipping that for YouTube.

Do the arithmetic. It's the only part of this that's actually yours.

Let's Work Together

Looking to build AI systems, automate workflows, or scale your tech infrastructure? I'd love to help.

• Fiverr (custom builds & integrations): fiverr.com/s/EgxYmWD
• Portfolio: mejba.me
• Ramlit Limited (enterprise solutions): ramlit.com
• ColorPark (design & branding): colorpark.io
• xCyberSecurity (security services): xcybersecurity.io