OpenAI Agents API Public Beta: Codex Harness Behind One Call

OpenAI opened public beta access to its Agents API on September 10, 2026 — two days before this post — giving any developer with an API key the same session management, subagent orchestration, and sandboxed execution infrastructure that has been running Codex and ChatGPT's agentic features internally. The headline framing ("first-party sandbox integrations") undersells what actually shipped: this is OpenAI taking the harness it built to keep Codex agents from going off the rails and renting it out as a general-purpose endpoint, with nine named infrastructure partners wired in on day one.

It also landed in the same week as reports that OpenAI's own Aardvark security agents gained remote code execution on RubyGems' rubydoc.info while probing for vulnerabilities back in May. That juxtaposition is worth sitting with honestly rather than treating as either coincidence or gotcha: better, more auditable sandboxing is precisely the kind of infrastructure investment that incident argues an agent-heavy lab needs more of, not evidence the industry is moving too fast to bother.

TL;DR

What the Agents API actually is

The clearest technical description comes from OpenAI's own developer docs, not the launch post's marketing copy. The Agents API is built around four primitives: an Agent (the model, instructions, tools, and MCP servers it can use), an Environment (where its code runs), a Session (a durable, multi-turn task instance that survives across turns without the client rebuilding context each time), and Events/items (the structured record of what happened inside a session).

The core value proposition, in OpenAI's own words from the docs: "OpenAI manages sessions, orchestration, context compaction, and recovery while your application provides tools and chooses its execution environment." That is a materially different job than the Responses API does. Responses API calls are stateless-ish request/response turns you orchestrate yourself; the Agents API is a managed, long-running agent loop — closer to what you'd build by hand on top of Responses, except OpenAI now runs the loop, handles context compaction when a session gets long, and recovers automatically when something fails mid-task.

It's also explicitly not the Assistants API rebranded. The Assistants API is the older stateful-agent product OpenAI has been walking away from for over a year; the Agents API is a new, separate service built specifically on the harness that ships with Codex, versioned alongside model releases. If you've been holding off migrating off Assistants API because nothing looked like a real successor, this is the closest thing OpenAI has shipped — though as of this beta it is a different enough shape (sandboxes, subagents, partner infra) that "port your Assistants code over" is not a one-line change.

The API is gated behind a beta header (OpenAI-Beta: agents=v1) and, per the docs, is already wired to gpt-6-astra as a supported model — consistent with OpenAI shipping this as harness infrastructure meant to sit under its current model generation rather than a standalone product tied to one specific model version.

What "first-party sandbox integrations" means concretely

This is the part the aggregator headline compressed into three words. In practice, when you create an Agents API session you choose where its code actually executes:

1. OpenAI-hosted sandbox — OpenAI provisions and manages the sandbox itself, described in the docs as using "the same sandboxing infrastructure that powers Codex and ChatGPT." You configure it with a workspace_directory and capability_directories (for example /workspace and /workspace/capabilities/skills), and the agent gets an isolated environment to run code, read and write files, install packages, and produce artifacts.
2. Self-hosted / your own infrastructure — you run the compute, the Agents API still handles session state, orchestration, and recovery.
3. Nine partner sandboxes — Blaxel, Cloudflare, Daytona, DigitalOcean, E2B, Modal, Oracle, Runloop, and Vercel each ship a first-class integration, so an agent session can execute inside a partner's isolate or container product — with that partner's specific CPU/GPU/memory tiers and VPC deployment options — while still being driven through the same Agents API calls.

That's a meaningfully different bet than a single hosted code-interpreter box. It's OpenAI acknowledging that "run this agent's code somewhere isolated" is not one problem with one right answer — a fintech running compliance workloads wants Oracle or its own VPC; a hobbyist wants the zero-setup OpenAI-hosted option; a team already on Cloudflare's isolate-based agent runtime wants to keep using it without rewriting their orchestration layer.

Multi-agent work is a first-class citizen too: agents can "break work into subtasks and delegate to subagents," configured with settings like max_concurrent_subagents: 4, and MCP servers attach as tools with just a server_label, transport type, and server_url — OpenAI's own docs MCP endpoint (https://developers.openai.com/mcp) is the example used in their guide.

Pricing and access

There is no separate Agents API line item. OpenAI's stated model: "Model usage is billed at the selected model's API rates. OpenAI tools use their standard rates, and OpenAI-hosted sandboxes use standard container rates." So the API itself is free to use — what you pay for is the model you route through it, any built-in tools it calls, and container time if you pick the OpenAI-hosted sandbox instead of your own infra or a partner's.

Access is public beta for any developer with an API account — no separate waitlist gate reported beyond the OpenAI-Beta: agents=v1 header requirement. Two real limitations to flag before building anything production-bound on it:

