OpenAI launches Agents API public beta for building autonomous agent workflows

On September 10, 2026, OpenAI announced "Introducing the Agents API" — a public beta of a managed service that gives developers the same agent harness and infrastructure that powers Codex and ChatGPT for Work. The core idea is a single API call that creates a durable agent session: developers specify the task, model, tools, and execution environment, and OpenAI runs the agent loop — session orchestration, context compaction, tool coordination, subagent delegation, and recovery — on its own infrastructure.

Key announced mechanics:

• Endpoint/interface: POST https://api.openai.com/v1/agents/sessions (SDK surface client.beta.agents.sessions.create), gated during beta by the OpenAI-Beta: agents=v1 header.
• Managed harness: OpenAI handles sessions, orchestration, context compaction, and recovery; the application provides tools and chooses the execution environment.
• Environments (three options):
  1. OpenAI-hosted sandbox — the same sandboxing infrastructure that powers Codex and ChatGPT; configurable with files, packages, skills, and plugins.
  2. Self-hosted — run codex exec-server inside your own environment; it registers with a restricted key and connects over WebSocket (all connections outbound).
  3. Partner sandboxes — nine first-class integrations at launch: Blaxel, Cloudflare, Daytona, DigitalOcean, E2B, Modal, Oracle, Runloop, and Vercel.
• Tools: MCP servers, custom functions, and built-in tools such as web search; plus "tool search" (loads relevant tool definitions on demand to save tokens) and "programmatic tool calling" (parallel/chainable calls with results filtered in code).
• Multi-agent: built-in subagent delegation with per-subagent context and max_concurrent_subagents (examples show 3–4).
• Long sessions: automatic context compaction as a session approaches its context limit; sessions can continue across turns (durable sessions), stream progress, and be steered mid-run; webhooks/event streaming supported.
• Open-source foundation: the harness is "powered by the open-source Codex harness" (github.com/openai/codex) — OpenAI operates and maintains it, developers can inspect the code.
• Pricing: no additional fee for the Agents API itself; you pay the selected model's standard API rates, standard rates for OpenAI tools, and standard container rates for OpenAI-hosted sandboxes.
• Data controls (beta limits): data residency currently US-only; Zero Data Retention (ZDR) is not supported, even when using a self-hosted or partner sandbox.
• The changelog entry (Sep 10) frames it as: "Build agents with a managed Codex harness while OpenAI handles session orchestration, context compaction, and recovery."
• Same-day context: OpenAI's changelog also shows GPT-Live 1 going GA in the API and key-expiration controls the same day; GPT-6 Astra (the model used in Agents API examples) launched Sep 3; third-party coverage notes the same morning also brought ChatGPT for Financial Services. OpenAI separately confirmed that Agent Builder and Evals will be retired on November 30, 2026, steering code-based workflows toward the Agents SDK and Agents API.

Customer quotes in the announcement (all COMPANY CLAIM): Ciridae (eval score 0.71→0.85, 4× latency reduction from subagent flows), SafetyKit (60% cost reduction per case), Hypha (86% fewer failed agent responses in financial services), Nash.ai (thousands of long-running agents managing hundreds of millions of deliveries), Dwelly (fan-out across hundreds of agents), deepsense.ai (implementation + independent review + remediation in a real repo), Long Lake, WithCoverage.

From the discovery record: "OpenAI moved the Agents API to public beta, exposing general-purpose autonomous agent orchestration to all developers." Verified and expanded:

• Before: teams building agents assembled their own infrastructure: an agent runtime, session/state database, context-compaction routine, retry policy, sandbox fleet, and subagent orchestration — or used the open-source, self-hosted Agents SDK (available since March 2025, updated May 2026 with sandbox agents and an open-source harness) on top of the Responses API.
• Now: the harness is a hosted service. OpenAI runs and maintains the agent loop; developers consume it through one session-create call. This is the same infrastructure class that Codex and ChatGPT for Work use internally.
• Not changed: the API is still in beta; the SDK surface is behind the beta.agents namespace; execution environment choice is retained (BYO compute is a first-class option, not an afterthought); the harness source remains open.

