OpenAI Opens the Codex Harness Itself as the Agents API

OpenAI launched the Agents API in public beta on September 10, 2026, opening the agent harness and infrastructure behind Codex and ChatGPT for Work through a single API call. There are no additional fees, and developers pay only for the tokens and tools their agents use. A session-creation call specifies the model, tools, and environment, while context compaction, tool search, and subagent coordination are handled by a harness OpenAI maintains. The substance of this launch is not a new model but a change of ownership over the layer sitting between the model and the application. ASAP works only from the specifications stated in OpenAI's own announcement.

What is on sale here is the harness and the infrastructure, not the model

What OpenAI opened is the harness it refined running Codex at a scale of millions of people. The announcement sorts the requirements for a useful agent into two parts. One is a powerful harness that manages context, uses tools efficiently, and coordinates subagents. The other is infrastructure that keeps agents running reliably for days, in environments where they can work with files, run code, and save intermediate results.

The call shape appears as example code in the announcement. A developer passes an agent object, vault_ids, environment, and input to a single client.beta.agents.sessions.create. Inside the agent object sit the model name gpt-6-astra, a tools array pointing at an MCP server, and a multi_agent setting. In the example, multi_agent has enabled set to true and max_concurrent_subagents set to 3. The environment sets type to openai_hosted and lists /workspace/capabilities/skills under capability_directories.

The task string in the example shows exactly what kind of work this API targets. It instructs the agent to investigate an elevated 5xx rate on service-api over the last 30 minutes, delegate deployment, error, and dependency analysis to subagents, and save findings, evidence, and recommended mitigation in /workspace/outputs. That is not a single response but investigation, delegation, and artifact storage bound into one session.

The execution environment is a choice among an OpenAI sandbox, nine partners, and your own infrastructure

OpenAI hosts and maintains the harness, but the developer picks the compute environment. The announcement lists an OpenAI-managed sandbox, the developer's own infrastructure, and sandbox partners. The named partners are Blaxel, Cloudflare, Daytona, DigitalOcean, E2B, Modal, Oracle, Runloop, and Vercel.

The announcement gives three reasons for the partner program: fully managed environments or deployment inside a customer VPC, specific file and secret storage mechanisms, and differing CPU, GPU, and memory configurations with performance, cold-start, and cost profiles to match a company's workflow.

For teams that want to start quickly, OpenAI also introduced its own hosted sandbox. It runs on the same sandboxing infrastructure behind Codex and ChatGPT, with OpenAI provisioning and managing it. These sandboxes can be configured with files, packages, skills, and plugins so an agent has what it needs for the task.

Context compaction and tool search move out of application code and into the harness

The three capabilities the Agents API absorbs into the OpenAI-operated harness are context management, tool use, and subagent orchestration. The first is context management. As a session approaches its context limit, the API automatically compacts earlier context while preserving what the agent needs to continue, so developers can build workflows spanning multiple context windows without implementing compaction logic themselves.

The second is tool use. Tool search loads relevant tool definitions as needed, reducing token usage and cost while preserving the model's cache. Programmatic tool calling lets agents run calls in parallel, chain related operations, and filter or combine results in code, so they can work through large volumes of data while returning only relevant results to context. Supported surfaces are MCP, custom functions, and built-in tools such as web search.

The third is subagents. Multi-agent support breaks complex tasks into independent pieces delegated to subagents running in parallel. Each subagent keeps its own context while the main agent coordinates and merges results. The stated benefit is faster research, analysis, and coding tasks, without the developer building orchestration.

An open-source harness that OpenAI operates is the core of this launch

From here this is ASAP's reading. As the announcement states, the Agents API is powered by the open-source Codex harness, and OpenAI operates and maintains that harness while developers inspect the public codebase. Source open, operations retained, and that pairing aims at two things at once: auditability and retention. Visible logic reduces black-box concern, while the actual execution path stays with OpenAI.

The problem this addresses is named in the announcement itself. Taking advantage of new model capabilities often means reworking the harness, which takes time away from improving the application. The Agents API provides versioned access with each model launch and improves the harness alongside the models. Read the other way, OpenAI absorbs a maintenance cost that self-hosting teams were carrying, and in exchange the application becomes coupled to OpenAI's model release cadence.

The boundary sits where the announcement draws it. OpenAI supplies the harness and infrastructure as a foundation, and tells developers to focus on the tools, knowledge, and workflows that make their agent unique. That is a proposal to relocate differentiation toward tools and data, while the territory agent frameworks have been competing over, such as context compaction and subagent coordination, drops into the base layer.

"No additional fees" does not make the cost math simpler

The billing terms are plain. There are no additional fees for the Agents API, and developers pay for the tokens and tools their agents use. Read as a sentence it removes an adoption barrier, but cost prediction moves in the opposite direction.

The reason is that every capability absorbed into the harness consumes tokens. Automatic compaction is a model call that summarizes earlier context, tool search is a selection step that injects tool definitions, and each subagent maintains its own context. Setting max_concurrent_subagents to 3 puts up to three contexts on the meter alongside the main agent. The more the harness decides on its own, the more of the billing decision sits outside application code.

The number to examine in an adoption review is therefore total token distribution per session, not unit price. Since the announcement assumes long-running work measured in days, intuitions calibrated on short request-response billing do not transfer. And with OpenAI stating it will iterate quickly on feedback during the public beta, details such as when compaction triggers or how tool search behaves remain subject to change.

The first things to settle are sandbox location and the secret path

For any team evaluating adoption, the first question is where the data executes. Among the three options, the explicit inclusion of the developer's own infrastructure and of deployment inside a customer VPC matters most in practice. The OpenAI hosted sandbox is the fastest start but places code and files in an OpenAI-managed environment, while a VPC deployment keeps control at the cost of partner selection and operational load.

The second question is vault_ids, which appears in the example code. Passing a credential-store identifier into session creation means the scope of secrets the agent can reach is also the blast radius. Credentials issued to an agent that runs for days, executes code, and writes files are better scoped per task at least privilege than mapped to a human account.

The third question is the MCP dependency. The tools array in the example points at an external MCP server over HTTP transport. Exposing internal observability tools or data sources over MCP makes them immediately usable by an agent, but that server then becomes an externally callable execution surface. Most organizations still keep MCP servers inside the private network, so using the Agents API means designing the exposure boundary and authentication first.

One customer quote is the only number published

Three verification limits are worth stating before any team commits a production path to the Agents API in its September 2026 public beta. First, the only quantitative figure in the announcement is effectively a single customer quote. Jack Weissenberger, CTO of Ciridae, states that an evaluation score rose from 0.71 to 0.85 and that latency dropped by a factor of four. Those are the customer's own measurements, and the benchmark conditions and the baseline configuration are not given.

Second, there are no performance figures for the behaviors the harness is said to handle. No measurement is published for when and how much automatic compaction compresses, how many tokens tool search saves, or how much subagent parallelism accelerates which tasks. The announcement presents these effects in prose only.

Third, the status is public beta. OpenAI states it will iterate quickly on feedback while working toward general availability, and asks developers to report what works and where friction appears. That is early for treating the interface and behavior as fixed when designing a production path.

Taken together, this launch pulls a layer of competition beneath the model onto OpenAI's side of the line. Context management, tool coordination, and subagent orchestration that agent frameworks used to supply are now API defaults, and in exchange developers shed harness maintenance and hand over some control of the execution path. Whether that trade favors a given team depends on how much of the harness that team was touching in the first place.

Source: OpenAI announcement "Introducing the Agents API" (September 10, 2026)