OpenAI Turns Codex Harness Into Cloud API for Autonomous Agents

Harness-as-a-Service: Building with the Agents API | DevDay 2026 — OpenAI

OpenAI

OpenAI converted its Codex harness into a managed service because developers building multi-hour workflows cannot reliably operate context compaction, session routing, and sandbox state recovery on their own.

AI-assisted summary of Harness-as-a-Service: Building with the Agents API | DevDay 2026 — original source. Check the original for full context.

Source published:

Key ideas

  • OpenAI launched the managed Agents API built on the Codex harness, moving from raw inference endpoints to fully managed 'Harness-as-a-Service' infrastructure. (0:21)
  • The platform introduces computer use over the API, enabling models like Astra to interact directly with graphical user interfaces in hosted sandboxes. (5:01)
  • Built-in history compaction and harness state reconciliation solve context window exhaustion and network dropouts across multi-hour execution runs. (9:15)
  • Enterprise rollouts include Notion, Rakuten, Bain & Company, and an integration delivering managed agents natively inside AWS Bedrock. (17:08)

Detailed notes

## Background Published by OpenAI on YouTube on November 11, 2026, this DevDay presentation covers building with the Codex harness via the Agents API. According to the description, the session explores how developers can run agents within their own environments, sustain long-running tasks, and understand which parts of the underlying infrastructure are managed by OpenAI.

## TL;DR OpenAI engineers Charlie and Steve explain the architectural transition from raw model endpoints to Harness-as-a-Service, using the Codex harness and Agents API to handle long-running execution, state reconciliation, and decoupled sandboxes. They address core cloud challenges—such as context compaction, mid-flight session steering, and turn-based observability—that previously forced engineering teams to re-implement complex scaffolding. Charlie showcases a live airline rebooking workflow where parallel subagents and MCP tools evaluate strict passenger constraints with human-in-the-loop sign-off. The talk highlights enterprise deployments at Notion, Rakuten, Bain, and AWS Bedrock, illustrating how zero-overhead orchestration unlocks massive parallel agent workflows.

## Atmosphere & style The presentation carries the polished, forward-looking energy typical of an OpenAI developer conference, balancing deep systems engineering with pragmatic code demonstrations. Steve and Charlie communicate as seasoned product architects who openly recount past mistaken assumptions about what developers wanted before pivoting to an opinionated, fully managed service. The pacing shifts smoothly from whiteboard-style architectural diagrams to live operational consoles, creating an empowering and inspiring atmosphere that invites developers to rethink software engineering at a scale of thousands of concurrent autonomous agents.

## Bulletin - [00:21](https://www.youtube.com/watch?v=b7l_Dhe1h8M&t=21s) OpenAI launched the managed Agents API built on the Codex harness, moving from raw inference endpoints to fully managed 'Harness-as-a-Service' infrastructure. - [05:01](https://www.youtube.com/watch?v=b7l_Dhe1h8M&t=301s) The platform introduces computer use over the API, enabling models like Astra to interact directly with graphical user interfaces in hosted sandboxes. - [09:15](https://www.youtube.com/watch?v=b7l_Dhe1h8M&t=555s) Built-in history compaction and harness state reconciliation solve context window exhaustion and network dropouts across multi-hour execution runs. - [17:08](https://www.youtube.com/watch?v=b7l_Dhe1h8M&t=1028s) Enterprise rollouts include Notion, Rakuten, Bain & Company, and an integration delivering managed agents natively inside AWS Bedrock.

## Key takeaways - [00:21](https://www.youtube.com/watch?v=b7l_Dhe1h8M&t=21s) Agent architectures have transitioned from short-lived inference wrappers into long-running, autonomous harnesses capable of multi-day workflows. - [01:25](https://www.youtube.com/watch?v=b7l_Dhe1h8M&t=85s) OpenAI conceptualizes its stack as a three-tier hierarchy: the foundational Responses API, the actionable Codex Harness middle layer, and the fully managed Agents API. - [03:20](https://www.youtube.com/watch?v=b7l_Dhe1h8M&t=200s) Developer feedback showed strong demand for managed harness infrastructure rather than self-hosted scaffolding, prompting the creation of Harness-as-a-Service. - [05:01](https://www.youtube.com/watch?v=b7l_Dhe1h8M&t=301s) Decoupling the execution harness from the local POSIX filesystem allows commands to run across both OpenAI-hosted sandboxes and customer-owned cloud infrastructure. - [05:01](https://www.youtube.com/watch?v=b7l_Dhe1h8M&t=301s) Computer use is officially available over the API, bringing GUI interaction capabilities to Astra inside OpenAI-hosted environments. - [07:29](https://www.youtube.com/watch?v=b7l_Dhe1h8M&t=449s) Exposing structured conversation turns rather than raw tool logs is essential for building human-in-the-loop and observable agent user interfaces. - [09:15](https://www.youtube.com/watch?v=b7l_Dhe1h8M&t=555s) Automated history compaction preserves essential operational state across context window limits during multi-hour or multi-day tasks. - [09:52](https://www.youtube.com/watch?v=b7l_Dhe1h8M&t=592s) Harness resilience requires cross-checking environment state against audit logs to safely recover from partial failures and mid-execution network drops. - [12:45](https://www.youtube.com/watch?v=b7l_Dhe1h8M&t=765s) Agents API sessions can be configured in fewer than a dozen lines of code with support for local capability directories and MCP server plugins. - [12:45](https://www.youtube.com/watch?v=b7l_Dhe1h8M&t=765s) Developers can regulate multi-agent execution and token expenditure by setting strict concurrency caps on background subagents. - [15:07](https://www.youtube.com/watch?v=b7l_Dhe1h8M&t=907s) Agents can synthesize deterministic Python validation scripts to programmatically audit complex business constraints before human approval. - [17:08](https://www.youtube.com/watch?v=b7l_Dhe1h8M&t=1028s) Major partners including Notion, Rakuten, Bain & Company, and AWS Bedrock are running production agent workflows on the Agents API infrastructure. - [19:10](https://www.youtube.com/watch?v=b7l_Dhe1h8M&t=1150s) Lowering harness operational costs toward zero enables massive parallel agent swarms to evaluate hundreds of hypotheses simultaneously.

## Detailed walkthrough ### [00:21](https://www.youtube.com/watch?v=b7l_Dhe1h8M&t=21s) The Shift to Frontier Agents and the Evolution of the API Stack

