OpenAI Deploys 10,000 Agents to Solve Navier-Stokes Math Problem

What Comes After Loops?: Deep Dive Into Agentic Architecture | DevDay 2026 — OpenAI

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)

Reading summary

OpenAI engineers Raj Bhatek and Eric outline the architectural evolution of autonomous systems, arguing that agent design has shifted from brittle external loops to internalized model persistence, requiring developers to adopt lean single-agent baselines before scaling to coordinated swarms. From External Loops to Internalized Persistence (7:02) Early autonomous AI development relied on external harnesses and brute-force workarounds—such as bash-based 'Ralph loops' and automated continue prompts—to prevent agents from stopping prematurely. OpenAI initially addressed this friction in Codex by co-designing the reasoning model with an execution harness via the Responses API and introducing native compaction (/compact). In this setup, models are explicitly trained to compress long-horizon execution trajectories without losing critical task constraints. With GPT-5.5's isolated --goal parameter and the subsequent release of GPT-5.6, persistence was baked directly into model weights, allowing agents to evaluate their own progress and self-terminate without external loop prompts. As demonstrated by community use cases, such as an agent playing Slay the Spire 2 autonomously for five hours, models evolved to manage long-horizon execution independently, paving the way for autonomous subagent coordination in GPT-6. Lean Agent Defaults and Effort Scaling (10:46) Addressing developer workflows, Eric cautions against prematurely deploying multi-agent architectures for standard engineering tasks. Because newer reasoning models autonomously handle context compaction and error recovery, a well-prompted single agent is typically sufficient. Spawning unnecessary subagents introduces heavy token costs and risks a 'middle management tax,' where agents consume compute negotiating permissions and reviewing each other instead of producing functional code. When decomposition is required, Eric advocates for 'effort scaling' using orchestration patterns such as the Coordinate skill. Rather than forcing developers to manually select model tiers, a primary integrator (Sol Medium) handles baseline implementation, selectively escalating complex reasoning bottlenecks to Astra High and offloading repetitive chores to Luna High. While not an absolute guarantee against high token billing, dynamic tiering reduces operational decision friction while matching computational power to task difficulty. Structured Topologies and Context Anchoring (14:27) For specialized, highly coupled tasks, developers can implement targeted multi-agent topologies rather than rigid hierarchies. In 'The Pair' architecture, two peer agents maintain continuous bidirectional communication across an open channel. In one case study involving legacy game porting, one agent constructed reverse-engineering capture hooks while the other built Blender ingestion shaders, allowing both sides to immediately adapt to downstream data constraints. For long-term projects, Codex within ChatGPT can orchestrate departmental chat threads (such as engineering, art, and QA) under an overarching producer agent. To prevent operational drift across extended runs, Eric advises counteracting the degradation caused by repeated human steering. Frequent user interventions combined with repeated context compactions often cause agents to fixate on recent edge-case corrections while forgetting initial instructions. Developers can anchor execution by requiring agents to maintain an active 'compact work log' in context, explicitly recording the high-level objective, active work streams, and the relationship between recent user feedback and the overarching goal. Massive Swarm Architecture in Scientific Discovery (19:44) Transitioning from individual developer environments to extreme scaling, Raj details OpenAI's deployment of an internal reasoning model and Codex to address the Navier–Stokes Millennium Prize problem. The deployment coordinated 10,000 concurrent agents, which generated approximately 130 billion output tokens and exchanged 2.7 million inter-agent messages. To manage this scale without redundant computational waste, OpenAI structured the fleet into specialized 'agent teams.' Teams operated with varied initial problem prompts to foster diverse analytical paths, while open cross-team communication channels allowed clusters to query findings and avoid duplicated dead ends. When exploration identified the unforced Euler result, the orchestration layer pivoted the entire 10,000-agent collective to converge on that breakthrough. Bhatek reports that this swarm paradigm has resolved more than 100 long-standing mathematical problems. The presentation underscores that agentic best practices carry a short shelf life as underlying model capabilities rapidly advance. While massive swarms demonstrate the viability of autonomous scientific discovery, routine software engineering increasingly benefits from stripped-down architectures that rely on native model reasoning rather than complex, over-engineered scaffolding.

