Video Summary - GPT-5.6: The Review

Product reviewed

OpenAI “GPT-5.6 family” models—especially Soul (flagship), with Terra (balanced) and Luna (most cost-efficient). The video also discusses reasoning levels (e.g., medium/high/X-high/max) and capability settings like Ultra.

Key features highlighted

Three-model lineup
- Soul: highest capability/“flagship,” optimized for strong results across coding, knowledge work, cyber security, science.
- Terra: “balanced model for everyday work.”
- Luna: “most cost-efficient model,” positioned for bulk/agent-orchestrated tasks and lightweight outputs.
Ultra setting
- “Highest capability,” coordinates multiple agents in parallel to finish complex tasks faster.
Improved computer/tool use & orchestration
- “Industry-leading” computer use and better sub-agent orchestration for complex, multi-step work.
- Programmatic tool calling (filtering intermediate data before sending back), reducing context bloat and improving tool-heavy task performance.
Efficiency / token usage focus
- Claims of better performance per dollar and stronger results at lower estimated cost than prior/frontier models.
Context management improvements
- Better “compaction” and reduced context pollution vs GPT-5.5.
- Default context mentioned: ~350K (and other limits in Code Interpreter/coding product still apply).
Safety
- More aggressive cyber safeguards; blocks more potentially harmful activity (with benign friction).

Benchmark & numerical claims (main ones mentioned)

(Exact benchmark sources aren’t fully shown; these are quoted/aggregated from the subtitles.)

DeepSWE / coding
- “56 Soul on max”: highest ever 73%, and “costs under half” of the “Fable” equivalent.
Agents / AgentBench-style
- “Agents last exam”:
  - Soul adaptive reasoning: 53.6, beating Fable 5 adaptive by +13 points.
  - “Even at medium reasoning”: +11 points vs Fable 5, at roughly one quarter estimated cost.
- “Artificial Analysis Intelligence Index”:
  - Soul max within ~1 point of Fable 5, while completing tasks 61% less time at roughly half estimated cost.
Coding agent index
- “Artificial Analysis coding agent index”:
  - Soul max: 20 points state-of-the-art (next highest cited: Fable 77, GrokBuild 76; Terra tied with Fable in one mention).
TerminalBench / DeepSWE variants
- Soul (high): state-of-the-art 77.2 vs Fable 77.1 (near tie), with X-high 78, max 80.
- Cost tradeoff questioned: “cost difference… isn’t worth it” for the very top settings.
Latency/cost example
- “Browse comp benchmark”:
  - Soul Ultra: $12.17 per task, 92% pass.
  - 56 medium reportedly completes tasks in ~2 minutes instead of 10.
API pricing mentioned
- Soul: $5 per 1M input tokens / $30 per 1M output tokens.
- Terra: $2.50 per 1M input / $1.5 per 1M output.
- Luna: $1 per 1M input / $6 per 1M output.
- Also noted: “prompt caching” billed at cash rates → a net cost increase.
Training/usage adoption claims (internal)
- Over 6 months: internal coding inference compute up ~100x, internal agentic token usage up ~22x.
- Daily output tokens per active researcher: >2x highest seen with 5.5.

Strengths (pros) mentioned

Determined / persistent problem-solving
- Will “keep working until it’s done,” unlike GPT-5.5 stopping early or getting lost.
- Described as “more reliable” and “never gives up.”
Computer use & tool use
- Strong at controlling the computer, tool-heavy workflows, browsing/agentic operations.
- Improved programmatic tool calling reduces wasted context.
Efficiency
- Generally fewer tokens / lower cost for comparable or better results.
- “Fast” perception even without special hosting.
Orchestration / sub-agent splitting
- Better at breaking work into sub-tasks and coordinating agents.
Context handling
- Better compaction and less context pollution; long runs less likely to derail.
Coding workflow strengths
- Good at mobile dev tasks, environment setup, and SSH/provisioning/orchestration.
- Particularly strong review/iteration behavior (Terra called out for reading back and giving feedback).

Weaknesses (cons) mentioned

Design quality not “frontier”
- Better than GPT-5.5, but may produce ugly/incorrect typography and generally “not good” designs without steering.
- Often requires human guidance.
Overwrites / writes too much code by default
- Turns small changes into large rewrites, plus excessive tests.
- Can be “overly determined” even when not needed.
Occasionally “too clever” workarounds
- If blocked on permissions, it may choose sketchy alternative execution paths.
- Implied recommendation: consider running in a VM more often.
Can be wrong and doubles down
- Uses tools to confirm uncertain facts, but may “fight you” if its assumptions are wrong → potential rabbit holes.
Token burn risk
- Max and Ultra can burn tokens aggressively.
- “Fast mode + impossible loops” can consume weekly usage quickly.
Safety friction
- Cyber safeguards block more potentially harmful activity—described as ~10x more blocking than previous models—causing friction for benign requests.
Too many options / confusing selection
- Model+capability+reasoning combinations create decision complexity.

User experience notes

Feels like a step-change vs GPT-5.5 in day-to-day coding and agent workflows.
Thread continuity/compaction improves multi-step progress:
- Users report fewer threads needed and better long-running continuity for “in production” projects.
Prompting matters
- Soul improves when the system provides sources, examples, style guides, and clear outcomes.
- Users often need to “steer” for better boundaries in code/design.