Charlie from the developer experience team and Steve from the API team open by reflecting on how the industry has spent well over a year anticipating that autonomous agents would represent the next fundamental evolution in artificial intelligence. By 2026, that ambition has materialized at the frontier. Organizations and internal teams at OpenAI routinely delegate mission-critical, end-to-end responsibilities to agents, from investigating active production outages and resolving customer support tickets to reconciling corporate finances across engineering, finance, and marketing departments. While advanced models like Astra and GPT-6.1 Sol serve as the central engine capable of driving extended multi-step workloads, software infrastructure must radically transform alongside them: “We've gone from putting an API endpoint on top of an inference stack to building an entire harness as a service,” Charlie explains.

```mermaid flowchart TD accTitle: Maslow's Hierarchy of Inference accDescr: Three-tiered architectural stack showing the progression from foundational model access to fully managed agents.

subgraph Hierarchy["Maslow's Hierarchy of Inference"] C["Agents API<br/>'Self-Actualization'<br/>Automates business workflows without harness ops"] B["Codex Harness<br/>'Hands to Do Work'<br/>Coding, browser actions, presentation editing"] A["Responses API (2025)<br/>'The Base Foundation'<br/>Multimodal inputs & outputs: text, images, reasoning"] end

A --> B B --> C ```

Steve recounts that building agentic developer infrastructure has been an iterative journey across multiple model generations. In 2023, OpenAI introduced the Assistants API to provide developers with hosted workflows incorporating tools like File Search and Code Interpreter. However, models of that era, such as GPT-4 Turbo, were realistically limited to workflows lasting only a few seconds. By contrast, GPT-6 Astra is capable of orchestrating dozens of specialized tools reliably over spans of hours or days. To support these reasoning-first capabilities, OpenAI launched the Responses API in 2025, allowing developers to exchange rich multimodal payloads—including raw text, vision, and internal reasoning traces—with the underlying models. Steve conceptualizes OpenAI's current architecture as layers of a cake, or a "Maslow's hierarchy of inference": - **The Responses API (Base Layer):** Serves as the flexible, foundational transport layer for complex agentic harnesses. - **The Codex Harness (Middle Layer):** Gives models actionable "hands" to perform real-world tasks like writing code, modifying slide decks, or controlling web browsers. - **The Agents API (Top Layer / Self-Actualization):** Allows developers and companies to automate key products and workflows without the operational overhead of hosting and maintaining an agent harness at scale.

---

