OpenAI Agents API and Claude Managed Agents solve the same problem: the provider runs the AI agent loop, stores the session, and provides a code sandbox. As of October 4, 2026, both platforms are in beta and built around the same concepts: agent, environment, session, events. The main differences are in the models (GPT at OpenAI, Claude at Anthropic), the design of multi-agent workflows, action approval policies, and pricing: OpenAI charges for the container, while Anthropic charges $0.08 per hour of session runtime. Neither platform supports Zero Data Retention, and both are officially unavailable in Russia (OpenAI, Anthropic).OpenAI, Anthropic).
For developers, technical leaders, and product owners choosing a managed agent platform. A detailed breakdown of the first platform is in the article “OpenAI Agents API: What It Is, How It Works, and How Much It Costs”. Here we compare the two platforms using the same criteria. We did not measure GPT and Claude model quality and this is not a substitute for a legal review of the project.
Editorial: Vladimir Lomtev AI Studio. Prepared on October 4, 2026 based on the official documentation and pricing pages from OpenAI and Anthropic, verified on that date. The editorial team did not test the platforms themselves: the code examples are taken from the documentation. The article was published on the website of Vladimir Lomtev’s AI Studio, which implements AI agents; the services section appears before the conclusion. There are no affiliate links or compensation from OpenAI or Anthropic in this material.
At a glance
- Both platforms are a managed harness plus a sandbox: cloud-hosted by the provider or self-hosted.
- OpenAI Agents API provides browser control for the agent (computer use), environment templates, and trace export to OTLP.
- Claude Managed Agents provides versioned agents, a hard session budget in dollars, scheduled runs, result checking against a rubric, and approval policies for each tool.
- Models are billed by tokens on both platforms. Compute: OpenAI uses container-based pricing, while Anthropic charges $0.08 per hour in the
runningstate. - If data cannot be stored with the provider, neither platform works: Zero Data Retention is not available on either one.
Contents
- What We’re Comparing
- How We Compared Them
- Summary Table
- Architecture: Shared Model and Differences
- Sandboxes and Environments
- Tools, MCP, and Action Approval
- Multi-Agent Workflows
- Additional Capabilities
- Secrets and Access Credentials
- Pricing: Two Different Formulas
- Data, Limits, and Availability
- If You Need an Agent on Your Own Servers: Agents SDK and Claude Agent SDK
- Which One to Choose: Scenario-Based Recommendations
- Russia: Availability and Legal Considerations
- FAQ
What We’re Comparing
OpenAI Agents API is a managed service that runs the Codex harness: OpenAI handles sessions, orchestration, context compression, and recovery, while the application connects tools and selects the environment. The public beta opened on September 10, 2026, and browser control was added on September 29 (OpenAI changelog).
Claude Managed Agents is, by Anthropic’s definition, “a ready-to-use, configurable agent wrapper running in managed infrastructure.” It is designed for long-running and asynchronous tasks: Claude reads files, runs commands, searches the web, and executes code in a secure environment (Managed Agents overview). Public beta started in April 2026 (ITBrief), and access is enabled by default for all Claude API accounts.
If someone says “Claude agents,” they may mean two products. Managed Agents is the hosted platform, the direct equivalent of OpenAI Agents API. Claude Agent SDK is a library you run yourself; its comparison with OpenAI Agents SDK is covered in a separate section.
How We Compared Them
The methodology is simple and verifiable:
- Sources. Only the official documentation, changelogs, and pricing pages from the two providers, open on October 4, 2026. Industry publications were used only for the Claude Managed Agents launch date.
- Criteria. 14 parameters that matter when choosing a platform: status, models, agent configuration, environments, network, tools, MCP, approvals, multi-agent support, secrets, schedule and budget, pricing, data retention, availability.
- What We Didn’t Compare. Model quality, response time, and reliability under load: that requires your own tests on your workloads, and we did not run them.
- Limitation. Both platforms are in beta, so features and pricing may change. Before making a decision, check the documentation as of your project date.
Summary Table
| Criterion | OpenAI Agents API | Claude Managed Agents |
|---|---|---|
| Status as of 04.10.2026 | Public beta, header OpenAI-Beta: agents=v1 |
Beta, header managed-agents-2026-04-01 |
| Models | OpenAI models (in examples — gpt-6-astra) |
Claude 4.5 and newer |
| Agent configuration | Inside a session or a saved agent by agent_id |
Separate agent with versions; the session is bound to a version |
| Environments | No sandbox, OpenAI sandbox, or your own | Anthropic cloud sandbox or your own |
| Cloud Sandbox | Linux, Python, Node.js; up to 4 vCPU and 16 GB | Ubuntu 24.04; up to 8 GB of memory and 10 GB of disk space |
| Sandbox Network | enabled, disabled, restricted (up to 100 hosts) |
unrestricted or limited with a host list |
| Built-In Tools | Bash, file editing, web search, browser control | Bash, read, write, edit, glob, grep, web search, and page loading |
| MCP | From OpenAI infrastructure, from the environment, stdio | Servers in the agent configuration, credentials in vaults |
| Action Approval | Approval for new websites in the browser; the app runs the functions | Policies always_allow, always_ask, auto for each tool |
| Multi-Agent Support | Subagents with a shared environment, parallel limit | Coordinator and up to 20 agents in the composition, up to 25 parallel streams |
| Scheduling and Budget | Not covered in the sections reviewed; spending limits at the organization level | Cron-based runs, hard session budget in dollars |
| Compute Fees | Container Rates | $0.08 per hour of session in the running |
| Data Storage | US only, no Zero Data Retention | No Zero Data Retention and no HIPAA BAA |
| Russia | Not on the list of supported countries | Not on the list of supported countries |
The source lines are listed in the sections below.
Architecture: Shared Model and Differences
The overlap in core concepts is immediately noticeable. In OpenAI, these are agent, environment, session, events, and elements (Agents API overview). In Anthropic, they are agent, environment, session, and events (Managed Agents overview). In both cases, the app sends messages, receives an event stream, and can adjust the agent on the fly. As a result, your application architecture changes less when moving between platforms than the integration code does.
The difference lies in the approach to configuration. In OpenAI, you can define the agent directly when creating a session, and a saved agent is optional; changes to it apply only to new sessions (agent configuration). In Anthropic, the agent is a required separate object. Every change creates a new immutable version, and the session is pinned to a version at the moment of creation (agent setup). Anthropic's approach adds one extra step, but it provides rollback and version comparison without additional work.
Results are easier to retrieve in different ways. In OpenAI, files from /workspace/outputs are published as immutable artifacts after a run (files and artifacts). Both platforms support event streaming and webhooks; Anthropic's webhooks are also in beta (Managed Agents webhooks, Agents API webhooks).
Sandboxes and Environments
Cloud sandboxes. OpenAI offers three sizes: 1 vCPU and 1 GB, 2 vCPU and 4 GB (default), and 4 vCPU and 16 GB. A sandbox with no activity and no keep-alive signals for an hour may be deleted (OpenAI sandboxes). Anthropic's sandbox runs on Ubuntu 24.04 with up to 8 GB of memory and up to 10 GB of disk space. It comes with Python 3.10–3.13, Node.js 20–22, and Playwright with the Chromium browser preinstalled (cloud sandbox guide).
Network. OpenAI offers modes enabled, disabled and restricted with a list of up to 100 exact hostnames. Anthropic has two modes: unrestricted with a shared blocklist, and limited, where only hosts from allowed_hostsare allowed, plus separate flags for package managers and MCP servers (Managed Agents environments). Important detail: environments created through the Anthropic API get unrestrictedby default, so network restrictions need to be set explicitly.
Your own infrastructure. In both platforms, the agent loop stays with the provider, while commands run in your environment. In OpenAI, an executor called codex exec-serverruns inside the environment and connects over an outbound WebSocket (OpenAI’s own sandboxes). In Anthropic, you run an “environment worker” that pulls tasks from a queue over outbound HTTPS; ready-made workers are available in the ant CLI and in the SDKs for Python, TypeScript, and Go (Anthropic’s own sandboxes). Anthropic explicitly warns that tool inputs and outputs still go through the provider’s control plane so the model can see the results.
Sandbox partners overlap in part. At launch, OpenAI named Blaxel, Cloudflare, Daytona, DigitalOcean, E2B, Modal, Oracle Cloud, Runloop, and Vercel (OpenAI announcement). Anthropic mentions guides from Cloudflare, Daytona, and Modal.
Tools, MCP, and action approvals
Built-in tools. In Claude Managed Agents, the agent_toolset_20260401 set includes bash, file read/write/edit, glob search, grep search, web search, and page loading; individual tools can be disabled (Managed Agents tools). In OpenAI, if an environment is available, Bash and apply-patch are available, plus web search and browser control in the OpenAI sandbox (computer use). There is no separate computer use tool in the built-in Managed Agents tools list. Browser automation there can be done through code using the preinstalled Playwright.
Your functions. Both platforms let you define your own tool: the agent requests a call, your code executes it, and returns the result. In OpenAI, this is done with function tools via requires_action, and in Anthropic, with custom tools, similar to client tools in the Messages API (OpenAI functions, Managed Agents tools).
MCP. OpenAI supports three modes: HTTP connection from its own infrastructure, HTTP from the session environment, and a stdio process inside the environment (MCP in Agents API). In Anthropic, MCP servers are declared in the agent configuration, and credentials are stored in vaults and attached to the session (MCP connector). In an environment with a limitednetwork, Anthropic MCP servers are blocked until their hosts are allowed.
Action approvals. This is where the approaches differ the most. Anthropic sets policy per tool: always_allow (no confirmation), always_ask (the session waits for approval), or auto (the server decides whether to execute, reject, or ask). By default, built-in tools run without confirmation, while MCP tools require it (approval policies).
In OpenAI, approval is built into browser control: the user confirms access to each new site. The documentation separately notes that this does not guarantee confirmation of every action (computer use). For other actions, control is handled through functions executed by your application.
Multi-agent workflows
In OpenAI, subagents are enabled with the multi_agent.enabledparameter, and the number of parallel subagents is limited by max_concurrent_subagents. Subagents share the main agent’s environment, inherit MCP tools and search settings, but do not support functions (OpenAI multi-agent).
In Anthropic, the coordinator agent gets a “composition” — a list of agents it can delegate work to. Each agent has its own model, system prompt, tools, MCP servers, and skills, and work happens in separate threads with its own history. Limits: one delegation level, up to 20 unique agents in a composition, and up to 25 parallel threads. The sandbox, file system, and vault credentials are shared (Anthropic multi-agent).
Practical takeaway: Anthropic’s setup is more convenient when subtasks need different models or tools — for example, a low-cost model for reading documents and a stronger one for the final decision. OpenAI’s setup is simpler for parallel processing of similar tasks with one configuration, if subagents do not need calls to your backend.
Additional capabilities
In Claude Managed Agents documentation, there are features with no direct equivalent in the parts of the Agents API we reviewed:
- Outcome checking against a rubric (outcomes). You define criteria for the finished result, a separate “evaluator” in its own context checks the artifact, and the agent revises it until it matches (outcomes).
- Scheduled launch. Deployment starts agent sessions on a cron schedule and keeps a launch history (scheduled deployments).
- Session budget. A hard spending cap in dollars: once it is reached, the session is paused with the status
budget_reached, without losing history (budgets). - Memory stores for transferring knowledge between sessions (agent memory).
OpenAI Agents API has its own strengths: browser management in a hosted sandbox, environment templates, plugins with skills and MCP configuration, programmatic tool calls and on-demand tool discovery, tracing with export to OTLP JSON (tracing, plugins). Costs can be limited at the organization level: starting in July 2026, OpenAI supports hard monthly limits, after which the API returns a 429 error (change log).
Secrets and access
The secret protection model is nearly the same across both platforms. Both use vaults for MCP server credentials (static_bearer, mcp_oauth) and for environment variables, where the sandbox sees only a placeholder and the real secret is injected on outbound requests (OpenAI vaults, Anthropic vaults). On Anthropic, OAuth token lifetimes are extended automatically using the stored refresh token; OpenAI also supports refresh-based renewal if refresh data is provided.
The general rule for both platforms: anything stored in the environment can be read by code generated by the agent. That is why the application’s main API key is not placed in the sandbox, and a separate environment key with minimal permissions is used for internal infrastructure. We covered how to design control boundaries for an agent in the article "Managing AI Agent Autonomy".
Pricing: two different formulas
Neither platform charges for the API itself, but compute is billed differently.
OpenAI Agents API: model tokens + standard tool rates + OpenAI sandbox container rates. The container costs $0.03 (1 GB), $0.12 (4 GB), or $0.48 (16 GB) per 20-minute session; for eligible sessions, billing is per minute with a 5-minute minimum (OpenAI pricing).
Claude Managed Agents: model tokens + $10 per 1,000 web searches + $0.08 per session hour. Time is billed to the millisecond and only while in the running status: waiting for a message or approval is not billed. There is no separate charge for container hours. The Batch API discount does not apply to sessions. When inference is pinned to the US (inference_geo: "us"), tokens cost 1.1x more (Anthropic pricing).
Model rates as of October 4, 2026, USD per 1 million tokens, standard processing:
| Model | Provider | Input | Output |
|---|---|---|---|
| gpt-6-astra | OpenAI | $10.00 | $50.00 |
| gpt-6.1-sol | OpenAI | $2.00 | $10.00 |
| gpt-6-luna | OpenAI | $0.10 | $0.50 |
| Claude Fable 5.1 | Anthropic | $10.00 | $50.00 |
| Claude Opus 5.5 | Anthropic | $4.00 | $20.00 |
| Claude Sonnet 5.5 | Anthropic | $2.00 | $10.00 |
| Claude Haiku 4.5 | Anthropic | $1.00 | $5.00 |
For OpenAI, short-context rates are shown.
Calculation example (illustration, not a forecast). One task: 400,000 input tokens with no cache, 30,000 output tokens, 40 minutes of sandbox runtime. For OpenAI, we use gpt-6.1-sol and a 4 GB container; for Anthropic, Claude Sonnet 5.5 with the same token rates:
| Article | OpenAI Agents API | Claude Managed Agents |
|---|---|---|
| Input | 400,000 × $2 / 1M = $0.80 | 400,000 × $2 / 1M = $0.80 |
| Output | 30,000 × $10 / 1M = $0.30 | 30,000 × $10 / 1M = $0.30 |
| Compute | 40 min × ($0.12 / 20 min) = $0.24 | 40 min × ($0.08 / 60 min) ≈ $0.053 |
| Total | $1.34 | ≈ $1.153 |
This calculation shows only how the formulas work. Models from different providers use different tokenizers and deliver different quality, so the same task will produce a different number of tokens and a different number of attempts. To compare cost, you need to look at the price of an accepted result on your own tasks.
Caching, retries, subagents, and paid tools are not included in the calculation. In this example, compute fees on both platforms are noticeably lower than token fees, so the main cost-saving lever here is model choice and context length. For more on comparing cloud and self-hosted models, see “Cloud or local LLM: how to compare TCO”.
Data, limits, and availability
Data storage. Agents API supports data residency only in the United States and does not support Zero Data Retention; a custom sandbox does not change that (Agents API overview). Claude Managed Agents is “designed as a stateful service”: history, sandbox state, and results are stored by Anthropic. Because of that, the service is not covered by Zero Data Retention or a HIPAA BAA, and sessions and files can be deleted through the API (Managed Agents overview). You can pin an agent’s inference geography with the inference_geo parameter (agent setup).
Request limits. Anthropic’s Managed Agents endpoints allow 300 create requests per minute and 1,200 read requests per organization, plus overall account limits (Managed Agents reference). In the Agents API documentation, we did not find separate request limits; it describes size limits instead: up to 4 MiB for configuration and input data (Agents API sessions).
Cloud platforms. Claude Managed Agents is available in Claude API and on Claude Platform on AWS, where features differ (Managed Agents overview). OpenAI’s documentation includes a page about Bedrock Managed Agents, a separate Amazon Bedrock service with similar concepts but its own API contracts (OpenAI on Bedrock Managed Agents).
If you need an agent on your own servers: Agents SDK and Claude Agent SDK
If a managed platform is not a fit, both providers offer libraries where the agent loop runs in your own process. OpenAI Agents SDK is an open framework for multi-agent scenarios with task handoff, guardrails, and tracing (Agents SDK repository). Claude Agent SDK provides the tools, agent loop, and context management that power Claude Code, packaged as a library for Python and TypeScript. It includes built-in tools, hooks, subagents, MCP, permissions, and sessions (Claude Agent SDK overview).
The libraries remove the question of state storage with the provider, but not the question of sending data to the model: requests to the OpenAI or Anthropic API remain external. An agent runs fully inside your own environment only with a model deployed by you. Such a system should be tested end to end, including tools and environment; see the article “AI agent wrapper”.
What to choose: the right solution by use case
OpenAI Agents API makes more sense if:
- your team already uses OpenAI models and wants to move long-running tasks into a managed environment;
- the agent needs to work in a browser with user-approved websites;
- you care about environment templates, plugins, and exporting traces to an existing observability stack through OTLP;
- the subtasks are repetitive and can run under one subagent configuration.
Claude Managed Agents makes more sense if:
- you need the Claude model and the built-in file tools;
- agent versioning and configuration rollback are important;
- you need a hard session budget, scheduled runs, or automatic result checking against a rubric;
- the subtasks need different models or tools within one session;
- you need detailed approval policies for each tool.
Neither is a fit if:
- your data requirements prohibit storing state with an external provider or require Zero Data Retention;
- your product operates in a country where the provider’s API is not officially available;
- the task can be solved with a single model call — agent scaffolding will only add cost and latency.
If you are unsure, run a short pilot on both platforms with one task, one acceptance criterion, and the same budget cap. Deciding based on the price of an accepted result and the share of successful runs is more reliable than any feature comparison.
Russia: availability and legal considerations
As of October 4, 2026, Russia is not listed among the supported countries for the OpenAI API (OpenAI), nor among Anthropic’s supported countries (Anthropic). OpenAI warns on its page that use of, or access from, countries outside the listed ones may result in account suspension. For Russian companies, that restriction matters more than any line in a summary table.
The second issue is personal and commercial data. Both platforms store session state with the provider abroad and do not support Zero Data Retention. If the agent works with personal data, the permissibility of transfer and storage should be reviewed with legal counsel before development begins. This article is not legal advice.
A practical alternative in such cases is a model in your own infrastructure or with a Russian cloud provider, plus your own agent wrapper. The architectural patterns from both platforms remain useful: long sessions, a sandbox with restricted networking, secrets outside the environment, budgets, explicit approval for risky actions.
Frequently Asked Questions
What are Claude Managed Agents in simple terms?
It’s an Anthropic service that runs the agent loop on Claude and gives it a sandbox with bash, files, and web search. You create the agent, environment, and session, send tasks, and receive an event stream. The service is in beta.
How is Claude Managed Agents different from Claude Agent SDK?
Managed Agents is a hosted platform: the agent loop and sandbox run at Anthropic or in your worker. Claude Agent SDK is a library with tools and the Claude Code loop that you run and maintain in your own application.
Which platform is cheaper?
In our example, Anthropic’s compute charge is lower for the same runtime, but model tokens account for most of the bill there. The final cost depends on the model chosen, context length, and number of attempts, so compare the cost of an accepted result on your own tasks.
Can you run the agent code on your own servers?
Yes, both platforms support custom sandboxes. The agent loop still remains with the provider, while tool inputs and outputs are passed to it, so data storage requirements still apply.
Do both platforms support MCP?
Yes. In the OpenAI Agents API, an MCP server can be connected from OpenAI infrastructure, from the environment, or as a stdio process. In Claude Managed Agents, servers are specified in the agent configuration, and credentials are stored in vaults.
Can you cap the spending of a single agent?
Claude Managed Agents has a hard session budget in dollars. In the documentation we reviewed for the OpenAI Agents API, there is no equivalent, but organization-wide monthly spending limits are available, along with control through model selection, the number of subagents, and deletion of inactive sessions.
Which platform should you choose for work from Russia?
Neither is officially available in Russia as of October 4, 2026. For Russian projects, models in your own infrastructure or Russian cloud services are usually considered.
How Vladimir Lomtev’s AI studio helps you choose and implement an agent platform
Platform comparisons are useful once it is clear what work the agent should do and what data it can access. Vladimir Lomtev’s AI studio builds AI agents integrated with communication channels and business systems, and deploys language models, including on the customer’s own servers. For platform selection, we can:
- audit the process and data: which steps to delegate to the agent, which systems it touches, and what cannot be sent to an external provider;
- design and test an agent MVP integrated with CRM, ERP, or 1C, with limited tool permissions;
- deploy the model within the company perimeter if cloud platforms are not suitable because of availability or data requirements.
The first step is to describe one process: current metrics, data sources, constraints, and the criterion by which the agent’s result is considered accepted. With that description, you can honestly compare options in a pilot. Discuss the project.
Conclusion
OpenAI Agents API and Claude Managed Agents are structured in a similar way: the provider runs the agent loop and session, while you connect tools and choose where code runs. The choice is not determined by the basic concepts, but by the details: models, multi-agent setup, approval policies, budget and schedule, and the compute pricing formula.
If your team works with GPT and needs a browser controlled by the agent, start with the Agents API. If you need Claude, agent versions, budgets, and rubric-based evaluation, start with Managed Agents. If data cannot be stored with the provider or the API is unavailable in your jurisdiction, both platforms are off the table: consider your own wrapper and a model in your own environment. In any case, the decision should be made based on a pilot for one task with a measurable acceptance criterion.