OpenAI
Engineering teams can eliminate continuous integration maintenance by delegating debugging to autonomous multi-agent hierarchies, which now resolve complex code failures around the clock for $16 an hour.
AI-assisted summary of What Will You Build With Coding Agents That Don’t Quit? | DevDay 2026 — original source. Check the original for full context.
Source published:
Key ideas
- OpenAI showcased autonomous Codex deployments running continuously for weeks, including a 1,000-hour CI maintenance agent that authored over 100 pull requests per week and directly merged 213 fixes. (5:46)
- Prompting methodologies have evolved from hyper-prescriptive execution plans to concise, outcome-driven specifications: a 200-word prompt without code governed the six-week CI agent run. (4:12)
- The operational token cost of running continuous 24/7 maintenance agents was approximately $32 per hour initially and dropped to $16 per hour with GPT-6 Sol. (24:01)
- Long-horizon agent stability relies on native context compaction, Git worktrees for parallel isolation, and remote cloud environments with periodic heartbeats for asynchronous code review loops. (15:11)
Detailed notes
## Background Published on YouTube by OpenAI on November 11, 2026, this DevDay presentation details insights gained from an autonomous Codex run that operated for more than 1,000 hours maintaining continuous integration builds and test suites. The talk covers criteria for selecting recurring engineering tasks, structuring feedback loops, optimizing token spend, and establishing clear boundaries for human intervention.
## TL;DR OpenAI engineers Friel and Vivi showcase how frontier models have transitioned from brittle, micromanaged execution plans to durable, outcome-driven agents capable of running autonomously for weeks. Drawing on a flagship experiment where Codex ran for over 1,000 hours to resolve flaky CI failures and landed over 200 fixes, they break down the architectural patterns that enable multi-week stamina—such as sub-agent orchestration, Git worktrees, context compaction, and persistent documentation via `AGENTS.md`. The presentation highlights how operational economics have plummeted to roughly $16 per hour with GPT-6 Sol and provides a five-step playbook for engineers looking to offload repetitive operational toil.
## Atmosphere & style The session balances visionary frontier demos with pragmatic, trench-level engineering realities, driven by easygoing camaraderie and self-deprecating humor between the co-presenters. Moving from creative spectacles like autonomous 21-kilometer Nürburgring 3D renders to the unglamorous grind of debugging floating-point CI flakes, the narrative feels like an honest, insider post-mortem rather than a polished sales pitch. Watching it evokes both relief at the prospect of delegating tedious maintenance backlogs and excitement about transitioning from hands-on coders to directors of autonomous agent teams.
## Bulletin - [05:46](https://www.youtube.com/watch?v=U1IVZy9FhVQ&t=346s) OpenAI showcased autonomous Codex deployments running continuously for weeks, including a 1,000-hour CI maintenance agent that authored over 100 pull requests per week and directly merged 213 fixes. - [04:12](https://www.youtube.com/watch?v=U1IVZy9FhVQ&t=252s) Prompting methodologies have evolved from hyper-prescriptive execution plans to concise, outcome-driven specifications: a 200-word prompt without code governed the six-week CI agent run. - [24:01](https://www.youtube.com/watch?v=U1IVZy9FhVQ&t=1441s) The operational token cost of running continuous 24/7 maintenance agents was approximately $32 per hour initially and dropped to $16 per hour with GPT-6 Sol. - [15:11](https://www.youtube.com/watch?v=U1IVZy9FhVQ&t=911s) Long-horizon agent stability relies on native context compaction, Git worktrees for parallel isolation, and remote cloud environments with periodic heartbeats for asynchronous code review loops.
## Key takeaways - [00:19](https://www.youtube.com/watch?v=U1IVZy9FhVQ&t=19s) Autonomous agents can synthesize complex 3D assets and animated fly-throughs from minimal inputs, including full crash recovery across multi-day rendering runs. - [04:12](https://www.youtube.com/watch?v=U1IVZy9FhVQ&t=252s) Prompt engineering has transitioned away from micromanaged step-by-step scripts toward outcome-focused prompts that define boundaries and trade-offs. - [05:46](https://www.youtube.com/watch?v=U1IVZy9FhVQ&t=346s) A continuous integration maintenance agent ran continuously for six weeks (>1,000 hours) using a prompt of just 200 words. - [07:25](https://www.youtube.com/watch?v=U1IVZy9FhVQ&t=445s) Delegating debugging tasks to parallel sub-agents transformed the lead agent into an orchestrator, scaling throughput across 5,800+ sessions. - [07:25](https://www.youtube.com/watch?v=U1IVZy9FhVQ&t=445s) The autonomous CI agent resolved complex non-deterministic issues, such as a floating-point Heisenbug in GPU test environments. - [10:28](https://www.youtube.com/watch?v=U1IVZy9FhVQ&t=628s) Agents can independently isolate physical hardware issues down to specific cluster nodes and coordinate technical inquiries with human system owners. - [10:28](https://www.youtube.com/watch?v=U1IVZy9FhVQ&t=628s) To prevent aggressive or reckless test deletions, the system instantiated reviewer subagents to audit proposed code removals before human escalation. - [12:12](https://www.youtube.com/watch?v=U1IVZy9FhVQ&t=732s) Aligning one long-lived thread to a single objective alongside an AGENTS.md file provides persistent guidelines, off-limits boundaries, and operational scratchpads. - [15:11](https://www.youtube.com/watch?v=U1IVZy9FhVQ&t=911s) Default context compaction eliminates context rot, enabling uninterrupted agent threads to run stably for months at a time. - [17:55](https://www.youtube.com/watch?v=U1IVZy9FhVQ&t=1075s) Git worktrees give parallel child threads isolated checkouts, preventing merge conflicts and race conditions when subagents build concurrent features. - [20:46](https://www.youtube.com/watch?v=U1IVZy9FhVQ&t=1246s) Ultra mode equips Codex to tackle deep, complex bottlenecks within a single thread by coordinating specialized diagnostic and patching subagents. - [22:27](https://www.youtube.com/watch?v=U1IVZy9FhVQ&t=1347s) Automated heartbeats wake agents on scheduled intervals to inspect pull request feedback, handle reviewer remarks, and resume blocked work. - [24:01](https://www.youtube.com/watch?v=U1IVZy9FhVQ&t=1441s) Running continuous engineering agents around the clock cost $32/hr initially and halved to $16/hr with GPT-6 Sol, offering high leverage relative to developer time. - [25:17](https://www.youtube.com/watch?v=U1IVZy9FhVQ&t=1517s) Deploying production agents successfully requires identifying operational time sinks, establishing closed automated verification loops, and enforcing explicit escalation boundaries.
## Detailed walkthrough ### [00:19](https://www.youtube.com/watch?v=U1IVZy9FhVQ&t=19s) Pushing Models to Build 3D Formula 1 Worlds
Friel, working on engineering acceleration at OpenAI to help engineers and researchers keep shipping, introduces the session alongside Vivi from the developer experience team. Vivi explains that much of his day involves experimenting with frontier models to discover how far they can be pushed. Lately, that experimentation has centered on generating rich 3D worlds using Codex and Astra. As a passionate Formula 1 enthusiast, Vivi wanted to see whether Astra could dissect an F1 vehicle and render its internal anatomy, answering basic curiosity about what the cars are composed of.
```mermaid flowchart TD accTitle: F1 Modeling and Circuit Generation Architecture accDescr: Pipeline showing how Codex and Astra transformed reference assets into 3D models and an animated fly-through of the Nürburgring. subgraph Ferrari["Ferrari 3D Exploration"] A["7 Reference Photos"] --> B["Codex + Astra on Remote Machine"] B --> C["Rendered 3D Model"] B --> D["Clay Version"] B --> E["Wireframe Version"] B --> F["Interactive Explorer Website"] end subgraph Circuit["Nürburgring Nordschleife Fly-Through"] G["Track Name Prompt"] --> H["Codex Autonomous Controller"] H --> I["Research Sub-Agents: Geometry & Track Data"] H --> J["Blender Frame Rendering Engine"] J --> K["Crash Recovery: Resumed from Saved Frames"] K --> L["21 km, 70-Turn Cinematic Video"] end ```
To explore the car, Vivi executed Codex paired with Astra on a remote machine under a single objective: construct a Ferrari alongside an interactive website allowing users to explore all its underlying components. The model received only seven reference photographs. Over several days of autonomous iteration, Astra not only assembled the complete rendered 3D vehicle and exploration site, but also generated clay and wireframe visualizations without ever being prompted to do so.
- Goal given to the agent: “Build a Ferrari and a website where I could explore all that it's made of.” - Inputs required: Only seven reference photographs provided to Codex. - Autonomous output: Full 3D interactive model, website, unprompted clay render, and unprompted wireframe view.
[01:55](https://www.youtube.com/watch?v=U1IVZy9FhVQ&t=115s) Generating a 21-Kilometer Nürburgring Fly-Through
Vivi then expanded the scope from a single vehicle to an entire racing circuit, tasking Codex with creating a full fly-through animation of the Nürburgring. The agent was provided nothing beyond the name of the circuit, leaving it to scour references online, map out the track geometry, and chart its own camera path. Rather than settling for a short layout, Codex autonomously opted to recreate the complete Nordschleife circuit—spanning 21 kilometers and 70 distinct turns, an environment roughly three times the size of a standard Grand Prix circuit.
The resulting video took slightly over two days to generate. The bulk of that duration was pure compute latency, with Codex delegating the heavy lifting to Blender while standing by for frame renders. Codex dispatched sub-agents to independently research track layouts, verify geometric fidelity, and schedule rendering batches. Because rendering a 21-kilometer course is compute-intensive, the system encountered several hard interruptions caused by RAM exhaustion and CPU overheating. Codex demonstrated resilience by automatically detecting saved frames upon recovery, resuming progress where it left off, and completing the run across two days without human babysitting.
- Circuit scope: Full Nordschleife course covering 21 kilometers and all 70 turns (3× larger than an average F1 track). - Production duration: Slightly over two days, with most time spent waiting on Blender frame rendering. - Sub-agent utilization: Dedicated sub-agents handled track research, geometric verification, and render scheduling. - Fault tolerance: Automatically recovered from system crashes caused by RAM limits and CPU overheating by parsing cached render frames. - Vivi on agent stamina: “What was best about this was Codex automatically picked up from where these saved frames were and kept going for these two days.”
[04:12](https://www.youtube.com/watch?v=U1IVZy9FhVQ&t=252s) From Micromanaged Execution Plans to Outcome-Driven Agents
Reflecting on how quickly agentic capabilities have expanded, Friel looks back at the prior year's DevDay stage presentation where he introduced "exec plans"—a rigid scaffolding system designed to help Codex tackle hard multi-hour problems. At that time, keeping Codex running productively for seven hours was considered a massive milestone, requiring prompts so lengthy and hyper-prescriptive that they had to be broken across slides. Those early prompts dictated exact code samples, libraries, and precise implementation workflows, while demanding that the model produce an upfront plan for human review and iterative debate before taking action.
Today, prompting paradigms have shifted dramatically. Instead of prescribing low-level code mechanics or negotiating multi-step roadmaps, engineers now specify the target outcome, boundary constraints, and trade-offs, allowing models like Astra and Sol to chart their own implementation paths. This newfound reliability prompted Friel to examine recurring, maintenance-heavy engineering workflows that drain engineering time through relentless manual supervision.
- Evolution of prompts: Shifted from massive, multi-slide, code-heavy instructional prompts down to goal- and trade-off-oriented descriptions. - Autonomy comparison: A 7-hour run required constant hand-holding a year prior, whereas modern workflows run unprompted for days across complex tasks. - Friel on trusting modern models: “Today, with Astra and Sol, I'm much more comfortable just telling it specifically that. I tell it the goal and the outcome I want, what I care about, what are the trade-offs that I'm concerned with. And then, I tell it it can figure out the steps.”
[05:46](https://www.youtube.com/watch?v=U1IVZy9FhVQ&t=346s) The 1,000-Hour CI Maintenance Agent
Friel's team is responsible for engineering acceleration at OpenAI, which includes keeping continuous integration (CI) green across the organization so researchers and engineers can merge code and ship models. In large codebases, CI suites frequently fail due to flaky tests—tests that randomly fail on one execution and pass on the next—triggering deep investigations that can consume hours or days of an engineer's time while incoming failures continuously queue up. To break this cycle, Friel initiated an experiment to determine if an autonomous agent could shoulder CI maintenance indefinitely without ongoing human intervention.
```mermaid flowchart TD accTitle: Autonomous CI Triaging and Delegation Flow accDescr: Hierarchical agent architecture showing the Sol controller managing CI runs and directing parallel worker sub-agents. subgraph Manager["Primary Sol Agent (Controller)"] A["200-Word Rule Prompt"] --> B["Trigger CI Test Suites"] B --> C["Monitor & Collect Failures"] C --> D["Orchestrate & Dispatch Sub-Agents"] D --> E["Slack Coworker Communication & PR Landings"] end subgraph Workers["Sub-Agent Fleet (5,800+ Sessions)"] D --> F["Sub-Agent: Pull Code & Reproduce"] F --> G["Iterate on Fixes"] G --> H["Push to CI & Verify Pass"] end H -->|"Merge Candidate"| E ```
The resulting agent ran continuously for six weeks, clocking over 1,000 hours of runtime before being deliberately shut down—not due to failure, but because coworkers had begun deploying parallel agents of their own to handle similar workloads. In stark contrast to the massive prompts of the prior year, this autonomous CI run was launched with a prompt of just 200 words. It contained zero code and zero prescriptive fix patterns; it simply pointed the agent to the repository, defined rules for triggering test suites, instructed it on using CI compute resources conscientiously, and outlined how to communicate with human engineers on Slack.
- Total runtime: Over 1,000 operating hours across six consecutive weeks. - Prompt footprint: Approximately 200 words, establishing behavioral guardrails rather than implementation code. - Shutdown rationale: Turned off intentionally after colleagues began adopting and running their own maintenance agents. - Friel on the recurring CI burden: “Now, a test can fail legitimately because it's broken code, but often it will fail one time and pass the next. That's a flaky test. Someone then has to look at that and determine what the cause is... and the trickiest of these can take hours or days to debug.”
[07:25](https://www.youtube.com/watch?v=U1IVZy9FhVQ&t=445s) Delegating to Sub-Agents and Managing CI at Scale
The 1,000-hour deployment initially launched on model version 5.6 Sol running in a single thread. In this early setup, Sol sequentially diagnosed failures and authored patches within the same execution loop. However, four days into the experiment, Friel noticed the agent would get trapped debugging a single complex failure, stalling progress on newly arriving flakes. Friel interrupted the agent with a crucial course correction: delegate the repetitive debugging legwork to sub-agents.
This structural shift transformed the primary Sol thread into an orchestrator that gathered test signals, prioritized incoming failures, and assigned targeted issues to sub-agent sessions while coordinating PR reviews with human engineers over Slack. Sub-agents handled the time-consuming cycles of pulling repositories, reproducing flakiness, drafting code changes, and verifying test suites against CI. Joking about his evolving title, Friel observed that after describing himself as a "manager of agents" the previous year, he had effectively become a "director of agents," supervising a lead agent that commanded its own team.
```mermaid flowchart LR accTitle: Sol Autonomous Maintenance Metrics accDescr: High-level metrics tracking commits, PRs, tool calls, and merged fixes across the 1,000-hour agent run. A["1,000+ Operating Hours"] --> B["~500,000 Tool Calls"] B --> C["5,800+ Sub-Agent Sessions"] B --> D["67,000+ Wait Loops"] A --> E["1,000+ Commits"] E --> F["100+ PRs / Week"] F --> G["213 Self-Authored Merges"] A --> H["600+ Slack Coordination Messages"] ```
Over its six-week lifespan, the agent generated significant engineering throughput, authoring over 100 pull requests per week, pushing upwards of 1,000 commits, and broadcasting over 600 Slack messages to coordinate landing patches. In total, the system directly merged over 213 of its own code fixes. Whenever a proposed patch was skipped, it was typically because the agent noticed an engineer had already authored an equivalent fix, gracefully deprioritizing its own PR in favor of human work.
During a post-run retrospective, the agent demonstrated self-awareness regarding its workflow dynamics; it noted that its peak five-day stretch of productivity occurred when Friel completely stopped sending it messages. Across its half-million tool calls and 5,800 sub-agent sessions, more than 67,000 invocations were patience loops—waiting for long CI runs to complete, mirroring the exact downtime human engineers experience when stepping away for coffee while pipelines execute. Rather than picking easy fruit, the agent knocked down some of the most elusive technical debt in the repository, including fixing a non-deterministic Heisenbug triggered by floating-point math anomalies in GPU-based test environments.
- Operational velocity: Produced >100 pull requests per week and >1,000 total commits across the run. - Collaboration metrics: Sent >600 Slack messages to teammates and merged 213 autonomous fixes into the mainline. - Tool usage: Logged ~500,000 tool invocations, >5,800 sub-agent sessions, and >67,000 asynchronous wait checks. - Benchmark fix: Solved an intermittent Heisenbug involving non-deterministic floating-point discrepancies inside GPU tests that human engineers routinely bypassed by retrying. - Friel on team hierarchy: “Last year at DevDay, I joked that I'd kind of become a manager of agents, and this year, I've been promoted to a director of agents. I give an agent a job, and then it manages a team of agents to get it done for me.” - Friel on the agent's candid retrospective feedback: “I did a retrospective with the agent after the run, and while it didn't say anything directly about my managing style, it did say that it was most productive for a five-day stretch when I didn't message it once.”
[10:28](https://www.youtube.com/watch?v=U1IVZy9FhVQ&t=628s) Debugging Hardware and Interrogating Deletions
Reflecting on a particularly thorny investigation that was completely outside his wheelhouse, the speaker describes spending significant time reading through an agent thread to reconstruct what had occurred. Over several weeks of correlated logs, the agent managed to isolate an intermittent failure to a single specific node. The subagent spent several days teaching itself how to execute tests repeatedly on that exact machine until it reproduced the bug. Then came what the speaker considers the most remarkable breakthrough: rather than getting stuck or silently failing, the agent initiated contact with the researchers who owned the machine. It framed a structured technical collaboration, detailing how it reproduced the failure and asking whether the issue stemmed from an undeclared, out-of-scope machine-level software optimization or an actual physical hardware defect like a faulty GPU.
```mermaid flowchart TD accTitle: Agent Bug Investigation and Verification Loop accDescr: An autonomous agent correlates logs to locate a bad node, reproduces intermittent bugs, checks with system owners, and verifies solutions with reviewer subagents before pinging a human.
subgraph Investigation["Log & Node Investigation"] A["Correlate Weeks of Logs"] --> B["Isolate Faulty Node"] B --> C["Subagent Learns Node Test Loop"] C --> D["Intermittent Reproduction"] end
subgraph Escalation["System Owner Outreach"] D --> E["Engage System Researchers"] E --> F{"Software Optimization or Bad GPU?"} end
subgraph Resolution["Patch & Safety Check"] F --> G["Draft Fix or Test Removal"] G --> H["Spawn Reviewer Subagent"] H --> I["Interrogate Proposed Code"] I --> J["Human Pull Request Review"] end ```
The speaker notes that while the fastest way to get a continuous integration build back to green is often to simply delete the failing test, teams naturally harbor skepticism toward that shortcut. Whenever the agent questioned whether deleting a test was legitimate, it spawned a secondary reviewer agent tasked specifically with interrogating and verifying the first agent’s logic before ever escalating to a human engineer. Delegating this operational burden gave the speaker hundreds of hours back over the summer to focus directly on scaling infrastructure. As the speaker highlights: “And Codex giving me this time back allowed me to focus on scaling our infrastructure.”
- The agent correlated weeks of cluster logs to track intermittent failures down to a single physical machine. - Debugging and test-loop generation on that machine took several days of autonomous subagent execution. - Reviewer subagents audited proposed test deletions and fixes prior to human notification to prevent trivial test gutting. - Running Codex around the clock unlocked equivalent engineering effort spanning thousands of machine-hours.
[12:12](https://www.youtube.com/watch?v=U1IVZy9FhVQ&t=732s) Single Outcome Threads and AGENTS.md Context
Vibi takes over to break down the architectural features that make these multi-week agent runs possible, noting humorously that his co-presenter’s agent was dubbed "Frillbot." While the agent produced hundreds of commits and pull requests across the summer, Vibi boils the entire paradigm down to six essential Codex capabilities, starting with dedicating one thread to each specific outcome. Within a single dedicated thread, developers can map plans, monitor progress, supply iterative feedback, and redirect the agent on the fly. For engineers who prefer hands-off execution, Vibi points to slash commands: “Some of us are slash goal enjoyers over here. So, for those of you, you can even use slash goal and tell Codex to relentlessly go after that task and not stop until it is completed, no matter what happens.” In a continuous integration scenario, a thread’s objective can be framed to watch the build system, reproduce test failures, iterate on candidate fixes, and open PRs for review.
To ground that mission in institutional knowledge, developers configure an `AGENTS.md` file within the repository. This document serves as persistent operational guidance, defining where test suites live, outlining explicit engineering "dos," and staking out strict boundaries that are entirely off-limits. Vibi strongly emphasizes adding a requirement in `AGENTS.md` for Codex to maintain an active work log detailing both completed actions and pending explorations. If the agent ever runs into an environmental hiccup or execution boundary, it can simply read its own historical notes and resume seamlessly without starting from scratch.
- **Outcome-focused threads**: Keep one long-lived thread aligned with a single durable objective rather than scattering goals across disjointed chats. - **Relentless execution**: The `/goal` command locks the model onto an end-state and instructs it to cycle through obstacles without stopping. - **Rules of engagement**: `AGENTS.md` codifies repository boundaries, test execution recipes, and strict off-limits files. - **Persistent scratchpad**: Requiring Codex to log completed steps and unexplored hypotheses ensures clean continuity if interrupted.
[15:11](https://www.youtube.com/watch?v=U1IVZy9FhVQ&t=911s) Infinite Context with Compaction and Remote Environments
Addressing the widespread concern that maintaining a single conversation over weeks or months inevitably triggers context rot or output degradation, Vibi explains that context compaction completely changes the equation. Compaction condenses prior history while retaining critical operational context, enabling agents to operate across massive horizons. Vibi quips about its efficacy across engineering workflows: “A lot of the times I would joke about saying that compaction is a solved problem, which means that long horizon task is a solved problem.” He confirms he and his team run individual Codex threads continuously for three months at a time without manual resets, and compaction works natively out of the box with zero configuration changes.
Carrying out long-horizon runs on a personal workstation, however, creates an obvious physical bottleneck—engineers cannot realistically keep fleets of laptops awake and connected for six consecutive weeks. Remote environments solve this by letting Codex work over SSH connections across desktop, mobile, and web interfaces. For example, in a multi-day racetrack rendering project, Vibi pointed Codex to a remote development server provisioned with Blender, project assets, and internet access, leaving it to run unattended for days. Expanding on this, Vibi introduces the newly upgraded Codex Cloud, which provisions managed, pre-configured virtual machines without host-management overhead. Codex Cloud environments snapshot state automatically, periodically refresh git branches and dependencies, support custom plugins, and persist seamlessly across devices—a capability Vibi demonstrated by merging launch pull requests from backstage on his mobile device during the event.
- Compaction ships as default Codex behavior, preserving reasoning quality in active threads spanning over three months. - Remote SSH connectivity lets agents access dedicated servers with custom tooling (such as Blender runtimes and web browsing tools). - Codex Cloud delivers snapshotted, fully managed execution environments that stay up to date with remote git repositories automatically. - Unified cross-device state allows engineers to inspect, steer, and merge agent-authored pull requests from mobile, desktop, or browser.
[17:55](https://www.youtube.com/watch?v=U1IVZy9FhVQ&t=1075s) Plugins, Child Threads, and Worktrees
Giving an agent compute is only half the battle; it also requires ambient organizational context so it does not waste cycles investigating solved problems. Vibi cautions that when a build breaks, teammates may already be coordinating on Slack or tracking the failure in a ticketing system. Without external tool awareness, Codex will inevitably run in circles: “Codex can continue sort of working on that problem, but it would just be mindlessly running around like a headless chicken if it didn't know what is happening.” Connecting plugins for services like GitHub and Linear equips the agent to search existing issues, read discussions, and inspect related pull requests before writing redundant patches.
```mermaid flowchart TD accTitle: Parallel Child Thread and Worktree Architecture accDescr: A parent agent thread delegates subtasks to parallel child threads, each operating in an isolated Git worktree to avoid file conflicts.
A["Parent Coordinator Thread"] -->|"Oversee Overall Goal"| B["Branch Task Execution"]
subgraph ParallelExecution["Parallel Child Threads"] B --> C["Child Thread: Blender Assets"] B --> D["Child Thread: Web UI Viewer"] end
subgraph GitWorktrees["Isolated Git Worktrees"] C --> E["Worktree A (assets branch)"] D --> F["Worktree B (frontend branch)"] end
E --> G["Combined Pull Request / Merge"] F --> G ```
For large, multi-faceted initiatives—such as simultaneously modeling a 3D Ferrari in Blender and constructing the web application to display it—Vibi advises against cramming everything sequentially into one thread. Instead, Codex can decompose broad objectives into child threads managed by an overarching parent thread. To keep parallel subagents from corrupting shared local files, each child thread operates inside an isolated Git worktree—a dedicated disk checkout linked to the same repository. This gives every subagent free rein to test, build, and commit in parallel without stepping on adjacent work. Finally, to steer these expansive multi-month runs without derailing ongoing execution, Vibi introduces `/side`, a command designed to fork the parent thread's full context into an isolated exploratory workspace.
- **Ecosystem plugins**: Integrating GitHub and Linear feeds issue histories, ticket statuses, and team discussions directly into agent reasoning. - **Parent/child delegation**: Parent threads maintain high-level supervision while offloading discrete components to dedicated child threads. - **Git worktree isolation**: Allocating isolated worktrees per subagent prevents concurrent file writes and git index collisions during parallel feature development. - **Steering with `/side`**: Forking a thread’s context into a side branch allows developers to probe specific decisions without disturbing the main execution loop.
[20:46](https://www.youtube.com/watch?v=U1IVZy9FhVQ&t=1246s) Worktrees, Threads, and Ultra Mode for Hard Problems
VB highlights how essential Git worktrees and branching threads are to daily engineering flow, noting that using them avoids cluttering the primary conversation or corrupting local repository state. Being able to work across multiple projects and simultaneous feature branches without running into merge conflicts saves massive headaches, with VB emphasizing: “And we all hate merge conflicts.”
```mermaid flowchart TD accTitle: Thread Strategy vs Ultra Mode accDescr: Diagram distinguishing parallel execution across threads from deep reasoning in Ultra mode. subgraph ParallelTasks["Embarrassingly Parallel Problems"] A["Parent Thread"] --> B["Child Thread 1"] A --> C["Child Thread 2"] A --> D["Child Thread N"] end subgraph SingleHardTask["Deep / Difficult Bottlenecks"] E["Ultra Mode"] --> F["Investigate Root Cause"] E --> G["Try Potential Fixes"] E --> H["Think Outside the Box"] end ```
When an agent thread gets stuck after exhausting multiple conventional attempts without diagnosing what went wrong, Codex provides an escape hatch called "Ultra mode." Ultra mode gives the underlying model extensive time to deliberate and reason through difficult bottlenecks. Within that single thread, Codex can automatically spin up specialized sub-agents—tasking one with investigating the bug's root cause, directing another to prototype a speculative patch, and letting a third search for unconventional out-of-the-box angles. VB contrasts thread strategies by explaining: “when I have a problem that's embarrassingly parallel, I would have Codex use threads to split that task and work on that. And when I'm dealing with one really hard problem, much like the GPU problem that you mentioned and the floating point precision problem, I would switch to ultra.”
- Worktrees allow engineers to spin up sub-tasks dozens of times a day across disparate repos and features without merge conflicts. - Ultra mode manages sub-agents internally within a single thread context rather than forcing the user to coordinate multiple independent threads manually.
[22:27](https://www.youtube.com/watch?v=U1IVZy9FhVQ&t=1347s) Heartbeats and Scheduled Tasks
Long-running workflows frequently stall on external dependencies outside an agent's control, such as awaiting human code review on an open pull request. Rather than forcing an engineer to babysit the pull request or repeatedly message colleagues on Slack while they are away on a coffee break, Codex can register automated recurring checks called heartbeats. A heartbeat operates as an automated follow-up loop within the existing thread: every half hour or at an interval of choice, Codex wakes up with the complete accumulated context of prior attempts, inspects the pull request for fresh reviewer comments, addresses actionable feedback directly, and continues its work.
Scheduled tasks also power net-new tasks that run on recurring chron-like triggers. Users can instruct Codex to compile overnight status reports across their active repositories or generate weekly catch-up summaries for legacy projects they have not monitored recently. These autonomous jobs are configured via natural language prompts, parameterized by execution frequency, and managed directly from the "Scheduled" tab in the Codex application interface.
[24:01](https://www.youtube.com/watch?v=U1IVZy9FhVQ&t=1441s) Token Economics and the Real-World Cost of 24/7 Agents
Addressing the natural skepticism of an audience suspecting that running continuous agents for six weeks is an unaffordable luxury reserved only for OpenAI insiders with infinite token budgets, Frey breaks down the real production costs. Running Codex continuously around the clock across OpenAI’s entire engineering surface area—debugging build pipelines, stabilizing continuous integration, and repeatedly executing millions of test cases per loop—initially cost roughly $32 per hour. With subsequent model releases, that cost dropped sharply: “But with GPT-6 Sol last week, the price dropped to $16 an hour.”
| Execution Tier / Model | Approximate Run Cost (USD / Hour) | Operational Role & Efficiency Impact | |:--- |:--- |:--- | | **Initial Deployment** | ~$32 / hr | Continuous agent running 24/7 for 6 weeks fixing company-wide CI | | **GPT-6 Sol** | ~$16 / hr | Halves operating expenditure; delivers 2x token budget longevity | | **GPT-6.1 Sol** | <$16 / hr equivalent | Heightened token efficiency; highly competitive operational profile |
Frey emphasizes that the token cost represents only one piece of continuous automation, sitting alongside compute infrastructure for CI runners and human code reviews. Nevertheless, paying $16 an hour to automatically stabilize builds and eliminate engineering friction across an entire enterprise was universally considered a bargain by engineering management.
[25:17](https://www.youtube.com/watch?v=U1IVZy9FhVQ&t=1517s) Playbook for Hiring Codex Today
Closing out the session, Frey shares a practical framework for how developers can begin delegating significant engineering workflows to Codex immediately:
```mermaid flowchart LR accTitle: Playbook for Deploying Codex Agents accDescr: Flowchart outlining the five steps for onboarding Codex into developer workflows. A["1. Identify Time Sink<br/>(Backlog, PRs, CI, Logs)"] --> B["2. Establish Verification Loop<br/>(E2E Tests on Laptop/Cloud)"] B --> C["3. Define Trade-Offs<br/>(Let Model Delegate)"] C --> D["4. Structure Workspace<br/>(Sidebar Sections & Inbox)"] D --> E["5. Set Ground Rules<br/>(Escalations & Spend Limits)"] ```
1. **Target repetitive operational drag**: Select tasks that consume valuable focus—triaging ticket backlogs, speculatively implementing roadmap features via PRs, inspecting error logs, or fixing failing CI runs. 2. **Provide closed feedback loops**: Equip the agent with clear mechanisms to verify its own work and discern when a task is completed, such as end-to-end test suites running on a local laptop, a dedicated dev box, or Codex Cloud. 3. **Declare high-level objectives**: With GPT-6 generation models, engineers no longer need to micromanage individual steps; they can articulate desired outcomes and acceptable trade-offs, allowing the model to delegate subtasks autonomously. 4. **Organize using sections and inboxes**: Treat the Codex sidebar like an email inbox, using custom sections to group hundreds of active issues and letting background threads flag only items that require human eyes. 5. **Establish hard operational boundaries**: Set explicit escalation triggers for when an agent must alert an engineer or page the on-call responder, and configure strict concurrency caps or budget limits (such as constraining maximum simultaneous CI runs).
Frey leaves the DevDay audience with a closing challenge: “What could Codex take off of your plate? And what could you do with the time that it gives you back?”
## Notable quotes > [07:25](https://www.youtube.com/watch?v=U1IVZy9FhVQ&t=445s) Last year at DevDay, I joked that I'd kind of become a manager of agents, and this year, I've been promoted to a director of agents. I give an agent a job, and then it manages a team of agents to get it done for me. — Friel
## Mentioned OpenAI, DevDay 2026, Codex, Codex Cloud, Astra, Sol, GPT-6 Sol, GPT-6.1 Sol, Friel, Vivi, VB, Ferrari, Nürburgring Nordschleife, Blender, Slack, GitHub, Linear, Git
## Video description Learn from a Codex run that spent over 1,000 hours keeping builds and tests passing. Explore how to choose recurring tasks, improve feedback, manage token budgets, and decide when engineers should step in.
[Source](https://www.youtube.com/watch?v=U1IVZy9FhVQ)