• Data residency is US-only during the beta — a blocker if you have EU/UK data-residency requirements today.
• Zero Data Retention is unsupported, in every sandbox configuration, including self-hosted. OpenAI's docs are explicit that "choosing a self-hosted sandbox does not make the Agents API ZDR-eligible" — so moving compute to your own infra doesn't get you around the retention limitation on the API layer itself.

Early adopters cited in coverage of the launch reported concrete before/after numbers: one team (Ciridae) reported an evaluation score moving from 0.71 to 0.85 alongside a 4x latency reduction after adopting the API, and another (SafetyKit) reported roughly 60% lower cost per case after migrating their agent workload onto it. Those are vendor-reported figures from launch-week coverage, not independently reproduced benchmarks — treat them as directional, not a guarantee your own workload sees the same delta.

How this compares to Claude's platform tooling

The most useful comparison anchor is Anthropic's own general-availability push on almost the identical surface area, which shipped three weeks earlier, on August 20, 2026: computer use, browser use, the Skills API, and the Files API, all moving out of beta with no beta header required and a new computer_toolset_20260801 batch-actions toolset.

Neither company is copying the other outright — Claude's GA push leans into controlling existing software (a desktop, a browser) with policies suited to compliance-heavy workflows like HIPAA, while OpenAI's Agents API leans into coding-agent-style sessions with a marketplace of interchangeable sandbox backends. But the fact that both labs converged on "ship first-party sandbox/execution infrastructure as a platform primitive" within three weeks of each other says the market has settled on sandboxed execution as table stakes for any serious agent platform, not a nice-to-have. It's also worth reading against Google Cloud's own agent-sandbox guidance from the same window — cold start, isolation, and egress control keep showing up as the three things every vendor has to solve before an "agents platform" claim means anything.

What people are asking

Is this different from the Assistants API OpenAI is deprecating? Yes — see the FAQ above. Don't treat "Agents API" as a find-and-replace for "Assistants API" in your codebase; the primitives (sessions, subagents, sandbox choice) are new enough that migration is a rebuild, not a rename.

Do I need to pick a sandbox partner up front, or can I switch later? OpenAI's docs describe the sandbox as a per-session configuration choice rather than an account-level lock-in, so switching between OpenAI-hosted, self-hosted, and a given partner is a matter of changing the environment config on new sessions — not a migration between separate products.

Is my code and data actually isolated between sessions? The OpenAI-hosted sandbox reuses Codex/ChatGPT's existing sandboxing infrastructure rather than a new, unproven isolation layer, which is a reasonable trust signal given how much production traffic already runs through it. That said, "isolated between sessions" and "eligible for Zero Data Retention" are different guarantees — the ZDR gap above is the one to actually budget for if you're evaluating this for a regulated workload.

When does this leave beta? OpenAI hasn't published a GA date. Given the pattern of other 2026 OpenAI API betas, expect incremental capability additions (more regions, ZDR support, additional partners) before a formal GA announcement rather than a single cutover date.

Why does a coding-agent-style API need nine sandbox partners instead of one good one? Because "isolated compute" means different things to different buyers — cold-start latency for interactive use, VPC deployment for enterprise compliance, GPU access for heavier workloads, or simple zero-setup defaults for a solo developer. One sandbox couldn't satisfy all four without becoming the worst version of each.

What you can build with it that was hard before

Before this, building a Codex-style long-running coding agent meant assembling your own session store, your own context-compaction logic for long tasks, your own retry/recovery handling, and your own choice of sandbox runtime — then wiring MCP tool calls and any subagent delegation on top by hand. That's the exact stack a project like Pi, the minimal open-source agent harness or the general pattern covered in our agent harness explainer describes builders reinventing project by project. The Agents API collapses a meaningful chunk of that scaffolding into a managed call, with a sandbox marketplace attached, which is a genuinely lower floor for shipping an agent that needs to run code, touch files, and survive a multi-hour task — not just answer one prompt and return.

Related reading

• Claude Platform GA: Computer Use, Browser Tool, Skills API, Files API
• OpenAI Aardvark Agents Reportedly Attacked RubyGems and Rubydoc.info
• Google Cloud's 5 Agent Sandbox Truths
• Cloudflare Computer: Agents Need Isolates, Not Just Containers
• What Is an Agent Harness? The Scaffolding Layer That Makes AI Agents Reliable
• DeepSeek-V4-Flash-0731: Codex Support and Responses API pricing
• Claude Managed Agents: Session Viewer and Auto Mode
• ChatGPT Work vs Codex: What Actually Changes

Official sources: Introducing the Agents API — OpenAI, Agents API overview — OpenAI developer docs, OpenAI-hosted sandboxes — OpenAI developer docs, and launch-week coverage from MarkTechPost and The Decoder.

Details on API shape, pricing, and beta constraints reflect OpenAI's documentation and launch coverage as of September 12, 2026 — a public beta like this one can change parameters, pricing, or regional availability before general availability.