You're Using GPT 5.6 Sol Wrong (7 Rules)

Sol behaves differently from Fable, and using them the same way gets you the worst of both. Here are the 7 rules that fix it.

You're Using GPT 5.6 Sol Wrong (7 Rules)

Everyone's asking if Sol finally beats Fable. Wrong question. After four days running it across our own products and client work, the real answer is that Sol behaves differently from Fable, and using them the same way means you get the worst of both.

GPT 5.6 Sol shipped, and the whole conversation is "is it finally the Claude-killer?" That framing misses the point. We ran Sol for four days across our own products, including our community platform, and on client projects, and what we found wasn't better-or-worse. It's that Sol behaves differently from Fable. It finished in one run what normally takes Fable several conversations. It also kept taking actions in places where Fable would stop. And in reviews, it inspected parts of our app Fable had always refused to touch.

Here's the one-line model of the whole thing: Fable is better at deciding what to do, and Sol is better at carrying it through to the end. Every rule below follows from that.

Quick context on the release. GPT 5.6 shipped as three models: Luna and Terra (smaller, cheaper) and Sol (the capable one). The pitch is efficiency, meaning more work per token and more per dollar. OpenAI claims Sol beats Fable on coding and long-running tasks using fewer tokens and finishing in about half the time, at roughly equal intelligence for less cost. The Codex desktop app is now folded into the ChatGPT app (still reachable via the Codex CLI), and there's a new multi-agent mode called Ultra.

Rule 1: Set a boundary before you let it run

Fable usually stops or refuses when an action looks risky. Sol doesn't. It keeps going until the task is done. In one of our tasks it hit files and running processes in its way, so it deleted the files and killed the processes without asking. Fable would've stopped there. Others testing Sol saw worse, with one case wiping nearly every file on someone's Mac.

So before you leave it running, fence it in:

• Ask Codex to create a separate Git branch and commit the working version first. The branch doesn't limit what Sol can touch. It gives you a clean checkpoint to undo from.
• In the Codex config, set approval policy to never and sandbox to workspace-write. "Never" lets it work without waiting on you, and "workspace-write" keeps it inside the project folder. Don't pick full access, because that opens files outside your app.

Then flip the same trait into an advantage. When we handed Sol a full feature in AI Labs Pro, it stayed on the goal and built the whole thing in one pass. That's work that normally takes us several rounds with Fable, and it was faster.

Takeaway: Fence Sol in with a branch and workspace-write, then hand it the work you'd normally split across several sessions: a full feature, a full review, anything spanning the product.

Rule 2: Point it at the reviews Fable won't do

Sol reviews things Fable refuses to touch. To be clear, this isn't the occasional routing to Opus 4.8 (which mostly happens when you ask Fable to explain its reasoning, or the task involves something harmful). It's the safety restrictions built into Fable itself. We already run these reviews with Fable, so we know exactly where it stops. Sol didn't stop there. It kept reviewing the parts Fable always skipped, and it found real problems in them.

That's the first reason it reviews better. The second is that it can open the finished app and test it itself, which is Rule 3.

Rule 3: Lean on computer use for anything you can see or click

When a task involves something on screen, Sol reaches for computer use automatically. Inside the ChatGPT app it works across multiple tabs, uses sites you're already logged into, and downloads files, so it moves through the actual screens instead of only reading your project files. GPT models lead on computer use, so this is one of Sol's strongest areas.

What that looked like for us: we built a store feature where behavior changes by account. An admin sees different options than a regular member, and someone on the $20 plan can do different things than someone on the $100 plan. Checking it once isn't enough. Sol ran the full journey for every account type. It logged in as each, checked access, purchased a product, and repeated across every part of the app that changes by account.

Takeaway: When a feature behaves differently for different users, run the review in a new Sol conversation after the build. Give it the account types and what each should be able to do, then ask it to complete every journey end to end and report only the problems it can reproduce.

Rule 4: Strip prompts down to what actually changes the result

This one applies to Fable and Sol both, because newer models work out the basic steps themselves. The goal isn't shortest-possible prompts. It's removing instructions that don't change the outcome and making the ones that do more precise.