• Before (status quo until Sep 10, 2026): To ship a long-running production agent, a team had to own or assemble — per InfoWorld's synthesis — an agent runtime, context and session management, tools and external data connections, execution environments, and associated infrastructure; the open-source Agents SDK was a framework you ran yourself. Enterprise agent platforms from rivals were already emerging (Anthropic's Claude Managed Agents in public beta since April 2026; Amazon Bedrock AgentCore GA in June 2026; Microsoft Foundry Agent Service; LangGraph).
• Change (Sep 10, 2026): OpenAI productizes its internal Codex harness as a managed API in public beta for all developers: client.beta.agents.sessions.create(model, tools, environment, input) — OpenAI handles orchestration, compaction, recovery, subagents; a single API call creates a production-shaped agent; no harness fee.
• After (steady state during/after beta): Agent development shifts from building the loop to configuring it — task, model, tools, environment — and to the operational concerns OpenAI does not remove (observability of tool results, data residency, ZDR, cost control, security governance). Competitors now differentiate on portability (Bedrock AgentCore lets you switch models mid-session) versus OpenAI's vertical integration (models + harness + sandboxes + chat surface). Enterprises face a sharper build-vs-buy and lock-in calculus.

• A developer calls the sessions endpoint (SDK beta.agents.sessions.create) with an agent spec: model (docs examples use gpt-6-astra), instructions, tools (MCP servers via HTTP transport, custom functions, built-ins like web_search, programmatic_tool_calling), optional multi-agent config (enabled, max_concurrent_subagents), an environment (openai_hosted, self_hosted, or a partner sandbox via workspace_directory/capability_directories), and the input task.
• OpenAI provisions a session: the model runs the Codex agent loop — planning, tool calls, code execution in the chosen sandbox, file reads/writes, artifact production — with streamed events back to the application (agent.session.turn.completed etc.).
• Durability: the session retains state; the app can send follow-up input across turns (e.g., "add a max-depth option to tree.py") without rebuilding context; sessions can be deleted via DELETE /v1/agents/sessions/{id}.
• Context compaction: as a session approaches its context limit, OpenAI automatically summarizes earlier context to keep the agent working for hours/days without developer-written compaction logic.
• Subagents: the main agent can delegate independent tasks to subagents with their own context, running in parallel, and synthesize results — removing bespoke orchestration code.
• Sandbox options, deep: OpenAI-hosted (managed, configurable with files/packages/skills/plugins), self-hosted (run codex exec-server, which registers with a restricted key over an outbound WebSocket — confirmed present in the open-source repo as codex-rs/exec-server), or partner (Blaxel, Cloudflare, Daytona, DigitalOcean, E2B, Modal, Oracle, Runloop, Vercel).
• Operational caveat (from the quickstart): a completed turn does not guarantee every tool call succeeded; agent.session.idle alone is not a success signal — applications must inspect events and reported execution results. This is foundational to how these agents should be operated.
• APIs/versioning: beta header OpenAI-Beta: agents=v1; Python SDK 3.13.0 (Sep 10) lists the Agents API; Go/Java/Ruby/TS SDKs also show beta.agents surfaces.

• Standardizes enterprise agent-building on OpenAI's platform — the same week that agent-safety incidents (Anthropic's disclosure, S01; OpenAI's RubyGems-swarm attribution, S14) dominated the news, OpenAI mainstreamed autonomous-agent infrastructure for every developer. It makes "harness" a product category OpenAI owns by default in its stack.
• Ownership of the agent loop: OpenAI runs sessions, memory, compaction, recovery — the boring-but-critical plumbing where most agent projects stall (analysts: "agent development usually stalls between a working demo and a system capable of running unattended for hours").
• Ecosystem play: nine sandbox partners + open-source harness + MCP support signal a platform strategy (the harness layer decoupled from compute), not a walled garden — while retaining the session layer centrally.
• Competitive positioning: lands between Anthropic's Claude Managed Agents (beta since April) and AWS Bedrock AgentCore (GA since June), with Microsoft Foundry Agent Service and LangGraph also in the category; OpenAI's differentiator is the same harness that runs Codex/ChatGPT for Work plus first-party model access (GPT-6 Astra).
• Business-model signal: "no fees for the harness" pricing means OpenAI monetizes via model tokens, tools, and container time — aligning with its platform-volume strategy; also telegraphs the Nov 30 retirement of Agent Builder/Evals in favor of Agents SDK + Agents API.

