OpenAI Managed Agents May Simplify AI Deployment

OpenAI may use DevDay 2026 to introduce Managed Agents, a new platform layer for building, running, and deploying AI agents. TestingCatalog’s September 7 report says unreleased OpenAI Platform code references Agents, Environments, and Agent Sessions, along with support for OpenAI-hosted and customer-managed runtimes.

The reported interface also connects agent creation with a Codex-powered developer plugin in ChatGPT. If the product ships as shown, a user could describe an agent, configure its tools and execution environment, then deploy it without manually assembling every part of the infrastructure.

This remains pre-release evidence rather than a confirmed OpenAI announcement. As of September 7, 2026, OpenAI had not published Managed Agents documentation, pricing, availability details, or a public API specification. The screenshots nevertheless point to a larger shift: OpenAI may be preparing to sell not just models and agent-development components, but the operational control plane needed to keep agents running.

The Report Points to Agents, Environments, and Sessions

TestingCatalog says the unreleased platform separates Managed Agents into three main resource types: Agents, Environments, and Agent Sessions. One screenshot shows a beta POST /v1/agents endpoint and a creation form containing a model, instructions, reasoning settings, output configuration, tools, skills, and plugins.

Another reported screen presents a four-stage workflow:

1. Define the agent, including its model, instructions, and optional tools.
2. Choose an OpenAI-hosted runtime or attach a customer-controlled runtime.
3. Create a persistent session with optional initial input.
4. Exchange events with the running agent.

The interface describes a session as a durable workspace, suggesting that an agent could maintain task state across multiple interactions rather than starting from an empty context on every request.

OpenAI has not explained the formal boundaries between these resources, but the likely division is straightforward:

• An Agent would contain the reusable definition, such as its model, instructions, tools, skills, and behavior.
• An Environment would define where the agent executes and which compute, files, credentials, network connections, and software packages it can access.
• An Agent Session would represent one continuing task or interaction, including its history, state, files, and runtime events.

That separation matters operationally. Developers could update an agent definition without treating every running session as the same object. They could also operate several agents inside controlled environments while applying different permissions, resource limits, or compliance policies.

The names and relationships could still change before release. Pre-launch code often contains experiments, placeholder terminology, and incomplete interfaces. The screenshots are better treated as evidence of OpenAI’s direction than as final API documentation.

Managed Agents Would Package Existing OpenAI Building Blocks

OpenAI already offers most of the individual components needed to create an agent. AgentKit includes Agent Builder, ChatKit, connectors, evaluation tools, and reinforcement fine-tuning. OpenAI introduced that collection at DevDay 2025 as a way to move agent projects from prototypes toward production deployments.

The current Agent Builder documentation describes a visual canvas for assembling multi-step workflows. Developers can publish a workflow, embed it through ChatKit, or export code for use with the Agents SDK. Agent Builder therefore helps define the workflow, but developers still need to decide how the surrounding application, runtime, credentials, storage, and deployment process will work.

Managed Agents appears to sit one level above that toolchain. Instead of publishing a workflow and separately building the system that operates it, developers could create a first-class agent resource and attach it to a managed execution environment.

OpenAI has also been preparing the technical foundation. In June 2026, the company moved the Agents SDK runtime onto the Responses API and added unified shell and computer tools, approval policies, guardrails, compaction, and support for multiple compute providers. OpenAI said the revised architecture separates the agent harness from the compute layer, allowing developers to connect it to different infrastructure.

The SDK already supports persistent sessions that automatically retrieve and store conversation history. Developers can use local memory, SQLite, OpenAI-hosted conversations, or custom backends. A Managed Agent Session could promote that concept from an SDK feature into a platform resource with its own identifier, lifecycle, event stream, access policies, and monitoring. That interpretation is plausible, but OpenAI has not confirmed the leaked resource’s exact behavior.

In practical terms, OpenAI appears to be moving from “here are the pieces for an agent” toward “here is the service that operates the agent.”

The Codex Plugin Could Lower the Setup Cost

TestingCatalog describes a plugin that would help users build, configure, and deploy Managed Agents. The screenshot itself labels the product OpenAI Developer Plugin, rather than simply Codex Plugin, and shows it as a ChatGPT app connected to OpenAI Codex.

OpenAI’s current Developer Plugin documentation says the tool can produce deployable code through natural-language instructions in ChatGPT. Its documented workflows include connectors, Apps SDK applications, websites, landing pages, and general coding projects. Users describe the project, review a plan, let Codex generate and validate the code, then deploy or download the result.

Integrating that workflow with Managed Agents could remove several setup steps. A user might describe an internal research agent, allow the plugin to generate its instructions and tool definitions, select an execution environment, add approved connectors, and create a deployment from the same ChatGPT conversation.

That would lower the initial engineering cost, but it would not eliminate the difficult work. A generated agent still needs accurate tool schemas, scoped credentials, realistic evaluations, recovery logic, cost controls, and rules for handling ambiguous or unsafe actions. Making creation conversational can accelerate a prototype. It cannot prove that the resulting agent is safe to operate without supervision.

