OpenAI Agents API (Public Beta)

1. Introduction

1.1. Platform Positioning

OpenAI Agents API is managed Agent infrastructure that OpenAI announced entering public beta on 2026-09-10 (the release date follows the OpenAI official Changelog; the 2026-09-13 snapshot upgraded it from Grade-B media reporting to the Grade-A official source; the 2026-09-12 snapshot had recorded it as 09-11 based on media reports): it opens up the agent framework and infrastructure previously used only to power Codex and enterprise ChatGPT to all developers through a programming interface. Developers pay no additional fee for the API itself; billing is based only on tokens actually consumed and tool calls made. The same page of the official Changelog confirms: public beta requests carry the OpenAI-Beta: agents=v1 header; data residency is currently limited to the United States, and zero data retention (ZDR) is not supported.

Its product semantics can be summarized as a "hosting leap": a single API call creates a production-grade agent — specify the task, model, tools, and runtime environment, with no need to build underlying infrastructure such as context management or sub-agent orchestration yourself. This marks a shift in the focus of OpenAI's agent product line: from platform-style builder tools (Agent Builder / Evals, announced to be shut down on 2026-11-30) toward infrastructure APIs.

1.2. Basic Information Card

1.3. Development Timeline

1.4. Relationship to the Existing 02-openai-agents-sdk.md (Cross-reference)

OpenAI currently has two parallel agent product lines; the two do not overlap and do not replace each other, and must be clearly distinguished:

In short: the SDK is "writing Harness into your code," while the Agents API is "buying Harness as a service". The two can be combined — an agent orchestrated with the SDK can delegate long-running execution to the Agents API's managed runtime. This page does not repeat the SDK's capability details; it focuses on the managed runtime itself.

2. Glossary

3. Feature Description

3.1. Three Core Capabilities

The three capabilities announced by OpenAI form the functional backbone of the Agents API:

1. Context auto-compaction: as a session approaches the context window limit, the system automatically compacts earlier content, allowing an agent to keep running for hours or even days — shifting "long-session management" from a developer responsibility to a platform responsibility;
2. Tool search and parallel calls: relevant tool definitions are loaded on demand to reduce token consumption (tool definitions are no longer injected in full), and multiple tool calls can run in parallel;
3. Multi-agent orchestration: the main agent breaks down complex tasks and dispatches them to multiple sub-agents running in parallel; each sub-agent maintains its own context, and the main agent ultimately consolidates the results.

What the three share in common: all are "server-side versions of Harness-layer capabilities" — corresponding respectively to L1 (compaction), L2 (tool scheduling), and L3 (orchestration) in the six-layer model.

3.2. Compute Environment and Ecosystem Partners

• Hosted sandbox: shares the same sandbox infrastructure as Codex and ChatGPT, with fast startup and elastic scaling;
• First-party ecosystem integrations: Blaxel, Cloudflare, Daytona, DigitalOcean, E2B, Modal, Oracle, Runloop, Vercel, and others provide differentiated options including private-cloud deployment, specific storage mechanisms, and different CPU / GPU / memory configurations;
• Official positioning: covering the full spectrum of needs from rapid validation by startups to enterprise-grade production deployment.

3.3. Built-in Tools and Protocol Support

• MCP protocol: native support for integrating external tools;
• Custom functions: developers register custom function tools;
• Web search: a built-in search tool;
• Tool definitions are loaded on demand through the tool search mechanism to control context overhead.

3.4. Open-Source Codex Execution Framework

• The Agents API is built on the open-source Codex execution framework: the core logic for model calls, tool coordination, and context management can be inspected in a public codebase;
• OpenAI maintains and continuously optimizes the framework, so developers automatically benefit from every model upgrade without having to refactor their own agent architectures;
• The "open-source inspectable + hosted runtime" combination is a trust design: the logic is transparent and auditable, while operations are left to the vendor.

4. Platform Architecture

4.1. Server-Side Runtime Layers

