GPT-5.6 Sol: The Last-Gen Peak
Nerd Snipe's early access testing of GPT-5.6 Sol reveals a phenomenal execution machine that excels at long-running tasks and sub-agents, but falls short of Anthropic's Fable in strategic reasoning and discernment. The model burns through tokens efficiently, enables new workflows via computer use, and represents the pinnacle of current-generation capability—but not the next generation.
Context & Release Situation
Embargo and Early Access
The hosts recorded this episode weeks before 5.6's official release but were legally restricted from posting until launch. They had early access as OpenAI testers and experienced multiple temporary access losses during development, forcing them back to GPT-5.5 and highlighting the dramatic regression.
Paradox of Access
Unusually, the number of people with access to 5.6 decreased after its public release compared to the testing phase, as the early access group was suddenly cut off when the model went live.
Model Positioning & Competitive Landscape
OpenAI's Strategic Pressure
5.6 arrives at a critical moment: Anthropic's Fable represents a significant size increase and capability leap, and OpenAI likely had no time for new pre-training, making this primarily an RL pass on the GPT-5.5 base. OpenAI faces a climate where models risk being banned if deemed too powerful.
Generation Classification
5.6 is positioned as the absolute peak of the current generation—comparable to the best PS3-era games that squeezed every ounce from existing hardware. Fable is the first true next-generation model. 5.6 is not GBT-6; it's the capstone of the current era.
Core Behavioral Improvements Over 5.5
Long-Running Task Reliability
5.6 eliminates 5.5's critical flaw of stopping mid-task after completing the first part of work. It can sustain complex, multi-stage tasks for extended periods without requesting permission to continue, making it fundamentally more reliable for agentic workflows.
Regression Shock When Downgrading
When forced back to 5.5 during testing, the degradation was immediately painful. Work that 5.6 handled easily would only complete 20% of the way through on 5.5, prompting one tester (Julius) to crash out in frustration after using the superior model.
Improved Prompt Interpretation
5.6 interprets prompts more accurately, makes better tool calls, and fades into the background during use. Users notice 5.5 more than 5.6, which is the desired behavior—the model should be invisible when working well.
Coding & Technical Capabilities
Frontend Still Weak
5.6 shows marginal improvement over 5.5 in frontend generation. It follows design instructions better within existing systems but still defaults to generic LLM patterns: all-caps headings, overused card layouts, status pills, and visual bloat. Forcing it in the right direction requires significant prompting.
2D & 3D Spatial Reasoning Leap
5.6 excels at spatial reasoning for game development. It successfully rebuilt a 3D game from scratch, created 3D assets in Blender via CLI, and produced functional game code without manual review. The cursed-but-functional fish models it generated represent a significant capability jump.
Mobile Development (React Native > Swift)
5.6 performs remarkably well with React Native and Expo, even working around broken Apple developer accounts. It uses native glass components effectively and produces better mobile designs than web designs due to constrained component toolboxes. Swift UI performance is poor by comparison.
Svelte Mastery
5.6 handles Svelte out of the box with no issues. The model can execute Svelte tasks flawlessly, representing a baseline capability that all frontier models now meet.
Over-Engineering Tendency
5.6 tends to over-complicate architectures, adding unnecessary tests for every edge case and bloating API designs with 500+ commands when 10 would suffice. It lacks the discernment Fable demonstrates; it biases toward vomiting out comprehensive solutions rather than elegant ones.
Literal Instruction Following
5.6 exhibits strong literal interpretation: if you ask it to ask questions, it asks questions; if you don't, it won't. This is sometimes useful but limits deeper exploration. Fable is far better at inferring underlying intent and probing for clarification unprompted.
Test Obsession
5.6 loves writing tests. Even without explicit instruction, it adds extensive test coverage. When told to add tests, it adds even more. This reflects a bias toward defensive, thorough engineering.
Sub-Agents & Workflows: Codex vs. Claude Code
Codex Requires Explicit Sub-Agent Requests
Unlike Claude Code, Codex does not intrinsically spawn sub-agents. You must explicitly tell it to create them. This is a fundamental architectural difference: Codex treats sub-agents as a feature you opt into, while Claude Code treats them as a natural orchestration primitive.
Claude Code's Workflow Superiority
Claude Code uses code-based workflows (vanilla JavaScript files with stages) that allow dynamic, multi-threaded parallelization. Each stage can programmatically spawn zero to dozens of sub-agents. Codex's sub-agents are more rigid—one layer deep by default, limited by tool-call semantics.
UI Visualization Gap
Claude Code's TUI shows sub-agents in a navigable tree; you can drill into live sessions. Codex's desktop app shows sub-agents in a sidebar (inconsistently) and the CLI has no visualization at all. Monitoring is done via system tools like btop instead.
5.6 Better at Orchestration Than 5.5
5.6 is substantially better at orchestrating sub-agents than 5.5, though still not as intrinsic as Claude Code. When prompted to use sub-agents, 5.6 deploys them more effectively and maintains coherence across parallel threads.
Token Burn & Loop Economics
Extreme Usage Metrics
Theo spent $131,700 on tokens; Ben spent $93,000. Most came from 5.6 testing. These numbers are inflated by intentionally wasteful experiments (7-day Dropbox rewrites in Rust, 100-billion-token executive port costing $65k) but demonstrate the model's capability to sustain long-running tasks.
Pro Subscription Economics
The $200/month Pro subscription can yield up to $14,000 in usage value (per semi-analysis measurement) without resets, and up to ~$20,000 with resets. This makes the sub extraordinarily cost-effective for heavy users, though margins for OpenAI remain strong.
Sub-Agents as the Real Money Sink
Massive token burn comes from sub-agents and loops, not single-threaded runs. When a model spawns 7 parallel instances of itself, each running for hours, costs multiply exponentially. This is why local models struggle: you can't easily provision 7 GPUs on demand.
Practical Use Cases Much Cheaper
Real work (code that ships, PRs that merge) costs $400–$1,000 per session, not $65,000. The extreme numbers come from experimental loops. Practical workflows—PR auditing, feature implementation, mobile app building—are far more economical.
Computer Use & System Integration
Computer Use Excellence
5.6 is phenomenal at computer use. It navigates broken Google dashboards, jank third-party services (Genius Link), and complex UIs reliably. This capability is transformative for automating business tasks that previously required manual intervention.
Practical Automation Examples
Users now delegate tasks like GCP credential setup, Cloudflare Zero Trust configuration, and email inbox triage to the model. These are tasks that would have been too tedious to attempt manually but are now trivial to automate.
Linux Box Advantage for Sub-Agents
Running Codex on Linux eliminates macOS's aggressive process monitoring, which throttles performance when spinning up dozens of sub-agents. Linux allows dozens of parallel threads without resource contention, making it the superior platform for agentic workflows.
Tailscale & Remote Orchestration
Users can run long-lived agent workflows on remote machines via Tailscale, hosting the T3 Code web interface and accessing it from anywhere. This decouples the agent's runtime from the user's laptop, enabling true background execution.
5.6 vs. Fable: Detailed Comparison
Fable Thinks Wider; 5.6 Ships Better
Analysis of session logs shows Fable excels at strategic reasoning and broader problem-scoping, while 5.6 is superior at day-to-day coding execution and task completion. Neither dominates every stage; they're complementary.
5.6 Outreasons on Deep Tech; Fable on Architecture
5.6 excels at diving into provider internals and debugging technical problems (e.g., reasoning token issues with OpenRouter). Fable writes cleaner, more idiomatic code and reasons to ground truth with fewer probes.
Fable's Self-Critique Weakness
Fable believes its outputs are divinely mandated and resists critiquing its own work. It voted for its own plan to zero even when acknowledging benefits of alternatives. 5.6 is more neutral and self-critical, though this can lead to over-engineering.
Question Quality Gap
Fable asks better, more probing questions to clarify intent. 5.6 asks fewer questions and takes things more literally. This makes Fable better for exploratory work but 5.6 better for execution when requirements are clear.
Opus 4.8 Verdict: Impressive but Outclassed
Opus 4.8 praised 5.6's architecture as unusually well-architected and robust, but Fable tore it apart. Opus occupies a middle ground—better than 5.5, worse than both 5.6 and Fable.
Workflow Optimization & Psychosis Injection
Expanding Task Scope for Better Results
To maximize 5.6's potential, don't just ask it to do harder tasks—expand the scope earlier and later in the process. Instead of handing it a spec, let it participate in planning. Instead of accepting its output, have it test, iterate, and merge itself. Wider scope yields better results.
Agent MD & Psychosis Injection
Injecting coherent 'psychosis' into the model via detailed agent.md and context files dramatically improves output quality. One tester embedded Destiny lore into their agent prompt; another wrote extensive project philosophy. This shared mental model prevents bad assumptions from spiraling.
Pottery Analogy for Long Runs
Long-running tasks are like spinning pottery: small misalignments early on spiral into catastrophic failures. Fable catches these via discernment; 5.6 throws itself at the wall repeatedly. Constant back-and-forth alignment prevents derailment.
Map PCO Grill Skill
A skill that forces the model to ask clarifying questions until perfect alignment is achieved. This is essential for 5.6's long-running tasks, where shared understanding prevents token waste and architectural disasters.
Performance & Infrastructure Issues
Codex Desktop App Performance Crisis
The Codex desktop app consumes 215% CPU on a 20-core M5 Max—more than rendering complex Blender scenes. The culprit: MCP (Model Context Protocol) spawns a separate process for every sub-agent connection, and with 50 sub-agents running, macOS's security monitoring becomes a bottleneck.
MCP Architecture Limitation
MCP cannot be shared between threads; each connection requires a new process. This is an Anthropic design choice that cascades into massive resource overhead when running dozens of parallel agents on macOS.
Naming & Tier Strategy Critique
OpenAI's Naming Problem
OpenAI's tier naming (5.5, 5.5 High Reasoning, etc.) doesn't accommodate a model that's 2x larger and 50% more expensive. Anthropic's approach (Sonnet, Opus, Fable as distinct lines) scales better. A future GPT-6 carries the same weight as Fable, creating confusion.
Anthropic's Tier Advantage
Anthropic never increased prices within a tier; they only decreased them and added new tiers for higher capabilities. This creates clear shelf space for new models. OpenAI's pricing has been volatile within tiers, making positioning unclear.
5.6 Should Not Be Called GPT-6
5.6 is the capstone of the current generation, not the start of a new one. Calling it GPT-6 would mislead users into thinking it's next-gen when Fable is. A different naming scheme (e.g., GPT-5.6 Pro, GPT-5 Ultra) would be clearer.
Notable quotes
This is the very peak of last generation. Fable is at the top of the top tier. — Theo
When we lost 5.6, we're like, 'Okay, we're not coding today.' — Ben
Fable thinks wider, 5.6 ships better. — Theo (via Opus analysis)
Action items
- If using Codex for agentic workflows, explicitly request sub-agent creation; don't assume it will spawn them automatically.
- For long-running tasks, expand scope beyond the immediate request: include planning, testing, review, and iteration in the prompt.
- Create a detailed agent.md or context file that injects coherent project philosophy and constraints to prevent bad assumptions from spiraling.
- Run Codex sub-agent workflows on a Linux machine to avoid macOS resource contention; use Tailscale for remote access.
- Use the Map PCO Grill skill (or equivalent) to force alignment between you and the model before starting long-running tasks.
- For mobile development, prefer React Native + Expo over Swift UI; 5.6 handles the former far better.
- Test 5.6 on computer-use tasks (dashboard setup, service configuration) where it excels and can save significant manual work.