On September 10, OpenAI published the Agents API public beta on its official blog. This isn't a routine API update — it's a critical step in OpenAI's transformation from "model provider" to "agent platform."

Over the past year, countless startups have tried to build agent infrastructure on top of large models: context management, session persistence, sub-agent orchestration, tool calling, error recovery... This "glue code" formed the core moat for agent startups. Now, OpenAI says: I'll do all of this for you, and it's free.

The core idea of the Agents API is simple: developers specify the task, model, tools, and runtime environment in a single API call, and OpenAI automatically handles everything else — context compression, long-running sessions, sub-agent parallelization, fault recovery. This means the barrier to building a production-grade agent drops from "needs an engineering team" to "needs one line of code."

Codex Harness: OpenAI's Secret Weapon

At the core of the Agents API is the Codex harness — the same infrastructure OpenAI uses internally to run Codex. Codex is OpenAI's code generation agent that has been running internally for a long time, handling millions of tasks.

Now, this infrastructure is open to all developers. This means you can run your own agents with the same reliability, performance, and scalability — without building any infrastructure yourself.

Specifically, the Agents API provides three core capabilities:

First, long-running session management. Agents are no longer limited to single request-response patterns; they can run continuously in the background for hours or even days. OpenAI automatically handles context compression — when session context exceeds the model window, it automatically compresses historical information to ensure agents don't "forget" critical context.

Second, sub-agent orchestration. An agent can automatically split tasks and delegate them to multiple sub-agents running in parallel. It's like a project manager assigning tasks to team members — except here, all the "team members" are AI agents.

Third, tool calling and MCP support. Agents can call external tools, access databases, execute code, browse the web. And importantly, the Agents API natively supports MCP (Model Context Protocol), meaning you can seamlessly tap into the entire tool ecosystem already built for MCP.

Managed Mode: The Nightmare for Agent Startups

The pricing model of the Agents API is its most lethal aspect: only token and tool call fees, no additional service charges.

What does this mean? Over the past year, many agent startups built their business models around providing agent infrastructure (context management, orchestration, monitoring) and charging subscription or per-call fees. Now, OpenAI provides these capabilities for free — you only pay for the model's token costs.

This is like AWS's impact on traditional IDCs: you don't need to build your own data center; just pay as you go. Now, you don't need to build your own agent infrastructure; just call an API.

Of course, this doesn't mean all agent startups will die. Those with deep domain expertise in specific verticals (legal agents, medical agents, financial agents) still have room to survive — because their value lies not just in infrastructure, but in domain knowledge and data.

But startups that were purely doing "agent infrastructure" must now rethink their positioning. When OpenAI provides infrastructure for free, where is your value?

Developer Ecosystem: MCP Becomes the Standard

The Agents API's native MCP support is an important signal.

MCP (Model Context Protocol) is an open protocol proposed by Anthropic in 2024 to standardize how large models connect to external tools. Over the past year, MCP has gained widespread adoption — major players like Anthropic, Google, Microsoft, and AWS all support it.

Now, OpenAI officially embraces MCP through the Agents API. This means MCP is becoming the de facto standard for agent tool calling. For developers, this is good news: tools you build for MCP can now be used in OpenAI's agent ecosystem and on other MCP-supporting platforms.

This standardization benefits the entire agent ecosystem. It reduces adaptation costs for tool developers, improves tool portability, and ultimately accelerates the explosion of agent applications.

Competitive Landscape: OpenAI vs Anthropic vs Google

The Agents API launch clarifies the agent infrastructure competition.

OpenAI's strengths lie in model capability and user base. GPT-6 Astra is one of the strongest general models, and ChatGPT has hundreds of millions of users. The Agents API lets these users build agents directly without additional infrastructure.

Anthropic's strengths lie in safety and enterprise trust. Claude models have consistently led in safety and controllability, and many enterprise customers choose Anthropic precisely for its safety focus. Claude Code's adoption among developers is also growing rapidly.

Google's strengths lie in search and tool ecosystem. Gemini models are deeply integrated with Google Search, Gmail, Drive, and other services — a unique advantage in agent scenarios.

The winner of this competition ultimately depends on who delivers the best agent experience — not just model capability, but also tool ecosystem, developer experience, reliability, and security.

What Does This Mean for Developers?

For developers, the Agents API is a massive win.

Previously, building a production-grade agent required handling numerous engineering problems: context management, error recovery, concurrency control, monitoring logs... This "glue code" was often more complex than the agent's core logic. Now, OpenAI handles it all.

You can focus on the agent's core logic: What should it do? What tools should it call? How should it respond to users? — without worrying about underlying infrastructure.

Of course, this also means the barrier to agent development drops dramatically. When everyone can easily build agents, competition intensifies. The winners won't be those who "can build agents," but those who "know what problems to solve with agents."

The timing is also interesting. September 10, right at the start of fall developer conference season. Over the coming months, we'll likely see more agent platform updates — Anthropic, Google, and Microsoft are all preparing their own agent products.

The competition for agent infrastructure has only just begun.

See you tomorrow.