OpenAI Agents API: The Managed Codex Harness 2026

The OpenAI Agents API is a managed service, launched in public beta on September 10, 2026, that runs the Codex agent harness on OpenAI's infrastructure. You supply tools and pick an execution environment; OpenAI handles sessions, orchestration, context compaction, and recovery.

TL;DR

OpenAI opened the Agents API in public beta on September 10, 2026.¹ It rents you the same harness that runs Codex, behind one POST to /v1/agents/sessions.²

There is no separate fee for the Agents API — you pay model tokens, tool rates, and container rates for OpenAI-hosted sandboxes.¹²

The catch is in the docs, not the announcement. The Agents API "currently supports data residency only in the United States and does not support Zero Data Retention (ZDR)," and picking a self-hosted sandbox does not change that.²

That matters because GPT-6 Astra, the model in OpenAI's own code samples, does support Zero Data Retention for eligible API customers.³ The harness is what costs you the compliance posture, not the model.

And OpenAI is not first here. AWS shipped Bedrock AgentCore to general availability on October 13, 2025.⁴ Anthropic shipped Claude Managed Agents into public beta on April 8, 2026 — five months and two days before OpenAI.⁵

What You'll Learn

• What the OpenAI Agents API actually is, and what "managed Codex harness" means in practice
• How the Agents API differs from the Agents SDK and the Responses API
• Which sandbox you can run agents in — OpenAI-hosted, your own, or none
• What the Agents API costs, and which line items the "no additional fees" line does not cover
• Why the managed harness forfeits Zero Data Retention when the underlying model does not
• Who actually shipped a managed agent runtime first
• What OpenAI itself said about managed agent APIs five months ago
• How to read the customer numbers in the announcement
• What the agents=v1 beta header implies about longevity

What the OpenAI Agents API actually is

The Agents API gives your application access to the Codex harness through an OpenAI-managed API. OpenAI manages sessions, orchestration, context compaction, and recovery, while your application provides tools and chooses its execution environment.²

A harness, in OpenAI's own architecture documentation, is "the OpenAI-hosted Codex instance that runs the model and tool loop and maintains the agent's session."⁶

That is the whole product in one sentence. The loop that decides when to call a model, when to call a tool, when to summarize, and when to give up — that loop now runs on someone else's machines.

You create a session with client.beta.agents.sessions.create(), or with a raw POST to https://api.openai.com/v1/agents/sessions carrying the header OpenAI-Beta: agents=v1.²

The docs list official examples in JavaScript, Python, Go, Java, Ruby, and curl.²

The API is organized around four concepts: Agent (model, instructions, tools, MCP servers), Environment (an optional sandbox), Session (a durable agent instance), and Events and items (inputs and outputs).²

Hold that list. It comes back later.

Agents API vs Agents SDK vs Responses API

OpenAI now ships three agent runtimes, and its own documentation compares them directly.⁷

Source: OpenAI's "Compare agent runtime options" table.⁷

The distinction that the naming actively obscures: the Agents SDK is a library you run, and the Agents API is a service OpenAI runs. They are not versions of each other.

OpenAI's framing is that the SDK "gives your application control over deployment, storage, approvals, and runtime integration," while the API "runs the Codex harness and manages the underlying agent infrastructure so you can focus on what your agents do."⁷

Choosing between them is a control-versus-effort trade, and OpenAI labels it as such — "Low" versus "Medium" integration effort, in its own table.⁷

What the managed Codex harness gives you

OpenAI lists seven capabilities the managed harness supports: running commands and code in a sandbox, applying skills and instructions, connecting to external data through tools or MCP, steering the agent mid-task, summarizing previous work to manage the context window, delegating subtasks to subagents, and resuming a session where it left off.²

Three of those are the ones people build badly by hand.

Context compaction. The Agents API "automatically compacts earlier context as a session approaches its context limit," so developers can build workflows spanning multiple context windows without writing their own compaction logic.¹

Tool search. Rather than shipping every tool definition on every turn, tool search "loads relevant tool definitions as needed," which OpenAI says reduces token usage and cost while preserving the model's cache.¹

Subagents. Set multi_agent.enabled and max_concurrent_subagents, and the harness splits complex tasks into independent pieces. Each subagent keeps its own context; the main agent coordinates and merges results.¹

Anthropic's equivalent shipped earlier and ships with published limits. Claude Managed Agents uses a coordinator with a declared roster, capped at 20 unique agents and 25 concurrent threads, and a coordinator may delegate only one level deep — referencing an agent that has its own roster fails validation.⁸

OpenAI has published no equivalent ceilings for max_concurrent_subagents in the launch materials reviewed here. That is a documentation gap worth watching if you plan to fan out wide.

OpenAI hosted sandbox, self-hosted, or none

The environment.type field takes three values, and the choice is more consequential than it looks.⁶

Set it to none and the harness runs without compute. Good for agents that answer questions or call remote MCP tools — but the built-in Bash and apply-patch tools, workspace files, and executor MCPs are all unavailable.⁶

Set it to openai_hosted and OpenAI provisions and manages a sandbox for the session, using the same sandboxing infrastructure behind Codex and ChatGPT.¹⁶