• A production-shaped, long-running cloud agent (code execution, file work, artifacts, hours/days of continuity) from a single sessions.create call.
• Subagent-parallelized analysis/coding/research without building orchestration (customer-reported outcomes: 4× latency reduction, eval 0.71→0.85 at Ciridae; 60% cost-per-case reduction at SafetyKit; 86% fewer failed agent responses at Hypha — COMPANY CLAIM).
• Bursty fan-out workloads: hundreds of asynchronous agents without keeping idle infrastructure between peaks (Dwelly quote — COMPANY CLAIM).
• Bring-your-own compute: self-hosted or partner sandboxes (VPC deployments, custom storage/secrets, GPU/CPU profiles) while OpenAI runs the session layer — new architectures like "harness at OpenAI, execution in my VPC."
• MCP-connected agents (tons of tools without bespoke integrations), tool search, and programmatic tool calling for large-volume data work.
• Teams that had no capacity to build agent infrastructure can now stand up agents in hours; non-OpenAI-coded stacks can adopt the harness via SDKs (Python/JS/TS/Go/Java/Ruby) or raw cURL.

• GA timeline, GA pricing (will the "no harness fee" hold?), session duration/concurrency limits, and rate limits?
• When will data residency expand beyond the US and will ZDR become supported (the top blocker for regulated industries)?
• How will harness versioning work as models ship ("versioned access ... with each model launch") and will behavior drift break existing agents?
• Will OpenAI add model-agnostic harness use, or keep the Agents API OpenAI-models-only (vs. AgentCore's any-model positioning)?
• How will safety guardrails (sandbox network policies, permissions, misalignment monitoring on GPT-6 Astra) surface inside Agents API sessions?
• What happens to the open-source Codex harness relationship — does the API stay built on it, and does the open version keep parity?
• How do the nine sandbox partners' economics and isolation models differ in practice (secrets, egress, cold starts)?
• Impact measurement: does the managed harness actually cut time-to-production and TCO, as analysts expect?

• Beta iteration → GA: OpenAI explicitly says it will "iterate quickly based on your feedback as we work toward general availability"; watch for GA pricing, session limits, and residency expansion (the ZDR blocker).
• Ecosystem moves: expect the nine sandbox partners to ship differentiated integrations (VPC, secrets, cold-start, GPU profiles) and rivals to counter on portability (model switching, open harnesses).
• Consolidation of OpenAI's agent surface: Nov 30 retirements of Agent Builder and Evals; ongoing convergence of Codex CLI, Responses API, and Agents API into one agentic platform (consistent with the May 2026 ChatGPT+Codex reorganization).
• Safety crosscurrents: given the same-week agent-incident disclosures, expect regulators and enterprise security teams to probe managed-agent sandboxing, permissions, and auditability; any GA announcement will be read through the misalignment-disclosure framework OpenAI published Sep 16 (S02).
• PREDICTION: OpenAI will ship GA within roughly two quarters with tiered residency (adding at least EU/UK, matching the platform's other data-residency offerings) and some form of ZDR-supporting tier for enterprise agreements; the "no harness fee" will likely persist at GA but with tightened session/concurrency caps. Competitors (esp. AWS AgentCore's any-model harness and Anthropic's Claude Managed Agents) will force OpenAI to either open the harness to non-OpenAI models or lean harder on GPT-6 Astra integration.

This was the week AI's safety conversation went public and adversarial — four disclosed Anthropic agent incidents, a researcher-attributed agent swarm on RubyGems, misalignment-disclosure frameworks — and OpenAI spent that same week handing every developer the machinery to run durable, tool-wielding, subagent-parallel autonomous workloads with one API call. That juxtaposition is the story, not the API itself. The Agents API is a genuinely strong product: it collapses a large pile of unglamorous infrastructure (sessions, compaction, recovery, sandboxes) into a single call at a moment when agent-building was the industry's dominant bottleneck. But it also concentrates the agent loop — state, memory, orchestration — inside one vendor while the blast radius of autonomous agents is the week's loudest theme, and while the beta's own documentation warns that "a completed turn does not guarantee every tool succeeded." The era of agent-as-service has formally begun with the platform's default answer to the control problem being: here's the sandbox and the events — your jobs, and your liability, are what you build on top.