1. API layer: creates an agent with a single call (task, model, tools, and runtime environment — four elements);
2. Orchestration layer: multi-agent orchestration (main agent decomposes, sub-agents run in parallel, results are consolidated);
3. Execution layer: hosted sandbox (sharing Codex / ChatGPT's origins) + differentiated ecosystem-partner environments;
4. Context layer: automatic compaction and on-demand assembly of tool search;
5. Tools layer: MCP, custom functions, web search;
6. Model layer: the OpenAI model family (framework and model upgrades are decoupled, so you benefit automatically from upgrades).

4.2. Execution Flow of a Multi-Agent Orchestration Task

1. The developer creates an agent with a single API call, specifying the task, model, tools, and runtime environment;
2. While the agent runs, the context is automatically compacted as it approaches the window limit;
3. The main agent breaks down the task and dispatches multiple sub-agents to run in parallel;
4. Each sub-agent runs in an independent context and loads tool definitions on demand via tool search;
5. Tool calls (MCP / custom functions / web search) run in parallel;
6. Sub-agent results are returned, and the main agent consolidates the output;
7. Long-running execution (hours to days) is continuously carried by the hosted sandbox, with no developer intervention required.

5. Harness Design

5.1. Overview of the Six-Layer Capabilities

5.2. L1 Context Engineering Layer

• Automatic compaction is this platform's L1 cornerstone: compaction is triggered and executed automatically by the system with zero developer configuration — forming a three-tier comparison with Claude Agent SDK's Compaction (intervenable) and LangGraph's "no built-in compaction, you must build it yourself": OpenAI is the least effort but offers the least control;
• Tool search is a cross-cutting innovation between L1 and L2: tool definitions are loaded on demand rather than injected in full, directly compressing the static overhead in the context — a significant cost optimization for agents with many tools (dozens of MCP tools);
• The details of the compaction policy (when to compact, what to keep, whether it can be intervened with) are not public, marked [To be verified].

5.3. L2 Tools and Execution Layer

• The sandbox is the biggest selling point: the sandbox infrastructure shared with Codex / ChatGPT means "an execution environment that OpenAI itself has validated at scale in production" — a credibility asset that other hosted products would find hard to replicate;
• Parallel tool calls reduce latency on long-running tasks;
• The ecosystem-partner matrix (E2B, Daytona, Modal, Vercel, etc.) offers differentiated environment choices beyond the sandbox — developers can choose their execution location by storage and CPU / GPU configuration;
• In-group comparison: AgentCore's strengths lie in microVM isolation and the enterprise tool gateway, while the Agents API excels at the sandbox's "same-origin production validation" and the breadth of its partner ecosystem.

5.4. L3 Orchestration and Control Layer

• Single-call agent creation pushes the startup cost of orchestration to its minimum: the four elements of task, model, tools, and environment are declared in one call;
• Multi-agent orchestration follows the "main agent decomposes → parallel sub-agents → independent contexts → main-agent consolidation" pattern — isomorphic to AgentCore's Supervisor pattern, but emphasizing sub-agent context isolation (to avoid context crosstalk);
• Orchestration happens server-side, so the control flow is not programmable by developers (unlike the in-code handoff of the SDK) — a trade-off of flexibility for peace of mind;
• Interruption, resume, and human-in-the-loop (HITL) primitives do not appear in public materials, marked [To be verified].

5.5. L4 Memory and State Layer

• Long-running agents (hours to days) have their state continuously carried by the managed runtime, and the Nash case demonstrates the feasibility of "thousands of long-running agents";
• Public details on cross-session memory, checkpoints, and pause-and-resume are missing, marked [To be verified];
• In-group comparison: not as mechanism-based as LangGraph's Checkpointer / Time Travel; state management exists in the form of a "managed black box + automatic compaction".

5.6. L5 Evaluation and Observability Layer

• Public materials describe evaluation and observability capabilities only to a limited degree, marked [To be verified];
• Key background: OpenAI's Evals platform capabilities will go offline on 2026-11-30 (shut down in the same batch as Agent Builder), meaning OpenAI's investment in L5 productization is contracting — evaluation capabilities will need to be filled by external solutions (LangSmith, Langfuse, etc.) in the short term;
• The "evaluation scores" in customer cases (Cirridae 0.71→0.85) show the platform can support evaluation workflows, but the productized form has not been made public.

5.7. L6 Governance and Security Layer

• Sandbox isolation is the foundation of governance: the execution environment is isolated from the host and shares Codex / ChatGPT's origins;
• Continuation of enterprise governance: the Agents API inherits enterprise ChatGPT's agent infrastructure, and enterprise-grade governance capabilities (permissions, audit) are expected to carry over in part; beta-period details are not fully disclosed, marked [To be verified];
• Cost governance: usage-based billing is transparent by nature, but there is no public statement about hard budget guardrails;
• A noteworthy product-governance signal: shutting down Agent Builder / Evals and pivoting to an infrastructure API is itself a contraction decision by OpenAI on "governance of the agent product line" — supplier-direction risk should be factored into vendor selection.

5.8. Multi-Agent Orchestration and Sandbox Illustration

Figure 21-1 | Agents API multi-agent orchestration and the hosted sandbox

Data source: OpenAI's release statement (as relayed by outlets such as Wallstreetcn (华尔街见闻), 2026-09-11); illustrative.

6. Real-World Cases

Case 1: Early-customer quantitative data (vendor-disclosed basis)

The above are vendor-disclosed, media-relayed figures with no third-party independent verification; please note this when citing.

Case 2: Codex's large-scale production validation (background basis)

Agents API's sandbox and execution framework share Codex / ChatGPT's origins — Codex, as OpenAI's flagship programming assistant, has been running at large scale in production internally, and "a Harness that has been validated by its own vendor" is the credibility foundation that distinguishes it from startup hosted platforms.

7. Summary

7.1. Strengths

1. Extremely low barrier to entry: a single API call creates a production-grade agent, with context management and sub-agent orchestration fully managed;
2. L1 automation: automatic context compaction + on-demand tool search loading keep costs manageable for long sessions and many-tool scenarios;
3. Sandbox credibility: a production-grade execution environment sharing Codex / ChatGPT's origins;
4. Multi-agent orchestration: a clear orchestration pattern of parallel sub-agents + independent contexts + main-agent consolidation;
5. Open-source, inspectable framework: the Codex execution framework's code is public, its logic is auditable, and you automatically benefit from model upgrades;
6. Ecosystem-partner matrix: nine first-party integration partners covering differentiated compute environments;
7. No-barrier usage-based pricing: the API itself is free of charge, tied directly to usage.

7.2. Weaknesses

1. Beta-period uncertainty: features, pricing details, and regional restrictions are not fully disclosed, and the conditions for GA are unknown;
2. L5 contraction background: the Evals platform goes offline on 2026-11-30, so evaluation capabilities must be filled externally;
3. Non-programmable orchestration: the control flow runs in a server-side black box, with no public statement on interrupt / HITL primitives;
4. Missing L4 details: checkpoint and cross-session memory mechanisms are not public;
5. Product-line contraction risk: the shutdown of Agent Builder / Evals shows OpenAI's agent product line is still being adjusted quickly, and the long-term direction requires continued monitoring;
6. Vendor lock-in: sandbox, compaction, and orchestration are all tied to OpenAI infrastructure.

7.3. Applicability Boundaries

7.4. Selection Recommendations

• Decision vs. your own Agents SDK (02-openai-agents-sdk.md): choose the SDK for code-level control and the Agents API for operations-free hosting; the two can be combined;
• Decision vs. AWS AgentCore (15-aws-agentcore.md): choose the Agents API for the OpenAI stack and GPT models, and AgentCore for multi-framework, multi-model and AWS-ecosystem scenarios;
• Decision vs. Mistral Agents API (18-mistral-agents-api.md): choose OpenAI for deep long-running-agent and sandbox support, and Mistral for EU data sovereignty;
• Beta-period adoption advice: validate on non-critical-path tasks and closely track the GA terms and the evaluation alternatives after Evals' retirement (2026-11-30).

Information Gap Statement

1. Original official release: the original URL of OpenAI's official blog post was not directly verified (media reposts were verified), marked [To be verified].
2. Beta scope and restrictions: regional restrictions, rate limits, and SLA are not fully disclosed, marked [To be verified].
3. Pricing details: the specific unit price table for "billing by tokens and tool calls" is not fully disclosed, marked [To be verified].
4. L4 state management: checkpoint, pause-and-resume, and cross-session memory mechanisms are not public, marked [To be verified].
5. L5 evaluation form: the solution for carrying evaluation capabilities after Evals' retirement is not public, marked [To be verified].
6. L6 governance details: beta-period permission, audit, and budget-guardrail details are not fully disclosed, marked [To be verified].
7. Customer data: SafetyKit / Hypha / Cirridae / Nash figures are vendor-disclosed and have no third-party independent verification.

8. References

1. OpenAI launches the Agents API in public beta, opening Codex's underlying infrastructure to developers — Wallstreetcn (华尔街见闻, via NetEase repost), 2026-09-11. https://www.163.com/dy/article/L6H2UMJ505198NMR.html
2. OpenAI API Changelog (2026-09-10 entry: Released the Agents API in public beta) — OpenAI official developer documentation, 2026-09-10 (verified against the 2026-09-13 snapshot, Grade A). https://developers.openai.com/api/docs/changelog
3. OpenAI — official website. https://openai.com
4. OpenAI Platform — developer documentation. https://platform.openai.com/docs
5. Codex — OpenAI open-source execution framework codebase. https://github.com/openai/codex
6. Introducing Codex — OpenAI official blog, 2025-05. https://openai.com/index/introducing-codex/
7. E2B — ecosystem-partner website (open-source sandbox infrastructure). https://e2b.dev/
8. Daytona — ecosystem-partner website (compute environment). https://www.daytona.io/
9. Modal — ecosystem-partner website (compute environment). https://modal.com/
10. R18-IDE-Agents-Supplemental platform research report — this project's internal research report (AG-7 key fact card).