OpenAI put a price tag on agent infrastructure, and the price is zero. On September 10, 2026, the company launched the Agents API in public beta, exposing the same managed harness that powers Codex to any external developer.
TL;DR: OpenAI’s Agents API entered public beta on September 10, 2026, giving developers access to the managed Codex harness that runs OpenAI’s own coding agent. The API bundles cloud agents, subagents, hosted sandboxes, MCP tool integration, context compaction, and long-running execution into a single managed service — with no extra fee beyond standard usage, according to MarkTechPost.
What Is OpenAI’s Agents API and Why Does It Matter?
The Agents API is OpenAI’s managed service for building AI agents, launched in public beta on September 10, 2026. Its core pitch is simple: developers get the same execution infrastructure that powers Codex, OpenAI’s programming assistant, behind a single API call instead of assembling their own orchestration stack.
Why does that matter? Because agent orchestration is the part of agent development that most teams dread building. Loop management, tool dispatch, error recovery, memory handling — none of it is glamorous, and all of it breaks in production.
AlphaSignal went as far as saying the API “kills the orchestration layer developers hate building.” That framing may be aggressive, but it captures the intent: OpenAI is productizing the plumbing.
According to KuCoin News, OpenAI has opened its core agent architecture — the one running Codex — to external developers through this API. In my opinion, this is the most consequential part of the announcement. Codex has handled millions of real coding tasks in OpenAI’s environment, and that battle-tested loop is now a managed commodity.
The feature list includes cloud agents, subagents, hosted sandboxes, MCP tool support, context compaction, and long-running execution. Each of those deserves a closer look.
How Does the Codex Harness Work Behind the API?
The Codex harness is the execution scaffold that wraps a model into a working agent. It handles the agent loop: sending the model a task, executing tool calls, feeding results back, and repeating until the task is done. MarkTechPost describes it as the layer now “behind one API call.”
Behind that call, the harness manages several things developers previously had to wire themselves:
- The agent execution loop, from prompt to tool call to completion
- Tool dispatch and result handling, including MCP-protocol servers
- Context window management through automatic compaction
- Sandboxed code execution in OpenAI-hosted environments
- Spawning and coordinating subagents for parallel work
- Long-running task state, surviving multi-step workflows
- Cloud agent lifecycle, from creation to result retrieval
- Error recovery when a tool call or model response fails
The key architectural point: this is not a new agent framework. It is the same harness that runs Codex, repackaged as a managed service. BigGo Finance reported that OpenAI is “offering the same execution infrastructure” used internally.
For developers, that means less framework churn. Instead of gluing together a loop library, a sandbox provider, and a memory system, the harness comes preassembled. Is that lock-in? Partly — but it is lock-in to infrastructure that already runs at Codex scale.
What Are Cloud Agents and Subagents in Practice?
Cloud agents are agents that run in OpenAI’s cloud rather than on the developer’s own machines. You create one through the API, hand it a task, and it executes remotely — the developer’s infrastructure stays out of the loop entirely. DataStudios describes the model as cloud agents branching into subagents and hosted sandboxes, all routed through the Codex harness.
In practice, the workflow maps to calls like create_agent() to spin up an agent, with the harness handling scheduling, state, and execution. The agent persists in the cloud, which matters for long-running tasks: a job that takes hours does not need a developer’s server to stay alive, and the API’s long-running execution support keeps state intact across the session.
Subagents solve a different problem: decomposition. A primary agent can spawn child agents to handle parallelizable or isolated pieces of work, and the harness coordinates the results.
- A main agent breaks a large task into subtasks
- Each subagent receives its own scoped instructions
- Subagents run concurrently on OpenAI infrastructure
- Results flow back to the parent agent for synthesis
- Failures in one subagent do not necessarily kill the parent task
- Context stays smaller because each agent sees only its own scope
The subagent pattern maps directly onto how Codex already decomposes complex coding work. Bringing it into the API means developers get multi-agent coordination without building message-passing between agents themselves.
How Do Hosted Sandboxes Keep Agent Execution Safe?
Hosted sandboxes are isolated execution environments, maintained by OpenAI, where an agent’s code actually runs. When an agent needs to execute code, install dependencies, or manipulate files, it does so inside one of these sandboxes — not on developer servers and not in an unrestricted environment.
The security argument is straightforward. Agents that write and execute code are the highest-risk category of AI application, because a hallucinated command can do real damage. Sandboxing contains that blast radius.
- Code execution happens in an isolated environment per task
- Agents can run code, use terminals, and modify files safely
- The developer’s production systems are never touched directly
- Sandboxes are ephemeral, provisioned on demand by the harness
- OpenAI maintains and patches the underlying execution environment
- Resource limits are managed by OpenAI, not by each customer
For enterprise adoption, this may be the deciding feature. InfoWorld framed the launch around simplifying “enterprise AI agent development,” and enterprise security reviews consistently flag arbitrary code execution as a blocker. A vendor-managed sandbox shifts much of that review burden onto OpenAI.
The trade-off is control. Teams that need custom runtimes, specialized hardware, or strict data-residency rules may still prefer self-hosted execution. But for the majority of agent workloads — scripts, analysis, file processing, code generation — a hosted sandbox covers the requirement.
What Role Do MCP Tools Play in the New API?
MCP, the Model Context Protocol, is the open standard for connecting AI models to external tools and data sources. The Agents API supports MCP tools natively, which means an agent built on the API can call any MCP-compatible server — file systems, databases, SaaS APIs, internal services — without custom glue code for each integration.
This is a significant design choice. Rather than building a proprietary tool ecosystem, OpenAI is plugging its harness into the protocol the broader ecosystem has already adopted. DataStudios lists MCP tools among the API’s core capabilities alongside sandboxes and compaction.
Concretely, the flow looks like this: a developer registers an MCP server with their agent, the harness handles discovery of that server’s tools, and the model can then invoke those tools during execution. The Codex harness manages the dispatch, the results formatting, and the error handling when a tool misbehaves.
- Any MCP-compatible tool server works with the API
- Tool schemas are discovered through the protocol, not hardcoded
- The harness handles tool call routing and result handling
- Failures from tools are fed back to the model for recovery
- Existing MCP servers built for other stacks can be reused
- Combining MCP tools with subagents enables specialized tool-equipped workers
The result is an agent that can act on the real world — read a repository, query a database, file a ticket — through a standardized interface. Combined with hosted sandboxes and cloud execution, MCP support turns the Agents API from a model endpoint into a full agent runtime.
The remaining question is cost and scale in practice, which Part 2 covers.
How Does Context Compaction Support Long-Running Agents?
Context compaction is built directly into the Agents API so agents can run for hours without losing track of their task. The API summarizes or “compacts” older conversation state when the context window fills up, keeping the agent focused on what matters. Without this, a long coding or research session would simply overflow the model’s memory. Compaction handles that automatically.
The mechanism matters because real work rarely fits in a single context window. A cloud agent refactoring a large codebase may make hundreds of tool calls across files. Each call adds tokens. Compaction lets the harness compress completed subtasks into a shorter representation while preserving the current goal and recent results.
According to MarkTechPost’s coverage of the September 10, 2026 launch, compaction is one of the core managed features OpenAI exposes through the API, alongside sandboxes, subagents, and long-running execution. Developers do not have to write their own summarization pipeline. The harness decides when to compact and what to keep.
For teams migrating from Codex, this is familiar territory. The same machinery that lets the Codex programming assistant work through multi-hour coding sessions is now available behind a single API call. That continuity is the point: OpenAI is renting out infrastructure it already battle-tested internally.
How Does the Agents API Remove the Orchestration Layer Problem?
The Agents API replaces the glue code most teams write by hand: the loop that calls the model, parses tool output, retries failures, tracks state, and manages handoffs. AlphaSignal went as far as describing the launch as something that “kills the orchestration layer developers hate building.” That framing may be blunt, but it reflects a real pain point.
A typical homegrown agent stack includes several distinct subsystems. Consider what developers usually assemble themselves:
- An execution loop that routes between model calls and tool invocations
- Sandbox management for running untrusted code safely
- Subagent spawning and result aggregation
- Context window management and summarization
- Retry logic, timeouts, and failure recovery
- State persistence across long-running sessions
Each of these is a source of bugs. Each also takes engineering time away from the actual agent behavior a team wants to ship. OpenAI’s pitch is simple: the same harness that powers Codex now handles all of the above as a managed service.
The DataStudios analysis of the launch describes the API as exposing cloud agents, subagents, and hosted sandboxes as first-class primitives. Instead of stitching together a framework, a queue, and a container orchestrator, developers describe the agent’s tools and let OpenAI’s infrastructure run it. The trade-off is control. Teams with unusual requirements may still prefer their own stack, but for the common case, the managed path removes thousands of lines of plumbing.
What Does the Public Beta Include and Who Can Use It?
The public beta opened on September 10, 2026, and is available to external developers through the standard OpenAI API. According to BigGo Finance, OpenAI is offering the same execution infrastructure that powers its internal Codex assistant. This is not a stripped-down demo; it is the production harness exposed as a service.
The beta bundle includes a specific set of managed capabilities. Based on reporting from DataStudios and MarkTechPost, developers get:
- Cloud agents that execute in OpenAI’s infrastructure rather than local machines
- Hosted sandboxes for running generated code safely
- Subagents that can be spawned for delegated tasks
- Context compaction for long-running sessions
- MCP tool support for connecting external services
- The Codex harness itself, accessible behind one API call
- Long-running execution that survives multi-hour tasks
Any developer with API access can build on it during the beta. InfoWorld notes the launch targets enterprise AI agent development specifically, where the operational burden of running agents reliably matters most. Enterprises are exactly the customers who feel the orchestration pain most acutely.
How Does This Compare to Building Agents From Scratch?
Building from scratch means owning every failure mode yourself. The comparison comes down to time, reliability, and control. KuCoin’s reporting emphasizes that OpenAI opened its “core agent architecture” to external developers, which means teams get infrastructure proven at the scale of Codex usage rather than a prototype.
Here is how the two approaches stack up:
| Aspect | Agents API | From Scratch |
|---|---|---|
| Execution loop | Managed by OpenAI | Build and maintain yourself |
| Sandboxing | Hosted, managed | Self-hosted containers |
| Compaction | Automatic | Custom summarization code |
| Subagents | First-class primitive | Custom orchestration logic |
| Time to prototype | Hours | Weeks or months |
| Control over internals | Limited | Full |
| Vendor lock-in risk | Real | None |
Scratch-built agents still win when requirements are unusual: exotic sandboxing policies, on-premises deployment, or non-OpenAI models in the loop. A managed service also creates dependency. If OpenAI changes pricing, rate limits, or harness behavior, your agent inherits those changes.
In my opinion, most teams building standard coding, research, or workflow agents should start with the managed API and only fork their own stack when they hit a hard requirement. The maintenance burden of orchestration code is chronically underestimated.
What Should Developers Watch for Before Adopting It?
Adopting a managed agent service means accepting constraints on how your agents run. The beta status itself is the first thing to weigh: OpenAI launched the Agents API in public beta on September 10, 2026, and beta services can change behavior or pricing before general availability. Anything critical should be designed with that in mind.
Several open questions deserve attention during evaluation:
- Pricing structure beyond API usage — MarkTechPost reports no extra fee for the harness itself during the beta, but long-term pricing is unconfirmed
- Sandbox isolation guarantees for code handling sensitive data
- Observability: how much visibility you get into subagent activity and compaction decisions
- Data handling: what task context and code reside on OpenAI infrastructure
- Migration path if you later need to self-host
- Rate limits and concurrency caps for heavy workloads
The lock-in question deserves special weight. The harness, compaction, and sandbox behavior are all OpenAI-managed, so moving away later means rebuilding the orchestration layer you skipped. InfoWorld frames the launch as aimed at simplifying enterprise agent development, and simplification always implies a trade of flexibility for convenience. Teams should measure that trade against their own requirements rather than adopting on enthusiasm alone.
Frequently Asked Questions
When did OpenAI launch the Agents API?
OpenAI launched the Agents API in public beta on September 10, 2026. According to BigGo Finance, the beta exposes the same execution infrastructure that powers OpenAI’s internal Codex programming assistant to external developers.
Is the Codex harness really available through one API call?
Yes. MarkTechPost’s coverage describes the launch as “putting the Codex harness behind one API call,” with managed sandboxes, subagents, compaction, and long-running execution included. Developers no longer assemble these pieces from separate frameworks and infrastructure.
Do developers pay extra for the Agents API?
No extra fee is charged for the harness itself during the public beta, according to MarkTechPost. Developers pay standard API usage costs, though long-term pricing beyond the beta has not been confirmed.
Can developers create subagents and run them in sandboxes?
Yes. The DataStudios analysis lists subagents and hosted sandboxes as first-class features of the API, alongside cloud agents, MCP tools, context compaction, and long-running execution. Subagents handle delegated tasks while the parent agent aggregates results.
Summary
OpenAI’s Agents API public beta, launched September 10, 2026, turns the Codex harness into a managed service for every developer.
Key takeaways:
- The orchestration layer is gone. Execution loops, sandboxing, retry logic, and state management are handled by the same infrastructure that runs Codex.
- Compaction enables long-running work. Agents can operate for hours across large tasks without overflowing the context window, with summarization managed automatically.
- The feature set is concrete: cloud agents, hosted sandboxes, subagents, MCP tools, and compaction, all behind a single API call.
- Trade-offs remain. Beta pricing may change, and heavy reliance on managed infrastructure creates real lock-in.
If you are building agents this year, evaluate the beta against a scratch-built baseline and let the maintenance math decide.