OpenAI's Agents API went to public beta on September 10. That's the short version. The longer version is more interesting: what OpenAI actually shipped is the internal infrastructure that's been running their own coding agents — the harness underneath Codex — opened up as an API any developer can call with a key.

That framing matters. This isn't a new product built for the announcement. It's infrastructure that already exists, already handles long-running multi-step tasks for OpenAI's own users, now made available for you to build on. The session management, crash recovery, context compaction across long tasks, sub-agent coordination, lazy tool loading — all of that runs in the same system.

The design choice I find most deliberate: OpenAI priced the compute explicitly. Model tokens are model tokens. Tool calls are tool calls. Container sessions are billed by the minute with four tiers. You know what you're paying for before you start.

That's a specific product philosophy. Anthropic's Claude Code Projects, which launched seven days later, went the other direction: wrap everything in the plan, no new billing surface. Both are legitimate bets. They produce different experiences for different builders.

How it works

Four concepts, and the API only exposes four: agent, environment, session, and events.

An agent is a model plus tools plus instructions. An environment is where the agent runs — either OpenAI-hosted (pick a partner sandbox) or your own infrastructure. A session is a durable instance of an agent working on a task: created, given a goal, streamed or webhooks for progress, continued or steered. Events are the observation surface — what the session emits while it works.

The API handles the things that make multi-step agentic work hard to build yourself: context compaction when a session runs long, crash recovery when a container goes down mid-task, sub-agent spawning when a task needs delegation, lazy tool loading to keep the context window clean. You don't implement any of that. You define the agent, point it at an environment, create a session, and listen to events.

The model default is GPT-6 Astra — OpenAI's current frontier model, priced at $10 per million input tokens and $50 per million output. You can swap the model at session creation. The harness runs on whatever model you specify.

Source spread

• OpenAI — Introducing the Agents API [hype] — the primary source; clear on the four concepts and the partner ecosystem; less explicit about pricing until you read the footnotes
• MarkTechPost — Agents API public beta launch [builder] — "putting the Codex harness behind one API call" is the accurate framing; covers the launch mechanics
• TokenCost — Agents API sandbox pricing breakdown [skeptic] — the source to read if you care about what the container tiers actually cost at volume
• AiCybr — Codex harness, hosted sandboxes, subagents [builder] — good on the technical architecture, especially the sub-agent coordination model

What's real:

• The harness abstraction is genuinely useful. Crash recovery, context compaction, and sub-agent coordination are the parts of long-running agent work that most builders get wrong. Having the API handle them removes a category of failure mode that shows up late in development, when you're debugging a 40-step task that dropped state at step 23.
• Nine partners is a meaningful ecosystem. Vercel, DigitalOcean, E2B, Cloudflare — these aren't bootstrap startups. The integration depth varies, but having production-grade options on day one of public beta means you're not forced to bring your own compute if you don't want to manage it.
• Explicit pricing is auditable. You can model your cost before you run. Four container tiers, billed by the minute with a 5-minute floor. For production automation at scale, this matters a lot. Surprising compute bills are one of the most common reasons AI agent projects get killed after the prototype.
• Bring-your-own compute is a real option. If you have strong opinions about your execution environment — specific GPU access, existing cloud commitments, latency requirements — you can wire your own infrastructure and use only the orchestration layer. The model billing stays, the sandbox billing disappears.

What deserves a side-eye:

• "No harness fee" is accurate but incomplete. Correct: there's no line item labeled "Agents API fee." What you're actually paying is model tokens at GPT-6 Astra rates ($10/$50 per Mtok) plus tool calls plus container session time. For a 20-minute session at the highest tier that's $1.92 in compute alone, before tokens. Model the full stack before committing a production run.
• The partner ecosystem quality is uneven. Nine integrations at launch is a lot. The depth of those integrations — how well they handle the session lifecycle, how they manage crashes, what observability they expose — varies. Vercel and DigitalOcean have been partners in preview; the others may have less production runway. Evaluate before picking.
• GPT-6 Astra as default is expensive for long sessions. Frontier model pricing at $10/$50 per Mtok is the right call for hard end-to-end tasks. It's the wrong call for scaffolding, tool routing, and sub-task coordination that could run on a cheaper model. The API lets you set a different model at session creation. Do that.

What builders need to know

• Get an API key and run the entry tier first. $0.03 per 20-minute session removes cost as a reason not to try it. Spin up a small task against a sandboxed repo and verify the session lifecycle works the way you expect before committing to a design.
• Don't default to GPT-6 Astra for everything. Use the frontier model for the work that needs it. For orchestration, routing, and sub-task dispatch, a cheaper model at the same API surface will cut your token cost significantly.
• Pick your environment before your model. The environment choice (bring-your-own vs partner vs OpenAI-hosted) constrains what you can do with the execution context. Decide where the computation lives before you design the session loop.
• Build for the events stream. Sessions emit events. The right pattern is to build against those events — real-time progress, tool calls, sub-agent spawns — rather than treating sessions as black boxes and polling for results. The observability is there; use it.
• Model the full cost stack before production. Container session time + model tokens + tool calls at production volume. The 5-minute minimum per session matters if you're spawning many short tasks. Batch where you can.

Further reading

• OpenAI — Introducing the Agents API — the primary announcement with the four-concept overview
• OpenAI Agents API documentation — the technical reference for session lifecycle and environment configuration
• MarkTechPost — Agents API public beta — the clearest independent summary of what launched
• TokenCost — sandbox pricing breakdown — if you need to model full cost before committing
• GPT-6 Astra — model pricing and capability details for the Agents API default