OpenAI Opens Agents API to All Developers

30-Second Summary

OpenAI opened its Agents API to all developers on September 10, 2026. The API surfaces the same infrastructure that powers Codex. It manages sessions, orchestration, context compaction, and failure recovery so that developers only need to define their tools and choose an execution environment. Multi-agent delegation, MCP connections, and sandbox code execution are included. Pricing is usage-based: tokens and tools only, no platform surcharge.

At a Glance

• Topic: Agent Systems
• Company: OpenAI
• Date: September 10, 2026
• Announcement: Agents API launched in public beta, available to all developers
• What Changed: The managed Codex harness, previously accessible only within OpenAI's own products, is now an API developers call directly
• Why It Matters: Orchestration, session management, context compaction, and recovery, the hardest parts of production agent development, are now handled by OpenAI's infrastructure rather than your engineering team
• Who Should Care: Any operator building or evaluating AI agents for business workflows, especially those who have been held back by the complexity of production-grade orchestration

Key Facts

• Released: September 10, 2026 (public beta)
• Available to: all developers with an OpenAI API key
• Pricing: tokens and tool calls only, no additional platform fee
• Built-in capabilities: sandbox execution, file editing, MCP connections, artifact generation, multi-agent delegation
• Deployment options: OpenAI-managed sandbox, self-hosted infrastructure, or partner sandbox
• Architecture: the same managed harness that runs Codex, exposed as an API

What Happened

OpenAI announced the Agents API public beta on September 10, 2026, giving all developers access to the infrastructure backbone behind Codex. Previously, building a production agent required teams to write session management code, handle context window overflow, build retry and recovery logic, and wire together orchestration layers. The Agents API handles all of this automatically.

The API is designed around a minimal developer contract: supply your tools and specify where to run the compute. OpenAI's infrastructure takes over from there, managing the full lifecycle of the agent session, including state across turns, context compaction when the window fills, and automatic recovery if a step fails.

The feature set goes beyond basic orchestration. Agents running on the API can execute code in sandboxed environments, edit files, connect to external systems via Model Context Protocol (MCP) servers, generate and return artifacts, and delegate subtasks to other agents in a multi-agent arrangement. Operators can choose to run agent compute in an OpenAI-managed sandbox, bring their own infrastructure, or use a partner sandbox if they have specific compliance or latency requirements.

Pricing follows the same structure as the standard API. Operators pay for the tokens consumed and the tools called. OpenAI does not charge a platform fee on top. This makes cost modelling straightforward: the cost of an automated task is directly comparable to the cost of the human time it replaces.

Why It Matters

Production complexity is no longer a barrier. The hardest part of building an agent has never been the AI reasoning. It has been state management, context window limits, failure handling, and orchestration logic. These are now OpenAI's problem, not the developer's. A team that previously needed three engineers and six weeks to build a production-grade agent can now start with one engineer and a weekend.

MCP integration changes the reach of agents. MCP connectors now exist for many common enterprise systems, including document management, CRM, calendar, and file storage platforms. An agent using the Agents API can connect to these systems directly, without custom integration code. For operators, this means the gap between "I have an AI idea" and "the AI is running in my systems" has shortened considerably.

Multi-agent delegation opens up complex workflows. A single agent has a narrow effective scope. The ability to delegate subtasks to other agents, built into the API from launch, means operators can design workflows that involve parallel workstreams, specialised sub-agents, and hierarchical task decomposition without building custom orchestration layers to support it.

The cost model is now transparent and predictable. Usage-based pricing means operators can calculate the cost of running an agent against the cost of the manual process. The comparison is direct: tokens and tool calls versus person-hours. This is the calculation that turns an experiment into a business case.

Competitive pressure just increased. OpenAI has raised the floor on what constitutes a viable agent platform. Any competitor product that requires developers to build their own orchestration layer is now at a disadvantage. The market standard has moved.

The David and Goliath View

OpenAI just commoditised the engineering complexity of agent development. The managed harness, session persistence, context compaction, recovery logic, these capabilities were moats for teams with dedicated AI engineers six months ago. Today they are table stakes. What matters now is not who can build an agent but who knows what to build.

For operators in the ten to two hundred person range, this is the more important development than any model capability release. The question is no longer whether your team has the engineering capacity to ship an agent. It is whether you have the operational clarity to specify one. The firms that benefit most from the Agents API in the next six months will not be the technical teams. They will be the operations people who have spent years knowing exactly which parts of their workflow are mechanical, predictable, and high-volume.

The timing is also worth noting. OpenAI is releasing this one day after the CISA and NSA advisory warning operators about Chinese AI infrastructure. The message to enterprise buyers is clear: if you want managed, trusted agent infrastructure with predictable compliance characteristics, the American AI labs are making that argument through product as much as through lobbying.

Where This Fits in the AI Stack

The Agents API sits at the orchestration layer, the piece of the stack that coordinates how AI models, tools, and data sources work together on a task. Below it sit the models (GPT-6 Astra and others via the standard completions API) and the data sources (accessed via MCP connectors or custom tools). Above it sit the business applications that operators build on top. The Agents API abstracts away the middle layer that was previously custom-built by every team separately.

Questions Operators Are Asking

Do I need to rewrite existing agents to use the new API? Not necessarily. Existing agents using the completions API or Assistants API will continue to work. The Agents API is most valuable for new builds, or for agents that are currently fragile in production because of context limits or incomplete recovery logic. Evaluate the migration effort against the reliability gains.

What is the difference between the Agents API and the Assistants API? The Assistants API (released 2023) handled threads and message history. The Agents API goes further, adding multi-agent delegation, built-in code execution, MCP connections, and the full Codex harness for context compaction and recovery. Think of the Agents API as the Assistants API for production workloads that run autonomously rather than in response to user messages.

Can I run this on my own infrastructure for compliance reasons? Yes. The Agents API supports self-hosted sandboxes. Operators with data sovereignty requirements or specific compliance frameworks can route agent compute through their own environments while still using OpenAI's orchestration logic.

How does pricing compare to building the orchestration myself? You pay tokens and tool calls, the same as any API usage, with no added fee. The cost you avoid is engineering time to build and maintain the orchestration layer. For most operators, three to six months of senior engineer time to build comparable infrastructure significantly exceeds the token cost differential.

What happens if an agent step fails mid-task? Automatic recovery is built into the harness. The API retries failed steps according to OpenAI's managed recovery logic. For tasks where specific failure handling is required, developers can define their own recovery callbacks. The default behaviour covers most standard failure modes, including timeouts, tool errors, and context overflow.

Citable Summary

OpenAI launched the Agents API in public beta on September 10, 2026, giving all developers direct access to the same managed infrastructure, sessions, orchestration, context compaction, and recovery, that runs Codex. The API supports multi-agent delegation, MCP connections, sandboxed code execution, and artifact generation. Pricing is token and tool-use based with no platform surcharge. Developers can run agent compute in OpenAI-managed sandboxes, self-hosted infrastructure, or partner environments.