OpenAI has launched the Agents API in public beta, giving developers a managed way to build and run long-lived cloud agents using the same harness and infrastructure behind Codex.
A developer can define an agent's model, tools, environment, and task through a single API call. OpenAI then operates the orchestration layer that keeps the agent working: managing context, finding and calling tools, coordinating subagents, and connecting the agent to an execution environment where it can work with files, run code, and produce artifacts.
The product is the harness, not just the model
A capable model is only one part of a dependable agent. Long-running work also needs session state, context management, tool routing, isolated execution, recovery paths, and a way to split large tasks into focused pieces. Teams building those systems themselves can spend significant engineering time on infrastructure before reaching the workflow that differentiates their product.
The Agents API turns much of that infrastructure into a managed platform. OpenAI says it will maintain and evolve the harness alongside its models, while developers focus on proprietary tools, knowledge, interfaces, and business processes.
This builds on the architectural shift we explored in persistent agents becoming always-on digital teammates. The model may supply intelligence, but the surrounding harness determines whether that intelligence can remain coherent, use the right systems, and finish a real task.
Long sessions, large toolsets, and parallel agents
The API automatically compacts earlier context as a session approaches its limit, preserving the information needed to continue across multiple context windows. That removes one of the harder pieces of long-horizon agent engineering: deciding what to retain, summarize, or discard without breaking the task.
Tool search loads definitions only when they become relevant, reducing the context and cost burden of giving an agent access to a large catalog. Programmatic tool calling lets the agent execute calls in parallel, chain related operations, and filter results in code before returning only the useful information to its working context. Supported integrations include MCP servers, custom functions, built-in tools such as web search, skills, plugins, and vaults.
Multi-agent support gives the main agent another option: divide a complex job into independent assignments and delegate them to subagents with separate contexts. The primary agent remains responsible for coordination and synthesis, but developers no longer need to construct the entire delegation layer themselves.
Developers can choose where the work runs
Agent infrastructure is not one-size-fits-all. The Agents API can use an OpenAI-hosted sandbox, a self-hosted environment, or an integrated sandbox provider. That choice allows teams to balance setup speed with requirements around network access, secrets, data residency, specialized hardware, and infrastructure control.
OpenAI's hosted sandbox uses the same underlying environment technology as Codex and ChatGPT. It can be configured with project files, packages, skills, and plugins, giving an agent a managed workspace for code execution and artifact creation. Organizations with stricter or more specialized requirements can keep execution on their own infrastructure while still using the managed harness.
An open-source foundation with a managed path
The service is built on OpenAI's open-source Codex harness. Developers can inspect the public codebase and learn how the core loop coordinates model calls, tools, and context, while allowing OpenAI to operate and update the managed version.
That combination is strategically useful. Open source provides visibility into the orchestration logic; the API provides a supported path for teams that do not want to deploy and maintain every component themselves. It also lowers the risk of treating agent behavior as an opaque layer that can only be understood through prompts and outputs.
Why it matters for builders
The Agents API signals that the competitive unit in AI development is moving beyond the model call. Reliable context, effective tool use, controlled execution, delegation, and observability are becoming platform capabilities.
For product teams, this can shorten the path from prototype to a system that completes meaningful work. Instead of spending the first phase building a custom agent loop, a team can invest more of that time in workflow design, domain-specific tools, user experience, permissions, and evaluation.
The public-beta label still matters. Teams should expect changes and validate reliability, observability, security boundaries, failure recovery, and total execution costs before depending on the service for critical production workflows. Agents that run longer and use more tools create more opportunities for mistakes as well as more value, so approval gates and least-privilege access remain product requirements.
The larger direction is clear: OpenAI is turning the operational lessons behind Codex into reusable developer infrastructure. If the platform works as promised, building an agent may increasingly begin with defining the job and its environment—not rebuilding the loop that keeps it alive.