[03:20](https://www.youtube.com/watch?v=b7l_Dhe1h8M&t=200s) Why Developers Want Harness-as-a-Service

When OpenAI initially considered how developers would build with agentic systems, the team assumed developers would prefer maximum control and would implement their own execution scaffolding. In 2025, OpenAI released the local Agents SDK to assist teams building self-hosted architectures. However, developer feedback consistently revealed a recurring contradiction: teams understood their end products, workflows, and user needs intimately, yet repeatedly asked OpenAI how to actually structure the operational plumbing—inquiring whether agents should execute inside or outside isolated sandboxes, how secret management should function, and which tools were optimal.

As Steve recalls, OpenAI spent time asking developers what infrastructure they wanted, but teams really wanted opinionated, tested guidance and, ultimately, for OpenAI to operate the complex parts on their behalf. Recognizing that having an opinion on data, tools, and execution environments does not mean an engineering organization wants to run distributed agent scaffolding, OpenAI created the Agents API as a managed service built directly on the production-hardened Codex harness. Developers define instructions, tools, and environments, while OpenAI assumes operational responsibility for running the harness and continuously feeding back infrastructural improvements as frontier models advance.

---

[05:01](https://www.youtube.com/watch?v=b7l_Dhe1h8M&t=301s) Three Fundamental Engineering Challenges of Cloud Harnesses

Transitioning the local Codex harness into a distributed, multi-tenant cloud service proved far more challenging than simply placing an existing code harness behind a hosted REST endpoint. Steve outlines three critical engineering hurdles OpenAI had to resolve: 1. **Separating Harness from Execution Environment:** Decoupling a system historically designed to run locally on a developer's laptop with direct POSIX filesystem access, enabling it to securely manage remote environments and cloud sandboxes. 2. **Real-time Observability for Non-Deterministic Workflows:** Providing developers with clear visibility into an agent's dynamic decision-making path as it chooses tools and actions on the fly. 3. **State Preservation Across Multi-Hour Tasks:** Maintaining resilient execution context over long-running sessions, despite context window exhaustion, routine server redeployments, or hardware failures.

```mermaid flowchart LR accTitle: Decoupled Harness and Environment Architecture accDescr: Flow diagram showing how the cloud-hosted harness routes commands to isolated sandboxes and returns results.

subgraph Cloud["OpenAI Managed Cloud"] Harness["Agents API<br/>Codex Harness"] end

subgraph Routing["Session Connection"] Router{"Session Multiplexer<br/>& Security Boundary"} end

subgraph Execution["Execution Environments"] Hosted["OpenAI-Hosted Sandbox<br/>(Terminal / GUI Computer Use)"] BYO["Bring-Your-Own Sandbox<br/>(Customer Infrastructure)"] end

Harness -->|"Inspect & issue commands"| Router Router -->|"Session A"| Hosted Router -->|"Session B"| BYO Hosted -->|"Command results / stdout"| Router BYO -->|"Command results / stdout"| Router Router -->|"Parsed state"| Harness ```

Historically, the local Codex harness operated under the simple assumption that it lived on the user's workstation, reading and editing local files directly. Moving this to the cloud required a complete decoupling so the harness could communicate securely with arbitrary execution environments, whether hosted by OpenAI or managed within a customer's own cloud perimeter (Bring Your Own Sandbox). Whenever the agent issues a command—such as listing files in a directory—the system must rapidly identify the specific active session connection, dispatch the command across the boundary, isolate concurrent tenants, and return standard outputs to the model without latency stalls. To expand these terminal-based sandboxes, Steve notes a major feature announced at DevDay: “Today, we introduced computer use over the API, bringing the incredible abilities of Astra to use a GUI in OpenAI-hosted environments.”

---

[07:29](https://www.youtube.com/watch?v=b7l_Dhe1h8M&t=449s) Agent Observability and Turn-Based Visualization

Once an agent operates autonomously inside a virtual computer or sandbox, developers face the immediate UX challenge of communicating progress to end users. Because an agent dynamically reacts to user prompts, environment states, and tool responses, its path is inherently non-deterministic; it may backtrack, inspect unexpected directories, or delegate tasks to child agents. Without real-time transparency, users on long-running tasks cannot discern whether an agent is making meaningful progress or is stuck in an infinite failure loop.

Charlie explains that OpenAI initially believed exposing raw tool calls and model responses would provide developers with all the primitives required to construct their frontends. However, real-world internal usage quickly disproved this assumption: - An internal team building a conversational agent required multi-turn sessions where users gave instructions, inspected intermediate results, and iterated with follow-up requests. - Because the original API omitted structured conversational "turn" metadata, developers were forced to manually reconstruct the relational hierarchy between user prompts, subsequent tool executions, and final model answers. - Requiring developers to stitch together conversation graphs forced them to re-implement the exact harness logic they turned to OpenAI to offload.

OpenAI revised the API to surface first-class turn information, allowing client applications to render conversational and operational phases cleanly. Charlie points out that constructing a harness-as-a-service involves dozens of similar design decisions, directly determining what developers must handle themselves versus what can be safely delegated to OpenAI.

---

[09:15](https://www.youtube.com/watch?v=b7l_Dhe1h8M&t=555s) Long-Running Execution, Context Limits, and History Compaction

As tasks extend over hours or days, agent execution accumulates an immense amount of operational history, including bash outputs, source files, and intermediate chain-of-thought traces. Steve explains that this accumulated log inevitably threatens to overflow the model's context window, even when the broader objective remains incomplete:

> “Compaction is designed to solve this problem. The harness can carry useful information forward so the agent can continue across context windows.”

Without built-in compaction managed by the cloud harness, every developer attempting to run multi-hour tasks would be forced to invent their own context truncation, summarizing, and state serialization routines. However, context window exhaustion represents only one of the physical constraints encountered when supporting frontier systems like GPT-6 that operate continuously over days.

[09:52](https://www.youtube.com/watch?v=b7l_Dhe1h8M&t=592s) Solving Long-Running Sessions, State, and Network Drops

Traditional cloud architecture is heavily optimized for short-lived, sub-second requests: a client issues a request, the server queries a database, returns a response in under a second, and the transaction is complete. In contrast, autonomous coding agents can run tasks continuously for hours. Throughout these extended runs, users frequently need to steer or redirect the agent, requiring the infrastructure to locate that specific session among thousands of machines and route incoming requests correctly. Meanwhile, Codex may be waiting on a tool result running on an external host, depending on a complex web of inference infrastructure, storage layers, and third-party APIs. To deliver three nines of reliability (99.9%), every downstream dependency must meet or exceed that bar. When a server is recycled or a crash occurs, the harness must resume exactly where it stopped without repeating non-idempotent real-world actions.

```mermaid flowchart TD accTitle: Agent Session Reliability and Resilience Loop accDescr: Diagram showing how agent actions, environmental disconnects, state tracking, and recovery work together.

subgraph ClientControl["User & Routing Layer"] A["User Steering / Inputs"] --> B["Global Router / Session Locator"] end

subgraph Execution["Agent Execution Environment"] B --> C["Codex Session Host"] C --> D["Tool / Shell / File Execution"] D -.->|"Connection Drop"| E{"State Indeterminate"} end

subgraph Recovery["Agents API Harness State Engine"] E --> F["Environment Audit & Harness Log Reconciliation"] F --> G["Instant Thread Resume"] G --> C end ```

A core engineering dilemma arises during partial failures. If an agent issues a command to edit a file and the network connection drops mid-execution, receiving no result leaves the platform blind to whether the edit occurred. Replaying the command blindly could corrupt data, while failing to apply it breaks the agent's reasoning flow. To resolve this safely, the harness must account both for what actually transpired within the isolated execution environment and what was recorded by the harness logs. As the speaker explains: “To continue safely, we need to account for what happened in the execution environment, as well as what the harness reported.” The Agents API abstracts away this complexity—state preservation, server rotation, and seamless reconnection—freeing developers to run their own environments while OpenAI manages session durability.

- Standard web requests complete in under a second; agentic workflows routinely span hours. - Sessions must be discoverable across a distributed server pool to support mid-flight user steering. - Achieving 99.9% uptime requires every constituent component (inference, storage, tool APIs) to hit equal or better reliability. - State-tracking prevents duplicate side effects when rolling servers out during deployments.

---

[11:42](https://www.youtube.com/watch?v=b7l_Dhe1h8M&t=702s) Airline Rebooking Demo: SFO to ORD Flight AL204

Charlie takes the stage to demonstrate an airline operations console designed for massive, complex schedule disruptions. When a personal flight gets canceled, a traveler can query an assistant to find alternatives; when an airline cancels a flight, operations teams must rebook dozens or hundreds of stranded passengers simultaneously. Charlie presents a dashboard for canceled flight AL204 traveling from San Francisco (SFO) to Chicago. The dashboard flags edge cases that would normally flood human operations desks: individual travelers with rigid destination constraints, and multi-passenger family bookings requiring contiguous seating.

```mermaid flowchart LR accTitle: Flight Rebooking Multi-Agent Architecture accDescr: Visual flow from flight cancellation to multi-agent checks and human approval.

A["Flight AL204 Canceled<br/>(SFO to ORD)"] --> B["Agents API Session"]

subgraph MultiAgent["Multi-Agent Workspace"] B --> C["Flight Rebooking Skill<br/>(Local Files / MCP)"] C --> D["Primary Agent"] D --> E["Subagent 1: Seating Check"] D --> F["Subagent 2: Arrival Time Check"] end

subgraph Verification["Outputs & Approval"] E & F --> G["Hold Seats via Inventory Tool"] G --> H["Deterministic Python Verification Script"] H --> I["Human-in-the-Loop Review & Approval"] end ```

Charlie highlights two challenging passenger bookings: 1. **Erin:** Needs to reach Chicago O'Hare (ORD) specifically, rejecting alternate Chicago-area airports, with a strong preference for departing the following morning. 2. **Ava:** A group of four passengers traveling together, including children, with a strict constraint that all travelers must be seated together on the same flight.

Charlie initiates the rebooking process from the interface, launching two parallel Agents API background sessions to resolve the passenger disruptions while keeping human operators in the loop.

---

[12:45](https://www.youtube.com/watch?v=b7l_Dhe1h8M&t=765s) Configuring Sessions, Skills, MCP Plugins, and Subagents in Code

Charlie walks through the JavaScript code powering the rebooking demonstration, showing how an Agents API session can be instantiated in under twelve lines. The session definition designates an OpenAI-hosted sandbox as the runtime environment, though developers can provide custom infrastructure or third-party sandboxes. In this setup, general network access is disabled within the sandbox for security, and real-time event streaming is enabled to update the UI live.

```javascript // Conceptual representation of the session configuration shown in the demo const session = await agents.sessions.create({ environment: { type: "openai_sandbox", network_access: false, }, streaming: true, capability_directories: ["./skills/flight_rebooking", "./plugins/mcp_servers"], multi_agent: { enabled: true, max_concurrent_subagents: 2, }, }); ```

To guide execution, the agent workspace is loaded with a structured `flight_rebooking` skill file using the `capability_directories` parameter. This parameter accepts local file paths for domain skills as well as external plugins, such as Model Context Protocol (MCP) servers, granting the agent controlled hooks into broader enterprise systems. The agent uses a `search_flight_inventory` tool configured with advisory semantics: it can place temporary holds on seats, but cannot finalize bookings without human review. Charlie explains how subagents enforce business rules: “As another layer of checks in the agent's instructions, we've told it to delegate seating and arrival checks to two subagents.” To avoid runaway costs, Charlie caps subagent parallelism at two concurrent workers, noting that higher concurrency levels increase token consumption. Finally, the agent is instructed to produce three concrete workspace artifacts: a final proposal JSON, an options-comparison JSON, and an executable Python script to deterministically verify logic against customer constraints.

- Instantiating an Agents API session requires less than a dozen lines of JavaScript. - Environments support OpenAI-hosted sandboxes, custom developer infrastructure, or third-party providers. - `capability_directories` mounts local skills, configuration folders, and MCP server endpoints directly into the agent workspace. - Multi-agent settings allow fine-grained concurrency caps (`max_concurrent_subagents`) to manage token spend. - The workflow generates structured JSON summaries alongside deterministic Python test scripts.

---

[15:07](https://www.youtube.com/watch?v=b7l_Dhe1h8M&t=907s) Inspecting the Agent Workspaces, Logic Checks, and Approvals

Returning to the dashboard, Charlie reviews the completed sessions. Erin's activity log confirms that the agent spun up a sandbox, executed availability commands, consulted subagents for arrival checks, placed a temporary seat hold on a morning flight landing at O'Hare, and submitted its recommendation with an explanatory rationale. Charlie reviews the hold and clicks to confirm the booking.

Next, Charlie examines Ava's four-person family reservation. The activity tab shows identical orchestration steps, but the workspace files expose the agent's strict constraint handling: - **Flight AL314:** Ruled out because only one seat remained open. - **Flight AL744:** Ruled out because, despite having four open seats, it could not guarantee contiguous seating for the family. - **Accepted Flight:** Held four seats grouped together and generated the corresponding comparison files.

Inside the files tab, the agent generated the final proposal JSON, an options comparison matrix, and a deterministic Python validation script that executed inside the sandbox to verify the business logic against passenger parameters. Charlie approves Ava's rebooking directly from the console. Emphasizing the operational leverage, Charlie remarks: “With the agents API, we can work through these bookings in parallel and see why each flight was recommended while still making the final call for the human in the loop.”

---

[17:08](https://www.youtube.com/watch?v=b7l_Dhe1h8M&t=1028s) Developer Leverage and Enterprise Deployments: Notion, Rakuten, Bain, and AWS Bedrock

While developers can construct multi-step flows on top of low-level primitives like the Responses API, maintaining session routing, sandbox resilience, and tool synchronization creates massive engineering overhead. As Charlie highlights: “With the agents API, I don't have to build or maintain any of that infrastructure. I can focus on my application, the rebooking rules, when someone needs to approve a change.”

Enterprise adopters are using the platform across diverse production use cases:

| Customer / Partner | Implementation Detail | |:--- |:--- | | **Notion** | External agents allow teams to assign asynchronous tasks across team workspaces and integrate OpenAI agents via the Agents API. | | **Rakuten** | Integrates the Agents API into retail products for long-running workflows where users leave, return later, and provide incremental steering. | | **Bain & Company** | Generates synthetic audiences (virtual focus groups) modeled on empirical customer research to stress-test new products, surveys, and ad campaigns under human oversight. | | **AWS Bedrock** | Offers AWS-native Bedrock managed agents built in close collaboration with OpenAI, embedding the core Agents API directly into the AWS cloud ecosystem. |

Charlie closes by challenging developers to reconsider their software ambitions when orchestration costs drop toward zero: “What would you build if you could dispatch 100 or 1,000 or 10,000 agents to work on it?” Rather than limiting engineering teams to incremental features, massive parallel agent swarms make it possible to audit every enterprise microservice for vulnerabilities or tackle large-scale software engineering projects that were previously unthinkable.

[19:10](https://www.youtube.com/watch?v=b7l_Dhe1h8M&t=1150s) Scaling Parallel Workflows with the Codex Harness API

The session wraps up with a vision of what becomes achievable when harness infrastructure is exposed programmatically. Instead of executing ideas sequentially or running single-threaded evaluations, developers can now explore hundreds of distinct approaches to a research question simultaneously. By decoupling the execution harness and making it accessible via the Agents API, tasks that naturally lend themselves to concurrent exploration can be scaled up instantly without developers having to manually provision and orchestrate complex sandbox environments.

Expressing enthusiasm for the possibilities ahead, the speaker explains: “That's what excites me about making the Codex harness available through an API.” Opening up this level of harness control allows teams to rethink the scale at which their automated systems operate. As the speaker highlights: “You can now take work that is inherently parallelizable and dramatically expand the scope of what's possible.” Closing out the DevDay presentation, the speaker encourages the audience to take advantage of these primitives, signing off with an eager invitation to build: “I'd love to see what you come up with. Happy building.”

## Notable quotes > [00:21](https://www.youtube.com/watch?v=b7l_Dhe1h8M&t=21s) We've gone from putting an API endpoint on top of an inference stack to building an entire harness as a service. — Charlie

> [09:52](https://www.youtube.com/watch?v=b7l_Dhe1h8M&t=592s) To continue safely, we need to account for what happened in the execution environment, as well as what the harness reported.

> [19:10](https://www.youtube.com/watch?v=b7l_Dhe1h8M&t=1150s) You can now take work that is inherently parallelizable and dramatically expand the scope of what's possible.

## Mentioned OpenAI, Charlie, Steve, Astra, GPT-6.1 Sol, GPT-6, GPT-4 Turbo, Agents API, Responses API, Assistants API, Codex harness, Agents SDK, Model Context Protocol, Notion, Rakuten, Bain & Company, AWS Bedrock

## Video description Build with the Codex harness through the Agents API. Learn how to run agents in your environment, keep long-running tasks going, and understand which infrastructure OpenAI manages.

[Source](https://www.youtube.com/watch?v=b7l_Dhe1h8M)

Reading summary

At DevDay 2026, OpenAI presented the Agents API, shifting from raw inference endpoints to a managed "Harness-as-a-Service" that offloads the operational overhead of long-running, multi-step agent orchestration. Presenters Charlie and Steve argued that while frontier models like Astra can execute extended workflows, building reliable agentic software requires managed cloud infrastructure to handle sandboxing, state persistence, and observability. The Evolution to Harness-as-a-Service (0:21) Steve conceptualized OpenAI's developer infrastructure as a three-tiered "Maslow's hierarchy of inference." At the base lies the Responses API (introduced in 2025) for multimodal transport and reasoning traces; the Codex Harness forms the middle tier, providing tools to edit code, manipulate files, or control browsers; and the Agents API sits at the top to automate workflows without requiring teams to host execution scaffolding. This shift was motivated by feedback on the 2025 local Agents SDK, where developers consistently understood their domain logic but struggled with operational plumbing such as sandbox isolation, secret management, and distributed execution. Steve noted that while 2023 Assistants API workflows were functionally limited to a few seconds, models like GPT-6 Astra can orchestrate tools over hours or days. Solving Distributed Sandboxing and Execution Resilience (5:01) Transitioning the local Codex harness into a multi-tenant cloud service required decoupling the harness from the execution environment. The platform supports both OpenAI-hosted sandboxes—including newly announced GUI-based computer use—and Bring-Your-Own-Sandbox customer environments. The architecture uses a session router to direct commands across boundary layers without incurring latency stalls. To sustain multi-hour workflows, the system addresses state preservation and context exhaustion through built-in history compaction, carrying relevant context across windows rather than requiring custom truncation logic. Addressing session survivability, Steve emphasized that achieving 99.9% uptime requires tracking environmental state alongside harness logs. If a connection drops mid-execution, the harness reconciles what actually occurred in the sandbox against the harness log to prevent data-corrupting replays or broken reasoning flows upon redeployment. Turn-Based Observability for Non-Deterministic Workflows (7:29) Because autonomous agents dynamically branch, backtrack, or delegate subtasks, raw model outputs proved insufficient for user-facing applications. Charlie noted that an internal conversational agent team originally struggled because the API lacked relational structure between prompts, tool calls, and final answers, forcing developers to manually rebuild conversational graphs. OpenAI updated the API to surface first-class turn metadata, enabling frontends to render operational progress clearly. This structured observability ensures end users can distinguish meaningful multi-step progress from infinite loops or stalling. Parallel Multi-Agent Workflows and Human Approval (11:42) Demonstrating an airline operations console managing flight cancellations, Charlie showed how an Agents API session configured in under twelve lines of JavaScript can resolve complex traveler edge cases. The workflow mounted domain skills and Model Context Protocol (MCP) plugins, capped subagent concurrency to two workers to prevent runaway token spend, and placed advisory seat holds without finalizing bookings. For an individual traveler with a morning departure constraint and a four-person family requiring contiguous seating, the agent filtered unviable options, generated structured JSON comparisons, and executed a deterministic Python verification script in the sandbox before presenting the recommendations for human-in-the-loop approval. Enterprise Deployments and Parallel Scaling (17:08) OpenAI highlighted several production deployments leveraging the Agents API. Notion uses external agents for asynchronous task delegation across workspaces; Rakuten supports long-running retail flows where users leave and return to steer the agent; Bain & Company generates synthetic focus groups grounded in empirical research; and AWS Bedrock embeds the Agents API directly as an AWS-native managed service. Presenters framed the elimination of orchestration overhead as an unlock for massive parallelization, allowing organizations to concurrently audit microservices or test thousands of research avenues simultaneously. OpenAI argues that decoupling and hosting the agent harness allows organizations to shift focus entirely to application logic and guardrails. However, the presentation maintains that human-in-the-loop checkpoints and strict subagent concurrency caps remain necessary to govern non-deterministic behavior and manage token consumption.

Source quotes

[0:21] Charlie: We've gone from putting an API endpoint on top of an inference stack to building an entire harness as a service. [9:52] To continue safely, we need to account for what happened in the execution environment, as well as what the harness reported. [19:10] You can now take work that is inherently parallelizable and dramatically expand the scope of what's possible.

Original transcript

[0:21] Hey, everyone. [0:22] I'm Charlie from the developer [0:23] experience team. [0:24] And I'm Steve. [0:25] I'm an engineer on the API team. [0:28] And for well over a year, [0:31] we've heard about how agents are [0:32] going to change everything [0:33] and be the next evolution in AI. [0:35] And here in 2026, it feels like that's [0:38] actually become true at the frontier. [0:41] We can ask agents to investigate [0:43] an outage, to solve a support ticket, [0:46] or to help reconcile finances. [0:48] We're seeing that shift here at [0:49] OpenAI with Codex and ChatGPT work. [0:52] We're using agents across [0:54] the company, from engineering [0:55] to finance to marketing. [0:59] A big part of that, perhaps [1:01] the biggest part, is the model. [1:03] As models become more capable, we can [1:05] ask them to take on more involved work. [1:08] Astra and GPT 6.1 Sol can handle [1:11] larger tasks from start to finish. [1:15] But every time the model [1:16] can do more, the software [1:18] around it has to change, too. [1:20] We've gone from putting an API endpoint [1:22] on top of an inference stack to building [1:25] an entire harness as a service. [1:29] So, today, we want to tell you [1:31] what we learned building that harness, [1:33] why we're making it available [1:35] through the agents API, and show you [1:37] what you can now build with it. [1:39] But first, [1:40] Steve, how did we get here? [1:43] STEVE VILLACHICAVICSENCYPT Yeah. [1:44] So, this isn't the first time [1:46] that we've tried to tackle this problem. [1:48] With the assistance API, [1:50] we explored what it would look [1:51] like to give developers hosted [1:53] workflows with tools like File [1:55] Search and Code Interpreter. [1:57] But models have come a long way. [1:59] Back in 2023, GPT-4 [2:02] Turbo could use these [2:03] tools to accomplish workflows [2:04] that lasted maybe a few seconds. [2:07] GPT-6 Astra, on the other hand, [2:09] can use dozens of tools effectively [2:11] for hours or days on end. [2:14] With reasoning models, we needed [2:15] a more flexible foundation. [2:17] We launched the responses API in 2025 [2:19] to solve a more basic problem. [2:21] In order to build more advanced, [2:23] agentic workflows, developers needed [2:25] to be able to send many types [2:27] of content to the model, like text, [2:29] images, and reasoning, and get back [2:31] many types of content in return. [2:33] In hindsight, this proved to be [2:35] a pretty powerful foundation. [2:36] It supported a new wave [2:38] of agentic products, including [2:40] Codex and ChatGPT work. [2:43] We think of our APIs as layers [2:45] in a cake, or elements in a kind [2:47] of Maslow's hierarchy of inference. [2:50] The responses API is the base, providing [2:52] a solid interface for agentic harnesses. [2:56] Codex is built on top [2:58] of the responses API, giving the agent [3:00] hands with which it can do work, [3:02] like coding, editing presentation, [3:04] or using a browser. [3:06] And the agent's API is [3:08] self-actualization, allowing you [3:10] and your product to live up [3:12] to their full potential by [3:13] building agents that automate key [3:15] parts of your business or product [3:16] without the trouble of operating [3:18] the harness at scale. [3:20] So why did we take yet another [3:23] stab at putting an agentic [3:24] harness behind an API? [3:26] Well, at first, we assumed [3:27] that you all would want to build [3:29] a lot of this infrastructure yourselves. [3:30] Before we had great harnesses [3:32] like Codex, most folks [3:33] were writing their own. [3:35] In 2025, we shipped a local [3:37] agent harness, the agent's SDK, [3:39] to help folks along the path [3:41] of building and shipping agents [3:42] that they had total control over. [3:44] But I kept having conversations where [3:46] a team had a very clear idea [3:48] of the product they wanted to build. [3:50] They knew the workflow, they [3:51] knew where an agent would help. [3:53] But then they'd ask us, OpenAI, [3:55] how they should build it. [3:56] What tools should they use? [3:58] Should the agent run inside [3:59] the sandbox or outside the sandbox? [4:02] How should they manage secrets? [4:04] We were asking them what kind [4:06] of agent infrastructure they wanted. [4:08] But ultimately, they wanted [4:09] to come to us for opinions [4:10] about what was working well. [4:12] And one thing came up very directly. [4:14] How could they get us [4:16] to run it for them? [4:18] This was a useful distinction to learn. [4:20] As a business or developer, [4:22] you may have, you know, an idea [4:25] of what tools you want to use, [4:26] the data, or the execution [4:28] environment that the agent should use. [4:30] But that doesn't automatically mean [4:31] that you want to run the whole [4:32] harness yourself. [4:35] This is the core idea [4:36] behind the agents API. [4:38] A managed service built [4:39] on the Codex harness. [4:40] You define the tools, the data, [4:42] and the instructions. [4:44] You choose the environment [4:45] that the agent works in. [4:46] And we run the harness [4:48] and the services around it. [4:50] This also means that we can [4:51] keep improving that harness as [4:53] we learn from building agents [4:54] and as the models get better. [4:56] You don't have to independently [4:57] reproduce every single one [4:59] of these improvements on your own. [5:01] Now, this might sound [5:03] pretty straightforward. [5:04] You take the harness that we already [5:06] have in Codex, chuck it behind an API, [5:08] and you run it for people. [5:09] How hard could this be? [5:12] Well, actually, it turns out that doing [5:13] this is surprisingly difficult. [5:15] And there are some fundamental [5:17] engineering questions that we [5:18] needed to answer. [5:20] First, how do you take a harness [5:22] built to run on someone's laptop [5:24] and let it operate securely [5:26] in the cloud using a totally [5:28] different computer as its environment? [5:31] Two, how do you give developers [5:33] a useful view of what an agent's [5:35] doing as the agent is deciding [5:37] the steps as it goes along? [5:40] And three, how do you preserve [5:42] state over a task that might run [5:43] for hours even when we deploy [5:45] new code or a server dies? [5:49] These are the three key problems [5:51] that we want to walk you through. [5:52] What made them difficult, [5:53] how we approach them, and what [5:55] the answers ultimately let you build. [5:58] The Codex harness started off [6:00] with a reasonable assumption. [6:02] It's running locally on your computer. [6:04] It can read the file system, [6:06] change a file, and see the result. [6:08] But I remember a conversation we [6:10] had earlier this year where we [6:11] needed to upend that assumption. [6:14] We needed to separate the harness [6:15] from the environment where [6:16] the commands actually run. [6:18] As developers, you might want [6:20] the harness to run in sandboxes you [6:21] already operate, or you might want [6:23] us to operate the sandbox for you. [6:25] Either way, we needed [6:27] a way for the harness working [6:28] in the cloud to communicate [6:29] with any arbitrary environment. [6:33] And that immediately creates [6:34] another problem. [6:35] Say the model asks to list [6:37] files in the directory. [6:39] How do we get that command [6:40] to the right computer and then [6:41] get its result back quickly? [6:43] We need to go and find the environment [6:45] that's connected to that session, [6:46] send the command there, [6:48] and then get the result back [6:49] so that the model can continue. [6:51] And with many environments connected, [6:52] we also need to keep each session's [6:54] commands and results separate. [6:56] A command that used to be local now [6:57] has to cross this connection every time. [7:00] If you've been using the Agents API [7:02] for the last few weeks, you've been [7:04] able to bring your own sandbox or use [7:06] one that OpenAI spins up for you. [7:08] And in both cases, your agents [7:09] are quite capable, and they can use [7:10] the terminal to do a ton of work. [7:13] But as you heard in the keynote, [7:15] we're adding one new feature that you [7:16] all have been asking for a bunch. [7:18] Today, we introduced computer use [7:20] over the API, bringing the incredible [7:21] abilities of Astra to use a GUI [7:24] in OpenAI-hosted environments. [7:26] And I'll turn it back over [7:27] to Charlie to tell us more. [7:29] Charlie Walsh, thanks, Steve. [7:30] Once an agent can go off [7:32] and use a computer or a sandbox, [7:34] there's an immediate question for anyone [7:36] that's building a product around it. [7:37] What do you show people [7:39] while it's working? [7:40] You can't predict the path [7:42] that an agent will take in advance. [7:44] It depends on a ton of different [7:45] inputs, like the user's prompt, [7:46] or the results of a tool call. [7:48] Across different runs, an agent [7:50] might open a new set of files, [7:51] try an alternative approach, or hand [7:53] part of the job to another agent. [7:55] But your users still need [7:57] to follow what's happening, [7:58] especially with long-running tasks. [8:01] They'll want to know what the agent [8:02] is working on, or whether it's [8:03] gotten stuck and needs some help. [8:05] At first, we thought giving developers [8:07] the raw tool calls and model [8:09] responses would be enough for them [8:11] to build a great user experience. [8:12] But it turned out they [8:14] wanted more than that. [8:16] One of our internal teams ran into [8:18] this while building with the API. [8:20] Their sessions often involved several [8:22] rounds of back and forth between [8:23] the user and the agent. [8:25] A user could ask for something, [8:26] get an answer, and then come [8:28] back with a new request. [8:30] Which would then kick off [8:31] another round of work. [8:33] The team wanted to visualize the agent's [8:35] tool calls and responses by turns. [8:37] But our original API design didn't [8:39] easily give them that information. [8:41] They could have tracked those [8:43] relationships themselves, but that meant [8:44] rebuilding part of the harness [8:45] that they'd come to us to manage. [8:49] So we went back and made that turn [8:50] information available through the API. [8:52] The team could then decide how to show [8:54] the work without having to reconstruct [8:56] the entire conversation from scratch. [8:58] And this might seem obvious [9:00] in hindsight, but when you're building [9:01] a harness as a service, there are [9:03] dozens of design decisions like this. [9:06] They determine how much of the work [9:07] you can actually hand off to OpenAI, [9:09] how much you still have to figure [9:10] out yourself, and what sharp corners [9:13] you might run into as a developer. [9:15] Steve can take us through one example. [9:17] How do you keep an agent reliably [9:19] working for hours on end? [9:22] The longer an agent works, [9:24] the more history it accumulates. [9:26] Eventually, that history can [9:27] exceed the model's context window, [9:29] even if the task is still going. [9:31] Compaction is designed [9:32] to solve this problem. [9:34] The harness can carry useful [9:36] information forward so the agent [9:38] can continue across context windows. [9:40] Otherwise, every developer building [9:42] a long-running agent has to decide [9:43] how to manage that history themselves. [9:46] But context is only one [9:47] of the constraints that we run into. [9:49] GPT-6 can work for days on end, [9:52] but at some point we need to deploy [9:53] our own code or our servers will [9:55] die or otherwise get recycled. [9:58] So how do we do both? [10:00] A lot of cloud software is [10:02] designed around short requests. [10:04] A request comes in, it [10:05] touches a database, it returns [10:06] a response, and this all [10:08] happens in less than a second. [10:10] But agents can work for hours. [10:12] And while it's working, you might want [10:14] to steer it one way or another. [10:16] And this means that we have to go [10:17] and find your session among [10:18] all of our servers and route [10:20] your request there. [10:21] Or Codex might be waiting [10:23] for a tool result from another computer. [10:24] And all of this depends [10:26] on other systems, including [10:27] model inference, storage, [10:28] and the services that the tools call. [10:31] In order to have three [10:32] nines of reliability, [10:33] all of these systems need to have [10:35] the same reliability or better. [10:37] And if Codex crashes or we replace [10:39] a server during deployment, [10:42] we need to be able to pick [10:43] up exactly where we left off. [10:44] For example, your agent may have [10:45] already spent an hour investigating [10:46] a problem, or it may have taken [10:48] actions that we don't want to repeat. [10:49] So we need to keep track [10:51] of state very precisely, [10:53] rotate servers out at the right time, [10:55] and resume threads instantly [10:56] so your agents can keep [10:57] working indefinitely. [11:00] Here's a concrete example. [11:02] Suppose your agent wants to edit a file. [11:04] We send the command to the environment, [11:06] but then the connection drops. [11:08] What do we do? [11:09] Did the file get edited or not? [11:11] Receiving no result doesn't tell [11:13] us whether the action happened, [11:15] but replaying the command might [11:16] result in a bad outcome, too. [11:19] To continue safely, [11:20] we need to account for what happened [11:21] in the execution environment, [11:22] as well as what the harness reported. [11:25] But the agent's API [11:27] manages all of this complexity [11:28] so that you don't have to. [11:30] You can keep the environment [11:31] you already run, show users what [11:33] the agent's doing, and let the service [11:35] handle the long-running session. [11:36] And Charlie will show us [11:38] an application that does exactly that. [11:42] Imagine you're halfway through [11:43] a vacation, and your connecting [11:44] flight gets canceled. [11:46] As an individual, you [11:47] could use Codex or your dot [11:49] to research what's still available [11:50] and rebook your specific ticket. [11:53] But what if you're the airline? [11:56] Here we've got a flight dashboard [11:58] for flight AL204 from [12:00] San Francisco to Chicago. [12:02] The flight's been canceled, [12:03] which means rebooking dozens [12:05] or even hundreds of passengers. [12:07] In this view, we can see [12:08] a few of the more difficult cases, [12:10] the ones that might otherwise land [12:12] on an operation team's desk. [12:14] We might have one traveler that needs [12:16] to make it at an exact specific [12:17] airport, while another booking [12:19] might be four passengers [12:20] that all need to travel together. [12:22] Maybe they're a family with kids. [12:24] Why don't we start with those two? [12:28] I've gone ahead and kicked off [12:30] the rebooking process, which [12:31] is going to start two agents API [12:32] sessions in the background. [12:35] We can see here in the activity [12:36] tab, the agent has started work. [12:38] This is going to take a few minutes, [12:39] so why don't we go ahead while [12:41] that's working, and I want to take [12:42] you some of the actual code [12:43] that's powering this demo. [12:45] We'll start with this session, [12:47] which is the fundamental building [12:48] block of the agent's API. [12:50] Here we have an example of how you [12:52] can create one in JavaScript, which is [12:53] less than a dozen lines of code. [12:56] In this case, I'm specifying its [12:58] environment, which is going to be [12:59] an OpenAI hosted sandbox, but [13:01] of course, you're always free to bring [13:03] your own sandbox or work with one [13:04] of our third-party sandbox providers. [13:07] We're broadly disabling [13:08] network access in the sandbox, [13:10] and we've asked the session [13:12] to stream its events back to us [13:13] so that we can update the UI live. [13:17] When we created our rebooking agent, [13:20] we also gave it a flight rebooking [13:21] skill, which specifies the precise [13:24] steps the agent needs to take [13:25] in order to rebook a passenger. [13:27] We've loaded it from a local file [13:29] and added it to the agent's workspace, [13:31] and we're sharing it in the session [13:33] through the capability directories [13:35] field, which lets us not only share [13:37] skills, but we can also specify paths [13:39] to plugins, including MCP servers, [13:42] if we want to let our agents [13:43] have a little bit more engagement [13:44] with the wider world. [13:48] Speaking of engagement, one of the most [13:50] important parts of this demo is also [13:51] the search flight inventory tool. [13:53] That's what lets the agent [13:55] check for available seats [13:56] across a variety of flights, [13:58] but we do note in the description [13:59] that the results are advisory. [14:02] And so doing so can create [14:03] a hold on a ticket, but [14:04] a human needs to stay [14:05] in the loop in order to lock [14:06] that in and confirm the rebooking. [14:11] As another layer of checks [14:13] in the agent's instructions, [14:15] we've told it to delegate seating [14:16] and arrival checks to two subagents. [14:18] We wanted to wait for both [14:20] of those to come back before it [14:21] publishes the proposal. [14:23] To make this work, I've [14:25] enabled multi-agent mode, [14:26] and I've set the max concurrent number [14:29] of subagents that it can use to two. [14:30] This is a field that you can [14:32] tweak up or down, depending on how [14:34] much parallel work you have, but it [14:36] is worth noting that higher values [14:38] are likely to incur more token usage. [14:42] And last but not least, [14:43] we wanted the agent to come back [14:44] to us with a few files. [14:48] We wanted to create a JSON [14:50] file for its final proposal, [14:52] a JSON file for the different [14:53] options it compared, [14:55] and an actual Python script to kind [14:56] of deterministically check its logic [14:58] against the constraints that we gave it. [15:00] It looks like our agents might be done, [15:03] so let's go see how they did. [15:07] Here we've got Erin. [15:09] She needs to get to O'Hare. [15:10] No other options are workable. [15:12] Preferring to leave tomorrow morning. [15:14] We can see in the activity [15:15] tab here what the agent did. [15:17] After it started working, [15:19] it looks like it opened a sandbox, [15:20] ran those commands, used the tool [15:22] to check flight availability, [15:24] and delegate it to the two subagents [15:26] like we asked it to do. [15:28] Ultimately, it held some [15:29] seeds for approval, and it came [15:31] back to us with this recommendation, [15:32] along with some notes on why it [15:34] recommended this specific flight. [15:36] These seeds are on hold, like I [15:38] mentioned, to keep a human in the loop, [15:40] and so nothing is going to be locked [15:41] in until I approve the rebooking. [15:42] We'll do that now. [15:47] Now let's take a look at Ava's booking. [15:48] This is actually for four people, [15:50] including children, and one [15:51] of the constraints is they all needed [15:52] to be rebooked together. [15:55] We can look in the activity tab again, [15:57] and we'll see a very similar thing. [15:58] The agent went ahead and used a sandbox, [16:01] checked flights, checked with subagents, [16:03] and came back with a proposal. [16:06] In this case, though, we can see [16:07] in the workspace tab here [16:08] some of those checks that we [16:10] actually asked it to perform. [16:11] And we can see that although it [16:13] did select a recommended flight, it [16:15] ruled out AL314 because it [16:18] only had one seat available. [16:19] And it also ruled out AL744 [16:21] because while it did have four seats [16:23] available, it couldn't guarantee [16:25] that the seating would be altogether, [16:27] which was one of our requirements. [16:29] Over in the files tab, we've got [16:32] the final proposal JSON like we [16:34] wanted, the comparison of all [16:36] the different options it considered, [16:38] and the Python file so that we [16:40] can deterministically check its [16:42] logic against what we wanted. [16:44] So I can go ahead and approve [16:46] the rebooking for these as well. [16:48] And, you know, we've only looked [16:49] at two passengers here, [16:50] but a single cancelled flight can leave [16:52] dozens of these cases all at once. [16:55] With the agents API, we can work [16:57] through these bookings in parallel [16:59] and see why each flight was recommended [17:01] while still making the final [17:02] call for the human in the loop. [17:08] Now, if you're used to building [17:09] agentic applications, you might [17:11] notice that you could build something [17:12] like this with the responses API. [17:14] Many of the building blocks [17:15] already exist. [17:16] But as Steve showed, there's [17:18] a lot to get right to make [17:19] sure this all runs smoothly. [17:21] With the agents API, [17:22] I don't have to build or maintain [17:24] any of that infrastructure. [17:25] I can focus on my application, [17:28] the rebooking rules, when someone [17:29] needs to approve a change. [17:31] Not to mention, I can iterate on [17:32] my work much faster with Codex [17:34] since there's less code to write, [17:35] test, and maintain. [17:37] And we're already seeing customers find [17:39] some great use cases for the agents API. [17:42] With Notion's external agents, teams [17:45] who are working from Notion can assign [17:47] work and have it done asynchronously. [17:48] And now, Notion users can [17:50] bring OpenAI agents into [17:51] that workflow with the agents API. [17:54] Rakuten is bringing the agents [17:55] API into its products for getting [17:57] long-running tasks done with agents. [17:59] Users can give an agent work [18:00] and then come back to continue [18:01] to provide direction and feedback. [18:04] And Bain is using the agents [18:06] API to build synthetic [18:07] audiences for its clients. [18:09] You can think of these as [18:10] virtual focus groups. [18:11] AI-simulated customers based on real [18:14] customer research who give feedback [18:16] on new products, ads, or surveys. [18:19] Human experts are still [18:20] checking the results. [18:23] If you're building your own agentic [18:24] products and features but prefer [18:26] to stay within the AWS ecosystem, [18:28] as mentioned in the keynote, you can [18:29] also build with bedrock managed [18:31] agents powered by OpenAI. [18:33] We work closely together with the team [18:34] to use the core of the agents [18:36] API and customize and deeply [18:38] integrate it into AWS. [18:41] Now, we opened by talking about [18:43] how much more we can ask agents [18:44] to do now, but I want to close [18:46] by talking about what that means [18:47] for your ambitions as a developer. [18:50] What work would you take on if [18:51] you had dramatically more people [18:53] or time at your disposal? [18:55] What would you build if you could [18:56] dispatch 100 or 1,000 [18:59] or 10,000 agents to work on it? [19:01] You could investigate every [19:03] microservice for security holes. [19:05] You could take on software [19:06] mega projects that would have [19:08] previously been unfathomable. [19:10] Or you could explore hundreds [19:11] of different approaches to a research [19:13] question simultaneously. [19:16] That's what excites me [19:18] about making the Codex harness [19:19] available through an API. [19:20] You can now take work that is inherently [19:22] parallelizable and dramatically [19:24] expand the scope of what's possible. [19:27] I'd love to see what [19:28] you come up with. [19:29] Happy building.