On April 8, this blog covered Claude Managed Agents with a headline that doubled as a thesis: Anthropic built the agent loop you were going to write anyway. The pitch was that every team shipping a serious agentic workflow ends up writing the same few thousand lines of plumbing — session state, tool orchestration, checkpointing, retries, sandboxing — and none of it has anything to do with the actual product. Anthropic’s bet was that this plumbing belongs in the platform, not in every customer’s codebase.
On September 10, OpenAI shipped the same bet, five months later. The Agents API entered public beta, putting the Codex harness — the orchestration engine that runs OpenAI’s own coding agent — behind a single API call. If you squint at the architecture, it’s hard not to see Claude Managed Agents’ shape underneath it.
What OpenAI actually shipped#
The design is four objects. An Agent bundles a model, instructions, tools, and MCP servers. An optional Environment provides a sandbox — either OpenAI-hosted or connected from your own infrastructure or a supported provider. A durable Session holds the actual work across multiple turns. And events stream back from the session as it runs, giving the calling application visibility into what the agent is doing without polling.
OpenAI’s own framing, per its developer changelog, is that it “keeps the session alive, compacts the context when it fills up, and recovers after failures” — the application only has to supply instructions, tools, and MCP servers. That’s a near-verbatim restatement of what Anthropic pitched for Claude Managed Agents in April: sandboxing, checkpointing so long-running tasks survive a network blip, and tool orchestration handled by the platform rather than hand-rolled by every team that wants an autonomous coding agent. The Agents API is available in public beta for all developers, with no fee layered on top of standard usage costs — again mirroring Anthropic’s approach of pricing managed-agent compute as a straightforward extension of API usage rather than a separate product tier.
The one genuinely new wrinkle is that the underlying Codex harness is open source, so developers can inspect the actual orchestration logic OpenAI runs internally rather than treating it as a black box. That’s a legitimate transparency edge worth crediting — Anthropic hasn’t open-sourced the Managed Agents runtime itself, even though the Claude Agent SDK exposes a comparable set of primitives for building your own loop.
Where it’s rougher than the model it’s copying#
Two limits stand out, both disclosed directly in OpenAI’s own documentation: data residency for the Agents API is restricted to the United States during the public beta, and zero data retention is unsupported no matter which sandbox type a developer chooses. For a consumer prototype, neither matters much. For the enterprise customers this API is obviously aimed at — anyone running agentic coding workloads with data-residency or retention obligations, which by September 2026 is most regulated industries running production AI — those two gaps are disqualifying until they’re fixed, not launch-week nitpicks.
Compare that to where Anthropic’s own agent infrastructure has landed over the same five months. Claude Code shipped Bedrock GA back in April with Mantle’s zero-operator-access architecture built in from day one specifically for enterprise air-gap requirements, and this blog covered a maxEffortLevel and reliability-hardening pass just this week that’s explicitly aimed at exactly the kind of multi-region, compliance-sensitive deployments the Agents API’s beta-stage US-only residency can’t yet serve. Shipping the managed-agent-loop concept is the easy part, conceptually — OpenAI proved that by matching it in five months. Making it something a bank or a defense contractor can actually point their compliance team at without a caveat took Anthropic considerably longer than the concept itself, and OpenAI’s beta is currently earlier in that same climb, not further along it.
The convergence is the real story#
Zoom out and the interesting fact isn’t that OpenAI copied a specific product shape — it’s that this is now the second major lab in five months to conclude that the winning architecture for serious coding agents is a managed, sandboxed, session-based harness rather than a chat completion loop a developer assembles by hand. Google’s Antigravity, Cognition’s Devin Cloud (which just closed a $48 billion round partly on the strength of exactly this kind of always-on automation layer), and now OpenAI’s Agents API are all landing on some variant of the same primitives: durable sessions, sandboxed execution, tool/MCP wiring, and the platform — not the application developer — owning context management and recovery.
That’s the architecture Claude Code was built around from the start, and it’s the reason this blog has consistently argued that Cursor’s IDE-anchored, human-drives-every-keystroke model is the wrong bet for where the category is heading. When the lab most associated with the “just wrap ChatGPT in an interface” era ships a product whose own documentation reads like a paraphrase of Anthropic’s April announcement, that’s a stronger endorsement of the underlying thesis than any benchmark comparison would be.
What to watch#
Two follow-ups worth tracking: whether OpenAI extends data residency beyond the US and adds a zero-data-retention option before or after the Agents API exits beta, and whether Anthropic responds to Codex’s harness going open source by opening up more of Claude Managed Agents’ own runtime rather than keeping the SDK-primitives-only approach. Neither has happened yet.
Sources: OpenAI Developer Changelog (primary, direct fetch, September 10, 2026 entry); Introducing the Agents API — OpenAI (referenced via multi-outlet corroboration — MarkTechPost, Blockchain.News — after a direct fetch returned a 403); this blog’s prior coverage of Claude Managed Agents (April 10, 2026) and Cognition’s Series E close.