OpenAI Now Sells the Harness

OpenAI just turned the least glamorous part of its own stack into a product.

For two years the hard part of shipping an AI agent was never the model. It was everything wrapped around it: the loop that decides when to call a tool, the logic that keeps a session alive past the context window, the retry paths when a sandbox dies four hours into a job. Every serious team built that layer themselves, badly, twice. On September 10 OpenAI announced the Agents API in public beta and put its own version of that layer — the harness behind Codex — behind a single API call.

The pricing tells you what kind of move this is. There is no fee for the Agents API. You pay for tokens and tools, as listed on the standard pricing page. OpenAI is giving away the orchestration layer to keep the metering on inference.

What actually shipped

The Agents API exposes four objects. An Agent carries the model, instructions, tools and MCP servers. An Environment is the sandbox where code runs and files persist. A Session is durable and long-running. Events stream back from the session to your application. That is the whole surface area, and the compression is the point: a production agent is one sessions.create call specifying task, model, tools and environment.

Underneath sits the Codex harness, which OpenAI maintains and versions against each model launch. Three capabilities in it are doing most of the work. Automatic context compaction rewrites earlier context as a session approaches its limit, so workflows can span multiple context windows without anyone hand-rolling summarization. Tool search loads tool definitions on demand rather than stuffing every schema into the prompt, and programmatic tool calling lets the agent run calls in parallel and filter results in code before anything returns to context. Multi-agent support breaks a task into independent pieces and hands them to subagents, each with its own context, coordinated by a parent.

None of those three is novel as an idea. Every agent framework has attempted all of them. What is new is that they now ship as a maintained service that gets re-tuned each time the underlying model changes — which is precisely the work that decays fastest when you own it yourself.

Environments are deliberately unopinionated. You can run inside an OpenAI-hosted sandbox, on your own infrastructure, or with one of the named partners: Blaxel, Cloudflare, Daytona, DigitalOcean, E2B, Modal, Oracle, Runloop and Vercel. OpenAI is not trying to win the compute layer here. It is trying to sit above it.

The harness itself is open source on GitHub. Developers can read the coordination logic; OpenAI runs it.

Why give the orchestration away

Because orchestration was never where the margin was, and holding it closed was costing OpenAI token volume.

Consider the economics from OpenAI's side. Every hour a developer spends writing compaction logic is an hour their agent is not running in production burning tokens. Every brittle custom harness that fails at hour three of a long job is a session that terminates early. The bottleneck on inference revenue has not been model quality for a while — it has been how many agentic workloads survive contact with production long enough to run for days. Removing the hardest infrastructure work from the critical path is the most direct lever OpenAI has on consumption.

The customer numbers OpenAI published point the same direction. SafetyKit reported a 60% reduction in cost per case after migrating a review workflow. Hypha said separating harness from sandbox cut failed agent responses by 86%. Take those as vendor-selected figures, because that is what they are. But note the shape: the wins are reliability and cost-per-completed-task, not raw capability. That is an infrastructure story, not a model story.

There is a second reason, less flattering to competitors. Agent frameworks have been the main place where a developer's architecture becomes portable across model providers. If your orchestration lives in LangGraph or CrewAI or your own code, swapping the model underneath is a config change. If your orchestration is a managed OpenAI service holding durable session state, it is not. The Agents API is free in the way a well-designed platform is free.

Who this lands on

For agent framework vendors, this is the squeeze. The pitch for a framework has been "we handle the loop, the state, the retries, the subagent fan-out." OpenAI now handles all four, maintained against its own models, at no additional charge. The surviving ground for frameworks is model-neutrality and the ability to route across providers — the same defensive position gateway products have been building toward. Frameworks that were mostly a nicer wrapper around a loop have a hard year coming.

For sandbox providers, it is unambiguously good. Nine of them got named as first-class integrations on launch day, and OpenAI explicitly declined to make hosted compute mandatory. Modal, E2B, Daytona and the rest now have a funnel that did not exist on September 9. The trade is that they are components in someone else's architecture rather than the architecture.

