OpenAI
Internalized model persistence and cross-team coordination render external agent loops obsolete, enabling autonomous swarms to solve more than 100 long-standing mathematical problems.
AI-assisted summary of What Comes After Loops?: Deep Dive Into Agentic Architecture | DevDay 2026 — original source. Check the original for full context.
Source published:
Key ideas
- OpenAI traced the progression of autonomous systems from manual copy-paste execution and external bash loops to internal model persistence in GPT-5.6 and native multi-agent coordination in GPT-6. (0:17)
- Codex pairs reasoning models with an execution harness using native API compaction and external goal tracking, enabling agents to operate across multiple context windows without premature termination. (2:42)
- Eric from OpenAI's DX team warns against the 'middle management tax,' advising developers to default to single agents and only scale to multi-agent architectures when workloads strictly demand parallelization. (10:46)
- Demonstrating massive scale, OpenAI deployed a fleet of 10,000 collaborative agents that exchanged 2.7 million messages and generated ~130 billion tokens to tackle the Navier–Stokes problem. (19:44)
Detailed notes
## Background Published by OpenAI on YouTube on November 11, 2026, this DevDay presentation is titled "What Comes After Loops?: Deep Dive Into Agentic Architecture." The session explores the shift from simple agent loops to collaborating multi-agent teams, detailing the design choices and model advances behind autonomous architectures and previewing future paradigms.
## TL;DR OpenAI engineers Raj Bhatek and Eric trace the evolution of AI agents from early, fragile "loop engineering" workarounds to models with built-in persistence, execution harnesses, and native context compaction. They outline pragmatic developer patterns using tiered reasoning models—such as Sol, Astra, and Luna—warning against multi-agent over-engineering and the "middle management tax" before escalating to complex pair or departmental hierarchies. Finally, Raj details the architectural principles required to scale agent collectives to extreme limits, demonstrating how a coordinated network of 10,000 agents solved the long-standing Navier–Stokes problem.
## Atmosphere & style The presentation balances the energetic, pragmatic vibe of a technical developer keynote with ambitious scientific storytelling. Raj and Eric share an engaging, self-effacing rapport, blending relatable developer humor about obsolete workflows and prompt-tweaking anxieties with clear-eyed architectural blueprints. The pacing builds steadily from nostalgic recollections of manually pasting FizzBuzz code to the awe-inspiring revelation of massive 10,000-agent swarms tackling Millennium Prize mathematics, creating an inspiring and forward-looking atmosphere.
## Bulletin - [00:17](https://www.youtube.com/watch?v=nAubbmlhPfI&t=17s) OpenAI traced the progression of autonomous systems from manual copy-paste execution and external bash loops to internal model persistence in GPT-5.6 and native multi-agent coordination in GPT-6. - [02:42](https://www.youtube.com/watch?v=nAubbmlhPfI&t=162s) Codex pairs reasoning models with an execution harness using native API compaction and external goal tracking, enabling agents to operate across multiple context windows without premature termination. - [10:46](https://www.youtube.com/watch?v=nAubbmlhPfI&t=646s) Eric from OpenAI's DX team warns against the 'middle management tax,' advising developers to default to single agents and only scale to multi-agent architectures when workloads strictly demand parallelization. - [19:44](https://www.youtube.com/watch?v=nAubbmlhPfI&t=1184s) Demonstrating massive scale, OpenAI deployed a fleet of 10,000 collaborative agents that exchanged 2.7 million messages and generated ~130 billion tokens to tackle the Navier–Stokes problem.
## Key takeaways - [00:17](https://www.youtube.com/watch?v=nAubbmlhPfI&t=17s) The foundational agentic loop evolved from single-pass text generation to iterative cycles of tool execution, environment feedback observation, and subsequent reasoning. - [02:42](https://www.youtube.com/watch?v=nAubbmlhPfI&t=162s) Codex relies on the co-design of a reasoning model and an execution harness that exposes general primitives like the shell, filesystem, and computer use via the Responses API. - [05:07](https://www.youtube.com/watch?v=nAubbmlhPfI&t=307s) Native compaction via the `/compact` endpoint prevents context overflow by training the model directly to understand, compress, and resume from summarized semantic state. - [07:02](https://www.youtube.com/watch?v=nAubbmlhPfI&t=422s) External loop engineering patterns like Ralph loops were internalized in GPT-5.5 using the `--goal` flag, isolating primary objectives outside conversation history to avoid dilution. - [09:14](https://www.youtube.com/watch?v=nAubbmlhPfI&t=554s) GPT-5.6 internalized persistence directly into model weights, verifying its own intermediate steps and enabling multi-hour autonomous execution without external loop prompts. - [09:14](https://www.youtube.com/watch?v=nAubbmlhPfI&t=554s) GPT-6 unlocked autonomous task decomposition and subagent coordination, replacing rigid external orchestration scripts with native model judgment. - [10:46](https://www.youtube.com/watch?v=nAubbmlhPfI&t=646s) Developers should default to a single agent before spinning up multi-agent architectures to avoid runaway token consumption and unneeded operational complexity. - [12:31](https://www.youtube.com/watch?v=nAubbmlhPfI&t=751s) Effort scaling coordinates specialized model tiers—Astra High for deep reasoning, Sol Medium for primary orchestration, and Luna High for routine chores—to balance compute and cost. - [14:27](https://www.youtube.com/watch?v=nAubbmlhPfI&t=867s) The Pair architecture enables bidirectional peer collaboration between two specialized agents when solving tightly coupled problems with evolving mutual constraints. - [15:39](https://www.youtube.com/watch?v=nAubbmlhPfI&t=939s) Codex can autonomously act as a thread manager within ChatGPT, initiating dedicated sub-threads for tasks and synthesizing human steering back to the coordinator. - [17:36](https://www.youtube.com/watch?v=nAubbmlhPfI&t=1056s) Over-engineered supervisory agent hierarchies incur a 'middle management tax,' causing agents to spend tokens asking for permission instead of completing work. - [17:36](https://www.youtube.com/watch?v=nAubbmlhPfI&t=1056s) Maintaining a compact work log inside the context window preserves core objectives and prevents context drift across repeated compactions and frequent human corrections. - [19:44](https://www.youtube.com/watch?v=nAubbmlhPfI&t=1184s) Addressing the Navier–Stokes Millennium Prize problem required coordinating 10,000 agents that produced roughly 130 billion tokens across 2.7 million inter-agent messages. - [20:51](https://www.youtube.com/watch?v=nAubbmlhPfI&t=1251s) The agent teams architecture paired divergent prompting to explore distinct mathematical hypotheses with cross-team communication to avoid redundant computational dead ends. - [20:51](https://www.youtube.com/watch?v=nAubbmlhPfI&t=1251s) Uncovering the unforced Euler result served as the key inflection point that enabled the full 10,000-agent swarm to converge on a complete mathematical solution. - [22:54](https://www.youtube.com/watch?v=nAubbmlhPfI&t=1374s) Advanced reasoning models beyond GPT-6 have resolved over 100 long-standing mathematical problems, marking the transition of agent architectures into genuine scientific discovery.
## Detailed walkthrough ### [00:17](https://www.youtube.com/watch?v=nAubbmlhPfI&t=17s) Introduction and the Shift from Copy-Paste to Agentic Action
Raj Bhatek opens the DevDay session by introducing himself as part of the Applied AI engineering team at OpenAI. Reflecting on the fast-paced nature of the field and the talk's title, *What Comes After Loops?*, he jokes that while preparing the presentation, the team worried everything they wrote would be obsolete before they even took the stage. As models rapidly advance, the fundamental methods used to build agents change in tandem. Together with his colleague Eric, Raj sets out to rewind the clock to trace the design decisions made at OpenAI, showcase current agent capabilities, and preview what they have been cooking behind the scenes.
To illustrate how far autonomous systems have come, Raj revisits the launch of ChatGPT. When the chatbot first debuted, the very first test he gave it was to implement FizzBuzz—a staple interview question typically asked of junior software developers. ChatGPT generated the code, which Raj manually copied and pasted into his local code editor. It ran cleanly on the first try. While the raw intelligence was astonishing, the human operator was still stuck acting as the bridge between model generation and runtime execution: copying text into an IDE and seeing what happened.
The real transformation occurred when AI was granted agency through the combination of reasoning and tool use. Referencing the launch video for OpenAI o3, Raj highlights a demonstration where o3 was tasked with analyzing an image. Rather than answering in a single pass, the model used tools to zoom into visual details, inspect specific regions, reason through observations, and determine its subsequent actions. This cycle—taking an action, reasoning over the feedback, and planning the next move—defines the core agentic loop.
As Raj Bhatek put it when describing the underlying momentum of the ecosystem: > “As models get better, things change.”
- **The FizzBuzz Benchmark**: Used as a baseline to highlight the era when developers still manually moved code between ChatGPT and an editor. - **The Core Agentic Loop**: The foundational three-step cycle where the model takes action via a tool, observes the execution output, and reasons to formulate its next step.
---
[02:42](https://www.youtube.com/watch?v=nAubbmlhPfI&t=162s) The Codex Philosophy: Unifying Model and Harness
While early demonstrations used bespoke, narrow tools, OpenAI pursued a more ambitious question: what happens when an agent is given full access to a computer? This question led directly to the development of Codex, OpenAI's open-source general agent. The guiding design philosophy behind Codex is to give models the ability to act directly on their reasoning—enabling them to try an engineering approach, observe the system's reaction, and autonomously pivot when errors arise.
At the structural level, Codex is built upon the tight co-design of a reasoning model and an execution harness. The harness is responsible for managing system instructions, tool definitions, file system operations, shell environments, computer-use primitives, and conversation context across turns. Crucially, the relationship between model and harness is bidirectional: the harness design dictates how training data is structured, while the model's evolving capabilities dictate how the harness is engineered. Centered around the Responses API, the harness sends tool schemas to the model, intercepts tool call requests, executes them within an isolated sandbox, and appends the outputs back into the conversation context to evaluate whether to proceed with another turn.
```mermaid flowchart TD accTitle: Codex Model and Harness Execution Architecture accDescr: The interaction loop between the Responses API, the model, and the sandbox harness.
subgraph API ["Responses API Layer"] RAPI["Responses API Loop"] CTX["Context & History Manager"] end
subgraph Core ["Agent Brain & Sandbox"] MODEL["Reasoning Model"] SB["Execution Sandbox\n(Shell, Filesystem, Computer Use)"] end
RAPI -->|"passes tool definitions"| MODEL MODEL -->|"requests tool call"| RAPI RAPI -->|"dispatches execution"| SB SB -->|"returns stdout / stderr / feedback"| CTX CTX -->|"appends state"| RAPI RAPI -->|"evaluates next turn"| MODEL ```
Raj explains that this co-evolution eliminates manual human intervention: > “And really, we built the Codex around this idea of a model and a harness working together.”
- **Open-Source & Minimalist**: Codex was intentionally designed with minimal, highly generalizable primitives (shell execution, file system management, computer use) rather than brittle, specialized plugins. - **Generalization Target**: The overarching design goal is that any task a software engineer can perform on a computer terminal or workstation should be solvable by the agent.
---
[05:07](https://www.youtube.com/watch?v=nAubbmlhPfI&t=307s) Native Compaction for Long-Horizon Contexts
As agents execute shell commands, read large files, and ingest command line outputs, the conversation history inflates rapidly. Although context windows have expanded dramatically, they remain finite boundaries. For extended development tasks that span hours, the harness must preserve historical progress without overflowing available context or inducing catastrophic forgetting.
OpenAI solved this problem by integrating native compaction into both the Responses API and model pre-training/fine-tuning. When the conversation history approaches context limits, the harness invokes the `/compact` endpoint on the Responses API. Under the hood, this condenses the noisy, verbose trajectory of prior actions, file reads, and shell outputs into a concise, distilled semantic state. Rather than treating compaction as a naive external summarizer, the model itself is explicitly trained to understand what it means to be compacted, how to interpret a compacted state, and how to resume execution cleanly without losing momentum. This breakthrough unlocked true long-horizon work, allowing Codex to execute across multiple sequential context windows and compaction events.
Raj emphasizes the deep synergy required between model behavior and runtime infrastructure: > “So the model understands what it means to be compacted.”
- **The `/compact` Endpoint**: An internal primitive within the Responses API invoked automatically when token thresholds are reached. - **Trained Compaction Semantics**: Because the model is explicitly trained on compaction transitions, it knows which historical tokens are safe to discard and which key constraints must be carried forward into the next window.
---
[07:02](https://www.youtube.com/watch?v=nAubbmlhPfI&t=422s) Outer Loops and Loop Engineering: From Ralph Loops to `--goal`
Enabling long context horizons exposed an immediate behavioral limitation in earlier models: they lacked an intrinsic understanding of what "done" actually meant. Agents would make promising progress on a coding task, solve one or two sub-problems, and then terminate their turn prematurely. Developers began engineering external workarounds to force the model to keep working. Raj references a pattern popularized on Twitter by OpenClaw creator Peter Steinberger, which relied on continuously queuing up automated "continue" statements to nudge the model forward.
This practice kicked off the era of "loop engineering." Geoffrey Huntley popularized a prominent community brute-force pattern known as the "Ralph loop," which wrapped the agent in a bash script running against a persistent prompt file. Every iteration launched with a fresh context window, scanned the files modified during the prior run, assessed progress, and re-prompted the agent to continue iterating.
Recognizing the necessity of this pattern, OpenAI internalized loop engineering into Codex with the release of GPT-5.5 by introducing the `--goal` flag. Instead of keeping the top-level objective inside the standard context window—where it risked being diluted or summarized away during compaction—the harness isolates the objective in a dedicated state layer outside the conversation history. The harness monitors execution status, periodically verifies completion against the stored goal, and autonomously prompts the model to keep driving forward. If the model encounters an insurmountable error, it can explicitly flag that it is blocked, rather than silently halting.
Raj describes how developers originally tackled the problem of premature agent completion: > “What Peter and pretty much all of us were doing was creating this idea of an outer loop, right?”
- **The Ralph Loop**: A bash-driven outer loop that repeatedly invokes an agent against a prompt file with fresh context, using filesystem diffs to track progress. - **Codex `--goal`**: An externalized goal state managed by the harness outside the core context window, ensuring the objective survives multiple compaction events intact. - **Structured Exit Conditions**: Enables the agent to run continuously until the objective is genuinely satisfied, while providing a clean mechanism to surface genuine blockers.
[09:14](https://www.youtube.com/watch?v=nAubbmlhPfI&t=554s) Built-in Persistence and the Leap to GPT-6 Coordination
Reflecting on earlier iterations where agents relied on external scaffolding, Raj explains that observing goals survive past individual turns gave OpenAI the exact training signal they needed. Rather than constantly wrapping models in external harness loops to prompt them forward, the team asked why persistence shouldn't simply be built directly into model weights. This shift became reality in GPT-5.6, where the model inherently internalized what productive intermediate steps looked like, learned to verify its own output, and eliminated the need for continuous external prompting. Industry figures quickly noticed the shift; Raj points out that Shopify CEO Tobi Lütke highlighted how the model discarded the need for explicit `--goal` parameters and simply worked until completion, while Wharton AI professor Ethan Mollick granted Codex direct computer access and watched it play *Slay the Spire 2* autonomously for five hours straight.
While long-horizon coherence and computer use marked a massive breakthrough, they introduced fresh engineering bottlenecks: executing faster and parallelizing broad work streams. Early attempts at multi-agent setups during GPT-5.6 proved nascent, but the arrival of GPT-6 provided the intelligence leap necessary for models to coordinate autonomously. Rather than relying on rigid orchestration rules, the model gained the judgment to decompose complex problems, farm out discrete work items, and manage concurrent paths.
- Tobi Lütke praised the breakthrough, as Raj recounts: “Toby Luque, the CEO of Shopify, described it as the first model that no longer needed Dashgoal, it just kept going until it got the job done.” - Ethan Mollick demonstrated long-horizon computer use by letting Codex play *Slay the Spire 2* continuously for approximately five hours. - With GPT-6, internal model intelligence replaced fragile external loops, enabling models to divide tasks and coordinate their own subagents.
---
[10:46](https://www.youtube.com/watch?v=nAubbmlhPfI&t=646s) Starting Single: The Philosophy of Agent Teams vs. Token Costs
Eric from OpenAI’s Developer Experience (DX) team—welcoming a crowd noticeably larger than he anticipated and joking that attendees might know him from his posts on X—takes over to bridge internal research advances with everyday developer workflows. His primary guideline when approaching large, intimidating tasks is to resist the instinct to spin up an sprawling multi-agent system right out of the gate. Because the GPT-6 family can autonomously compact its context window, recover from errors, and iterate without external nudges, a single agent equipped with a well-defined prompt and verification criteria is often more than enough.
```mermaid flowchart TD accTitle: Single Agent Escalation Decision accDescr: Decision flow illustrating when to keep a single agent versus scaling out to multiple subagents.
subgraph SingleTask["Default Baseline"] A["Single Agent (GPT-6)"] --> B{"Task Complete or Failing?"} B -->|"Autonomous Compaction & Recovery"| C["Succeeds Independently"] end
subgraph MultiTask["Scale Out When Justified"] B -->|"Massive Scope / Parallel Needs"| D["Codex Ultra Orchestrator"] D --> E["Subagent A (PR Review / Subsystem)"] D --> F["Subagent B (Investigation / Feature)"] end ```
Developers should only scale up to multi-agent architectures when the workload strictly demands it, such as massive codebase refactors or end-to-end game development. In high-tier configurations like Codex Ultra, the system can clone itself and orchestrate copies dynamically. However, Eric issues a stern warning about the hidden costs of unnecessary multi-agent sprawl: every spawned worker consumes tokens at a punishing rate, often without providing measurable gains in completion speed or code quality. Knowing exactly when to trigger parallel decomposition versus keeping an operation localized remains the developer's core responsibility.
- As Eric flatly advises developers tempted by complex architectures: “Only add more agents when the work gives you a reason to.” - Eric emphasizes the economic trade-off of over-engineering: “Every agent Codex brings in can dramatically increase token use without necessarily making the work faster or better.” - Clear candidates for subagent parallelization include naturally partitioned tasks, such as reviewing five pull requests simultaneously or assigning distinct subagents to isolate a race condition.
---
[12:31](https://www.youtube.com/watch?v=nAubbmlhPfI&t=751s) Effort Scaling: The Coordinate Skill and Tiered Models (Astra, Sol, Luna)
To solve the friction of deciding which model tier to assign to an unpredictable workload, Eric introduces the concept of effort scaling. By using custom skills, developers can let Codex dynamically dial reasoning compute up or down on the fly. Rather than forcing the user to micro-manage model selection and endure constant decision paralysis, an orchestrating agent distributes subtasks across an ecosystem of specialized tiers—Astra, Sol, and Luna—matching the difficulty of the subtask to the model's strengths and cost profile.
```mermaid flowchart TD accTitle: Effort Scaling via Coordinate Skill accDescr: Sol Medium acts as the orchestrator, delegating hard reasoning to Astra High and repetitive tasks to Luna High.
subgraph Coordination["Coordinate Orchestration"] Sol["Sol Medium\n(Primary Workhorse & Integrator)"] end
subgraph DelegatedWork["Dynamic Scaling"] Astra["Astra High\n(Deep Reasoning & Test Failures)"] Luna["Luna High\n(Routine Chores & Busywork)"] end
Sol -->|"Escalate Deep Bottlenecks"| Astra Astra -->|"Resolved Logic & Diff"| Sol Sol -->|"Offload Repetitive Tasks"| Luna Luna -->|"Completed Chores"| Sol ```
Eric shares a trimmed-down version of an orchestration prompt he developed, titled the "Coordinate" skill. In this pattern, Sol Medium acts as the primary integrator that handles the bulk of day-to-day operations. When Sol encounters an obstinate test failure or complex architectural puzzle, it escalates that specific slice to Astra High for deep reasoning, integrating the resulting fix back into the main branch. Conversely, when simple administrative chores or repetitive updates arise, Sol hands them off to lightweight Luna High agents. While not a guaranteed cost-reducer—since Astra itself cannot always predict the most cost-effective path—it significantly smooths operational overhead and operational anxiety.
- Eric notes that while effort scaling is not a guaranteed silver bullet for API billing, “in many cases, it can be a huge help in helping you reduce the decision anxiety in picking the right model for the job.” - **Sol Medium** acts as the central hub, responsible for driving the feature forward, orchestrating delegating calls, and landing changes. - **Astra High** handles high-reasoning escalations, stepping in for several iterative turns to fix tricky logic before returning control to Sol. - **Luna High** takes on routine background tasks and busywork that would otherwise clutter the primary context window.
---
[14:27](https://www.youtube.com/watch?v=nAubbmlhPfI&t=867s) The Pair Architecture: Bidirectional Collaboration in Game Porting
Eric illustrates a tightly coupled topology he calls "The Pair," which he invented while attempting to port a legacy game over a weekend. He possessed the compiled, running game and raw assets from an ancient, long-lost game engine, but the engine software itself was defunct. His objective was to run the original binary, extract its rendering pipeline, and visually reconstruct the game scene inside Blender so he could rebuild the title in a modern engine.
```mermaid flowchart LR accTitle: The Pair Architecture Flow accDescr: Two peer agents coordinating back and forth between capture tech and Blender reconstruction.
subgraph ThePair["The Pair Architecture"] AgentA["Agent A\n(Capture Tech in Legacy Engine)"] AgentB["Agent B\n(Scene Rebuilding & Shaders in Blender)"]
AgentA <-->|"Continuous Feedback & Format Sync"| AgentB end ```
Rather than running a traditional top-down hierarchy, Eric spun up two interdependent agents in Codex with an open communications channel. One agent focused entirely on building capture hooks into the old engine binary, while the other worked on ingesting, unpacking, and rendering the exported scene data inside Blender. Because the capture requirements were fundamentally shaped by Blender's target formatting, the agents operated as genuine peers: whenever the Blender agent discovered an optimization or layout limitation, it informed the capture agent, which immediately adapted its extraction hooks. Eric encourages developers to photograph the technical prompt displayed on the slide, warning that setting up pairs requires unambiguous communication boundaries to prevent circular debates.
- The Pair architecture is ideal for tightly coupled, two-sided problems where progress on side B continually changes the technical constraints of side A. - Explicit prompt instructions are essential to establish clean handshakes and avoid conversational thrashing between the two paired instances.
---
[15:39](https://www.youtube.com/watch?v=nAubbmlhPfI&t=939s) Thread Management and Departmental Agent Hierarchies
Managing multiple concurrent tasks across different interfaces can rapidly overwhelm human developers. Eric reveals that Codex inside the ChatGPT application can act as an autonomous thread manager: it can spin up brand-new conversational threads, monitor external chat sessions, and actively inject instructions into running chats. This capability replaces brittle manual management scripts, allowing a developer to tell Codex to monitor an entire queue of pull requests and initiate a separate, dedicated chat thread for every single review. Because these models are communicative by default, any human intervention or "meddling" within an individual sub-thread is automatically summarized back to the top-level thread manager, allowing the overarching workflow to continue even if the developer steps away.
For sprawling endeavors like game development that span months, Eric recommends organizing long-running threads around department leads. Leveraging context compaction, each thread gradually accumulates domain-specific context and specializes in an area such as art direction, mechanics design, engineering, or QA playtesting. A central "producer" agent receives high-level directives from the human developer and orchestrates the leads: while the art director generates environmental props and the programmer pushes a code change, the QA agent runs playtests on the latest build.
- In the ChatGPT client, Codex can create, view, and steer sibling chat threads without mistaking them for standard within-thread subagents. - Human users can jump into any individual worker thread to manually guide implementation details without breaking the top-level coordinator's oversight. - In departmental agent structures, context compaction allows individual threads to mature over weeks into specialized domain experts (e.g., art directors, gameplay engineers, and producers).
---
[17:36](https://www.youtube.com/watch?v=nAubbmlhPfI&t=1056s) The Middle Management Tax and the Compact Work Log
Despite the effectiveness of multi-agent structures, Eric cautions against building gratuitous layers of oversight. When developers over-engineer agent org charts with layers of managers, reviewers, and directors, agents often become paralyzed by artificial protocols, spending tokens seeking permission from one another instead of producing code. Eric labels this friction the "middle management tax" and cautions engineers against designing bureaucratic agent teams that do not add concrete value.
```mermaid flowchart TD accTitle: Compact Work Log Memory Architecture accDescr: Preventing context drift across repeated compactions by maintaining an anchored work log.
subgraph HumanSteering["Human Steering"] Nag["Incremental Human Corrections ('Steers')"] end
subgraph ContextEngine["Codex Context Window"] Compaction["3-4x Context Compactions"] Log["Compact Work Log\n- Primary Objective\n- Active Work Stream\n- Synthesis of Latest Steer"] end
Nag -->|"Injects Feedback"| Log Compaction -->|"Preserves Core Intent via"| Log ```
A frequent practical hurdle during long agent sessions is drift caused by human steering. As developers monitor an agent, they frequently interrupt with small reminders, tweaks, and edge-case requirements. After three or four rounds of context compaction, however, the original prompt's overarching context begins to decay, leaving the agent overly fixated on recent small corrections while losing sight of the broader mission. To counteract this drift, Eric shares a simple pattern: instruct the agent to maintain an active, compact work log in its context that tracks three elements: the primary objective, current running progress, and exactly how the human's latest steering feedback ties back to the broader goal.
- Eric identifies an anti-pattern when agents stall out: “I call this the middle management tax.” - To keep systems manageable and lean, Eric advises: “Try not to overthink managing all your agents.” - Context compaction over extended workflows can cause models to lose foundational goals unless anchored by structured logging. - A compact work log must explicitly reconcile the overall project goal, active subtasks, and the relationship of the user's latest steering comment to both.
[19:00](https://www.youtube.com/watch?v=nAubbmlhPfI&t=1140s) Compact Context and the Shelf Life of Workflows
Eric wraps up his operational advice on running agents by emphasizing the balance between supervision and context management. Maintaining a compact work log prevents an agent from preserving an ever-expanding diary detailing every single failed test and bug fix since last Thursday's beta run. By instructing Codex to establish this streamlined logging pattern, developers gain the freedom to micromanage their agents naturally without overloading them or causing them to lose their operational bearings midway through complex executions.
Before handing the presentation back to Raj, Eric leaves the audience with a core mindset for building in AI: “Oh, and by the way, before I hand you back to Raj, I want you all to keep in mind that best practices have a shelf life and you should never get attached to your workflows.”
- Compact work logs prevent context degradation caused by recording every historical test failure. - Codex can be prompted directly to configure and maintain these tight execution logs.
---
[19:44](https://www.youtube.com/watch?v=nAubbmlhPfI&t=1184s) Scaling to 10,000 Agents: The Navier–Stokes Problem
Raj takes the stage to transition the discussion from orchestrating a handful of agents on everyday development tasks to massive, unprecedented scaling. Moving from a small cluster of agents to thousands introduces acute architectural challenges: keeping agents aligned toward a singular objective, maintaining global coherence, and ensuring work is partitioned effectively without devolving into chaos or conflicting efforts.
To illustrate how these challenges are solved in practice, Raj reveals OpenAI's breakthrough work on the Navier–Stokes problem, one of the long-standing Millennium Prize problems in mathematics. Tackling the problem required an internal model alongside Codex, running an enormous, coordinated swarm of agents. Raj urges the audience to pause and consider the sheer operational magnitude of the system, which generated millions of inter-agent exchanges and an immense computational footprint.
- **10,000 agents** collaborated simultaneously toward solving the problem. - **2.7 million messages** were exchanged across the collaborative network. - **~130 billion output tokens** were produced over the course of the full effort.
---
[20:51](https://www.youtube.com/watch?v=nAubbmlhPfI&t=1251s) The Agent Teams Architecture and Cross-Team Collaboration
Raj outlines the structural pattern used to orchestrate this massive fleet, terming it “agent teams.” The architecture is designed to balance deep, focused execution with wide, exploratory research. The system initialized multiple teams with distinct problem formulations and varied prompting to encourage diverse lines of reasoning. Each team comprised multiple specialized sub-agents working together locally while remaining connected to the broader network. Cross-team communication proved vital: agents could inspect what other clusters were exploring, pose inquiries, and share intermediate findings across team boundaries. Without this cross-pollination, running 10,000 agents would become prohibitively expensive due to redundant computations and duplicated dead ends.
```mermaid flowchart TD accTitle: Agent Teams Collaborative Architecture accDescr: Hierarchical architecture showing multiple agent teams communicating internally and across teams to solve a unified objective.
subgraph ProblemSpace["Unified Objective: Navier-Stokes"] T1["Team 1: Hypothesis Exploration"] T2["Team 2: Assumption Challenging"] T3["Team 3: Experimental Testing"] end
subgraph TeamOne["Team 1 Sub-Agents"] A1["Sub-Agent A"] <--> A2["Sub-Agent B"] end
subgraph TeamTwo["Team 2 Sub-Agents"] B1["Sub-Agent C"] <--> B2["Sub-Agent D"] end
T1 <-->|"Cross-team messaging"| T2 T2 <-->|"Share findings & prevent duplication"| T3 T1 <-->|"Cross-team queries"| T3 T1 --- TeamOne T2 --- TeamTwo ```
As the effort progressed, the roles and responsibilities of the teams dynamically adapted: some formulated hypotheses, others rigorously challenged foundational assumptions, and others executed computational experiments. When emergent discoveries surfaced new questions, the orchestrator dynamically spun up new teams or steered existing groups toward the most fruitful directions. A critical milestone occurred when the agents uncovered the unforced Euler result; at that juncture, the orchestration layer pivoted all teams to converge on that breakthrough, ultimately yielding the complete mathematical solution.
Regarding the necessity of broad communication and non-redundant exploration, Raj emphasizes: “If all 10,000 are working on the same thing, that's really expensive, right? We want them to make sure that we're encouraging diversity, and we want to know what each team is working on, so they're not all trying the same thing over and over again.”
- Problem prompts were deliberately varied across teams to seed divergent mathematical strategies. - Teams possessed local autonomy over their specific sub-approaches while adhering to global coordination constraints. - Identifying the unforced Euler result served as the key inflection point that allowed the entire 10,000-agent collective to align and finalize the solution.
---
[22:54](https://www.youtube.com/watch?v=nAubbmlhPfI&t=1374s) Beyond GPT-6 and the Future of Discovery
The agent teams paradigm has yielded extraordinary breakthroughs, particularly when paired with models extending beyond the capabilities of GPT-6. Using the internal model developed for the Navier–Stokes breakthrough, OpenAI has successfully resolved more than 100 long-standing problems across mathematics, and the architecture continues to drive active scientific and mathematical discoveries. Reflecting on the rapid progress of the technology, Raj remarks on how dramatically AI has evolved beyond simple toy code completions.
Looking toward the horizon, Raj underscores that the field is still in its infancy: “As model capabilities advance, the work we do with them can get a lot more ambitious.” He closes the presentation by challenging developers in the audience to dust off the high-friction, complex challenges they previously postponed or that older models failed to solve, pointing to a QR code for deeper technical documentation on the Navier–Stokes methodology. His final parting advice to the room is simple and direct: “You can always just build things.”
- More than 100 long-standing mathematical problems have been resolved using OpenAI's internal advanced reasoning models. - Model capabilities now drastically exceed early paradigms, moving from basic script generation to autonomous scientific discovery.
## Notable quotes > [10:46](https://www.youtube.com/watch?v=nAubbmlhPfI&t=646s) Only add more agents when the work gives you a reason to. — Eric
> [19:00](https://www.youtube.com/watch?v=nAubbmlhPfI&t=1140s) best practices have a shelf life and you should never get attached to your workflows. — Eric
> [10:46](https://www.youtube.com/watch?v=nAubbmlhPfI&t=646s) Every agent Codex brings in can dramatically increase token use without necessarily making the work faster or better. — Eric
> [22:54](https://www.youtube.com/watch?v=nAubbmlhPfI&t=1374s) As model capabilities advance, the work we do with them can get a lot more ambitious. — Raj Bhatek
## Mentioned OpenAI, Raj Bhatek, Eric, ChatGPT, OpenAI o3, Codex, Codex Ultra, Responses API, Peter Steinberger, Geoffrey Huntley, GPT-5.5, GPT-5.6, GPT-6, Tobi Lütke, Shopify, Ethan Mollick, Slay the Spire 2, Astra, Sol, Luna, Blender, Navier–Stokes problem
## Video description Trace the evolution from simple agent loops to collaborating agents. Explore the design choices and model advances behind that shift, and take a closer look at what comes next.
[Source](https://www.youtube.com/watch?v=nAubbmlhPfI)