Set it to self_hosted and your code starts the environment and connects an executor to the session. You own provisioning, reconnection, shutdown, and file preservation.⁶

OpenAI's architecture doc is refreshingly plain about what an environment can be: "a remote sandbox, your laptop, a Docker container, or an AWS Lambda function."⁶

For hosted options, OpenAI named nine sandbox partners: Blaxel, Cloudflare, Daytona, DigitalOcean, E2B, Modal, Oracle, Runloop, and Vercel.¹

That list grew. When OpenAI added native sandbox execution to the Agents SDK in April 2026, it named seven: Blaxel, Cloudflare, Daytona, E2B, Modal, Runloop, and Vercel.⁹ DigitalOcean and Oracle are the September additions.

OpenAI Agents API pricing: no fee, but not free

There is no separate charge for the Agents API itself. OpenAI's wording: "There are no additional fees for using the Agents API – you simply pay for the tokens and tools your agents use."¹

The docs are more specific. Model usage bills at the selected model's API rates, OpenAI tools bill at their standard rates, and OpenAI-hosted sandboxes bill at standard container rates.²

So three meters, not one.

For the model in OpenAI's own samples, gpt-6-astra, standard short-context pricing is $10.00 per million input tokens and $50.00 per million output tokens. Long context is $20.00 and $75.00. Cached input is $1.00; cache writes are $12.50.¹⁰

Container rates are listed at 1 GB $0.03, 4 GB $0.12, 16 GB $0.48, and 64 GB $1.92 per 20-minute session per container — with a separate note that eligible container sessions are billed by the minute with a five-minute minimum.¹⁰ Both statements appear on the same page; treat the effective rate as something to measure rather than model.

Built-in web search is $10.00 per 1,000 calls plus search content tokens at model rates.¹⁰

One more line worth budgeting for: regional processing endpoints carry a 10% uplift for models released on or after March 5, 2026.¹⁰ Which raises a question the Agents API answers in a way the announcement never mentions.

The Zero Data Retention catch in the fine print

At the bottom of the Agents API overview, after the code samples, is the sentence that should decide whether regulated teams adopt this at all:

The Agents API currently supports data residency only in the United States and does not support Zero Data Retention (ZDR). Choosing a self-hosted sandbox does not make the Agents API ZDR-eligible.²

Read the second sentence twice. Running the compute yourself does not buy back the compliance posture, because the thing retaining state is the harness, not the sandbox.

The Agents API retains session state so work continues across turns without rebuilding context.² That persistence is the product. It is also what forecloses ZDR.

The contrast is sharp. GPT-6 Astra — the model in OpenAI's Agents API code samples — "supports Zero Data Retention for eligible API customers," per OpenAI's own launch page.³

So a workload that runs under Zero Data Retention on the model today loses that eligibility the moment it moves to the Agents API. The model did not change. The runtime did.

Anthropic landed in exactly the same place, and said so more explicitly. Its docs state that because Managed Agents is stateful by design, "Managed Agents is not currently eligible for Zero Data Retention (ZDR) or HIPAA Business Associate Agreement (BAA) coverage."¹¹

Two independent labs, five months apart, hit the same wall. That suggests the constraint is architectural rather than a policy choice either could reverse on request.

OpenAI is not first to a managed agent harness

It would be easy to read a launch this size as OpenAI opening a category. The dates do not support that.

AWS put Amazon Bedrock AgentCore into preview in July 2025 and reached general availability on October 13, 2025.⁴ AgentCore is framework-agnostic by design — AWS advertises it as working with CrewAI, LangGraph, LlamaIndex, Google ADK, and, pointedly, the OpenAI Agents SDK.⁴

Anthropic announced Claude Managed Agents on April 8, 2026, describing it as a "pre-built, configurable agent harness that runs in managed infrastructure."⁵¹¹

Now go back to those four Agents API primitives — Agent, Environment, Session, Events. Anthropic's docs list Claude Managed Agents as "built around four concepts": Agent, Environment, Session, Events.¹¹

The same four nouns, in the same order, at two labs, five months apart. That is convergence on a shared abstraction, not evidence that anyone copied anyone.

Where they genuinely differ is billing. Anthropic charges standard token rates plus $0.08 per session-hour, metered to the millisecond and only while a session's status is running — idle, rescheduling, and terminated time do not accrue.¹² OpenAI charges no session fee and bills the sandbox as a container instead.²¹⁰

Anthropic also explicitly excludes the Batch API discount from Managed Agents sessions, on the grounds that sessions are stateful and interactive.¹²

The other real difference is the harness itself. AWS lets you bring any framework; OpenAI and Anthropic each run their own opinionated one. OpenAI says it provides "versioned access to these capabilities with each model launch," so the harness upgrades alongside the models rather than on your release schedule.¹

What OpenAI said about managed agent APIs five months ago

On April 15, 2026 — one week after Anthropic's launch — OpenAI published "The next evolution of the Agents SDK." It surveyed the landscape and drew a three-way distinction:

