OpenAI Releases Agents API in Public Beta, Offering a Managed Codex Agent Runtime

The service shifts the mechanics of keeping an agent working over time to OpenAI, while leaving developers to choose its tools and runtime environment. Its U.S.-only data residency and lack of Zero Data Retention narrow the immediate fit for some deployments.

By 4 min read
OpenAI Releases Agents API in Public Beta, Offering a Managed Codex Agent Runtime
OpenAI Releases Agents API in Public Beta, Offering a Managed Codex Agent Runtime

Listen to this story

The audio brief

About 1:37
0:001:37
Read transcript
OpenAI is putting the runtime behind its Codex agent system into the hands of developers through the Agents API, now in public beta. The important change is that teams can hand off much of the machinery required to keep an agent working over time. An application can create a durable session, send it a task, stream back events or receive webhooks, and later resume or steer that same session. OpenAI manages the session lifecycle, orchestration, automatic context compaction, and recovery. Developers still decide what the agent can do and where it runs. They can connect custom functions, web search, code execution, file editing, or MCP servers, then choose an OpenAI-hosted sandbox, a self-managed or partner environment, or no sandbox at all. The service can also break work into subtasks, delegate to subagents, and combine their results. There is no separate fee for the harness itself; model usage, OpenAI tools, and hosted sandbox usage are billed separately. The major limitation is data handling. Residency is currently available only in the United States, and the API does not support Zero Data Retention—even when execution is self-hosted. OpenAI also cites customer-reported gains, including Ciridae scores moving from 0.71 to 0.85 and SafetyKit claiming 60 percent lower cost per case, but those are not independent benchmarks. The question now is whether managed orchestration removes enough engineering work to justify giving up that control and accepting those deployment constraints.

Story brief

3 key points

OpenAI is making the runtime behind its Codex agent harness available through the Agents API public beta. Developers can persist sessions, stream events, use webhooks, compact context automatically, delegate subtasks, and resume work while choosing hosted, self-managed, partner, or no sandbox. The harness has no separate fee, but model, tool, and hosted-sandbox usage still costs money. The main enterprise caveat is...

  1. 01

    The API supports custom functions, MCP servers, web search, code execution, file editing, and artifact generation inside sandboxes.

  2. 02

    OpenAI manages session lifecycle, orchestration, context compaction, and recovery; developers remain responsible for tools and execution environments.

  3. 03

    Customer-reported results include Ciridae scores rising from 0.71 to 0.85 and SafetyKit claiming 60% lower cost per case; neither is independently benchmarked.

A developer can now hand off much of the machinery that keeps an AI agent running across a complex task: its session state, orchestration, context management and recovery. OpenAI has released the Agents API in public beta, giving all developers managed access to the Codex-based harness behind that work while they supply the tools and select where the agent executes.

The release changes what an application needs to build itself. Rather than only calling a model and assembling its own agent loop around it, an application can create a durable session, give it a task, receive output events and continue or steer the same session later. OpenAI says developers can follow progress through streamed output or webhooks, including when an agent finishes or needs more input.

A managed loop, with a developer-chosen workspace

The central division of labor is straightforward: OpenAI manages sessions, orchestration, automatic context compaction and recovery. The application provides the agent’s tools and chooses the execution environment. That environment can be an OpenAI-hosted sandbox, a developer-managed environment, an integrated partner sandbox, or no sandbox at all.

A sandbox gives the agent a place to act rather than simply respond. OpenAI says agents operating in one can run code, edit files, connect to Model Context Protocol, or MCP, servers, and produce artifacts. The API supports MCP connections, custom functions and built-in tools such as web search.

Capabilities aimed at longer work

The managed harness is designed for tasks that involve more than a single model answer. Its features include summarizing earlier work to manage the model’s context window, breaking work into subtasks, delegating those subtasks to other agents, and resuming a session where it left off. Those functions address recurring engineering work in agents that must keep track of progress while invoking tools over multiple turns.

Your application starts sessions and receives events and output from the Agents API. OpenAI runs the managed Codex harness and provisions and manages its sandbox.
With an OpenAI-hosted session, your application sends input and receives events, while OpenAI runs the agent and provisions and manages its sandbox. See environment options for setup and limitations. Source: developers.openai.com.
  • Automatic context compaction can summarize prior work as a session approaches its context limit.
  • Programmatic tool calling supports running and combining tool operations in code.
  • Multi-agent support can delegate independent tasks to subagents and combine their output.
  • The API can connect agents to external data through tools or MCP servers.

OpenAI lists examples that reflect that broader workflow: an incident-response agent that investigates alerts and seeks approval for recovery actions; a data analyst that queries a warehouse with read-only SQL; and a GitHub issue investigator that reproduces reported bugs and shares findings. They are examples of intended applications, not performance evidence for the API itself.

The constraint sits outside the sandbox choice

The launch comes with a material data-handling limit. The Agents API supports data residency only in the United States and does not support Zero Data Retention. OpenAI says choosing a self-hosted sandbox does not make the API eligible for Zero Data Retention. For organizations whose requirements depend on those controls, moving the execution environment outside OpenAI does not resolve the limitation.

There is no separate charge for the Agents API harness itself, according to OpenAI. Usage is billed through the selected model’s API rates, while OpenAI tools and OpenAI-hosted sandboxes carry their standard rates. That makes the product decision less about a new platform fee than about whether to adopt OpenAI’s managed runtime for the workloads a team wants to automate.

OpenAI has also published customer-supplied results, including a Ciridae evaluation-score increase from 0.71 to 0.85 and a fourfold latency reduction in subagent flows, plus SafetyKit’s reported 60% lower cost per case. Those figures are not independent benchmarks, but they point to the claim the new service is asking developers to evaluate: whether a managed harness can reduce the operational work of building agents without giving up too much control.

Editorial analysis

Our Read

OpenAI’s release makes the agent harness itself a product boundary. Developers can retain control over an agent’s tools and execution environment while handing session persistence, context management and recovery to OpenAI. That may appeal where the workflow and connected data matter more than custom orchestration. But the launch also makes data handling a decisive architectural question: the API is U.S.-residency-only and cannot be used with Zero Data Retention, even with a self-hosted sandbox. The next meaningful test is whether OpenAI broadens those controls or whether developers needing them keep the runtime layer under their own management.

Sources

  1. developers.openai.comAgents API | OpenAI API
  2. marktechpost.comOpenAI Launches the Agents API in Public Beta, Putting the Codex Harness Behind One API Call

Loading discussion...