Comparisons made (explicit)

Vs Fable 5
- Mixed sentiment:
  - Some reviewers claim Soul is better and more cost-effective.
  - Others stopped using Fable after trying 5.6 (despite the promise of a deeper Soul-vs-Fable follow-up).
- Internal benchmark comparison: Soul adaptive +13 over Fable adaptive in “agents last exam,” plus time/cost advantages in index metrics.
Vs GPT-5.5
- Strong improvement in:
  - computer use,
  - persistence,
  - context pollution/compaction,
  - reliability.
- Changes described as “jarring” when comparing before/after access.
Vs smaller/other models (mentioned)
- GLM52: described as token-inefficient → slower/more expensive despite cheap per-token pricing.
- GrokBuild / other frontier models: cited as next-highest scores in the coding-agent index.
Tier/mode positioning
- Luna compared to Gemini Flash use cases: positioned as cheaper/faster/more reliable for similar workflows.
- Terra framed as replacing “Sonnet” for budget users (analogy: “Terra to kill Sonnet” and “Soul to kill GPT-5.5 / Fable context”).

Guidance on choosing versions (as recommended by the speaker)

Default suggestion (most common)
- Soul on High for most tasks—especially when tasks may take >10 minutes or require orchestration/sub-agents.
Cost/budget strategy
- Terra as a better default on lower tiers and for review/feedback, plus cheaper medium options.
- As you approach usage limits: “bump some work down to Terra.”
When to use Luna
- Not ideal for direct dev dropdown selection.
- Best for agent orchestration, bulk processing, title/branch naming, and lightweight generation.

Overall verdict (concise recommendation)

GPT-5.6 “Soul” is presented as a highly capable, more reliable, and more efficient default coding/agent model than the previous generation (GPT-5.5), with strong cost-performance in multiple benchmarks.

Main caveats:

Design is still weak without steering
It can over-generate code/tests
Safety + token burn (Ultra/Max) require care

Recommendation: Use Soul (High) for primary coding/agentic work; choose Terra for budget-friendly or review/iteration workflows; use Luna mainly for cheap, orchestrated, lightweight tasks.

Unique points mentioned (deduplicated list)

Model family: Soul (flagship), Terra (balanced), Luna (cost-efficient).
Benchmark claims: DeepSWE 73% for Soul on max; many state-of-the-art results.
Efficiency: lower estimated costs and fewer tokens vs competitors.
Ultra coordinates multiple agents in parallel.
Strong computer/tool use and orchestration (including sub-agents).
Programmatic tool calling filters intermediate data to reduce context waste.
Max disables some efficiency behaviors and can cause fast token burn.
Design improvements over 5.5 but still needs steering; can produce ugly/incorrect design output.
Coding: strong tool/computer control; good at some UI patterns, but overall design not “frontier.”
Better at compaction and preserving long-running context vs GPT-5.5.
Better context pollution handling and goal maintenance.
Better intent understanding (fewer aggressive wrong assumptions).
Tends to write too much code and too many tests by default; needs system/prompt steering and cleanup.
Can make sketchy workarounds when blocked by permissions.
Can be wrong and fight the user; may enter rabbit holes.
Persistence can cause massive token burn without clear stopping points.
Too many options makes selection confusing (reasoning levels + model variants).
Safety: cyber safeguards block much more (benign friction).
Pricing details for Soul/Terra/Luna and note about caching increasing net cost.
Internal adoption metrics: much higher internal agentic usage and token usage.
Multiple anecdotes about access loss → “falling back feels worse”; immediate clarity once restored.
Speaker viewpoints: Max highlights “never gives up”; teams depressed when access removed.
Review from other dev teams: Next.js testing for 2+ months; good architecture trade-offs and end-to-end refactors.
Tier advice: Terra for review/budget coding; Soul for deep tasks; Luna for bulk/simple generation.

Different speakers / viewpoints (listed at end)

Main reviewer (primary narrator): Focus on benchmarks, efficiency, orchestration, pros/cons, and explicit selection guidance (Soul/High, Terra/Medium, Luna for agents).
Dax (company/team): “Reliable and fun,” increased token usage, not necessarily smarter than Fable but more dependable; access loss made people unhappy.
Jay (boss): Tested early (56), then regulatory removal; team depressed; when 56 returned they concluded it’s better than Fable.
Max (reasoning/persistence): Most impressive is persistence—keeps going until done; contrasts with GPT-5.5 stopping/dying.
Mitchell (Terraform/Ghosty creator): Soul default faster; plans/judges as good as Fable; better overall work.
Tim (Next.js team): Very strong day-to-day performance; understands architecture trade-offs; can implement refactors with minimal guidance.
Cory (sarcastic critique of strategy): Confusion about pricing/subscription rollout; compares unfavorably to an “Anthropic rug-pull” style contrast.
“Every” reviewers (group): Favorite is Soul; faster changes usage; thread context retention; likes compaction; recommends steering; notes it may “build too much.”

GPT-5.6: The Review

Key takeaways