For enterprise buyers, the calculus on building in-house shifts again. The build-versus-buy line keeps moving as the commodity layer rises, and it just rose past agent orchestration. If your platform team is six months into an internal harness, the honest question this week is whether the remaining differentiation is in the loop or in the tools and domain knowledge you plug into it. OpenAI's framing is that it supplies the harness and you supply everything that makes the agent yours. That framing is self-serving and also roughly correct.

For OpenAI's rivals, the pressure is to match the managed-runtime layer rather than the feature list. Anthropic, Google and the open-weight ecosystem all have agent tooling. What they mostly do not have is a durable, hosted session object that survives for days and gets re-tuned with every model release. Matching a feature is a quarter of work. Matching an operated service is a different commitment.

The part worth watching

The interesting risk is not lock-in — developers price that in. It is what happens to debuggability when the loop is someone else's.

Compaction is the clearest case. When the harness decides which earlier context to discard as a session approaches its limit, it is making a judgment call that can silently change an agent's behavior twelve hours into a job. You can read the open-source logic. You cannot version-pin OpenAI's production deployment of it to the release you tested against. For a coding agent, a bad compaction means a wasted run. For an agent in a regulated workflow, it means an outcome you cannot fully reconstruct.

The same applies to subagent orchestration. Parallel fan-out with independent contexts is a real speedup and a real source of nondeterminism. OpenAI's quoted customers are running logistics and financial-services workloads on this. Those are exactly the domains where "the harness improved and our outputs changed" is an audit finding rather than a changelog entry.

Public beta is the right label. OpenAI says it will iterate quickly toward general availability, which is the honest way of saying the semantics are not frozen.

The shape of the market now

Strip the announcement down and a pattern shows up that has repeated in every platform cycle: the layer everyone hated building becomes free, and the company that gives it away collects rent one level down.

Agent capability has been converging for a while. Coding agents have been priced on reliability rather than raw ability for most of this year, and the same logic is arriving for agents generally. When the model tier is broadly comparable across providers and the harness is a solved, managed service, what is left to compete on is tools, data access, domain knowledge and the interface — the things OpenAI explicitly told developers to keep.

That is a narrower moat than most agent startups have been pitching. It is also the only one that was ever really theirs.

The infrastructure layer of any technology becomes free at exactly the moment owning it stops being profitable. Watch what the giver keeps.

Frequently Asked Questions

What is the OpenAI Agents API?

The Agents API is a managed service, in public beta since September 10, 2026, that lets developers run cloud agents on the same Codex harness OpenAI uses internally. It handles orchestration, durable long-running sessions, context compaction and subagent coordination through a single API call, so developers do not build that infrastructure themselves.

How much does the Agents API cost?

There is no additional fee for the Agents API itself. Developers pay only for the tokens their agents consume and the tools they invoke, at standard rates on OpenAI's pricing page. Costs therefore scale with agent activity rather than with a platform subscription, which makes long-running agents the main variable to monitor.

What is the Codex harness?

The Codex harness is the coordination layer that manages model calls, tool use and context across an agent's run. It powers OpenAI's Codex product and is published as open source, letting developers inspect the logic. With the Agents API, OpenAI operates and maintains that harness rather than developers running it themselves.

Which sandbox providers work with the Agents API?

Agents can run in OpenAI-hosted sandboxes, on a developer's own infrastructure, or through partner environments. OpenAI named Blaxel, Cloudflare, Daytona, DigitalOcean, E2B, Modal, Oracle, Runloop and Vercel as first-class integrations at launch, covering managed environments, VPC deployments and varied CPU, GPU and memory configurations.

Editor's note — sources: OpenAI, "Introducing the Agents API" (Sept 10, 2026); OpenAI Agents API documentation and compaction guide; the openai/codex repository; OpenAI's API pricing page; MarkTechPost launch coverage. Customer metrics are figures OpenAI published in its own announcement and have not been independently verified.