If you've spent the last year putting together OpenAI's Responses API to a homemade orchestration loop, a sandbox provider, and a retry-handling script that nobody quite trusts, OpenAI has just taken a chunk of that plumbing off of your plate.
On September 10, 2026, OpenAI released its Agents API to all developers in public beta: a managed, hosted version of the same Codex harness powering its internal coding and research agents. Teams evaluating whether to build this kind of workflow in-house or bring in dedicated AI agent development expertise now have a genuine managed alternative to weigh against a custom build.
This blog covers what exactly this is, how it compares to the other three OpenAI APIs claiming the word "agent," its cost, and what to watch out for before pointing production traffic towards it.
Why This Matters Right Now
The timing is not incidental: OpenAI's original stateful-agent primitive, the Assistants API, stopped accepting requests on 26 August 2026; threads and runs now return errors instead of executing anything.
Teams that built on top of Assistants have spent the year migrating off of it, mostly onto the lighter, stateless Responses API. But Responses was never a good fit for agents that need to run for minutes or hours, touch a sandbox, recover from a dropped connection, and hand subtasks off to other agents.
Teams that were building such workloads are now left to cobble them together on top of Responses, usually with a framework like LangGraph or CrewAI filling the orchestration void.
What the Agents API Actually Is
Strip away the marketing, and the Agents API is organized around four primitives; understanding them up front will save you a re-read of the docs later.
Agent: the configuration object: which model, what instructions, which tools, and MCP servers it can reach.
Environment: the optional sandbox. Set it to none for agents that only call remote tools, openai_hosted for a managed sandbox with shell and file access, or self_hosted if you need the agent running on your own infrastructure.
Session: a durable, persistent instance of an agent. Unlike a stateless chat completion, you don't replay the whole conversation on every call; you send new input to the same session ID.
Events and items: events are the live stream of what's happening as the agent works; items are the saved record (messages, tool calls, outputs) you can retrieve later, even after a stream disconnects. Teams building this kind of session management from scratch often find it faster to bring in an agentkit builder specialist than to reverse-engineer the patterns themselves.
A session is processed in turns. Sending a message to an idle session will create a new turn; sending a message to a session that is waiting for a turn will steer it away from the previous path, not queue behind it.
This distinction is important, as it makes it possible to redirect the agent's work during the turn instead of waiting for it to finish.
Agents API vs. Responses API vs. Assistants API vs. Agents SDK
OpenAI now has four surfaces that all touch the word "agent," and picking the wrong one costs real integration time. Here's how they actually differ as of September 2026:
| Surface | Status | State management | Best for |
|---|---|---|---|
| Assistants API | Retired Aug 26, 2026 | Hosted threads/runs | Nothing, migrate off it |
| Responses API | Recommended default | Server-side, via previous-response chaining or the Conversations API | Single-turn or lightly-stateful calls; teams that want to hand-roll their own orchestration |
| Agents API | Public beta since Sept 10, 2026 | Durable sessions, managed by OpenAI | Long-running, multi-step agents that need sandboxes, recovery, and subagents |
| Agents SDK (open-source) | Actively maintained | You manage state in your own process | Teams who want an orchestration framework but full visibility into every decision |
The practical trade-off is control versus plumbing. If you're already running LangGraph or a hand-built loop on top of Responses, the Agents API doesn't obsolete that setup but it does absorb a significant chunk of the value proposition of those tools: session persistence, context-window management, and delegating subtasks to secondary agents. Whichever direction you lean, the underlying orchestration work often overlaps with broader workflow automation initiatives that teams already have on their roadmap.
You're giving up some visibility into orchestration decisions to avoid maintaining that orchestration code yourself.
One migration note: if you have Assistants API code still lying around, do not try to map threads and runs to sessions and turns on a field-by-field basis.
The shapes don't match, and mechanical porting tends to introduce subtle bugs. It's a rewrite of your orchestration layer, not a rename.
What It Actually Costs
| Model | Input / 1M tokens | Cached input / 1M | Output / 1M tokens |
|---|---|---|---|
| gpt-6-astra (default) | $10.00 | $1.00 | $50.00 |
| gpt-5.6-sol | $4.00 | $0.40 | $20.00 |
| gpt-5.6-terra | $2.00 | $0.20 | $12.00 |
| gpt-5.6-luna | $0.20 | $0.02 | $1.20 |
The practical trade-off is control versus plumbing. If you're already running LangGraph or a hand-built loop on top of Responses, the Agents API doesn't obsolete that setup, but it does absorb a significant chunk of the value proposition of those tools: session persistence, context-window management, and delegating subtasks to secondary agents.
You're giving up some visibility into orchestration decisions for getting to not maintain that orchestration code yourself.
One migration note, if you have Assistants API code still lying around, is to not try to map threads and runs to sessions and turns on a field-by-field basis.
The shape doesn't correspond, and mechanical porting tends to produce subtle bugs. It's a rewrite of your orchestration layer, not a rename.
What's In Scope: Environments, Tools, and Subagents
Three environment types cover most use cases, none of which skip the sandbox entirely, and are the cheapest option, right for agents that only need to call remote tools like web search or an MCP server.
openai_hosted gives the agent shell access, file editing, and code execution in a managed sandbox, and is the default for coding assistants and data-analysis agents.
self_hosted puts the agent on your own infrastructure or private network, which is the option that's worth reaching for if the agent needs to access internal systems or have specific compliance controls, at the cost of owning provisioning and reconnection yourself.
On tools, the Agents API supports the same categories as Responses: function tools you host and execute yourself, OpenAI's built-in web search, and Model Context Protocol server connections. Wiring these tool calls into your existing backend is typically where API development work becomes the bottleneck, not the model configuration itself.
It also adds a native programmatic_tool_calling mode that allows the harness to invoke certain tools without a full model round-trip on every call, lowers both latency and token spend on tool-heavy agents.
Subagent delegation is the newly introduced capability here. Better formatting: multi_agent.enabled on an agent's config, and it can split a task into independent pieces and run them concurrently. OpenAI's own example is comparing release notes across several versions of a library and merging the findings into a single answer.
That's a win on tasks that can parallelize themselves well; it's a waste of token spend on a single linear task, where running four subagents just multiplies the bill to answer something one agent could have handled.
Six Things to Decide Before You Build
Do you need a sandbox at all? If the agent only calls remote tools, set the environment.type to none. It's cheaper and removes a whole class of sandbox failure modes.
Which model actually needs to be gpt-6-astra?
Reserve the flagship model for tasks where getting it wrong is expensive. Route routine work to gpt-5.6-terra or gpt-5.6-luna.
Streams or webhooks for monitoring?
Open streams don't survive a process restart, a deploy, or a load-balancer timeout. For anything long-running in production, build around items and webhooks, not a held-open stream connection. This is the same class of reliability problem that DevOps consulting teams deal with daily, and the answers tend to look similar: durable state, observability, and a recovery plan that doesn't depend on a live connection.
Does the task actually parallelize?
Multi-agent delegation earns its cost on independent subtasks. On a single linear task, it's overhead.
What's your recovery plan for a dropped connection?
Streams don't replay missed events. Retrieving the session's saved items to see what already happened, not blindly resending the original request, is how you avoid duplicate turns.
Does your compliance posture allow US-only data residency?
As of this beta, the Agents API supports US data residency only and does not support Zero Data Retention, even with a self-hosted sandbox. That rules it out today for some regulated workloads regardless of technical fit.
Where RejoiceHub Fits
RejoiceHub is not going to sell you a wrapper around this API; we're going to develop, deploy, and maintain agents on top of it (or whatever other underlying technology stack is appropriate for the type of workloads you have; the Agents API is probably not what you want to use yourself). There are three broad ways for you to engage with us:
Fixed-scope build: a defined agent (support triage, internal research assistant, code-review bot) shipped to production with monitoring in place, priced against a defined set of tools and environments, drawing on our broader generative AI development work where it's a good fit.
Staff-augmentation / embedded engineering: our engineers work inside your existing agent roadmap on a monthly retainer, useful when you already have infrastructure and need hands to extend it, including teams that need dedicated machine learning development support alongside the agent work itself.
Strategy and architecture review: a shorter engagement to evaluate whether a managed harness like this one, an open-source framework, or a hybrid approach fits your compliance and cost constraints before you commit engineering time, run through our AI strategy consulting practice.
The cost will be based on the scope of the task, the environments required (if any), and potential self-hosting requirements for regulatory reasons.
Please reach out to RejoiceHub's AI strategy consulting team for a scoped estimate rather than a generic number, as a non-environment research agent versus a self-hosted, sandboxed coding agent will have vastly differing cost profiles on the same model.
An Honest Landscape Check
The Agents API is not the only way to build production agents in 2026, and it will not be a good fit for many teams.
If you need full visibility into every orchestration decision, or you are already heavily invested in LangGraph, CrewAI, or a home-rolled loop over the Responses API, this managed harness makes you less successful than you would be in your existing stack. Teams in that position are often better served by open-source consulting support to strengthen what they already have rather than a wholesale switch.
If your compliance requirements include Zero Data Retention or non-US data residency, this API is not an option, at least as of the time of writing. This API is still changing rapidly (it is, as of this writing, three days old), and SDK method signatures and event-type names are likely to change quickly (more quickly than a well-established and well-documented general-purpose API would).
Real value proposition: teams that are exhausted by writing their own context-compaction and recovery logic, teams that need to implement subagent delegation, and teams that are using OpenAI models anyway and have no particular reason to want to write their own orchestration layer.
Production Checklist: Security, Monitoring, and Beta Caveats
Before you point real user traffic at an agent built on this API, work through this list:
Scope your API keys: Generate project-scoped keys with only api.agents.read, api.agents.write, and api.responses. Never reuse an org-wide key for agent workloads, since a code-executing agent is a bigger blast radius than a normal completion call.
Keep credentials out of the sandbox: If the agent can read its own API key, a prompt injection through a fetched web page or a tool result could exfiltrate it.
Build recovery around items, not streams: A dropped connection doesn't mean a failed turn, retrieve the session's saved items before deciding whether to resend anything.
Don't trust an idle session as a success signal. agent.session.idle only means the agent stopped working, not that it succeeded. Check for agent.session.turn.completed and inspect the actual output.
Set a webhook, not just an open stream, for anything long-running. Streams don't survive deploys or load-balancer timeouts; sessions and their items do.
Confirm data residency and retention requirements before you build anything regulated. US-only residency and no ZDR support are current, hard limits of the beta.
Run a batch of representative test inputs before shipping. Check three things independently: did the turn complete, did the tool calls inside it succeed, and does the output hold up to a human reviewer? Silent partial failures are the easiest failure mode to miss here.
Conclusion
The Agents API does not limit what is possible with the models at OpenAI; instead, it limits who must build and maintain the plumbing around them. For teams that do not want to maintain their own session persistence, context management, and subagent orchestration, it is an engineering-time win.
For teams with particularly strict compliance requirements or a substantial investment in their orchestration infrastructure, it is worth considering before any migration efforts commence.
If you are trying to determine which category you fall into, RejoiceHub scopes agent architecture decisions such as this one for a living, get in touch before committing a sprint to the wrong stack.
Frequently Asked Questions
What is the OpenAI Agents API?
It's a managed, hosted way to build AI agents. It gives you sessions, sandboxes, and built in tools so you don't have to build your own orchestration layer from scratch.
When did OpenAI release the Agents API?
OpenAI released the Agents API to all developers in public beta on September 10, 2026. It runs on the same harness that powers OpenAI's own coding and research agents.
What happened to the Assistants API?
The Assistants API stopped taking new requests on August 26, 2026. Threads and runs now return errors, so any app still using it needs to move to a different setup.
How is the Agents API different from the Responses API?
The Responses API is stateless and works well for single turn calls. The Agents API adds durable sessions, sandboxes, and recovery tools built for long running, multi-step agents.
What is a session in the Agents API?
A session is a durable, ongoing instance of an agent. Instead of resending the whole conversation each time, you send new input to the same session ID to continue.
Does the Agents API support subagents?
Yes. Turning on multi agent settings lets an agent split a task into smaller pieces, run them at the same time, then combine the results into one final answer.
How much does the Agents API cost?
Pricing depends on the model you pick. The flagship model costs more per token, while lighter models cost a fraction of that, so routine tasks can run much cheaper.
Does every agent need a sandbox?
No. If an agent only calls remote tools, you can skip the sandbox entirely. Sandboxes only matter when an agent needs to run code, edit files, or use a shell.
9. Does the Agents API support Zero Data Retention?
No, not yet. As of this beta, the Agents API supports US only data residency and does not offer Zero Data Retention, even if you use a self hosted sandbox.
10. Should I migrate straight from the Assistants API to the Agents API?
Not by mapping fields one to one. Threads and runs don't match sessions and turns, so treat the move as a rewrite of your orchestration layer, not a simple rename.
