OpenAI's new secret weapon has just been released

The release: Codex is no longer just an app

OpenAI’s new secret weapon is not a single model. It is the managed layer around the model. On September 10, 2026, OpenAI introduced the Agents API in public beta, describing it as a way to build and run cloud agents with the Codex harness fully managed by OpenAI [1]. The practical meaning is straightforward: developers can now access, through an API, the orchestration infrastructure that OpenAI built to make Codex useful for long-running software tasks.

That is why the announcement matters. For years, the AI platform race has been framed as a contest over benchmark scores, context windows and price per token. The Agents API shifts attention upward in the stack. The question is no longer only “which model is smarter?” It becomes “which provider can keep autonomous work alive, observable, safe enough and economically efficient while it calls tools, edits files, delegates subtasks and survives failures?”

The official launch page says the API brings to developers the same harness and infrastructure that powers Codex through a simple, flexible API [1]. OpenAI’s developer documentation frames the product more explicitly: the Agents API gives applications access to the Codex harness through an OpenAI-managed API, while OpenAI manages sessions, orchestration, context compaction and recovery [2]. In other words, OpenAI is productizing the execution loop.

What developers actually get

A traditional model endpoint answers a request. An agent runtime has to do much more. It needs to maintain task state, decide when to call tools, process tool results, recover from interruptions, manage context and, increasingly, coordinate multiple specialized workers. OpenAI’s documentation says agents can operate in sandboxes where they execute code, edit files, connect to MCP servers and produce artifacts [2].

The architecture is built around four concepts: an agent, an environment, a session, and events or items [2]. The agent holds the model, instructions, tools and MCP servers. The environment is the sandbox or computer where the agent can access files and run commands. The session is the durable unit of work. Events and items provide the record of what happened during the session. That is a major distinction from one-shot chat completions: the developer is no longer expected to rebuild the entire working memory and tool loop on every request.

OpenAI’s launch example shows a session created by specifying a task, model, tools, vaults and an environment, including a multi-agent configuration with max_concurrent_subagents [1]. The point is not the syntax. The point is the contract. The developer describes the work and the allowed capabilities; OpenAI runs the harness that moves the job forward.

Independent summaries of the release converge on the same interpretation. AI Weekly described the public beta as exposing a managed Codex harness that handles sessions, orchestration, context compaction and recovery, while developers provide tools and choose execution environments [3]. The Agent Times described the service as a managed cloud layer with session management, multi-agent support, MCP integration and sandboxed execution, without a separate platform fee beyond token, tool and container usage [5].

Why the sandbox choice matters

The most important design decision may be the separation between the harness and the execution environment. OpenAI says developers can choose where the agent runs: in an OpenAI-managed sandbox, on their own infrastructure, or with sandbox partners [1]. The named ecosystem partners include Blaxel, Cloudflare, Daytona, DigitalOcean, E2B, Modal, Oracle, Runloop and Vercel [1].

That flexibility is more than a procurement feature. It addresses the central tension of autonomous agents: to be useful, they need access to files, packages, secrets, repositories and internal systems; to be safe, they need hard boundaries. The API therefore treats the sandbox as the blast-radius boundary, while the harness remains the managed intelligence layer.

For fast prototyping, OpenAI-hosted sandboxes offer the lowest-friction path. OpenAI says these sandboxes use infrastructure that also powers Codex and ChatGPT, and can be configured with files, packages, skills and plugins [1]. For regulated or security-sensitive workloads, self-hosted or partner environments may be more attractive because they allow companies to keep execution closer to existing infrastructure and controls. But the trade-off is not eliminated: OpenAI’s documentation says the Agents API currently supports data residency only in the United States and does not support Zero Data Retention, even when developers choose a self-hosted sandbox [2].

That limitation is likely to shape early enterprise adoption. A team building an internal incident-response bot in a U.S.-only environment may accept the beta constraints. A bank, healthcare provider or European public-sector customer may need to wait for broader residency and retention controls. The beta is public, but production readiness will vary sharply by use case.

The multi-agent turn

