Tech • AI • Robotics • Game
Harness-as-a-Service: Building with the Agents API | DevDay 2026
9.1/10TL;DR
OpenAI has launched a managed Agents API built on the Codex harness, aimed at letting developers run long-lived, tool-using AI agents in cloud or hosted environments without operating the underlying orchestration infrastructure themselves.
KEY POINTS
From workflows to full agent harnesses
Agent systems have moved beyond short tool calls into extended workflows that can last hours or days. Earlier hosted tooling such as the Assistants API supported tasks measured in seconds, but newer models including GPT-6 Astra and GPT-6.1 Sol are positioned to handle much larger jobs from start to finish. That shift required moving from a simple inference endpoint to what amounts to a managed harness for planning, tool use, execution, and recovery.
Built on the Responses API and Codex
The company describes its stack as layered: the Responses API provides multimodal inputs and outputs, Codex adds practical execution abilities such as coding and browser-style work, and the new Agents API exposes that orchestration layer as a service. The goal is to let developers define tools, data, instructions, and execution settings while outsourcing the operational burden of running the harness at scale.
A response to developer demand for managed infrastructure
A key lesson from developer feedback was that many teams wanted guidance and hosting more than raw flexibility. Even when they knew which tools or environments they wanted, they still needed answers on secrets management, sandbox design, and where the agent should run. The new API is designed for those teams: they keep control over tools and environments, but OpenAI runs and improves the harness.
Core engineering problem: separating harness and execution environment
The original Codex setup assumed local execution on a developer machine, where the agent could directly read files and run commands. In the cloud, the harness has to communicate with arbitrary remote environments, whether customer-operated sandboxes or OpenAI-hosted ones. That means routing each command to the correct machine, returning results quickly enough for the model to continue, and isolating many simultaneous sessions so commands never cross between them.
New computer-use capability over the API
A major addition is computer use through the API, bringing Astra’s ability to operate a graphical user interface inside OpenAI-hosted environments. That expands the system beyond terminal-heavy automation and into GUI-driven workflows, a feature developers had requested heavily. The API now supports both bring-your-own sandboxes and hosted execution, with live event streaming for status updates.
Visibility into long-running work
Observability emerged as another major requirement. Raw tool calls and model outputs were not enough for teams building user-facing products around long-running agents, especially when users return for multiple rounds of requests. The service now exposes work by conversational turns, making it easier to show what an agent is doing, where it may be stuck, and how successive requests relate to one another without forcing developers to reconstruct that logic themselves.
Keeping agents alive for days
Long-lived agents face two operational constraints: context limits and infrastructure failures. The system uses compaction to carry forward the useful parts of a growing history when a session nears the model’s context window. It also tracks session state precisely enough to survive code deploys, server replacement, or crashes, allowing work to resume without replaying risky actions that may already have happened.
Reliability depends on more than inference
The platform is designed for three nines reliability, but long-running agents depend on more than one service. Model inference, storage, external tools, and session routing all need comparable reliability. One example highlights the challenge: if an edit command is sent to a sandbox and the connection drops, the system must determine whether the file changed before deciding whether it is safe to retry.
Airline rebooking demo showed human-in-the-loop automation
A sample application handled rebooking after a canceled flight by launching parallel agent sessions for difficult passenger cases. One traveler needed O’Hare specifically and a tomorrow morning departure; another booking involved four passengers, including children, who had to travel together. The agents searched seat inventory, delegated seating and arrival checks to two subagents, produced recommendation files in JSON, and generated a Python script to verify the logic against the stated constraints.
Parallelism with approvals preserved
In the airline workflow, available seats could be placed on hold, but a human still had to approve the final rebooking. One candidate flight was rejected because it had only one seat available; another was rejected because it had four seats but could not guarantee that the family would sit together. The example illustrated the intended model for the API: agents perform parallel analysis and structured preparation at scale, while humans keep final authority over consequential actions.
Early adopters and ecosystem reach
Notion is using the technology for asynchronous external agent workflows, Rakuten is applying it to long-running product tasks, and Bain is building synthetic audiences that simulate customer feedback while keeping human review in place. For organizations staying in the AWS ecosystem, the same core system is also being exposed through Bedrock managed agents powered by OpenAI.
CONCLUSION
The new Agents API is aimed at turning advanced agent behavior into managed infrastructure rather than a custom engineering project. Its significance lies in making long-running, parallel, tool-using automation more practical while keeping developers in control of rules, environments, and human approval points.
Ask a question