OpenAI Launches the Agents API: What Managed AI Agents Mean for Your Business

For the past year, every company that wanted its own AI agent had to build a surprising amount of plumbing first. The model was the easy part. The hard part was everything around it: keeping context under control, coordinating tools, restarting broken sessions, and stitching together sandboxes where the agent could actually run code. On 10 September OpenAI removed most of that work in one move. The new OpenAI Agents API, now in public beta, packages the same harness and execution infrastructure that powers Codex and hands it to any developer behind a single API call.

This is a bigger deal than another model release. Models change every few months, but infrastructure decisions stick. If the managed approach works the way OpenAI promises, a two-person team will be able to ship the kind of agent product that used to need a dedicated platform squad.

In this post we look at what the Agents API actually includes, what it costs, where the limits are, and what a business that is planning agent features should do with this news.

What the OpenAI Agents API actually is

The short version: it is Codex without the coding assistant on top. OpenAI has been running long-lived, tool-using agents in production for a while, and the Agents API exposes that runtime as a managed service. Orchestration, context management, tool coordination and subagent delegation all move from your application code into OpenAI's hosted infrastructure.

In practice you create a session, give the agent a task, and the service handles the rest. Sessions are durable, so an agent can work on something for hours or days, report progress, accept new instructions midway, and pick up where it left off. OpenAI says a basic agent can be spun up in under a minute, and from the early demos that claim looks fair.

The point to understand is that this is a different product from the Agents SDK that OpenAI shipped back in April. The SDK gives you harness code to run and modify yourself. The API gives you the harness as a service. Teams that want full control will keep the SDK; teams that want to ship fast will likely pick the API.

Sandboxes: hosted, self-hosted, or through a partner

Agents are only useful when they can actually do things, and doing things means executing code somewhere. The Agents API offers three options here. The default is an OpenAI-hosted sandbox, the same isolated environment Codex and ChatGPT use, with configurable files and packages. For teams with stricter requirements there is a self-hosted route, where the agent connects to your own infrastructure over a WebSocket. And there is a partner list that is honestly the most interesting part of the launch: Cloudflare, Vercel, DigitalOcean, Modal, E2B, Daytona, Runloop, Blaxel and Oracle all ship first-class integrations on day one.

That partner list tells you where this is going. OpenAI is not trying to own the compute layer; it wants to own the orchestration layer and let the rest of the industry plug in underneath. For businesses already running on Cloudflare or Vercel, the practical result is that agent execution can live next to the rest of your stack instead of in yet another vendor's cloud.

One caution: unsandboxed execution is also supported, and it should be treated with the respect it deserves. An agent with direct access to a production machine is a risk you take deliberately or not at all.

Subagents and the end of hand-rolled orchestration

The feature that will save teams the most engineering time is built-in subagent support. A main agent can split a complex job into independent pieces, hand each piece to a subagent with its own separate context, then collect and combine the results. The current configuration allows up to three concurrent subagents per session.

Until now this pattern meant writing your own scheduler, your own message passing, and your own failure handling. Plenty of teams did it, and plenty of teams got it subtly wrong. Early customers quoted in the launch coverage suggest the managed version holds up: one company reported evaluation scores rising from 0.71 to 0.85 after moving to the API, with subagent latency cut roughly four times, and another cut cost per case on review workflows by 60 percent.

The other quiet improvement is automatic context compaction. Long sessions eventually outgrow the model's context window, and every serious agent team has written some version of summarise-and-truncate logic to cope. The Agents API now does this automatically as a session approaches its token limits. It is not glamorous, but it removes one of the most common sources of weird agent behaviour in production.

What it costs and where the limits are

The pricing model is refreshingly simple: there is no separate fee for the Agents API at all. You pay for model tokens, tool usage and container time, exactly as you would if you had built the harness yourself. To give a sense of scale, the flagship gpt-6-astra model runs at 10 dollars per million input tokens and 50 dollars per million output tokens, and sandbox compute is metered on top.

Simple does not mean cheap, though. Agents burn tokens in a way chat interfaces never did. A single long-running session with a few subagents can chew through millions of tokens without anyone noticing, so budget alerts and per-session caps should be part of your setup from day one, not an afterthought.

The bigger constraints right now are about data. The beta runs with US data residency only, and Zero Data Retention is not supported. For a European business handling customer data, or anyone in a regulated industry, that is a real blocker rather than a footnote. OpenAI will presumably widen this over time, but today the Agents API is best suited to workloads where the data can legitimately live in the US.

The competitive picture

The launch did not happen in a vacuum. On almost the same weekend Salesforce pushed its Agentforce line to general availability with seven named agents and a new orchestration layer, and security vendors like Zscaler announced tooling for monitoring fleets of agents. Anthropic's CEO used the moment to call for the industry to slow down, warning about swarms of autonomous agents, while Nvidia's CEO countered that companies will eventually run hundreds of thousands of them.

Strip away the noise and the direction is clear enough. Every major vendor is converging on the same idea: agents as managed infrastructure rather than clever prompt engineering. For buyers this competition is good news. Twelve months ago building a serious agent meant a custom stack; now at least three credible vendors will run the hard parts for you, and prices will feel that pressure.

It also means the differentiation moves up a level. When everyone has access to the same managed harness, the value sits in your data, your workflows and your integration quality, not in the orchestration code itself.

Practical takeaways for businesses building digital products

If you are already running agents on your own stack, do not rush to migrate. The beta label is there for a reason, and your existing harness works. But it is worth running one real workload through the Agents API side by side and comparing cost, latency and failure rates. The early numbers suggest the managed version may win on all three.

If you have an agent project on the backlog, the calculation just changed. Features that were quoted at months of platform work, things like a support agent that investigates issues across your systems, or an internal research assistant that reads your documentation and drafts answers, are now mostly integration projects. Start with a narrow, well-bounded task, keep a human approving anything the agent wants to change, and measure before you expand.

And whatever you build, sort out governance early. Decide which systems an agent may touch, log every action it takes, and set spending limits per session. The Harness survey published this week found that 77 percent of enterprises claim a complete inventory of their agents while only 44 percent actually run active discovery. That gap between confidence and control is exactly where incidents come from.

Final notes

The Agents API is OpenAI making a familiar move: take something only specialists could build, wrap it in an API, and let the market experiment. It worked for models, and there is little reason to think it will not work for agents. The beta restrictions on data residency will hold back some serious adopters for now, but the direction is set, and the cost of trying is close to zero because there is no platform fee.

Our advice is to treat this quarter as the time to run a pilot. Pick one process, give an agent a tightly scoped version of it, and learn how the economics and the failure modes look on your own workload. The companies that do that now will be choosing between mature options next year, while everyone else is still reading launch posts. If you would like help scoping or building that pilot, this is exactly the kind of project we work on at Davydov Consulting, and we are happy to talk it through.