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)