The episode opens with a candid meta-explanation: Theo and Ben recorded this episode in a burst of excitement during early access to GPT-5.6 Sol, only to sit on it waiting for OpenAI's green light to publish. Theo films the intro alone on a Saturday evening, two days after the public release, visibly annoyed at the delay. Ben drops the key paradox: this may be the first ever model release where the number of people with access actually shrank at launch, since every early tester lost their privileged access simultaneously when it went live ^{[1] — Theo "I think this is the first ever model release where by being released, the number of people who have access is less than before it was relea…" 01:29 Play} . They describe holding a 'memorial' for the model when access was cut mid-testing, with Ben watching a countdown timer at a concert. Despite the frustration, they're effusive in their appreciation for OpenAI's generosity in providing early access, and frame the episode as an honest time capsule of organic first impressions.

After a brief, self-deprecating introduction, Theo takes the lead in framing why this particular model drop matters beyond the usual benchmarks. OpenAI is releasing into a world where Anthropic's Fable (Claude's frontier model, internally called Mythos-class) represents a genuine generational leap — a much larger model backed by a company that was previously compute-constrained and no longer is. Theo argues this is OpenAI's first time releasing into a position where they feel legitimately behind, not just slightly off. The model was almost certainly built on the same Phi-5 base with a new RL pass rather than a fresh pre-training run, and had to compete with Fable's size advantage while facing a political climate increasingly hostile to frontier model releases. The stakes feel different from previous cycles, making 5.6 one of the most consequential OpenAI drops in recent memory.

Theo and Ben dig into their actual day-to-day experience with 5.6, and the clearest signal emerges not from the model itself but from the regression to 5.5. Theo describes the single most noticeable change: 5.6 doesn't stop after the first part of a task and ask for permission to continue ^{[1] — Theo "5.5→5.6 regression: 1/5th completion: When forced back to GPT-5.5 during testing, tasks that 5.6 happily ran to completion got only about a…" 08:10 Play} . That habit was one of his biggest frustrations with 5.5, and with 5.6, it simply vanished. When forced back to 5.5 during testing windows, similar tasks got only about a fifth of the way through before stopping — a stark regression. Ben adds a philosophical point: the best AI is the one you don't notice ^{[2] — Ben "I notice Phi-5 more than I notice the new model, which is huge. Like, that's what you want AI to do. If you notice it, it's bad." 09:20 Play} . He'd previously thought 5.5 was so good that future model improvements would be imperceptible — he was entirely wrong. The hosts also flag the deeper cognitive dynamic: spending time with a better model raises your expectations, which then makes the older model feel far worse than it ever did before.

Ben walks through Clerk's full feature set in a hands-on sponsor read. The pitch centers on Clerk's component system: you mount a sign-in component and Google/GitHub auth just works. Toggle on orgs in the dashboard and organization management appears. Their newer billing product integrates directly into the user and org object system, meaning when a user checks out, their subscription is automatically synced everywhere. Ben shows two live projects — Pickthing and Lawn — demonstrating how the same underlying components can be styled completely differently. The key selling point is that AI coding agents handle the customization beautifully, making Clerk one of the most agent-friendly auth platforms available.

The conversation turns to the one area where neither host had high hopes — and those expectations were roughly met. GPT-5.6 still defaults to the same tired LLM frontend tells: all-caps headings, excessive callouts, generic card layouts, and the infamous status pill that appears in every UI regardless of context. Theo is unimpressed and makes clear the Codex app would look significantly better if the model were stronger at frontend. The exception is Ben's mobile experience: working in React Native with Expo's blessed native components, he found that the constrained component palette actually prevented the model from over-engineering. Native Glass components were used correctly and the dev server workflow on his broken Apple developer account was navigated without issue. Theo gave up early on Swift but concedes the React Native experience was meaningfully better than with 5.5.

Theo walks through a live demonstration that visibly surprises even him: he gave 5.6 his old fish slap game codebase and asked it to rebuild the game in 3D. Without being told anything about the game's theme or style, the model not only built a functional 3D game but also generated 3D assets using Blender via its CLI access. The resulting fish assets are recognizable if cursed, and the game itself plays and functions correctly. Theo hadn't read a line of the code. The moment lands as a real marker of how far things have come: a year ago the conversation was about whether models could code at all, now Theo's complaint is about the default hotkey choices. This segment also surfaces an interesting technical detail — Blender has a CLI, which the model discovered and used autonomously.

This chapter traces the evolution of how both hosts actually use these models. Fable was the catalyst: it was the first model that made genuinely long, complex runs feel worth attempting. When Fable was taken away, they found 5.6 could carry those same expanded workflows further than any previous OpenAI model. Theo explains the economics: a $200 Codex subscription, per Semianalysis measurements, delivers up to $14,000 worth of compute per period — and with two usage resets that restore a full week, this can reach $20,000 per month ^{[1] — Theo "According to Semianalysis measurements, a $200/month Codex subscription can yield as much as $14,000 worth of token usage in a single perio…" 34:00 Play} . He's careful to note that the outrageous dollar figures on their dashboards ($131,700 and $93,000 respectively) represent deliberate stress-testing experiments, not practical work. His real workflow tasks — auditing open PRs, rebasing, coordinating merges — ran on a single 5.6 thread spawning targeted subagents, and were both cheaper and more valuable.

