I can't believe they released this - CourtneyR.dev's 2nd Brain

I can't believe they released this 🔗 **Source:** [I can't believe they released this](https://www.youtube.com/watch?v=t8hfOyF4ehw) > [!note]+ Document Notes > tags: [ai-coding-agents, gpt-5-6, reasoning-effort, sub-agents, claude-code, codex-cli] > author: Theo (Theo Browne) > source: Theo - t3.gg > reference: https://www.youtube.com/watch?v=t8hfOyF4ehw > date created: {{date:YYYY-MM-DD}} {{time:HH:mm}} > > # 🏷️ Title: I can't believe they released this >  ## 🧭 Table of Contents - [📝 Summary](#-summary) - [📖 Main Content](#-main-content) - [🗒️ Notes](#️-notes) - [📚 References](#-references) - [🗣️ Paraphrase](#️-paraphrase) - [📰 Newsletter](#-newsletter) - [✅ Action Items](#-action-items) - [🧪 Hypotheses](#-hypotheses) - [📊 Methodology](#-methodology) - [❓ Questions](#-questions) - [🔮 Future Research](#-future-research) - [💡 Implications](#-implications) - [🧠 Learning Styles Assessment](#-learning-styles-assessment) - [📊 Accessibility Assessment](#-accessibility-assessment) - [🌍 DEIB Assessment](#-deib-assessment) - [✅ Logical Validity](#-logical-validity) - [🛡️ DARVO Analysis](#-darvo-analysis) - [🎯 Conclusion](#-conclusion) ### 🔗 References - OpenAI Codex CLI (open source) — referenced throughout as the basis for the v1/v2 sub-agent comparison. - Claude Code "workflows" feature — referenced as the contrasting, code-defined sub-agent implementation. - Firecrawl (soydev.link/firecrawl) — video sponsor, web-scraping/MCP tooling. - Theo's prior videos: "Claude Code is good" and a cost-savings video comparing max vs. x-high reasoning token burn (both mentioned, not linked in the transcript). ## 📝 Summary - OpenAI shipped GPT-5.6 with three model variants and two new "reasoning levels," Max and Ultra, exposed in tools like Codex and the ChatGPT/Codex app. - Theo's central claim: Ultra is not actually a reasoning level. It's a skill/toggle that gets appended to the system prompt, telling the model to spawn many sub-agents — mirroring how Anthropic's "Ultrathink"/"Ultra Code" works in Claude Code. - Because Ultra defaults the parent agent and every spawned sub-agent to max reasoning, and Codex's current sub-agent implementation (v2) doesn't let you cap sub-agent reasoning levels, using Ultra can trigger runaway, nearly-infinitely-recursive max-reasoning sub-agent trees that burn tokens at extreme rates. - Theo reports blowing through his 5-hour Codex usage limit in 20 minutes, then again 40 minutes later, using Ultra once. He warns this is more dangerous now that OpenAI is temporarily removing the 5-hour limit (so a runaway Ultra session could consume an entire week's quota). - He walks through Codex's two internal sub-agent architectures: v1 (simple, ticket-based dispatcher; finished, currently default) and v2 (mailbox-based, agents can message each other and spawn further sub-agents, unfinished/in-progress) — and shows that the models.json cache now silently forces GPT-5.6/Ultra onto v2 regardless of user configuration. - He contrasts this with Claude Code's "workflows," a code-defined (JavaScript-based) approach to orchestrating sub-agents with fixed phases, schemas, and an eventual hard stop — which he considers the better-designed implementation, even though he thinks Anthropic's Ultra Code UX (folding it into the reasoning-effort selector) was itself a mistake that OpenAI copied. - Key stakeholders: OpenAI/Codex team, Anthropic/Claude Code team, individual power users/developers burning API quota, and content creators like Theo influencing rapid product iteration via public feedback (Slack/Twitter). - Risk/tradeoff: using Ultra without understanding it can silently consume rate limits and money; the fix requires either waiting for OpenAI to patch the UX and sub-agent reasoning controls, or manually avoiding Ultra and building custom workflows instead. - Bottom line: don't use Ultra right now. Treat it as an unfinished, mislabeled feature, not a "smarter" reasoning setting; the defaults for GPT-5.6 (without Ultra) are still good. ## 📖 Main Content - **What "Ultra" actually is.** In the model selector, reasoning levels shown are low, medium, high, extra-high (XH), max, and ultra. Theo argues Ultra is fundamentally different in kind from the others: it's not a point on a reasoning-intensity spectrum but a system-prompt injection (like invoking a skill/slash command) that tells the model to spin up more sub-agents. He demonstrates this in Claude Code first: selecting "Ultra Code" via `/effort` doesn't actually set the reasoning level to "ultra" — it sets it to X-high and separately flags a workflow-triggering behavior at the bottom of the UI. - **Anthropic did it "mostly right," OpenAI did it wrong.** Claude Code's Ultra Code defaults to X-high (not max) reasoning for the parent and is explicit that it's a toggle, though Theo still thinks it's too easy to leave on by accident. Codex/ChatGPT copied the *UX* (folding Ultra into the reasoning-effort slider) without copying the underlying safety choice — Codex's Ultra sets max reasoning, and because sub-agents in Codex can't presently be told to run at a lower level than the parent, every spawned sub-agent also runs at max. Theo calls this "nearly infinitely recursive maxes" and identifies it as the primary reason Ultra burns so many tokens. - **Concrete cost/rate-limit damage.** Theo hit his 5-hour Codex limit in 20 minutes using Ultra on "fast mode," manually reset it, and hit the limit again in another 40 minutes — twice in under an hour, from one Ultra run. He connects this to a policy change where OpenAI is temporarily removing the 5-hour limit (to stop people from hitting it too fast), which he says makes Ultra riskier because there's no longer an early warning before a much larger weekly quota gets consumed. - **Codex's sub-agent architecture: v1 vs. v2.** Using GPT-5.6 (Soul, in his terminology) inside both Codex and Claude Code to read Codex's own open-source code, he summarizes: v1 is "a dispatcher hiring temporary helpers by ticket number" — a simple tool-call mechanism where the root agent spins up sub-agents with a task and a limited/summarized slice of context, and each sub-agent reports results back up. V2 is "a named project team with an org chart and mailboxes" — a much more complex system with task-path naming (e.g., `/root/research`, `/root/research/tests`), typed inter-agent messages (`send_message`, `follow_up_task`), no depth limit on nested sub-agents (default cap of 4 running concurrently, which Theo had manually raised), and — critically — a default of sharing the *entire* main-thread history with every sub-agent (configurable to none or a fixed number of turns), which he calls "really [redacted] stupid" because it multiplies token cost and can still let bad context propagate even though GPT-5.6 resists context pollution better than prior models. - **A quiet routing change.** Codex's `models cache` JSON file added a `multi-agent version` field that is hardcoded to v2 for the newer "Soul"/"Terra" models and v1 for everything else — meaning users can no longer choose v1 for the new models regardless of local configuration, and v1/v2 cannot coexist without triggering errors (especially with custom v1 settings). - **v2 in practice.** Theo used v2 more but found it noisier and not clearly better in output quality — it runs much longer, spins up more sub-agents, and burns far more tokens without a demonstrated quality gain in his testing. He quotes a viewer/commenter (JKF) agreeing that "too many people designed sub-agents v2 and caused it to be bloated." - **The better alternative: Claude Code "workflows."** Workflows let a developer programmatically define sub-agent orchestration as actual code (a JavaScript file Claude Code writes and can save): a `meta` (name, description, phases), `schemas` (typed outputs per phase), and prompts that can be built programmatically (loops, maps, conditional context insertion). Phases run in sequence — e.g., a "review" phase that fans out parallel sub-agents (each with an assigned model/effort/schema), followed by a "synthesizing" phase that consumes the stringified JSON results of the prior phase. Theo describes workflows he's used with up to 12 phases (example given: research → verify → synthesize → critique → finalize), each with its own schema, shared boilerplate prompt content, and filtering logic based on fields in the returned JSON (e.g., a "needs follow-up" boolean) that determines whether more sub-agent work gets queued. - **Why workflows are structurally safer.** Because the phases and their count are defined ahead of time in code, a workflow run has a hard cap on total duration/scope even if a single phase spins up many sub-agents (his example: finding 72 issues in a file could spawn 72 fix sub-agents in one phase, but the workflow still terminates once phases are exhausted). Ultra/v2, by contrast, ends only when the agents decide to stop, which is why it can run indefinitely and burn unpredictable amounts of tokens. - **Theo's verdict on what OpenAI copied wrong.** "I think OpenAI copied the wrong parts. They copied the UX, which was bad... and they didn't copy the implementation, which is good, because workflows are an awesome way to break up work programmatically." He teases a dedicated upcoming video on using GPT-5.6 inside Claude Code directly (not as a sub-agent call) via workflows. - **Practical guidance for less technical users.** Theo explicitly tells viewers who are anxious about "falling behind" that they can simply keep using default settings and ignore Ultra entirely — these companies iterate fast on feedback (he notes several of his complaints were already fixed within about six hours of him raising them on Slack), and the non-Ultra defaults for the new models are still good. - **Uncertainties/contested claims (Theo's own framing, not independently verified in this note):** the exact token-burn multiplier for max vs. x-high reasoning (he cites "up to two times more token burn... between 4% and 10% better" from a prior video, not re-derived here); whether OpenAI's system-prompt changes for v2 actually bust prompt caching (he says "not positive about that, but I would be surprised" it doesn't); and the claim that Anthropic "started this trend" of mislabeling a sub-agent toggle as a reasoning level, which is Theo's causal narrative, not something demonstrated with primary-source Anthropic documentation in this video. ### 🗒️ Notes > Source note: the transcript retrieved for this video does not contain machine-readable timestamps (no `mm:ss` markers), so segments below are organized topically in transcript order rather than anchored to exact times, to avoid fabricating timestamp data. #### 🧵 Cold open — GPT-5.6, Max, and Ultra introduced - OpenAI released three GPT-5.6 model variants plus two new reasoning levels, Max and Ultra. - Quote: "As good as OpenAI makes them sound here, saying that it's the highest capability setting, coordinating multiple agents across parallel work streams, I'm here to tell you that they're kind of lying." - Claim: "Ultra isn't a reasoning level. It is also bad." - Theo blames Anthropic for originating the pattern he considers misleading: "I blame Anthropic for all of this." #### 📣 Sponsor segment — Firecrawl - Firecrawl pitched as open-source web-scraping tooling: URL → markdown/JSON/screenshot, SDKs, CLI, free tier without an API key, search + page-interaction features, a "monitor" feature for page-change alerts, and MCP server support for ChatGPT/Codex and other tools. #### 🔍 Demonstrating that Ultra isn't a reasoning level - In the ChatGPT/Codex app, the effort slider order changed (Theo suspects due to his feedback) to hide Ultra from the main slider; it's still present under a secondary "effort" panel. - In Claude Code, selecting "Ultra Code" via `/effort` visibly sets reasoning to X-high, not to "ultra" — proving Ultra Code is a system-prompt append (skill), not a reasoning tier. - Quote: "Ultra isn't a reasoning level. It's effectively a toggle that turns on a change in your system prompt, telling the model to do more sub agents." #### 🔥 Why Ultra burns tokens — the "infinitely recursive maxes" problem - Codex's Ultra sets max reasoning for the parent agent; sub-agents inherit that same max setting because Codex currently has no mechanism to set a lower reasoning level for spawned sub-agents. - Quote: "Ultra is nearly infinitely recursive maxes, which means it burns tokens. This is the primary reason Ultra is bad." - Theo says he asked OpenAI for at least an interim fix (a hard-set sub-agent reasoning level) and considers Claude Code's implementation "far ahead" on this point. #### ⏱️ Rate-limit damage report - "I blew my first 5-hour limit in 20 minutes using ultra on fast mode... I hit the 5-hour limit twice in under an hour." - Context: OpenAI is temporarily removing the 5-hour limit because people were hitting it too fast — a change Theo calls good overall but riskier for Ultra users since the 5-hour ceiling previously acted as an early warning before burning ~20-25% of a weekly quota. #### 🧩 Codex sub-agents v1 vs. v2 - v1 described as "a dispatcher hiring temporary helpers by ticket number" — simple tool-call based spawning, root agent waits and summarizes results; this is the finished, currently-default implementation. - v2 described as "a named project team with an org chart and mailboxes" — sub-agents can message each other, spawn their own sub-agents (no depth limit, 4 concurrent by default), use path-based names, and by default share the entire main-thread history with each sub-agent (configurable to none or a set number of turns). - Quote: "By default, all of the history in your main thread is going to be shared to all of the sub agents. Spoiler, this is really [expletive] stupid." - A new `multi-agent version` field in Codex's models cache JSON hardcodes newer models (Soul/Terra) to v2 regardless of user configuration, and v1/v2 cannot run simultaneously without errors. #### 🧪 Real-world impressions of v2 - Theo turned v2 on manually before it became default; found it runs much longer and spins up more sub-agents without a clear quality improvement in his testing, and burns far more tokens. - Cites a viewer comment (JKF): "It sounds like too many people designed sub agents v2 and caused it to be bloated" — and agrees. #### 🛠️ Claude Code "workflows" as the better-designed alternative - Workflows = programmatically defined sub-agent orchestration as an actual JavaScript file: `meta` (name/description/phases), `schemas` (typed phase outputs), programmatic prompt construction, and sequential phase execution (e.g., review phase with parallel sub-agents on different models/efforts → synthesizing phase consuming prior JSON results). - Example workflows described: a 2-phase review/synthesize flow, and a more complex 5-phase flow (research, verify, synthesize, critique, finalize), plus mention of workflows with 12+ phases. - Key structural advantage: phases are fixed in code, so the workflow always terminates, even if an individual phase spawns many sub-agents (his example: 72 sub-agents to fix 72 found issues in one phase) — unlike Ultra/v2, which "ends when the agents decide to end, not when the code is completed." #### 🎯 Verdict and guidance - "I think OpenAI copied the wrong parts. They copied the UX, which was bad... and they didn't copy the implementation, which is good, because workflows are an awesome way to break up work programmatically." - Direct advice for anxious/non-technical viewers: keep using defaults, don't use Ultra, wait for the companies to iterate — "it's not that big a deal." - Shout-out to a viewer (Maria) for a mockup of what the model selector should look like (Ultra as a separate switch, not a reasoning-effort tier), which Theo says several others (TBO, Dominic, GDB) reportedly agree with. - Teases an upcoming dedicated video on using GPT-5.6 inside Claude Code via workflows. ## 📚 References - [Firecrawl](https://soydev.link/firecrawl) — video sponsor; open-source web scraping/MCP tooling mentioned in the ad read. - [Theo - t3.gg on YouTube](https://www.youtube.com/@t3dotgg) — channel source, inferred from channel metadata (channelTitle "Theo - t3․gg"). - Codex CLI (OpenAI, open source) — referenced repeatedly as the codebase Theo had GPT-5.6 read to compare v1/v2 sub-agent implementations; no specific repo URL given in the transcript. - Claude Code "workflows" feature (Anthropic) — referenced as the contrasting orchestration model; Theo references a prior video ("Claude code is good") and an upcoming video specifically about this, neither linked in the transcript. ## 🗣️ Paraphrase - Paragraph A paraphrase: OpenAI's GPT-5.6 release added a reasoning-effort option called "Ultra" that looks like just another step up from Max, but it isn't a reasoning level at all — it's a hidden instruction injected into the system prompt that tells the model to aggressively spawn sub-agents, the same trick Anthropic already uses for "Ultra Code" in Claude Code. The difference is that Anthropic's version defaults those sub-agents to a moderate (X-high) reasoning level, while OpenAI's version defaults everything — parent and every nested sub-agent — to max reasoning, with no way (yet) to dial sub-agents down independently. That's why one Ultra run torched Theo's 5-hour usage limit twice in under an hour, and why it's especially dangerous now that OpenAI has temporarily lifted the 5-hour cap that used to act as an early warning before your entire weekly quota was gone. - Paragraph B paraphrase: Underneath Ultra sits Codex's newer, still-unfinished "v2" sub-agent architecture, which lets agents send each other messages, spawn further sub-agents with no depth limit, and — by default — hands every sub-agent the entire conversation history, all of which multiplies token cost without a clear win in output quality. Theo contrasts this unfavorably with Claude Code's "workflows," where sub-agent orchestration is written as literal code with fixed phases and typed schemas, so a run always terminates predictably no matter how many sub-agents a single phase spawns. His conclusion: OpenAI borrowed Anthropic's confusing UX (folding a sub-agent toggle into the reasoning slider) but not its safer defaults, and definitely didn't adopt the code-based workflow pattern that actually solves the runaway-cost problem — so for now, skip Ultra and just use the model defaults. ## 📰 Newsletter - Heads up if you're using GPT-5.6 in Codex or the ChatGPT app: "Ultra" in the reasoning-effort menu isn't a smarter thinking mode — it's a switch that tells the model to spawn a swarm of max-reasoning sub-agents, and it can chew through a 5-hour usage limit in under 20 minutes. - Theo (t3.gg) breaks down why: Codex's newer "v2" sub-agent system lets agents message each other and spawn nested sub-agents indefinitely, shares your entire chat history with each one by default, and currently has no way to cap sub-agent reasoning below the parent's level. - The safer pattern for building your own multi-agent flows: Claude Code's "workflows," which define phases, models, and schemas in actual code so the run always has a fixed endpoint — worth a look if you're building agent orchestration and want predictable cost. - Practical takeaway for the team: hold off on Ultra in Codex for now; the plain GPT-5.6 defaults (no Ultra) are solid, and this is a fast-moving space where OpenAI has reportedly already fixed several rough edges within hours of public feedback. ## ✅ Action Items #### DevRel - Developer advocacy: none surfaced — this is third-party commentary on OpenAI/Anthropic products, not an internal DevRel program. - Education: if courtneyr.dev or gstack content touches AI coding-agent workflows, consider a short internal note warning contributors off Codex "Ultra" until reasoning-level controls for sub-agents ship. - Developer experience: none applicable — no SDKs/docs owned by us are implicated. - Developer marketing: none applicable. - Community management: none applicable. - Internal/external/cross-project: worth flagging to anyone using Codex CLI in CI or automation that Ultra/v2 sub-agents can silently multiply token spend. #### OSPO - Not applicable to this source — the video is a product-usage critique, not an open-source governance topic. #### Community - Not applicable to this source — no maintainer/contributor/sponsor ecosystem is discussed. #### WordPress - Not applicable to this source — content has no WordPress connection. #### The WPCC - Not applicable to this source. ### FAIR - Not applicable to this source. ## 🧪 Hypotheses - H1: Codex's "Ultra" reasoning level, when used with the current v2 sub-agent implementation, produces measurably higher token consumption per task than the same task run at X-high effort without Ultra. - H2: Allowing sub-agents to inherit a lower reasoning level than their parent (as Claude Code's Ultra Code does by defaulting to X-high) would reduce average token burn for multi-agent tasks without a proportional loss in output quality. - H3: Code-defined orchestration (Claude Code "workflows") produces more predictable total run time/cost than tool-call-driven sub-agent spawning (Codex v1/v2) for equivalent multi-step tasks. - H4: Sharing full conversation history with every sub-agent (Codex v2's default) does not improve task accuracy enough to justify its added token cost compared to sharing a summarized or truncated context. - H5: Public developer feedback (Slack/Twitter) measurably accelerates iteration speed on frontier-lab agent-tooling UX compared to standard internal QA/beta cycles. ### 📊 Methodology - H1/H2: Controlled task battery run at fixed prompts across effort settings (X-high, Max, Ultra) and sub-agent-reasoning configurations, measuring input/output tokens and wall-clock time via API usage logs; repeat across several task types (code review, bug fix, multi-file refactor). - H3: A/B run identical multi-phase tasks through Codex v1, Codex v2, and Claude Code workflows; measure total tokens, total sub-agent count, and wall-clock time to completion; compare variance in these metrics across repeated runs of the same task. - H4: Ablation test — run the same sub-agent task with full-history sharing vs. summarized-context sharing vs. no shared history; score output quality with a fixed rubric or human/LLM-judge review and compare against token cost. - H5: Track time-to-fix between a documented public complaint (e.g., a timestamped tweet or Slack message) and the corresponding shipped change in release notes/changelogs, across multiple reported issues, to see if the "six-hour fix" anecdote generalizes. ### ❓ Questions - Will OpenAI expose a way to set sub-agent reasoning levels independently of the parent agent's level, and on what timeline? - Does Codex's v2 system-prompt change actually invalidate prompt caching, as Theo suspects but doesn't confirm? - What is Anthropic's own stated design rationale for defaulting Ultra Code's sub-agents to X-high rather than max — is this documented anywhere, or is it inferred purely from observed behavior? - Will OpenAI move Ultra out of the reasoning-effort slider and into a separate toggle, as suggested by the viewer mockup (Maria) referenced in the video? - How does removing the 5-hour Codex usage limit interact with Ultra/v2 specifically — has OpenAI published guidance on this combination? ### 🔮 Future Research - A side-by-side benchmark of Codex v1 vs. v2 vs. Claude Code workflows on identical real-world coding tasks, scoring both output quality and total cost. - Investigation into whether GPT-5.6's resistance to "context pollution" (mentioned as better but not perfect) can be quantified across the full-history-sharing default in v2. - Tracking whether OpenAI's rapid post-launch patches (referenced anecdotally) hold up over a longer window, to assess whether "wait and it'll get fixed" is a reliable general strategy for this product category. ### 💡 Implications - Practice: teams building on Codex should treat "Ultra" as experimental/unstable rather than a premium quality tier, and budget monitoring accordingly until sub-agent reasoning controls ship. - Policy: usage-limit policy changes (like temporarily removing the 5-hour cap) interact with feature design (Ultra's runaway sub-agent spawning) in ways that can surprise users; vendors arguably owe clearer warnings when relaxing one safety rail while another (reasoning-level inheritance) remains unaddressed. - Security: none directly discussed in this source — no security vulnerabilities are covered, only cost/rate-limit risk. - Education: content like this functions as informal user education filling a documentation gap; official docs describing Ultra as "the highest capability setting" arguably understate the actual behavior and risk. - Funding models: the sponsor segment (Firecrawl) reflects a common creator-economy funding pattern for this kind of technical content; not a structural implication of the main topic. ### 🧠 Learning Styles Assessment - Reading level estimate: transcript is conversational, first-person, and technical without being formally structured; approximate Flesch-Kincaid grade level 8-9 (long run-on spoken sentences raise the score despite simple vocabulary). #### 👀 Visual learners - Present: original video includes on-screen terminal demos, UI screenshots of the effort selector, and diagrams of the workflow phases (not visible in transcript-only form). - Improve: this text-only note would benefit from screenshots of the Codex effort slider, a diagram contrasting v1 vs. v2 sub-agent trees, and a labeled diagram of a workflow's phase sequence. #### 🔊 Aural learners - Present: the source itself is narrated video/audio content — well suited to aural learners in its native form. - Improve: a short (2-3 min) audio-only recap of the "why Ultra is bad" argument would serve listeners who don't want the full 26 minutes. #### 🗣️ Verbal learners - Present: Theo defines terms conversationally (e.g., "Ultra Code is a skill," "workflows are a way to programmatically define...") and uses analogies (v1 as "a dispatcher hiring temporary helpers," v2 as "a named project team with... mailboxes"). - Improve: a short glossary (Ultra, sub-agent, workflow, mailbox, reasoning effort) would help readers unfamiliar with agent-tooling jargon. #### 🧩 Kinesthetic learners - Present: none directly — video is demonstrative/verbal, not hands-on for the viewer. - Improve: a companion checklist ("how to check what reasoning level your sub-agents are actually running at") would give kinesthetic learners something to do. #### 🧠 Logical learners - Present: the v1-vs-v2 comparison and phase-based workflow description are inherently structured/logical. - Improve: a table comparing Codex v1, Codex v2, and Claude Code workflows across dimensions (context sharing, depth limit, termination condition, reasoning-level control) would suit logical learners better than prose. #### 🧑‍🤝‍🧑 Social learners - Present: Theo explicitly cites viewer/community feedback (JKF's comment, Maria's mockup, Twitter crash-outs) as part of the narrative. - Improve: linking directly to the referenced tweets/comments would let social learners follow the actual discussion thread. #### 🧘‍♀️ Solitary learners - Present: the video works as a solo-watch explainer; no interactive prompts. - Improve: a short self-check ("do you know whether your current agent session is using Ultra? how would you check?") would suit solitary reflection. #### 🌿 Naturalistic learners - Present: none — the topic is entirely about software architecture and API cost, with no environmental or ecosystem framing. - Improve: not a natural fit for this content; skip rather than force a naturalistic angle. ### 📊 Accessibility Assessment #### Screen reader semantics - Present: this note uses heading structure that a screen reader can navigate; the original video would rely on YouTube's caption track. - Improve: ensure the video itself has accurate closed captions (the auto-generated transcript used here contains garbled words like "aents" for "agents" and "56 soul" for what is likely "GPT-5.6" spoken as "five six" — suggesting captions may need manual cleanup for accessibility). #### Keyboard navigation - Not applicable to this source — this is a video/text artifact, not an interactive interface. #### Contrast and readability - Present: this markdown note uses plain text with heading hierarchy, which renders with theme-appropriate contrast in most Markdown viewers. - Improve: not applicable beyond standard Markdown rendering. #### Text resizing and reflow - Not applicable to this source — no fixed-layout media in the note itself. #### Media and captions - Present: the video presumably has YouTube's auto-captions (the retrieved transcript appears to be auto-generated, given transcription artifacts). - Improve: a manually corrected caption/transcript would fix garbled technical terms ("aents"→"agents", model names) for deaf/hard-of-hearing viewers relying on captions. #### Forms and interactions - Not applicable to this source — no forms involved. #### Standards reference - Caption accuracy gap maps to WCAG 2.2 AA 1.2.2 (Captions, Prerecorded) — auto-generated captions with transcription errors are a common but incomplete way to meet this criterion. ### 🌍 DEIB Assessment #### Cultural breadth - Present: none specific — content is US-centric tech-industry commentary (OpenAI, Anthropic, English-language developer tooling). - Improve: no international examples or non-English tooling perspectives are included; not essential to this topic but worth noting as a gap. #### Inclusive language - Present: casual, informal register throughout ("crash out," "kind of lying," bleeped profanity); not exclusionary but very in-group/developer-culture specific. - Improve: a plain-language summary paragraph would help readers outside the Codex/Claude Code power-user niche follow the core claim. #### Neurodiversity support - Present: the Main Content and Notes sections above impose chunked structure on otherwise very long, run-on spoken sentences. - Improve: the original spoken delivery is dense and tangential (frequent self-interruption, "don't worry, we'll get there"); a structured written explainer benefits neurodivergent readers who find rambling audio harder to parse. #### Representation - Present: the video credits an editor (Ph4seon3) and quotes a viewer comment (JKF) and a mockup contributor (Maria) by name. - Improve: no further representation concerns identified in this technical/product-critique content. #### Psychological safety - Present: tone is critical of specific companies/products but not of individuals; frustration is aimed at product design decisions ("I blame Anthropic for all of this" is framed as tongue-in-cheek/hyperbolic, immediately followed by acknowledging Anthropic "did mostly get this right"). - Improve: none needed — the tone stays within normal tech-critique bounds without targeting individuals. ### ✅ Logical Validity #### Strong reasoning - Causal demonstration: Theo shows (not just asserts) that selecting "Ultra Code" in Claude Code visibly sets the reasoning-effort display to X-high rather than "ultra," which directly supports his core claim that Ultra is not itself a reasoning level. This is strong because it's an observed, repeatable UI behavior, not just an inference. - Empirical/anecdotal evidence: the specific account of hitting the 5-hour limit twice in under an hour is a concrete, falsifiable claim (checkable against his own usage logs) that supports the "Ultra burns tokens excessively" argument better than a general assertion would. - To clarify further: the note above already flags that his "2x token burn for max vs. x-high" figure is cited from a separate prior video and not re-derived here — readers should treat it as Theo's earlier claim, not independently verified in this transcript. #### Fallacies - Hasty generalization (mild): "I think max makes sense almost ever" and broader claims about token-burn multipliers are extrapolated from his own testing/benchmarks referenced from another video, not shown in this one — presented with appropriate hedging ("depending on the bench") but still asserted as a general rule. - Appeal to authority/social proof: the closing line — "it seems like everybody from TBO to Dominic to even GDB himself agrees" — leans on named authority figures agreeing with him, without detailing their actual reasoning; a fix would be to quote or link their specific arguments rather than naming them as validators. - Post hoc framing (mild): Theo attributes recent Codex UI changes (hiding Ultra from the main slider) to OpenAI "listening to me," based on timing correlation with his feedback rather than confirmed causation; he does hedge this ("I think they actually listened to me"), which softens but doesn't eliminate the fallacy risk. #### Tone of voice - Predominantly informal, high-energy, self-aware "ranting" register ("I am at the point where I am now using 56 soul in other harnesses," "Oh boy," "I crashed out pretty hard about this on Twitter") — Theo explicitly names his own tone ("I know I am crashing out hard about this") and contextualizes it as enthusiast intensity rather than alarmism, then pivots to reassuring, calmer guidance for less technical viewers. ### 🛡️ DARVO Analysis - Not applicable to this source — DARVO (Deny, Attack, Reverse Victim/Offender) is a framework for analyzing responses to accusations of wrongdoing between people/institutions in conflict. This video is technical product commentary; no party is denying an accusation, attacking an accuser's credibility, or reversing victim/offender status. The closest analog — Theo's "I blame Anthropic for all of this" — is presented as a self-aware, hyperbolic joke immediately qualified by praise for Anthropic's implementation choices, not a genuine DARVO-style deflection. ## 🎯 Conclusion - Bottom line: Codex's "Ultra" reasoning level is not a reasoning level at all — it's a system-prompt toggle that forces max-reasoning sub-agents, currently with no way to cap sub-agent reasoning independently, which makes it capable of burning an entire multi-hour usage quota in minutes. Claude Code's equivalent ("Ultra Code") has a safer default (X-high for sub-agents) but the same underlying pattern of disguising a sub-agent toggle as a reasoning tier. The structurally better approach, in Theo's view, is Claude Code's code-defined "workflows," which guarantee a run terminates because the phases are fixed in code rather than left to the model's discretion. - Practical next steps for readers: avoid Codex's Ultra option until sub-agent reasoning-level controls ship; if orchestrating multi-agent tasks yourself, prefer fixed-phase, schema-driven workflows over open-ended sub-agent tool-calling; and if anxious about keeping up, it's safe to simply use GPT-5.6's non-Ultra defaults and wait for these rough edges to be patched. ## 🔄 Refactor Appendix — I can't believe they released this > Density: 2–5 Literature atoms (H3), 0–3 Permanent candidates (H4). > Defaults: 3 Literature, 1 Permanent. Resonance filter: if you can't > articulate in one line why a claim matters, drop it. > > Konik claim-header rules: present tense, declarative, ≤10 words when > possible, searchable, unique, mirrors annotation focus if present. > > Atomicity: one declarative sentence per atom. "and"/"also" → split. > > Tag pool: #bmf · #addendum · #xref · #articleseed · #storystem · #share · #aphorisms ### 📚 Literature Atoms (H3) #### Ultra is a system-prompt toggle, not a reasoning level > [!quote] ID:rw_atom1 > "Ultra isn't a reasoning level. It's effectively a toggle that turns on a change in your system prompt, telling the model to do more sub agents." **Context & use**: - Mid-video, after the Claude Code demonstration where selecting Ultra Code visibly sets effort to X-high instead of "ultra." - This is the load-bearing claim of the whole video — everything about token burn and rate-limit risk follows from it. **Tags**: #xref **Highlight**: [view highlight](readwise://t8hfOyF4ehw)  #### Codex Ultra inherits max reasoning into every sub-agent > [!quote] ID:rw_atom2 > "Ultra is nearly infinitely recursive maxes, which means it burns tokens. This is the primary reason Ultra is bad." **Context & use**: - Follows the explanation that Codex's sub-agent implementation has no current way to set sub-agents to a lower reasoning level than the parent. - Directly explains the mechanism behind the rate-limit-nuking anecdote later in the video. **Tags**: #xref #addendum **Highlight**: [view highlight](readwise://t8hfOyF4ehw)  #### One Ultra run can exhaust a 5-hour usage limit in 20 minutes > [!quote] ID:rw_atom3 > "I blew my first 5-hour limit in 20 minutes using ultra on fast mode cuz I didn't know how much crazier it would be." **Context & use**: - Personal usage anecdote given as concrete evidence for the token-burn claim. - Practically useful as a cautionary data point for anyone considering enabling Ultra. **Tags**: #share **Highlight**: [view highlight](readwise://t8hfOyF4ehw)  #### Workflows guarantee termination; open-ended sub-agents don't > [!quote] ID:rw_atom4 > "Ultra is much more likely to just go forever because it ends when the agents decide to end, not when the code is completed." **Context & use**: - Comes during the contrast between Codex's tool-call-driven sub-agent spawning and Claude Code's code-defined workflow phases. - Names the structural design difference that Theo considers the actual fix for runaway cost. **Tags**: #xref #articleseed **Highlight**: [view highlight](readwise://t8hfOyF4ehw)  ### 🧠 Permanent Candidates (H4) #### Orchestration that terminates by code beats orchestration that terminates by model choice **Claim** (one sentence, Courtney's voice): When a multi-agent system's stopping condition is written in code (fixed phases) rather than left to the model's judgment, total cost and runtime stay bounded no matter how much work a single phase generates. **Evidence pointer**: [[#Workflows guarantee termination; open-ended sub-agents don't]] **Scope & conditions**: Holds for any agentic system where token cost scales with agent count and turn count; breaks down if the fixed phases themselves are too coarse-grained to bound the work inside a single phase (e.g., a phase that fans out to an unbounded number of sub-agents with no per-phase cap). **Links** (≥1 with annotation): - [[Codex sub-agent v1 vs v2 tradeoffs]] — because contrasts on control vs. flexibility - [[Claude Code workflows design]] — because applies-in agent-orchestration design decisions  ### ✏️ Fleeting Queue - [F1] Check whether OpenAI ships independent sub-agent reasoning-level controls for Codex, and whether that changes the Ultra cost profile — https://www.youtube.com/watch?v=t8hfOyF4ehw #xref - [F2] Watch for Theo's teased follow-up video on using GPT-5.6 inside Claude Code via workflows — likely relevant if courtneyr.dev or gstack tooling ever adopts similar multi-agent orchestration patterns #articleseed ### → Things 3 (max 2 actions) - [ ] Avoid enabling "Ultra" in Codex/ChatGPT until sub-agent reasoning-level caps ship — general AI-tooling hygiene #things