The interesting thing about AI agents right now isn't that they can write code.
It's that we're starting to build infrastructure around them.
On September 10, OpenAI introduced its Agents API, exposing the same kind of harness behind Codex to developers. Instead of developers building their own systems for context management, tool use, long-running sessions, sandboxes, and subagent coordination, the API provides those pieces as infrastructure.
That changes how I think about building with AI.
A New Execution Pipeline
Until recently, the basic pattern was pretty simple:
App → LLM → Response
Now we're moving toward something more like:
App → Agent → Tools → Sandbox → Subagents → Files → APIs → Result
The model is only one part of the system.
What makes this interesting is the amount of work happening around the model. OpenAI's new API supports long-running sessions, context management, tool discovery, MCP, parallel subagents, and hosted or external sandbox environments.
That means an agent can do something closer to actual work instead of simply producing an answer.
And I think that's the important shift.
Context, Recovery, and Table Stakes
When I build something with an AI coding tool, I don't really care whether the model can generate a React component in a few seconds anymore. That's becoming table stakes.
What matters more is whether the agent can understand the repository, inspect the right files, use the right tools, make changes, test them, recover from mistakes and continue working without me constantly explaining what happened.
“The infrastructure around the model becomes just as important as the model itself.”
The Rise of Multi-Agent Systems
This is also why multi-agent systems are becoming interesting. Instead of asking one agent to do everything, you can split a problem into smaller tasks and let several agents work in parallel before combining their results. OpenAI's Agents API explicitly supports this kind of subagent orchestration.
And this isn't just an API idea.
We're already seeing similar thinking in developer tools. Anthropic's recent Claude Code Projects update lets developers coordinate multiple coding sessions under one project, with shared goals and memory while individual agents work on separate branches.
So the developer workflow is starting to look less like:
I write the code.
And more like:
I design the system that gets the code built.
That's a pretty significant change.
The Environment Is the Product
It also means that things like permissions, testing, observability, cost control and sandboxing aren't optional details anymore. If an agent can run code, access files and call external tools for hours, the surrounding system has to know what it is allowed to do and what it actually did.
For me, that's probably the most interesting part of this whole transition.
The future of AI development may not be about having the smartest model sitting inside your application.
It may be about building the best environment for that model to operate inside.
And we're only starting to figure out what that environment should look like.