Hosted and Self-Hosted Runtimes Change the Enterprise Case

The most consequential detail in the report may be the runtime choice. TestingCatalog’s screenshots say users could select an OpenAI-hosted runtime or attach their own. The article also says Managed Agents are being designed for self-hosted environments.

An OpenAI-hosted runtime would favor convenience. OpenAI could provision the compute, maintain the execution software, stream events, and integrate tracing or evaluation data directly into the platform. Developers would avoid operating a separate agent service and could potentially move from configuration to deployment quickly.

A customer-controlled environment would favor governance and infrastructure flexibility. Enterprises may need agents to execute close to private data, use internal network services, run approved software images, or follow organization-specific security controls. A self-managed runtime could also help companies retain existing cloud commitments and monitoring systems.

“Self-hosted” should not be interpreted as OpenAI distributing its proprietary model weights. Based on the reported interface and OpenAI’s current SDK architecture, the more likely design would place the agent’s execution environment on customer infrastructure while model requests continue through an OpenAI API. The company’s revised Agents SDK already separates the agent harness from compute and permits developers to connect different compute providers.

OpenAI would not be entering an empty category. Anthropic introduced Managed Agents for enterprises in August 2026, initially through a private preview on Google Cloud’s Vertex AI. Anthropic describes its offering as a complete agent system with long-running sessions, memory, task management, permissions, integrations, and managed infrastructure. It also says customers will eventually be able to connect their own infrastructure.

That comparison helps explain the timing. Model providers increasingly compete on the infrastructure around their models, not just benchmark scores. A company that provides the model, agent framework, runtime, evaluation suite, connectors, and deployment system can capture more of the application stack.

The Hard Problems Start After an Agent Is Created

The agent-creation screen is the easiest part of a managed service to demonstrate. The harder questions concern what happens when an agent runs for hours, touches sensitive systems, creates files, executes code, or makes a costly mistake.

OpenAI’s existing hosted shell tool already illustrates some of the controls required. Hosted containers are isolated, outbound network access is disabled by default, and shell activity can appear in model-generated logs. OpenAI’s updated Agents SDK also supports approval policies and guardrails for computer interactions.

Managed Agents will need similarly explicit controls for:

• Secret storage and credential rotation
• Network access and domain allowlists
• Tool-level permissions
• Human approval checkpoints
• Session retention and deletion
• Resource and token budgets
• Concurrent execution limits
• Audit logs and trace exports
• Failure recovery and session checkpointing
• Agent, prompt, and environment versioning

Sessions create another set of complications. Durable state is valuable when an agent performs research, writes code, or completes a multi-stage business process. It can also preserve incorrect assumptions, sensitive data, or compromised instructions. OpenAI will need to explain how session memory differs from ordinary conversation history, how long it persists, and whether developers can inspect, clone, pause, restore, or delete it.

Pricing could determine whether Managed Agents become a default choice or a premium convenience. Developers may have to pay for model tokens, runtime duration, file storage, networking, tool calls, traces, and persistent sessions. TestingCatalog’s report contains no pricing, and the screenshots do not show whether hosted and self-managed environments would use different billing models.

DevDay Must Resolve the Missing Details

The leaked interface is detailed enough to show a coherent product direction, but several essential questions remain unanswered:

• Will Managed Agents launch publicly at DevDay or enter a limited preview?
• Which OpenAI models, tools, skills, and plugins will be supported?
• Can developers create and manage every resource through an API, or will some configuration require the platform interface?
• What exactly runs in a self-hosted environment?
• How are sessions persisted, billed, paused, and recovered?
• What isolation guarantees apply to hosted environments?
• Will regional deployment and data-residency controls be available?
• How will existing Agent Builder workflows and Agents SDK projects migrate?
• What service-level commitments will OpenAI offer for long-running tasks?

TestingCatalog notes that the agents interface is not currently accessible and bases its report on code found before the announcement. Features could be delayed, renamed, restricted to selected customers, or released with fewer capabilities than the internal interface suggests.

The distinction between a preview and a production service will be important. A visual agent creator can be useful for demonstrations, but enterprises need predictable APIs, version control, observability, support policies, security documentation, and transparent pricing before they can depend on an agent platform for critical work.

Final Thoughts

If OpenAI launches Managed Agents as reported, the important development will not be another interface for writing agent instructions. OpenAI already has Agent Builder, the Agents SDK, tools, connectors, sessions, tracing, and evaluation products. Managed Agents would matter because they could connect those pieces through a persistent platform control plane.

The self-hosted option could be especially valuable, provided it gives companies meaningful authority over compute, networking, credentials, and runtime policies. If it amounts only to a connector that forwards work to a customer server, its enterprise value will be more limited.

DevDay’s creation demo may show how quickly someone can make an agent. The better test will be whether OpenAI can make that agent economical, observable, secure, and reliable after the demo ends.