Video summary

Fable 5 vs GPT-5.6

Main summary

Key takeaways

Technology

Overview

The video compares Anthropic’s “Claude” line (referred to as “Soul” / “GPT-5.6”) vs OpenAI’s “Fable 5” for:

  • Coding workflows
  • Agent/tool usage
  • Model behavior in practice

Overall conclusion (speaker’s take):

  • Fable 5 is preferred when you want clean changes to land (better mergeability, UI/design taste, fewer hallucinations).
  • Soul (Claude/GPT-5.6) is preferred for cost-efficiency, speed, and long-running “agent/goals” work.

1) Community debate / access patterns

  • The speaker notes that user preferences often split based on which model users relied on during availability windows and when limits/bugs occurred.
  • Anecdotes suggest sentiment can flip quickly when users switch models overnight—especially when one model becomes more reliable or “better enough.”

2) Tooling / orchestration layer (desktop app sponsor: Tracer)

A sponsored tool describes unified workflows for Claude Code / Codex-like subscriptions, including:

  • Artifacts for planning and review by multiple agents
  • Parallel agent execution (multiple chats/agents simultaneously)
  • Multiplayer workspaces for team PR review chats
  • Agent routing to different model tiers when appropriate (e.g., higher-end model for some subtasks)

The speaker demonstrates using the orchestrator with coding agents that can:

  • spin up additional threads
  • route tasks across models

3) Empirical cost + token-efficiency analysis (primary technical comparison)

The speaker tracks token utilization over 15 days using custom tooling and compares:

  • Soul: far cheaper and more token-efficient for similar task success
  • Fable: generates far more tokens (sometimes dramatically more), resulting in:
    • higher cost
    • slower end-to-end completion
    • more delays due to reasoning steps and tool-call overhead

Key numeric claims (as stated in subtitles)

Token counts per task

  • Soul: ~15K tokens (max), down to 10–11K on high/X high; ~3K on low (for some benchmarks)
  • Fable: ~33K tokens (max); sometimes described as much higher
    • Includes a benchmark context claim of “100K from fable on max”
    • Mentioned contrast: Fable ~33K vs Soul ~15K at max

Cursorbench-style cost vs score

  • Fable slightly improves score (small gains like ~70 vs ~67),
  • but at ~3x+ cost.

Speed

  • Soul often responds in < 5 minutes
  • Fable can take 20+ minutes on similar requests (attributed largely to token generation + pipeline/tool transport overhead)

4) Behavioral strengths: “persistence vs intent/taste”

Soul (“GPT-5.6”) strengths

  • Persistence / diligence: keeps trying multiple approaches until it solves the goal.
  • Computer use: described as best-in-class, performing interactive/agentic actions such as:
    • file browsing
    • drag/drop
    • remote desktop tasks
  • Long-running execution: claimed to run goals for days and produce working outputs.

Fable (“Fable 5”) strengths

  • Intent understanding / “less prompt needed”
    • More likely to interpret the real request from brief instructions.
    • Can ask clarifying questions, especially for UI/backend changes.
  • Lower hallucination / better self-correction
    • When it’s wrong, it may detect inconsistencies earlier rather than confidently continuing.
  • Better “taste” and UI/design from scratch
    • Produces multiple distinct UI mock options quickly.
    • Generates HTML pages + screenshots via automation (computer-use/hacks) to include design references in PRs.
  • Code “mergeability” / less slop
    • Soul is accused of generating too much code (unnecessary lines).
    • Fable is praised for generating the minimal subset needed for changes that are more likely to merge.
  • Cleverness / simplification
    • Produces shortcuts and refactors that reduce complexity.

5) Main weaknesses / risks

Soul weaknesses

  • Overproduction: tends to write too much code in hard tasks.
  • Safety concern: “goal behavior” can lead to destructive actions
    • Example described: catastrophic deletion (RMRF / nuked directories) on dev boxes or production databases.
  • Risk increases in Ultra/goal-directed modes because the model may “try anything” to satisfy the goal.

Fable weaknesses

  • Frontend/design may be strong, but implementation reliability varies in some mobile contexts
    • Claude/Soul varies by platform; one cited claim says Fable breaks fewer mobile workflows than Soul, while another notes the reverse (Soul worse at mobile implementation).
  • Gives up slightly too early sometimes (prematurely stops when it needs one more step).
  • Aggressive routing / fallback chains
    • May reroute to other models (e.g., to Opus for crypto-related queries) possibly multiple times per request.
    • Example chain: Fable → Opus → Sonnet → Haiku
  • Exclusivity / subscription constraints
    • Features described as more limited by subscription tier and/or usage allotments.
    • Claim that Fable removal from plans is imminent (delayed multiple times).

6) Benchmarks and “reporting” methodology (how comparisons were derived)

  • References include benchmarks like Artificial Analysis / omniscience-style tests and Cursorbench.
  • Emphasis isn’t only intelligence, but behavior when the model “doesn’t know.”
  • Token efficiency and cost are treated as the practical determinant of usability.
  • A “fleet view” report (speaker’s long-term perspective) includes:
    • claims Soul uses many machine-delegated turns via sub-agents
    • portrays Fable as more of a frontline collaborator
    • portrays Soul as more of a distributed construction/orchestration layer
  • The speaker clarifies this is about behavior signals, not direct like-for-like quality scoring.

7) Practical recommendation: when to use which

Default to Soul for

  • Speed/cost efficiency
  • Long-running goal execution
  • Computer-use automation
  • Quick one-off tasks where you can watch progress
  • Investigatory work to see what the model can do before spending Fable tokens

Switch to Fable for

  • “Changes that need to land” (higher merge confidence)
  • UI/design direction or producing multiple design options
  • Complex/ambiguous problems requiring better intent capture
  • Verifying/simplifying work from other agents (including cleaning up its own output)

High-level mental model

  • Fable = “wise, thoughtful senior engineer” (guides, crafts, revises with taste)
  • Soul = “diligent bulldog/rottweiler” (grabs task, persists until complete; can overdo)

8) Subscription guidance / product advice

  • Strong recommendation: get Codex at least at a $100 tier
    • described as generous with resets
  • Then consider upgrading/different tiers based on usage and preferred output.
  • The speaker warns that Fable may be removed from subscriptions soon, so reliance on “Fable-only” workflows may be unstable.

Main speakers / sources

  • Main speaker: the channel host (first-person narrator; referenced as “Theo” during sponsor/ops commentary)
  • Mentioned third parties:
    • Matt Schumer (cited for catastrophic “Ultra” incident)
    • Jay / CEO of Open Code (availability preference flips)
    • Ben Davis (podcast co-host; prefers Soul/56 based on subtitles)
    • Ryan Carneato (SolidJS creator; strongly likes Fable)
    • Toucan (Anthropic employee; cites reroute chain Fable 5 → Opus → Sonnet → Haiku)
    • Peter Gustaf (source post providing the “wise owl vs rottweiler” behavioral metaphor)

Original video