Keep the outcome, the real limits, and what has to be true before the task is done. Drop the noise. Don't map every folder when they're named clearly, don't repeat a rule in three places, and don't narrate every step.

We tested this on our animation system. We kept the working code the model copies (a concrete pattern beats a description) and the exact background and accent colors (so it doesn't invent new ones each run). Then we found what to cut: a rule telling it to save the finished animation in the output folder. We removed the line, reran, and Sol still saved it there. The instruction wasn't doing anything.

Takeaway: The test for any line in your prompt or skill: remove it, rerun the same task, and check if the result changes. If it's still reliable, the line probably isn't earning its place. (Keep a few if you swap in weaker models that need the hand-holding.)

OpenAI reports this kind of cleanup improved their own results by 10 to 15% while using 41 to 66% fewer tokens.

Rule 5: Keep Ultra off for now

Ultra is Sol's multi-agent mode. It splits the task and runs several agents at once. OpenAI positions it for the hardest work, but every agent spends its own tokens, so it burns usage much faster. When we ran Ultra on the same work as regular Sol, the finished quality was about the same. Usage went up, results didn't. OpenAI's own numbers show roughly a 2 to 3 point difference. Not worth the spend yet.

Rule 6: On a subscription, keep Sol as the default

If you're building in Codex, don't route smaller tasks to Terra or Luna. They're cheaper through the API, which matters when your product pays per request. But on a Codex subscription you're working within your plan's usage, so the math changes. We routed the lighter work to the smaller models. They finished, but the quality drop meant we spent more time fixing results than we saved. We went back to Sol for the whole task.

Takeaway: With per-request billing, smaller models can pay off. On subscription usage, keep Sol as default, because correction time costs more than you save.

Rule 7: Use Fable to decide, Sol to build

The cleanest way to position them: Fable is a preview of where coding models are heading, and Sol is the most complete version of how they work today. And speed shapes the workflow more than benchmark scores do. Fable, Opus, and Sonnet all take longer on the same work, while Codex models are much faster (and that's without fast mode, which costs 1.5 times the usage). That speed is the main reason we've been reaching for Codex models more.

So split the jobs:

• Fable, before the build. Use it when you need to decide how the app should work, how a feature should be structured, or why a hard problem keeps recurring.
• Sol, once the decisions are made. Use it for the full feature, the long-running work, the review, and anything that needs to be checked on screen.

FAQ

Is Sol smarter than Fable? No. On hard problems without a clean solution, Fable still finds the better answer. Sol's edge is executing once the decision is made. It carries a task through without you pulling it back on track.

What settings keep Sol from doing damage? A working Git branch as a checkpoint, approval policy set to never, and sandbox set to workspace-write. Avoid full access.

Is the multi-agent Ultra mode worth it? Not right now. It burns tokens across several agents for roughly the same result, about 2 to 3 points in OpenAI's own numbers.

Should I route small tasks to Terra or Luna to save usage? Only if you're billed per request via the API. On a Codex subscription, the quality drop costs more correction time than it saves, so keep Sol as default.

Why does Sol review better than Fable? It isn't blocked by Fable's built-in safety restrictions on certain parts of a codebase, and it can open and test the finished app itself via computer use.

Resource prompt

Paste this into Codex before a long autonomous build so Sol is fenced in and aimed correctly:

Before you start, set up a safe checkpoint and boundaries:

1. Create a new Git branch and commit the current working version as a checkpoint.

2. Confirm you are running with sandbox = workspace-write (project files only), not full access.

TASK: [the full feature or review; give it the whole thing, not a fragment]

DONE WHEN: [the conditions that must be true for this to be finished]

HARD LIMITS: [anything you must NOT touch or change]

If this is a review of a feature that behaves differently per user:

- Account types: [e.g. admin / member / $20 plan / $100 plan]

- What each should be able to do: [...]

Use computer use to complete every journey end to end for each account type, and report only the problems you can reproduce.

The skills, workflows, and review setups we use across our own products and client builds live inside AI Labs Pro.