The move to Linux isn't ideological — it's pragmatic. Theo noticed macOS's syspolicyd consuming 215% of his M5 Max's CPU just from Codex running subagents in the background, more than rendering complex Blender scenes ^{[1] — Theo "Linux removes macOS process overhead: Moving agents to Linux eliminates macOS's aggressive process monitoring of Codex subagents, which was…" 39:15 Play} . Ben explains the root cause: MCP cannot share a single connection across threads, so 50 simultaneous subagents require 50 separate MCP server processes, 50 computer use instances, and all the associated overhead. macOS watches every single one of these processes suspiciously. On Linux, none of that overhead is present — you can spin up dozens of threads without touching system performance. Both hosts now run their long-running agent tasks on network-accessible Linux boxes, using T3 Code's web interface over Tailscale to monitor and interact with sessions from anywhere, including their phones.

Ben makes the case for localization as an underrated growth lever, framing it as the single change that expands your app's addressable market from millions to billions of users. General Translation is the infrastructure behind Cursor, Ramp, and Netlify's localization. The integration is lightweight: wrap your Next.js config with gtConfig, wrap translatable components with tComponent, then run npx gt-translate before your production build. The sponsor read is brief but technically specific, targeting the developer audience directly.

This is the episode's most technically dense chapter, and arguably its most important. Theo carefully distinguishes between what a subagent is (a one-dimensional tool call that spins up an agent, waits for completion, and returns output) and what Claude Code's workflow primitive is (a vanilla JavaScript file the model writes itself, with dynamic stages, conditional subagent spawning, and true parallelism in a single tool call) ^{[1] — Theo "Claude Code gives agents a full JavaScript workflow file they write themselves — dynamic, multi-stage, and parallelizable in one tool call.…" 48:20 Play} . Codex's subagent system is a pre-built feature the OpenAI team coded; Claude Code's is code the agent generates on demand for the specific task at hand. This architectural difference, combined with Claude Code's superior TUI visibility into running subagents, has created a gap that both hosts now feel more acutely than the raw model capability difference between 5.6 and Fable. Ben adds that UltraCode in Claude Code simply adds a prompt layer pushing the model toward workflows, suggesting the gap is solvable but hasn't been solved yet in Codex.

Theo pulls out one of the episode's richest segments: two separate AI-generated analyses of his coding session logs, one comparing 5.5 to 5.6 and one comparing 5.6 to Fable-5. The 5.6 vs Fable comparison is the one that lands hardest. The analysis finds that Fable-5 'thinks wider' and is the stronger strategic advisor, while 5.6 'ships better' and is the stronger day-to-day coding agent ^{[1] — Theo "Fable 5 thinks wider, 5.6 ships better. Fable-5 is the stronger strategic advisor. F5-6 is the stronger day-to-day coding agent. The differ…" 54:40 Play} . The communication styles are starkly different: 5.6 produces terse, telegraphic build-bot receipts while Fable writes conversational prose that teaches the maintainer. But the most surprising finding is Fable's self-assessment blind spot: it voted for its own plan 6-0 in a head-to-head planning comparison, even while acknowledging benefits of the alternative ^{[2] — Theo "Fable is much worse at critiquing its own work. It thinks its outputs are gifts from heaven. Like it is the divinely mandated model that do…" 58:37 Play} . Ben interprets this as a feature of Claude's training — the 'Claude constitution' instills conviction that can become stubbornness — while 5.6's mechanical execution makes it genuinely neutral.

The hosts pull back from the extreme numbers and reflect on what actually moved the needle. The $65k Executor port was a meme — Ben admits it up front. But the days spent at $1,000 worth of tokens (about 1 billion) produced real, shipped work: Ben built a full Hermes agent interface system including a mobile app, web app, Mac Mini server, and Cloudflare tunnel architecture, all from a single coherent run. The key insight from both hosts is that the right mental model isn't 'do harder tasks' — it's 'go further in both directions.' Start earlier in the process, before you've even thought the problem through, and end later, after the agent has opened the app, tested its own work, responded to PR comments, and self-merged. These extended delegation loops are where the real leverage is found.

The episode takes its most memorable turn here as Ben confesses to a late-night experiment: he copy-pasted chunks of the Destiny universe's lore into a project's agents.md, ran the model with Groq subagents fighting each other alongside the main 5.6 instance, and got surprisingly good results. The UI outputs had genuine personality — custom SVG diagrams, interesting animations, and non-generic flow — precisely because the prompt was so far out of distribution ^{[1] — Ben "Ben spent an entire night in deep back-and-forth dialogue with Claude Code to build an agents.md that embedded a specific, unusual worldvie…" 1:05:50 Play} . He then took the concept seriously, spending an entire night in deep dialogue with Claude Code, sending five paragraphs back and forth until 9am, building a coherent internal tooling aesthetic he describes as 'cursed but functional.' Theo summarizes the philosophy: to escape generic LLM outputs, you need to give the model your psychosis ^{[2] — Theo "The thing he's trying to say is you need to give the model your psychosis." 1:04:45 Play} . He closes the segment by joking that this is exactly how humanity gets wiped out — by showing the models Terminator to see how they behave.

The episode closes on a tired but satisfied note. Theo checks his laptop battery — a 32% drain on a brand-new M5 Max MacBook during the recording, which he'd predicted would be worse. He takes one final shot at Codex's performance asking OpenAI to get their app in order given how good the underlying model is. Ben explains the root cause is actually MCP's architecture, not OpenAI's fault. They remind listeners to rate and review the podcast across platforms — including their newly added YouTube Music presence — and to follow their Twitter account for memes. Theo asks permission to finally go play video games, Ben grants it, and the episode ends.