Model-agnostic frameworks are flexible but do not fully utilize frontier models capabilities ; model-provider SDKs can be closer to the model but often lack enough visibility into the harness; and managed agent APIs can simplify deployment but constrain where agents run and how they access sensitive data.⁹

That third clause was a criticism of a product category OpenAI has now entered.

And it was accurate. The Agents API constrains where agents run — US-only data residency — and how they access sensitive data — no ZDR.² OpenAI described the trade-off before making it.

To be fair, OpenAI narrowed the gap it identified. The Agents API lets you keep compute inside your own perimeter via self_hosted, and the harness is open source, which answers the "lack enough visibility" complaint aimed at provider SDKs.¹⁶

The Codex harness lives at github.com/openai/codex under Apache-2.0, written mostly in Rust, and carried 119,631 stars and 18,270 forks as of September 11, 2026.¹³

One caveat on that. OpenAI says the Agents API is "powered by the open-source Codex harness" and that developers "can inspect and learn from its public codebase."¹ That is a visibility claim, not a guarantee that the hosted harness is byte-identical to the repository at any given moment.

The customer numbers are vendor-reported

OpenAI's announcement carries eight customer testimonials.¹ Four are excerpted below, and not one of their figures is independently verified.

Every figure here is an OpenAI-published customer statement, quoted from the announcement page.¹ None comes with a methodology, a baseline definition, or a reproducible harness.

The Hypha number is the most interesting and the most opaque. An 86% reduction in failed responses, attributed specifically to separating the harness from the sandbox, is a strong architectural claim — and "failed agent responses" is not a defined term anywhere in OpenAI's documentation.

As of September 11, 2026, one day after launch, no independent evaluation of the Agents API had been published. Treat the announcement's numbers as directionally interesting and structurally unaudited.

That pattern is not new. Our look at DeepSeek Harness and its open agent loop found the same gap between a harness vendor's published numbers and anything a third party could reproduce.

The agents=v1 beta header question

Every Agents API request carries OpenAI-Beta: agents=v1.² Developers who have been on the platform a while will recognize that pattern, and not fondly.

OpenAI-Beta: realtime=v1 was the Realtime API Beta. OpenAI announced its deprecation on September 15, 2025 and removed it on May 12, 2026.¹⁴

The broader record is worth having in front of you before you build a business on a beta surface. OpenAI's deprecations page documents three product retirements announced on a single day, June 3, 2026: Agent Builder, the Evals platform, and reusable prompts — all scheduled to shut down on November 30, 2026.¹⁴ The Assistants API shut down on August 26, 2026, a year after its notice.¹⁴

None of this predicts anything about the Agents API. OpenAI's stated notice periods are real — at least six months for generally available models, at least three for specialized variants.¹⁴

But those commitments are written about models. OpenAI's deprecations page does not publish an equivalent notice guarantee for beta API surfaces, and the Realtime beta's roughly eight-month window from announcement to removal is the closest precedent available.¹⁴

The practical hedge is the same one that applies to every agent platform: keep tools behind MCP, keep business logic out of vendor-specific session objects, and know what a migration would cost before you need to price it. We made the same argument about enterprise MCP servers as the agent action layer, and it holds here.

Who this is actually for

If you are prototyping, the Agents API removes weeks of infrastructure. Context compaction, tool search, subagent orchestration, durable sessions, and sandbox lifecycle are all real work you no longer do.¹²

If you are in a regulated industry, the US-only residency and ZDR exclusion are likely disqualifying, and no sandbox choice fixes them.² The Agents SDK remains the path that keeps state under your control.⁷

If you are multi-model by policy, neither managed harness is built for you. Anthropic says Managed Agents is "purpose-built for Claude," and OpenAI's Agents API documentation shows only OpenAI models.²⁵ AWS AgentCore's framework-and-model-agnostic posture is the structural answer there.⁴

And if you already went through a forced agent migration this year, you know the calculus. AWS gave Bedrock Agents customers a deadline and a destination — the shape of that transition is covered in our piece on AWS closing Bedrock Agents.

The bottom line

The interesting thing about the Agents API is not that OpenAI built a managed agent runtime. AWS and Anthropic got there first, and the abstraction has converged so tightly that OpenAI and Anthropic now describe it with the same four nouns.

The interesting thing is what the managed layer costs you. Not in dollars — the token and container meters are ordinary. In posture.

GPT-6 Astra supports Zero Data Retention.³ The Agents API does not, and self-hosting the sandbox does not restore it.² Anthropic's managed harness lands on the identical exclusion for the identical reason.¹¹ Statefulness is the feature and statefulness is the disqualifier, and you cannot buy one without the other.

OpenAI wrote that trade-off down in April, as a criticism of somebody else's product category.⁹ Five months later it shipped into that category, and the constraint it named is right there in the documentation.

That is not hypocrisy. It is a fairly precise piece of self-knowledge that happens to also be the best available buyer's guide. Read the April paragraph, then read the limitations note at the bottom of the overview page, then decide whether your data can live in a US-only stateful session.

For everyone else — and that is most teams — a managed harness that handles compaction, tool search, and subagents on day one is a genuinely good deal at no marginal fee. Just don't wire it in so deep that agents=v1 becomes load-bearing.

References