Source quotes

[10:46] Eric: Only add more agents when the work gives you a reason to. [19:00] Eric: best practices have a shelf life and you should never get attached to your workflows. [10:46] Eric: Every agent Codex brings in can dramatically increase token use without necessarily making the work faster or better. [22:54] Raj Bhatek: As model capabilities advance, the work we do with them can get a lot more ambitious.

Original transcript

[0:17] Hey, everybody. [0:18] How's it going? [0:20] Great. [0:22] My name is Raj Bhatek. [0:23] I'm part of our Applied AI engineering [0:24] team here at OpenAI, [0:26] and excited to be with you all today. [0:30] When we were naming the session, [0:31] What Comes After Loops, [0:32] we joked that by the time we [0:34] finished the content, [0:36] everything would be outdated. [0:37] So what we have today, [0:39] it's for today. [0:41] But that's honestly what [0:42] building agents has been like [0:43] for the past year or so. [0:45] As models get better, things change. [0:47] How we build them really does, too. [0:49] So today, Eric and I are going [0:51] to rewind a bit, tell you about [0:52] how we got here, some of the design [0:54] decisions we made here at OpenAI, [0:56] what you can do with agents today, [0:58] and then share some stuff [0:59] that we've been cooking. [1:01] So before we get started, I [1:02] want to rewind a bit. [1:03] I want to take you guys back [1:05] to when we launched ChatGPT. [1:07] So when it first came out, [1:09] the first thing I did was I [1:10] had ChatGPT write FizzBuzz. [1:12] Show of hands, how many of you [1:13] know what FizzBuzz is? [1:16] Cool. OK. [1:17] For those of you who don't, FizzBuzz [1:18] is a very common coding interview [1:19] question we give to junior developers. [1:22] ChatGPT gave me the code. [1:23] I copied and pasted it into [1:25] my code editor, and I ran it. [1:29] What was really, [1:30] really cool was it ran. [1:32] It actually worked. [1:34] And everybody in the back [1:35] can hear me, right? Just want to make sure? [1:36] Cool. Sweet. [1:38] So I was very blown away. [1:40] I'm assuming a lot of you had [1:41] a similar reaction as well. [1:43] AI had gotten really, really [1:44] smart, and it was the beginning [1:46] of something big. [1:47] But what was different was [1:49] I was still the one copying [1:50] and pasting things, right? [1:51] I would write something in ChatGPT, [1:53] copy to my IDE. [1:54] I hadn't seen what happened. [1:56] But you know, that changes [1:57] when we let AI take action. [2:01] This video may look familiar. [2:03] This is really when we let AI combine [2:05] two things, reasoning and tool use. [2:08] The video may look, this is [2:10] from the 03 launch video. [2:11] We gave 03 the task [2:13] to analyze an image. [2:14] You can see how it works with the image. [2:16] It can zoom in. [2:16] It can reason over the details. [2:18] It can inspect things, [2:20] figure out what to do next. [2:21] That was really the big shift from [2:23] the previous example, where the AI [2:25] was actually now using tools. [2:27] It could take action. [2:28] It could reason over the result. [2:30] And it could plan its next step. [2:32] This is what we call the agentic loop. [2:35] In this example, we give [2:36] it very bespoke tools. [2:38] But what happens when we give it [2:39] access to a computer? [2:42] This is when we introduced Codex. [2:44] Codex is our general [2:45] agent here at OpenAI. [2:47] And our design philosophy here [2:48] is we want the agent to be [2:50] able to act on its reasoning. [2:52] It could try and approach. [2:53] It could see what happened. [2:54] It could change course. [2:56] And really, we built the Codex [2:58] around this idea of a model [2:59] and a harness working together. [3:02] What's also important is [3:04] we train the model to actually [3:05] work within this harness. [3:07] So it understood the tools it had. [3:09] It could learn how to use them. [3:10] It could understand the feedback [3:11] it was getting. [3:12] And this union of the model [3:14] and the harness is really [3:15] what formed the Codex agent. [3:17] And really, how we design [3:19] the harness informs how we [3:20] do training and vice versa. [3:22] How we train the model informs how [3:23] we build the harness. [3:24] So I want to dig [3:25] into that a bit. [3:27] Let's think back [3:28] to our FizzBuzz example. [3:29] I had to copy and paste code. [3:31] Before, both Codex and then [3:33] a big jump we saw with GPT-5, [3:35] we now just hand over the whole [3:37] task to the model. [3:38] Codex could write the code. [3:39] It could run it. It could check the output. [3:41] If it made a mistake, it would [3:43] then just go and fix it. [3:44] What was cool was we could [3:46] even automate FizzBuzz. [3:48] So I now want to go and take [3:50] a look under the hood of what [3:51] the harness actually looks like. [3:55] So really think about the harness. [3:57] Think of it as managing [3:58] the instructions, the tools, [4:00] and what the model actually sees, [4:02] and the actual execution [4:03] environment of its actions itself. [4:06] It also manages the context, [4:08] so what it carries from the next [4:09] step to the next. [4:10] And with Codex, we were [4:11] very opinionated. [4:13] You'll notice Codex is open [4:14] source, by the way. [4:15] We kept it very minimal. [4:17] We want to give it very [4:18] generalizable tools. [4:19] And we want to think, hey, if [4:21] we give it access to a computer, [4:22] what does it need to act? [4:24] So from the shell to the way [4:25] it uses the file system, [4:27] or how it uses computer use, [4:28] we were very opinionated [4:29] about how we made the design. [4:31] So the way you should think [4:32] about Codex is, hey, if I [4:34] can do a task on the computer, [4:35] I want to give the model [4:37] the ability to figure it out. [4:38] We want the model to generalize, [4:40] and just like you and I [4:41] would be using the computer. [4:44] So how does it work? [4:45] Really, at the center of everything [4:47] is the Responses API. [4:48] It's a loop that we manage [4:49] in the Responses API. [4:51] We pass the tool [4:52] definitions to the model. [4:53] And now when the model requests [4:54] a tool call, we manage the execution [4:57] within the sandbox itself. [4:59] We then manage the actual conversation [5:01] context, and we append that. [5:02] And the harness really decides [5:04] whether we take a next step [5:05] or a next turn. [5:07] I talked about this a bit earlier, [5:08] but the harness changed [5:09] the way we approach training. [5:11] And what we learned from building [5:12] the harness informs how we train [5:14] the model, and the capabilities [5:15] we built into the model inform [5:17] how we build the harness. [5:18] I think the best example [5:20] of this is how we trained compaction [5:21] into both the harness and the model, [5:24] especially in situations where [5:25] one context window wasn't enough. [5:29] For those of you who are familiar [5:30] with this idea of context, [5:31] really think of it as the information [5:33] the model has in front of it. [5:35] This could be its instructions, [5:37] the history of the work, the task. [5:39] And as the agent kind of executes [5:41] tool calls, as it reads files, [5:43] as it checks results, [5:44] the history grows. [5:46] But that context window [5:47] still has a limit. [5:48] For long tasks, we need to make [5:50] sure that we're giving it room [5:52] to keep working but not forget [5:53] about the work it's already done. [5:56] And that's where your native compaction [5:57] was really, really big in Codex. [5:59] As the context window filled up, [6:02] sorry, and everybody can hear me, right? [6:04] Sorry, I just want to make sure. Louder. [6:06] Louder. OK, yes, I will talk louder. [6:08] I promise. [6:09] OK. As the window fills up, we request [6:11] compaction through the responses API. [6:13] So if you guys have seen the slash [6:15] compact endpoint, the responses API, [6:17] we're calling that under the hood. [6:18] This condenses [6:19] the history of the conversation. [6:21] It works into a stellar state, [6:23] carries the bill forward. [6:25] But what's really special in Codex [6:26] itself is we actually train this idea [6:29] of compaction into the model. [6:31] So the model understands what [6:32] it means to be compacted. [6:33] It understands what it means to work [6:35] forward from a compacted state. [6:37] It understands to resume [6:38] from compaction. [6:39] So it understands what [6:41] to keep in the conversation and what [6:42] to remove as it goes forward. [6:45] This unlocked a really big thing for us, [6:46] and this was long horizon work. [6:48] So the model could work across [6:49] multiple context windows, it could [6:51] work across multiple compaction events, [6:53] and now that it had the capacity [6:54] to work longer, the next task [6:57] was how do we actually get it [6:58] to keep going until it was done. [7:02] Earlier models didn't understand [7:03] the idea of what done meant, [7:05] and they would make good progress, but [7:07] they would just end their turn early. [7:09] I know I was not too happy [7:11] about this, and this is something [7:12] that Peter Steinberger, the creator [7:13] of OpenClaw, put on Twitter. [7:15] It was just a way of getting [7:17] the model to work longer and longer, [7:18] and it was purely to cue [7:20] a bunch of continue statements [7:21] over and over again. [7:23] What Peter and pretty much [7:24] all of us were doing was creating [7:25] this idea of an outer loop, right? [7:27] You just keep nudging the model [7:29] until it finishes. [7:30] So at this point we really needed [7:31] to understand how do you get [7:33] the model to keep working? [7:34] And this was really the foundational [7:36] idea behind loop engineering. [7:39] Geoffrey Huntley made this very popular [7:41] with the idea of a Ralph loop. [7:42] How many of you know what a Ralph loop is? [7:43] Cool, sweet. [7:45] So this was a kind of a brute [7:46] force idea of like, hey, [7:48] let me give it a bash loop, [7:49] let me get the agent to work against [7:50] that prompt file, and have [7:52] it work over and over again. [7:53] And we'd start each run with a fresh [7:55] context window, we'd pick up [7:56] the files from the last run, [7:58] and we'd keep going. [8:01] What was really cool about the loop is [8:02] it kept the agents just working, right? [8:04] They would work towards some sort [8:05] of objective, they would check what was [8:07] done, they would keep going. [8:08] It was really for us to manage [8:10] how that loop was executed, right? [8:12] How do I know if I made progress? [8:14] How do I know when to stop? [8:15] But really this philosophy [8:17] of like, keep iterating, [8:18] and like trying again and again [8:20] was this idea of loop engineering. [8:24] We brought that pattern into [8:26] Codex with dash goal. [8:27] How many of you used dash goal before? [8:29] Cool, sweet. [8:30] So we did this with GPT 5.5, [8:32] and the idea here was we wanted [8:34] to make sure it survived beyond [8:35] the end of a turn, right? [8:37] With goal, we gave Codex an objective, [8:39] the harness saves it separately [8:41] outside of the actual core context [8:43] window so it can't be compacted, [8:45] it tracks the status, and then it [8:47] sees if the agent is done working. [8:50] What was cool about dash goal was since [8:52] it was saved outside of the actual [8:54] conversation window, you could [8:55] just work for a very long time. [8:57] You could work across multiple [8:58] compaction events, and because there [9:00] was always that nudge or that check [9:02] to keep working, the model knew [9:04] like, hey, I have to keep going. [9:06] Or if there was an actual genuine [9:07] blocker, it could make [9:08] a request and say, hey, I'm blocked, [9:10] I actually need to stop. [9:11] And since this was done independently, [9:14] the goal could survive the end [9:15] of a turn, and it would just keep [9:17] working until it got the job done. [9:19] But this gave us a really good [9:21] kind of signal for training. [9:23] Hey, we understand what persistence is, [9:26] why don't we just build that into [9:27] the model? [9:29] And with GPT 5.6, that was [9:31] our really big unlock. [9:33] We trained persistence [9:34] into the model itself. [9:36] The model could understand what [9:38] useful steps meant, they could [9:39] check its own work, and it wouldn't [9:40] need another set of continues. [9:44] Toby Luque, the CEO of Shopify, [9:46] described it as the first model that no [9:47] longer needed Dashgoal, it just kept [9:49] going until it got the job done. [9:52] And Ethan Mullica, Wharton [9:53] professor of AI, [9:54] said he gave Codex access [9:56] to his computer and had [9:57] it placed Slay the Spire 2 [9:58] for about five hours straight. [10:00] We now have models that could reason, [10:02] they could generalize new tasks, [10:04] they could use a computer like you [10:06] and I, and they could work [10:07] coherently over a very long horizon. [10:10] But I introduced a new [10:11] set of challenges, right? [10:12] Like, how do we get [10:13] the model to work faster? [10:14] How do we get to parallelize work? [10:15] And we introduced this idea [10:17] of multi-agents early into 5.6.0, [10:20] but it wasn't until we got GPT [10:22] 6, it was when we got this huge [10:23] leap in intelligence, where we let [10:25] the model actually coordinate itself. [10:27] It understood how to decide to split [10:29] up problems, work on different things. [10:32] And now I'm going to hand it [10:33] over to Eric to go into a bit [10:34] more detail on how you can work from [10:36] single agents to multiple agents. [10:38] So, pass out to him. [10:46] Hey, everyone. [10:47] It's a much bigger crowd than I [10:48] was expecting today. [10:49] So I'm Eric. [10:50] You may recognize me from [10:51] my post on X. [10:53] I work on the DX team at OpenAI. [10:56] My role here is to serve as [10:58] your bridge to the talented researchers [11:00] and engineers working on Codex. [11:02] And a big part of that is [11:03] finding best practices and putting [11:05] them into words for you [11:06] all to do more with Codex. [11:08] So, to build on Raj's walk down [11:11] memory lane, let's take a look [11:12] at Codex today and explore what's [11:14] possible with all the capabilities [11:16] we now have access to. [11:18] When you're taking a long task, [11:20] it's super tempting to start by [11:22] building a whole team of agents. [11:24] But you're almost always better [11:26] off starting with just one [11:27] and giving it a clear task [11:29] and a way to check its work. [11:31] The GPT-6 series can keep working, [11:34] compact their context, and push [11:36] through failures with no external [11:38] loop telling them to continue. [11:40] For many tasks, that's honestly enough. [11:43] Only add more agents when [11:44] the work gives you a reason to. [11:48] Okay, so what about tasks where [11:51] that won't work, like a complete [11:52] code-based refactor or a whole game? [11:54] With GPT-6, [11:56] our models were trained to coordinate [11:58] and collaborate from the jump. [11:59] And they can tackle these hard [12:01] problems by breaking them down into [12:03] independent pieces and multitasking. [12:05] Using Ultra, [12:07] Codex will make copies of itself [12:09] all on its own and collaborate [12:11] with those copies to tackle [12:12] even the largest of projects. [12:14] But here's the thing. [12:16] Every agent Codex brings in can [12:19] dramatically increase token [12:20] use without necessarily making [12:22] the work faster or better. [12:24] It's up to you to decide when [12:26] a problem needs the extra help. [12:30] Some tasks are obviously [12:32] decomposable, like asking [12:34] your agent to review five PRs. [12:36] This makes it easy to be explicit, [12:38] as you can ask Codex to assign [12:40] a subagent to each one. [12:42] Other tasks require broad research, [12:44] like fixing a tricky race condition. [12:46] Here, you can just ask Codex [12:48] to use a couple of subagents [12:49] to split up the investigation. [12:51] A small nudge is enough for Codex [12:53] to bring in help, and each added [12:55] agent can keep its own working context [12:57] and make progress on its part. [12:59] With the right prompt, you can shape [13:02] your agents into complex geometries. [13:04] Be careful, though, [13:05] as it's easy to build structures [13:07] that don't add any value. [13:09] So what if we could automatically [13:12] manage the reasoning effort [13:13] and the models assigned to a given [13:15] task using subagents so we [13:18] don't have to think about it? [13:19] This is where effort scaling comes in. [13:24] We can introduce a lever that allows [13:26] Codex to ramp work up when it [13:28] really matters and down when it doesn't. [13:31] With the right skill, you can have [13:32] Sol ask Astra for help when it [13:35] is to spend a few turns iterating [13:36] on a test failure and focus on [13:38] the difficult part while keeping [13:40] Sol in charge of the integration. [13:42] All the while, Luna agents can be handed [13:44] simpler supporting tasks that don't [13:46] need as much attention from Sol. [13:48] This won't always cost you less, [13:50] as even Astra can't perfectly [13:53] predict which model will solve [13:54] the task at the best price, [13:56] but in many cases, it can be [13:58] a huge help in helping you reduce [14:00] the decision anxiety in picking [14:01] the right model for the job. [14:04] So here's a shortened version of a skill [14:06] I've been working on called Coordinate. [14:08] You can take a picture of it if [14:09] you're around there. [14:11] It's designed to be used by Sol [14:13] Medium, which handles most work. [14:15] When it runs into a problem [14:16] it's having trouble with, it's told [14:18] to ask for help from Astra High. [14:20] When it encounters simple busy work, [14:21] it can toss those problems to Luna [14:23] High agents without a second thought. [14:27] When I was working on a game [14:28] porting project one weekend, [14:30] I ran into a problem that got [14:32] me to try a new agent structure. [14:33] I'm calling it the pair. [14:35] I had this old game I made years [14:37] ago that was built with an ancient [14:39] game engine I could no longer find. [14:41] I had the project files [14:42] and the running game though. [14:44] I wanted to take this old game, [14:46] run it, and then visually recreate [14:48] the running scene in Blender [14:50] so I could continue working [14:52] on it in a new game engine. [14:54] To do this, I had Codex summon [14:56] a pair of agents where one side [14:58] was tasked with getting the capture [15:00] tech working in the old engine [15:02] and the other agent was tasked [15:04] with unpacking and visualizing the scene [15:06] in a workable format in Blender. [15:09] Here, the format could inform [15:11] the capture tech so it made sense [15:12] for the two agents to split the work [15:14] and keep the communication flowing so [15:16] that if one side found an optimization, [15:18] the other could adapt. [15:21] Setting up a pair takes a bit [15:23] of special wording since you'll have [15:24] to make sure to define the communication [15:26] boundaries pretty explicitly. [15:28] So this prompt is pretty technical. [15:30] Take a picture of it and ask [15:32] Codex what it thinks. [15:33] Maybe it'll find the perfect task [15:34] in your project for a pair of subagents. [15:39] As you work in Codex, it's very [15:41] common to have many different [15:43] tasks running at the same time. [15:45] Jumping between a bunch of threads [15:46] can be pretty overwhelming though. [15:48] An easy way to make this more [15:50] manageable is to just ask Codex [15:52] to manage the threads for you. [15:54] In the ChatGPT app, Codex can start [15:56] new threads and even send messages [15:58] to and steer other running chats. [16:01] These are distinct from [16:02] subagents, with each chat [16:04] which each chat can also use. [16:06] Think of it as your thread manager, [16:08] taking in your overall goal [16:10] and replacing that loose script [16:11] you used to set up manually. [16:14] Setting this up is super easy. [16:16] You can just ask Codex to do it. [16:18] Here's an example where you can just [16:19] have it spin up a separate chat [16:21] for every PR in your review queue. [16:23] What's great is that you can just [16:25] open the chats after they've been [16:26] started and steer them manually [16:28] if you want to stay involved. [16:29] The best part though is that because [16:31] our agents are so naturally chatty, [16:34] they'll also keep the manager [16:35] involved with all your meddling. [16:37] So the work keeps moving [16:38] even if you decide you no [16:39] longer want to see it through. [16:42] One of the big benefits of Codex [16:44] Compaction is that context [16:46] can accumulate over time [16:48] and a thread can start to specialize [16:50] around the long-running task. [16:52] Game projects can take months [16:54] to complete and are naturally [16:55] broken down into distinct work [16:57] streams like art, design, [16:59] programming, and play testing. [17:01] Here you can assign each of those [17:03] lanes an agent who can run [17:05] them like a department lead. [17:07] The art director can handle all [17:08] the environment art while your play [17:10] tester tries the latest build [17:12] your programmer just finished. [17:14] You can just give your notes [17:15] and directions to the producer while [17:17] your agent team handles the rest. [17:21] When you're getting your game [17:22] project started, try setting [17:23] it up with a prompt like this. [17:25] It may not be the most efficient [17:27] way to work token-wise, [17:28] but it's really handy to be able [17:30] to drill down and brainstorm [17:31] a new mechanic while your producer [17:32] coordinates the next build to share. [17:36] While agents love to collaborate, [17:39] every time you make a new [17:40] rule about how they're supposed [17:42] to work together, they can start [17:44] to stall out as they seek approval [17:46] through made-up hierarchies. [17:48] I call this the middle management tax. [17:51] Try not to overthink [17:52] managing all your agents. [17:53] It's just often not worth the hassle, [17:55] and it makes it very easy [17:57] to lose track of how complex [17:58] your agent teams have gotten. [18:01] Now, before I wrap up today, [18:03] I want to bring in one more [18:05] thing that's made a huge difference [18:06] in how well my agents have stayed [18:07] on track through my constant steering. [18:10] I don't know about you, [18:11] but when I watch my agents work, [18:13] I constantly nag them with little [18:15] things I forgot to mention when [18:16] I sent the first prompt. [18:18] The problem is that after [18:19] the agent compacts like three [18:21] or four times, it might now have [18:23] drifted from your original prompt, [18:24] which still has a ton of important [18:26] context about the overall goal. [18:28] Agents only have so much short-term [18:30] memory, and just like you, that little [18:32] thing that you just can't get [18:34] to just yet, that keeps nagging you, [18:36] it'll just keep nagging you [18:38] unless you write it down. [18:42] The trick to keeping your models [18:44] on track as you constantly nag [18:45] them with steers is to just ask [18:48] them to keep a compact work log [18:50] that contains the overall goal, [18:52] your running work, and how [18:54] your last year relates to both. [18:55] By writing it down, the agent can [18:58] avoid losing track of active work [19:00] streams or some weird precision [19:01] you made to your agent when testing [19:03] your beta version last Thursday. [19:05] By keeping this work lag compact, [19:07] though, it stops your agent from [19:09] maintaining a never-ending diary [19:11] of every test that ever failed and why. [19:14] Ask your Codex to set one up [19:16] and enjoy the freedom of just naturally [19:18] micromanaging your agent without it [19:19] getting completely lost as it works. [19:22] Oh, and by the way, before I hand [19:23] you back to Raj, I want you all [19:25] to keep in mind that best practices [19:27] have a shelf life and you should [19:29] never get attached to your workflows. [19:32] Thanks for your time, everyone, [19:33] and now for a sneak peek into [19:35] the next generation of agents. [19:44] Great. [19:45] So Eric took us through what [19:46] we can do today and how we [19:49] can organize multiple agents [19:50] to work on everyday tasks. [19:52] But now, what's next? [19:53] Instead of a handful of agents, [19:55] how do we start thinking about things [19:57] at really big scale? [19:59] So what happens if we go [20:00] from a few to a thousand? [20:02] How do we get them to work cohesively? [20:04] How do we get them to maintain [20:05] coherence? [20:06] And how do we make sure that they're [20:07] working towards a singular goal? [20:10] You may have heard about our work [20:11] with the Navier-Stokes [20:13] problem, which is a long-standing [20:14] Millennium Prize problem. [20:16] Here we used an internal model [20:18] and Codex, and we found a solution [20:20] with 10,000 agents working together. [20:24] Across the full effort, [20:26] there were 2.7 million messages [20:28] and about 130 billion output tokens. [20:31] I want everybody to take a minute [20:33] to just take that in, right? [20:34] 2.7 million messages and 10,000 [20:37] agents working together. [20:39] So when you think about that scale, [20:40] how you divide the work matters, [20:42] how you manage context, [20:44] how do you make sure the agents [20:45] collaborate, and how do you make sure [20:47] that you divide the work correctly? [20:48] All that changes at this scale. [20:51] Now I want to go into a bit [20:52] of the architecture of how we [20:53] approach the problem. [20:55] You can refer to this pattern [20:57] as agent teams. [20:59] We let groups of agent teams [21:01] work towards a unified goal. [21:03] Our objective is to do two things. [21:05] We want to encourage both deep work, [21:07] but we also want to encourage [21:08] a wide research objective. [21:10] Right? Let's walk through how we approached it. [21:14] We started by initializing multiple [21:16] teams with different versions [21:17] of the problem and prompted it [21:19] to encourage different approaches. [21:21] So the way to really think about [21:22] this is these are individual [21:23] teams with multiple sub-agents [21:25] underneath, and they're all [21:26] working towards that unified goal. [21:29] What's important here is [21:30] communication, right? [21:32] Not only can they communicate [21:33] with themselves, but they [21:35] can also communicate across [21:36] different teams, right? [21:38] We want to make sure that they can share ideas. [21:40] If I have a finding, hey, [21:41] cool, team one, you should know [21:43] what team two just found out. [21:44] I can ask questions of other teams. [21:46] I can know what the other [21:47] team is working on. [21:48] And the big objective there is we [21:50] want to prevent duplicative effort. [21:52] This part's important, right? [21:53] We talked about 10,000 agents. [21:55] If all 10,000 are working on the same [21:56] thing, that's really expensive, right? [21:59] We want them to make sure that we're [22:00] encouraging diversity, and we want [22:02] to know what each team is working [22:03] on, so they're not all trying [22:04] the same thing over and over again. [22:08] What was important is as [22:09] the teams evolved, as they got [22:11] deeper into their respective idea, [22:12] what they actually did [22:14] changed as well, right? [22:15] One may have explored a hypothesis, [22:17] one may have challenged assumptions, [22:19] others ran experiments, but what was [22:20] important is that every team still [22:22] owned their own unique approach. [22:25] As we got deeper into the problem, [22:28] as new findings exposed new [22:29] questions, we created [22:31] and orchestrated new teams, right? [22:33] We may have steered teams towards [22:34] a more promising line, [22:36] but the goal remained the same, right? [22:38] The way we divided work can change, [22:40] but the goal and objective does not. [22:42] In Navier Stokes, when we found [22:44] the unforced Euler result, [22:46] we diverted all the teams towards [22:47] solving the problem, and by the end [22:49] of it, we had solved the solution. [22:50] So, whew! [22:54] This pattern has shown some [22:55] incredible results for us, right? [22:57] Especially with models that are [22:59] even more powerful than GPT-6. [23:01] With the internal model that we used [23:03] to solve Navier Stokes, we were able [23:05] to resolve more than 100 longstanding [23:07] problems across mathematics, and we [23:09] continue to use it to find new [23:11] discoveries in both math and science. [23:13] I think we can all say we've [23:15] come a long way from copying [23:16] and pasting FizzBuzz. [23:19] So, as we say every single year, [23:21] we're just getting started with agents. [23:23] As model capabilities advance, [23:25] the work we do with them can get [23:26] a lot more ambitious. [23:28] As we close today, my challenge [23:29] to all of you in the audience would [23:31] be take a problem that you've been [23:32] putting off for a while, or one [23:34] that previous models just couldn't. [23:35] Take some of the approaches we [23:37] talked about today, [23:38] check out the QR code that goes [23:39] into more detail on how we approach [23:40] the Navier Stokes problem, [23:42] and I'll leave it with this. [23:44] You can always just build things. [23:46] Thank you guys so much.