The release also marks the normalization of multi-agent work. OpenAI says the Agents API can break complex tasks into independent pieces and delegate them to subagents that work in parallel, each with its own context, while the main agent coordinates the results [1]. The developer docs say delegation is enabled through agent.multi_agent.enabled, and that the harness supplies the tools to create, message, wait for and interrupt subagents [2].

This is a meaningful abstraction. Before this kind of managed runtime, teams that wanted parallel agents often had to build their own scheduler, queue, state store, message protocol and observability layer. Now, OpenAI is packaging that pattern as a native capability. The default concurrency setting for subagents is documented as six, excluding the coordinator, and developers can set a positive integer limit when delegation is enabled [2].

The immediate use cases are obvious: compare release notes, inspect different failure causes, review separate documents, test multiple hypotheses, or split a codebase migration into independent tracks. The deeper implication is bigger. If agentic work scales through parallelism, then the runtime that coordinates agents becomes a strategic asset. Model quality still matters, but orchestration becomes the multiplier.

The economics of “free” infrastructure

OpenAI says there are no additional fees for using the Agents API itself; developers pay for tokens and tools, and OpenAI-hosted sandboxes use standard container rates [1]. The documentation similarly says model usage is billed at selected API rates, OpenAI tools at standard rates, and OpenAI-hosted sandboxes at container rates [2].

That pricing model is powerful. By not charging an obvious platform fee for the harness, OpenAI lowers the psychological barrier for developers to try it. But it also moves spending into the areas that can expand quickly: model calls, tool calls and runtime. The New Stack framed the launch as OpenAI opening the backend behind Codex to developers looking to run agents unattended for days [4]. That “for days” phrase is the economic hinge. A durable agent that keeps working can create value, but it can also consume compute continuously.

This is why observability, spend limits and governance will become as important as prompt design. Once agents are no longer short conversations but persistent workers, companies will need cost attribution, audit trails, approval gates and failure analysis. The Agents API is therefore not only a developer convenience; it is also a new surface for platform engineering.

Open source, lock-in and the new platform race

OpenAI says the Agents API is powered by the open-source Codex harness, giving developers visibility into the core logic that coordinates model calls, tools and context, while OpenAI operates and maintains the managed version [1]. This is a smart positioning move. It softens the perception that the runtime is a black box, while still making OpenAI the default operator of the most convenient hosted version.

The competitive message is clear. If the first phase of the generative AI race was models, the next phase is agent infrastructure. The winning platform may be the one that makes autonomous work reliable enough for business processes: not just generating code, but testing it, filing the result, explaining the change, asking for approval and resuming after interruption.

The Agents API does not remove the hard questions. It intensifies them. Who is accountable when a subagent makes a bad change? How should approvals be structured for production systems? What data can safely enter a managed session? When does a persistent agent become a privileged system user? These questions are not footnotes; they are the governance layer of AI version 2.0.

The bottom line

OpenAI’s release is important because it exposes the machinery behind the magic. Codex was already a signal that software work was moving from prompt-and-response toward delegated execution. The Agents API makes that pattern programmable for everyone with access to the beta.

The “secret weapon” is the harness: the managed loop that plans, calls tools, compacts context, recovers state and coordinates subagents. If developers adopt it, OpenAI will not merely sell intelligence by the token. It will operate the runtime where autonomous work happens.

That is the real shift. The agent era is not only about better models. It is about who runs the command center.

Sources from the last 72 hours

1. [1]Introducing the Agents APISep 10, 2026, 6:00 PM UTC
2. [2]Agents API | OpenAI APISep 10, 2026, 6:00 PM UTC
3. [3]OpenAI Ships Agents API in Public Beta, Exposing Managed Codex Harness With Sandbox and MCPSep 10, 2026, 10:56 PM UTC
4. [4]OpenAI’s researchers burned $7,000 a day on AI agents — now it’s opening the floodgatesSep 11, 2026, 9:27 PM UTC
5. [5]OpenAI Exposes Codex Agent Harness as Public API for Autonomous WorkflowsSep 11, 2026, 12:00 AM UTC

AI-generated article based on recent web research, then preserved as a dated editorial snapshot.