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) > <!-- atomicity: 1 idea ✓ --> > #### 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) > <!-- atomicity: 1 idea ✓ --> > #### 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) > <!-- atomicity: 1 idea ✓ --> > #### 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) > <!-- atomicity: 1 idea ✓ --> > ### 🧠 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 > <!-- atomicity: 1 idea ✓ --> > ### ✏️ 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 When OpenAI put out GBD 5.6, they didn'tjust put out a new model. They put outthree. But they didn't just put outthree new models either. They also putout two new reasoning levels. They addedmax and ultra as options you can use intools like Codeex. And I'm here to tellyou something about those options. Asgood as OpenAI makes them sound here,saying that it's the highest capabilitysetting, coordinating multiple agentsacross parallel work streams, I'm hereto tell you that they're kind of lying. Not because Ultra is bad, because Ultraisn't a reasoning level. It is also bad,which we'll talk about plenty, don'tworry. But the thing I want to make sureis clear is that Ultra is probably notwhat you think it is. But also, it isbad. I am incredibly frustrated with theway Ultra has been rolled out. Bothbecause it was not available to meduring my early access testing, so I hadto build all my familiarity with it inthe last few days, and also because it'sCaused a ton of confusion to people whoare trying to use these models the bestthey possibly can. And ready for themost unexpected twist here? I blameAnthropic for all of this. OpenAI aswell for shipping something that doesn't work. But Anthropic are the ones whostarted this trend that is not very goodand is misleading people like you and Iinto using things incorrectly and notreally knowing how to talk about them. Ihave a bunch of questions I want toanswer in this video. What is Ultra? Whyis it bad? How can it be fixed? And mostimportantly, what the [\_\_] is going onwith codecs? Because I am at the pointwhere I am now using 56 soul in otherharnesses. Specifically, here I am usingit in Claude code. I want to do my bestto break down what's going on and whyI'm making all these changes after areal quick break for today's sponsor. There's a weird contradiction I've beennoticing with AI. On one hand, itbenefits greatly from having access toThings on the internet. But on the otherhand, thanks to AI and all of thescraping that's been going on, most ofthe websites and sources that I need toget that info from have locked down andare nearly impossible to access. If onlythere was a really good open-sourcesolution that would allow your agents toaccess data in formats they understandfrom all over the web. Oh, is it on thescreen? Yeah, wire crawl is that. Theybuilt all the open source tooling youragents need to get data out of the web. And they also offer a super generoushosting platform for doing it yourself.I know most of us aren't reading outputsfrom APIs anymore, but they really arethis simple. You put in a URL, and whatyou get back is a markdown version ofthe page, a JSON version of the page, aswell as a screenshot of the pagescontent. They have SDKs for pretty mucheverything you're already using. And ifnot, you can always curl or use theirCLI, which honestly, the CLI has really,Really impressed me. Once you paste anAPI key, you can just tell your agentsabout it, and it'll give them access toinfo they might not have otherwise hadaccess to. And the result is supersimple markdown that your agents canactually understand and use for things. If all they offered was this direct URLscraping, it would already be one of themost useful things in my toolbox. Butthey offer way more. They have a generalsearch for finding things on the webthat you might not already have a URLfor, as well as interaction for when youwant to actually do things on a page. Myfavorite though is the monitoringfeature. Monitor lets you get notifiedwhen something changes on a page, likemaybe a price goes down or a releasehappens or an early access thing comesthrough. It's so useful for you and youragents to know when things change on theweb. And as great as the API is, notevery tool can use it, but you knowwhat? They can use an MCP server. Do youKnow how useful this is for Chat GPT andCodeex as well as every other tool ever. It's incredible. Two more really quickthings they wanted me to make sure youknow. The first is that you can use thiswithout even having an API key. It'sjust free. You'll hit limits eventually,at which point you can go add an APIkey, but like it's insane how generousall of these tiers are. You get a tonfor no money. And if you do need somemoney, they can help with that, too,because they're currently hiring. So, ifthis is interesting, hit them up. Givethe whole web tier your agents atsoy.firecrawl. First and foremost, let's start withwhat is Ultra. I'll start in theterminal so I can show you when youselect the model that Ultra is presentedhere as a reasoning level. You have low,medium, high, extra high, max, andUltra. If you use the Chat GPT app,formerly known as the Codeex app, theyStarts at the bottom as terraite, thenit goes to soul light, then soul medium,soul high, soul extra high. This is achange. It was going to ultra before, andI think they actually listened to me, andthey hid ultra from that slider. Ishouldn't have installed the update Ijust installed because, before I installed the update, ultra was at theend of this list. I have told OpenAIverbatim multiple times now that Ultrashould never have been included the wayit was in this selector. It even had afancy purple gradient it would do whenyou did it before. I'm thankful theykilled that because that was the biggestmistake. Why is it a mistake? It's becauseUltra isn't a reasoning level. I'llexplain in the easiest way I know how,which is with Claude code. Not becauseI'm going to ask it to explain, but Iwant to show you what happens when youdo slash effort. You have options here. Low, medium, high, XH high, max, andultra code. Huh? Ultra code. Ultra Ultra. Code. I wonder if there's some overlaphere. Ultra code was a pretty coolfeature in Claude Code, but you'llnotice underneath here, Ultraode saysX High plus workflows. Hmm. If you haven'tbeen keeping up with my recent proclacode arc, this is the big part of whyit's workflows. Ultra code isn'tworkflows, but it's a way to triggerthem. The more important piece to lookat here is the other thing it saysunderneath, which is X high. Youroptions are high, XH high, max with thefancy little like gradient on the textthere, but then ultra code does thesuper fancy gradient. Silly, but watchat the top here. I currently have Fable5 with high effort selected. So, when Ipress enter here, it's going to changethat to ultra, right? Nope. It changesit to Fable 5 with X high effort. Andultra code is just a state in thebottom. The reason for that is thatultra code isn't a reasoning level.Ultra code is a skill, and ultra is two. What do I mean by that? What I mean isthat it's the same as when you do aslash command to pull in a skill whereit takes the content of that markdownfile and it appends it to the systemprompt, so it's there when the nextmessage comes through. The reason theydo this is they want to make it easierto trigger sub agents. Ultra and UltraCode are both instructions for the modelto use way more sub agents. In CloudCode, this works through workflows, andin Codeex, it works through the agentimplementations called V1 and V2, whichI will crash out about momentarily. Don't worry. I just wanted to make surethat we understood this first andforemost. Ultra isn't a reasoning level.It's effectively a toggle that turns ona change in your system prompt, tellingthe model to do more sub agents. As muchas I love to give anthropic [ \_\_ ] theydid mostly get this right. It's a littletoo easy to leave Ultra Code on, whichisn't great. But as an implementationWith the system prompt change andspecifically the default to X,high effort, not to max, when you go toultra, the reasoning level is lower thanit was on max. Again, when I go toslash effort, low, medium, high, XH high,max, ultra. And the thing that'sunintuitive is that Ultra Code actuallypoints at X high, not at max. This isnot what Codeex does. Sorry, this is notwhat Chat GBT does. I also can't helpbut notice they are hiding the maxoption now. They're listening to me. It's fun seeing in real time OpenAImaking changes based on the things thatI'm shouting about on the internet. ButUltra is still hidden here under effortwhere it never should have been in thefirst place. When we click it, you'llsee all of these other changes under thehood. Ultra is using max reasoninglevels, which is absurd because maxreasoning burns tokens. I talked aboutthis a bit in my previous cost savingsvideo, but the TLDR is that max does up. To two times more token burn than X,higher high. Depending on the bench,it's between 4% and 10% better at morethan 2x the cost. So, I don't think maxmakes sense almost ever. But ultra isn'tmax. Ultra is nearly infinitelyrecursive maxes, which means it burnstokens. This is the primary reason Ultrais bad. The problem is that the parentagent and all of the sub agents are setto max reasoning. Well, Theo, this is aneasy fix. Just tell the parent agent,the top level, to spin up the sub agentson a lower reasoning level. I'll havemore to say on this in a bit, but theTLDR for now is that the version of subagents that SOUL uses does not currentlyallow for selection of reasoning levels. So, if you have ultra set, all of thechildren sub-agents spawned are alsogoing to be ultra. I crashed out prettyhard about this on Twitter, going as faras to say that Claude's code is far ahead. At the very least, they should give mean interim solution where I can hard set. Sub aent reasoning levels. The currentimplementation is so bad that I think ithas caused this perception shift wherepeople think that the new models are wayless efficient and will destroy yourrate limits. The new models won't dothat. At least with a little bit ofcareful use, they won't do that. Ultraabsolutely will. I blew my first 5-hourlimit in 20 minutes using ultra on fastmode because I didn't know how much crazierit would be. Instantaneously evaporatedmy limit. I burned a manual reset and Ievaporated again, another 40 minutes. Ihit the 5-hour limit twice in under anhour. All because I had one ultra rungoing. Hitting your 5-hour limit in 20minutes is bad, but what would be much worse is hitting your weekly limit in anhour and a half, which is dangerouslypossible right now because OpenAI istemporarily removing the 5-hour limitdue to people hitting it too fast. Thisis a good change overall, but if you'reusing Ultra, it's a little scary becausePreviously, that 5-hour limit being hitis almost a warning, like a hey, becareful. You're going to overuse thisand lose your weekly limit. And sincethe five-hour is like 20 to 25% of yourweekly, you would only lose 20 to 25% ofyour weekly usage. With this change, itis very much possible that Ultra couldnuke your whole week. So, be careful. I'm realizing now that the order ofevents I planned here isn't actuallygoing to make a lot of sense. So, I'mgoing to move how it can be fixed to beafter my rant about the current state ofCodeex. Oh, boy. So, as I said, the sub-aents version beingused doesn't expose the necessaryfunctionality. What do I mean by that?Well, what I mean is that there are twoversions of sub-aents in Codeex rightnow, labeled v1 and v2 internally. TheCodec CLI, which is what powers theCodeex desktop app, is open source. So, wecan actually look through the code here.I have 56 soul in Codec and Claude Code. Breaking down how the sub agentimplementations work, so that we cancompare based on their findings. Codexfinished first. I'll look at cloud codesfor the difference in a minute. I hadthem both going through the actual codebase to try and break up the differencebetween these implementations. ObviouslyLLM speak, so we'll get through and Iwill do my best to clean it up. V1 islike a dispatcher hiring temporaryhelpers by ticket number. V2 is like anamed project team with an org chart andmailboxes. Good enough. V1 is very much a simpletool call that is a way the model cantrigger another submodel to go dosomething. So let's say you tell themodel to go review three PRs. It canspin up three sub agents, one for each PR,with the instructions to go do that onething, and then when they're done,they'll all send up their findings, andthat top-level agent will decide what todo from there. Side note, this page isUgly as sin. I have things to say aboutthat soon, don't worry. But it startshere with five definitions worthknowing. They refer to the parent agentas the root agent. I think that's fine. Then there are the sub-agents, which arethe things spawned by that root agent.Sub-agents can also spawn themselves.We'll have to deal with that in a bit.Then there is the context, which is allof the info that the top-level agent andthe sub-agents have. Usually, sub-agentsare spawned by writing a new prompt orsummarizing the stuff going on in themain thread so that the sub-agent has alimited set of context. Remember thatbecause there are things going on here. The mailbox is a new concept in the V2implementation, where there are messagesfor the team as well as the ability tosend messages between different agents.And then there are slots, which are thenumber of agents that can be running, andthe shared workspace, which is the filesthe agents are working on. This does notNeed to be in here. This is not a greatdescription. What a surprise. The veryleast, it made decent diagrams here withV1. You have that root level agent, andit can spawn sub-agents to do specificthings that return a result when they'redone. V2 is a complete overhaul wherethe different sub-agents can talk to eachother and spawn sub-agents of their own. This sound familiar? Remember thatinfinite recursion thing I was talkingabout with Ultra? Yeah. There's aproblem, though. V1 is the finishedimplementation. This is what Codeex usesby default. And V2 is an overhaul thatthey are still working on. It's still awork in progress. V2 is very muchunfinished, and if you turn it on, youget errors for having V1 at all. Especially if you have anything changedabout V1, like custom limits, custominstructions, whatnot. You can't have V1and V2 on at the same time until now,because it's a really, really annoyingexception. In the models cache JSON,File, which is the file that Codeex usesto determine which models are availableto you, there's a new field they added. Multi-agent version, which is V2 forSoul and Terra, and V1 for everything.So now it doesn't matter what youhave configured or if you've manuallyopted into V2, the new models are alwaysrouting to V2. But V2 has some otherquirks. With V1, Codex had access tothis handful of tools for spawning,sending, waiting, closing, and resumingsub agents. They would create a separatethread, effectively with its own contextfor the agent to go do its thing, andthen respond when it's done. The parentwould wait for the agents to be complete,and then summarize whatever it got back. V2 is quite different because now it isbreaking down tasks instead of just subagents. An agent requires a task name. Aroot child named research becomes/root/research. Its tests become /root/research/tests.So, this is a path-based naming scheme forAgents to spawn sub agents. But thebiggest issue for me is the way ithandles context sharing. By default, allof the history in your main thread isgoing to be shared to all of the subagents. Spoiler, this is really [ \_\_ ]stupid. While 56 is way better at notfalling for context pollution where somebad thing in the history affects how itbehaves, it still does. This also is amassive increase in cost because the subagents now have way more context. I wouldassume that part of why they did this isto keep the cache consistent between theparent agent and the sub agents, but I'malso pretty sure there are changes inthe system prompt which is slightlyhigher, therefore busting the cache. Notpositive about that, but I would besurprised. Either way, getting one cacheright at the start of a new sub agentthread is far from a high cost. I thinkit's stupid to try and preserve cachebetween the parent or sorry, root agentand the sub agents. So, yeah, dumb. IDon't like this at all. As I said, bydefault, it now takes all of your turnsin all of the history when it goes tothat sub agent. But you can setdifferent amounts to share, like none ora number like three. And as I said, thedefault is the full history, which Ithink is really dumb. It also filtersout the tool calls. So that breaks cash. Where things start to get really weirdis this idea of mailboxes. Instead ofjust having a sub agent go do some workand then respond when it's done, theynow can send typed messages between eachother. Send message cues or notes.Follow-up task gives an idle helper morework and can start its next turn. Thisallows for the parent agent to sendadditional work down to an existing subagent when it decides it wants moredone. This is one of those things whereit, like, does genuinely sound reallyreally cool. In reality, mixed results. The finished work is routed to thedirect parent. So again, if they'reNested, tests send its results toresearch, which sends its results toroot. Yeah. And waiting no longer meanswait till it's done. It means wait tillwe get a message back. The root agentcan also list all of the sub agents andeven interrupt them if, for some reason,it wants to. If it got info from anothersub agent, it's like, "Oh, that thingprobably doesn't matter anymore. I cankill that." There is no depth limit inV2, so it could spawn infinitely nestedsub agents, but it can only run four at atime by default, which I had changed,which is a big part of how I hit crazyusage so quickly. Random observation, Idid run this prompt on both Codeex andClaude Code. Claude Code took a bitlonger. Again, I was using 56 soul onboth. If you feel like this design's alittle bloated, you're not the only one. I love this message from JFK here. Itsounds like too many people designed subagents v2 and caused it to be bloated. Iagree. I don't really like the design ofV2, and I didn't use it much when I wastesting 56 soul because again, theyhadn't added this change where it woulddefault route to V2. I did turn it onmanually near the end of my testing outof curiosity, and I noticed it would worka lot longer. Didn't get far enough onreal work to really see a difference inthe quality of the output, but itdefinitely goes a lot longer and spinsup a lot more. Don't necessarily lovethat, but it can. All of that said, I'vebeen using it more since, and I'm notreally impressed with the quality of thework and output I get from V2 with thecurrent settings and setup in codecs. While I do love the ability to spawn subagents to break up work and control thecontext a bit more, the changes to howcontext is managed and the changes tohow messages are passed make thisnoisier, is the simplest I can put it.And it also burns way, way, way moretokens as a result. And this leads us toour final question of how can it beFixed. I know this stuff scares a lot ofpeople, like they're afraid if they don'tget it right initially, they might missout on this opportunity. They might fallbehind all these things, and a lot of youguys are trying so hard to stay on topof the best solutions. If you're hereout of fear and not out of excitementand curiosity, the only thing I want you to take from this is that you shouldjust wait a bit. The currentimplementation is bad and has roughedges, but the OpenAI team is incredibleat taking feedback. I have been shockedas I film, at just how many of the thingsI'm complaining to them about have beenaddressed between the sixish hours agowhere I sent the complaint on Slack, andnow, when it's not there anymore. If youjust wait a little bit, these thingswill improve. It's continuing to use thedefaults and trusting that thesecompanies will get it figured outeventually, you'll be fine. It's notthat big a deal. I know I am crashing. Out hard about this, but I want you torealize this is because I am a hardcorenerd who cares too much and is justdigging into the details because theywant to. You don't have to do this tostay ahead. You can just use the toolsas they work by default, and they arestill really good. With all of thatsaid, I think OpenAI needs to rethinkhow they do sub agents. As I mentionedbefore, Ultra in Codeex is a prettyblatant copy of Ultra code in Claudecode, at least in how it is meant towork, where it's added to the reasoningeffort slider. It is meant to triggersub agents and be a way to force subagents on. It basically just appends tothe system prompt. Please, please,please use sub agents. But in Ultra onCodeex, it is doing that through theseweird sub agent tools like we've seen many times before. In Cloud Code, it'susing workflows. I've talked aboutworkflows a bunch before in my Claudecode is good video, and I plan to talkAbout them even more in my Claudeex video,where I show how I'm using 56 soulin cloud code directly, not as a subagent or a thing that cloud code calls,literally as the model inside of cloudcode directly. It's way better than Ithought it would be. The reason I'mdoing this is workflows. To put itsimply, workflows are a way toprogrammatically define a bunch of subagent stuff. In cloud code, you canactually save the file it writes becauseit's making a JavaScript file to do thiswork. And that's by defining a meta,which is a name, a description, and different phases because it has stagesthroughout its work. It then hasschemas, which are the typed outputsthat each of the phases should have. Itthen writes a prompt, and this isprogrammatic. So if it wants to insertthings programmatically, use a map orsome type of loop to add context in anddo different steps, it can because it isjust code. Once this is all defined, itCan call the different phases. Sorry tomy editor phase as I'm talking aboutphases. I'm sure that won't be confusingat all. So it starts phase reviewing. Itdefines reviews as a bunch of parallelagents. We have the first one here,which is a hard-coded prompt. Yourassigned perspective is 56 soul at highreasoning effort label review 56 soulphase reviewing model 56 soul effort high schema review schema agent typegeneral purpose and we do the same herewith another one that's using terra aswell and then one here using fable cuz Iasked it to use all three of these oncethis phase is completed because rememberwe awaited it up here I know crazy we'rereading code in a theo video again itstarts the synthesizing phase where itawaits another agent call where it ispassed these review results s as a JSONblob that's been stringified. And nowanother agent using Fable 5 on high isgoing to process all of the data it wasgiven and respond following theSynthesis schema. And this is how youcan programmatically use subagents. Allof the stages are defined ahead of time. And depending on what the outputs of agiven stage are or a given agent runare, it can decide if it should put theresults in another run in another subagent in a different stage. This one isreally, really simple because there wasonly two phases. There's the reviewphase and the synthesizing phase. I'vehad many more complex ones, though. I'vehad some that had 12 plus phases. Here'sone that had five. It was research,verify, synthesize, critique, andfinalize. Each of those got a schema for how theoutput should be formatted. It was givena common prompt to append to the top ofall of them because all of them need toknow what the directory is and a bit ofother information. It created thesedifferent topics that are keys andprompts for different things that we'llbe doing throughout. It then starts theResearch phase. It goes through anddefines multiple sub-agent to do all ofthat. It clears out any that didn't havean actual response in case that happens. But you can also filter based on a givenfield. Like if you had a field in theresponse that was should keepresearching true or false or needsanother review or needs follow-up orsolves problem whatever it decides toput in here. It can now use that contentto determine where to pass off the worknext because it is code. The problemwith most sub-agent implementations isthat they're leaning too hard into toolcalls. They work because the model willspit out a call, spin-up sub-agent withthis information, and then it does it, andthen it does another tool call foranother, and then it does it, and then itdoes it again, where the agent has tokeep all of this context itself and spineverything up as part of the LLM's work. With workflows, it's hardcoded but it'shardcoded on the fly. Previously, subAgents were just full-on hard-coded wherecertain harnesses, cough cough, oh Mike,PI, cough, cough, open code, hadhardcoded sub Agents descriptions likeThis is a researcher sub Agent. It doesthese things. This is an implement subAgent. It does these things. Workflows area really cool in-between where on thefly, it will create these different subAgent types and classes, and what they'reexpected to return with, and then createa flow, a workflow if you will, whereeach stage is determined based on whathappened on the fly with code that waswritten ahead of time. This does a few things really well, but the biggest itdoes is it kind of puts a hard cap onwhen this all ends. Instead of justgoing forever, which is really possiblewith Codeex's Ultra implementation,there's a fixed number of phases. Soeventually, it will get to the end. Itmight spin up a shitload of sub-agents in one field. For example, if you ask itto read three files and find things thatAre worth fixing, it might find 72things to fix in the first file and itmight spin up 72 sub agents in the nextsection, the next phase where it isfixing the things that it finds. That'sfine though because it will eventuallyget to the end always. Ultra is muchmore likely to just go forever becauseit ends when the agents decide to end, not when the code is completed. So, whatI'm trying to say is I think OpenAIcopied the wrong parts. They copied theUX, which was bad, where they disguisedit as a reasoning level where it isn't,and they didn't copy the implementation,which is good, because workflows are anawesome way to break up workprogrammatically. They are so awesomethat I'm causing problems for a lot ofpeople because of it. And I have a wholededicated video coming up about my usageof 56 soul in Claude Code. It's probablygoing to be the next video I post. So,make sure you subscribe and hit thatbell if you want to see it as soon as itDrops. I think you'll be surprised. Spoiler, I'm going to spend the majorityof this video crashing out about thesystem prompt in Codeex because it is somuch worse than I thought it would be.One last thing, shout out to Maria formaking this awesome demo of what themodel selector should look like inCodeex. Sorry, ChatGPT. You have thedifferent models in different effortlevels, but you also have Ultra as aswitch on the side. Because again, Ultraisn’t an effort level. Ultra is a skill.And it seems like everybody from TBO toDominic to even GDB himself agrees thatas silly as this is, something like thisdoes make sense. So, for now, don’t useUltra. If you really want to get thistype of thing, keep an eye out for myvideo on how to use workflows in CloudCode with GPD56 Soul because even Tibosupports my chaos here. Hope this washelpful, and until next time, peacenerds., I can't believe they released this, YouTube, 01kxh48zk7k7segethmfs04t4s.