The useful answer to "GPT-5.6 Sol or Claude Fable 5?" is not a leaderboard position. It is a division of labor.
After a day of side-by-side work, Nate Herk described Fable as the better manager and Sol as the better worker. That framing survives the other two tests in this post, but with an important correction: Pat Simmons saw Sol win much of his knowledge-work set, while Theo's enormous early-access run showed that Sol can keep shipping for hours without proving that every large artifact is production-ready.
Video credit: Nate Herk | AI Automation. Follow Nate on X.
Source Note
This post combines three creator tests with current official documentation. OpenAI's GPT-5.6 launch page and developer docs are the source of record for Sol pricing, availability, Programmatic Tool Calling, max, ultra, and OpenAI-published benchmarks. Anthropic's Fable product page and Claude Platform model guide are the source of record for Fable pricing, availability, context, refusals, and fallback behavior.
The YouTube results are creator-reported experiments, not controlled benchmarks. They remain useful because they expose behavior that benchmark tables miss: taste, persistence, over-engineering, harness efficiency, refusal rates, and how much human review a large result still needs.
Link Map
| Resource | Status | What it adds |
|---|---|---|
| Nate Herk: Sol vs Fable | Hands-on comparison | Three agentic builds, one-off API tasks, cost, speed, reliability, and the manager-versus-worker framing. |
| Theo: six weeks with GPT-5.6 | Early-access field report | 67 projects, long-running Codex work, Rust rewrites, native apps, CI, PR review, and a useful warning about prototype size versus verified completeness. |
| Pat Simmons: no-hype Sol review | Creator test suite | Ten builds across 3D, games, writing, decks, branding, and knowledge work against Fable, Opus 4.8, and GPT-5.5. |
| OpenAI GPT-5.6 launch | Official | General availability, official pricing, model tiers, benchmark tables, max, ultra, design, computer use, and knowledge work. |
| OpenAI model guidance | Official docs | Current API model-selection guidance before changing production defaults. |
| Programmatic Tool Calling | Official docs | Why Sol can coordinate tools and compress intermediate results more efficiently in tool-heavy workflows. |
| GPT-5.6 safety report | Official safety source | Capability and safeguard context for cyber, biology, long-running agents, and misuse monitoring. |
| Claude Fable 5 | Official | Fable positioning, API pricing, availability, agent use cases, and fallback behavior. |
| Prompting Fable 5 | Official docs | Anthropic's guidance for long-horizon autonomy, ambiguity, delegation, code review, and extended runs. |
The Short Answer
If the task is ambiguous, strategic, creative, or needs a model to decide what the work should become, Fable is still a strong first call. If the task is defined and needs to be implemented, checked, or repeated economically, Sol is the stronger default to test.
| Need | First model to test | Why |
|---|---|---|
| Ambiguous product direction | Fable 5 | Stronger creator-reported judgment, pushback, brainstorming, and orchestration. |
| Fast implementation and verification | GPT-5.6 Sol | Lower list price, strong computer use, efficient tool coordination, and fewer tokens in several reported runs. |
| High-volume repeatable work | Terra or Luna after Sol | Prove the workflow with Sol, then test whether a cheaper family tier preserves acceptance quality. |
| Creative writing and campaign direction | Fable 5, then compare Sol | Nate preferred Fable, but Pat's knowledge-work tests show the result can flip by prompt and artifact. |
| Long-running build with a measurable spec | Both | Fable may architect; Sol may execute. A review model should verify completion either way. |
Official Baseline: Price And Mixed Benchmarks
At official API list prices checked on July 10, 2026, GPT-5.6 Sol costs $5 per million input tokens and $30 per million output tokens. Claude Fable 5 costs $10 input and $50 output. Sol is therefore half the input price and 40% cheaper on output before prompt caching, tools, retries, and harness behavior enter the calculation.
OpenAI's own launch table does not support a simple "Sol wins everything" headline. OpenAI reports Sol ahead on the Artificial Analysis Coding Agent Index, Terminal-Bench 2.1, and DeepSWE. The same table shows Fable ahead on SWE-Bench Pro and slightly ahead on GDPval-AA v2. That split looks a lot like the creator evidence: Sol is exceptionally efficient and decisive, while Fable remains dangerous on hard, open-ended work.
| Officially published comparison | GPT-5.6 Sol | Claude Fable 5 | Read carefully |
|---|---|---|---|
| Artificial Analysis Coding Agent Index v1.1 | 80 | 77.2 | Sol leads in OpenAI's launch table. |
| Terminal-Bench 2.1 | 88.8% | 83.1% | Sol leads; Sol Ultra is listed higher again at 91.9%. |
| SWE-Bench Pro | 64.6% | 80.0% | Fable leads strongly on this software-engineering evaluation. |
| GDPval-AA v2 | 1,747.8 Elo | 1,759.6 Elo | Fable edges Sol on finished professional artifacts. |
These figures are reproduced from OpenAI's July 9 launch table. Benchmarks depend on harness, reasoning setting, tool budget, prompt, and evaluation method. They are a starting point for testing, not a purchasing decision by themselves.
Nate Herk: Fable Manages, Sol Ships
Nate's test is the cleanest direct comparison in the three videos. He ran Fable through Claude Code and Sol through Codex on three open-ended visual builds, then compared one-off API tasks.
His reported results show why quality and unit economics have to be read together:
- On the first creative build, Nate preferred Fable. The reported run cost was about $14.22 for Fable versus $4.50 for Sol, with roughly 90,000 versus 31,000 output tokens.
- On the scroll-driven interactive site, he again preferred Fable's result. Fable reportedly took about 23 minutes and cost $19.24; Sol took roughly seven minutes and cost a little over $1.
- On five different visual worlds, Nate gave Sol the win. Fable reportedly took 15 minutes and cost about $15; Sol took seven minutes and cost about $1.
- Across a separate batch of quick one-off API tasks, he reports Sol winning 24 to 3 and costing $16 versus $63 for Fable. He says many Fable losses came from refusals rather than lower answer quality when it did answer.
The lesson is not that Fable is "twenty times better" or that Sol is "twenty times cheaper" in general. It is that Fable often spent more tokens exploring and polishing an ambiguous idea, while Sol moved quickly toward a verifiable deliverable. Sometimes the extra exploration improved the artifact. Sometimes it was unnecessary.
Nate's final mental model is useful: Fable for reasoning, judging, advising, brainstorming, and orchestration; Sol for shipping, computer use, testing, devil's-advocate review, and execution. I would treat that as a routing hypothesis to test, not a permanent model identity.
Theo: Sol Can Work for Hours, But Output Size Is Not Completion
Video credit: Theo - t3.gg. Follow Theo on X.
Theo's test is not a normal buyer benchmark. He reports using between $180,000 and $240,000 of inference during roughly six weeks of early access across 67 projects. He explicitly says that spend is not a realistic normal use case.
What makes the video valuable is duration. Theo describes single threads running for more than 20 hours, a native SwiftUI rewrite, CI and release workflows, PR review, authentication work, a Rust rewrite of a Hermes-style agent, and a TypeScript-to-JavaScript transpiler written in Rust.
His strongest positive observation is persistence: GPT-5.6 understood intent better than GPT-5.5 and could keep working without losing the thread. That is exactly the kind of improvement that changes agent economics because fewer resets mean less duplicated context and less human babysitting.
His strongest caution is even more useful. One Rust compiler experiment grew to roughly 195,000 lines across 29 crates. A later Fable review judged it to be a broad prototype with a narrow verified slice, perhaps 5% of the way to a proper replacement. The artifact was enormous. The proven product was not.
Pat Simmons: Sol Makes a Strong Knowledge-Work Case
Video credit: Pat Simmons. Follow Pat on X or visit PerSimmons Studio.
Pat ran ten builds against Fable 5, Opus 4.8, and GPT-5.5: a Rubik's Cube solver, a 3D apartment, an interactive Milky Way, a shooter, a cinema knowledge graph, a graphic novel, a text adventure, a YouTube intro, a PowerPoint, and a Spirit Airlines rebrand.
The results moved around. Fable won some ambitious coding and 3D tasks. Sol won several knowledge-work and design-heavy outputs, including Pat's preferred PowerPoint and rebrand. GPT-5.5 and Opus also surprised him on individual tasks. That instability is the point: one prompt can reverse a confident model ranking.
Pat's final recommendation was close to Nate's, but not identical. He saw Fable as the better architect for hard coding and Sol as a compelling daily driver for knowledge work. His preferred system was model-agnostic: let Fable orchestrate when the task deserves it, let Sol handle substantial execution and professional artifacts, and use cheaper models for the rest.
The Harness Caveat
Nate's most important methodological caveat is easy to miss: the comparison was not only Fable versus Sol. It was also Claude Code versus Codex.
A harness changes how a model behaves through context management, tool definitions, browser and computer use, subagents, compaction, retries, testing policies, and when outputs return to the model. OpenAI's Programmatic Tool Calling can process intermediate tool results without flooding the main context. Claude Code has its own long-run scaffolding, subagent behavior, effort controls, and fallback handling. A faster or cheaper run may therefore reflect both model training and harness design.
For a fair internal eval, separate three questions:
- Model quality: compare the APIs with the same prompt, tools, and acceptance criteria.
- Productivity surface: compare Codex and Claude Code as complete products on the workflow you actually use.
- System economics: compare final accepted output, including retries and human review, not the first response.
Practical Routing Guide
| Work type | Recommended route | Review gate |
|---|---|---|
| Product strategy or unclear business problem | Fable first; Sol challenges and operationalizes | Human approves the problem, buyer, and definition of done. |
| Large greenfield build | Fable architects; Sol implements bounded workstreams | Tests, browser walkthrough, security review, and independent code review. |
| Bug fix or scoped feature | Sol first | Reproduction test, regression suite, and diff review. |
| Deck, spreadsheet, report, or web artifact | Sol first; Fable for difficult narrative or judgment | Facts, formulas, source citations, visual hierarchy, and audience fit. |
| Creative campaign or brand direction | Fable generates directions; Sol produces variants and assets | Human taste, brand system, legal checks, and final selection. |
| High-volume extraction or transformation | Start Sol, then test Terra or Luna | Sample-based accuracy checks and exception queue. |
| Cybersecurity or sensitive automation | Use the approved model and access path for authorized defensive work | Scope authorization, logs, refusal handling, least privilege, and human approval. |
Fable API integrations also need explicit refusal handling. Anthropic documents `stop_reason: "refusal"` as a successful HTTP 200 response and provides fallback paths. Do not silently assume the model named in your request completed the work. Log the actual model, fallback, cost, and reason.
A Seven-Task Eval Before You Pick a Default
Build a small eval from work you already do. Seven tasks are enough to expose meaningful differences without turning model selection into a research project.
- One ambiguous planning task.
- One scoped bug fix with a failing test.
- One visual frontend that must match a reference.
- One long document or spreadsheet deliverable.
- One browser or computer-use workflow.
- One repetitive API task run at least 20 times.
- One adversarial review where the model must find flaws in another model's output.
Record the same fields for every run: model, harness, reasoning level, prompt version, elapsed time, input tokens, output tokens, tool calls, retries, refusals, human review minutes, defects found after delivery, and whether the result was accepted.
The winning model is the one with the lowest cost per accepted result at the quality level your workflow needs. Sometimes that will be Fable. Sometimes it will be Sol. Often the best answer will be a small routing table instead of one permanent default.
Sources
- Nate Herk: I Tested GPT 5.6 Sol vs Fable 5. What You Need To Know.
- Nate Herk on YouTube and X
- Theo - t3.gg: So I've been using GPT-5.6 for a while
- Theo on YouTube and X
- Pat Simmons: GPT 5.6 Sol No-Hype Full Review and Testing
- Pat Simmons on YouTube, X, and PerSimmons Studio
- OpenAI: GPT-5.6 - Frontier intelligence that scales with your ambition
- OpenAI API: current model guidance
- OpenAI API: Programmatic Tool Calling
- OpenAI Deployment Safety: GPT-5.6
- Anthropic: Claude Fable 5
- Claude Platform: Fable 5 models, pricing, refusals, fallback, and billing
- Claude Platform: Prompting Claude Fable 5