Back to vendors
O

OpenAI Agents platform

Also known as: OpenAI Agents API, OpenAI Agents SDK, OpenAI ChatKit, OpenAI AgentKit, OpenAI Agent Builder

Visit site
Entry priceUsage based: model tokens at each model's API rate, hosted tools at their own rates, and sandboxes from $0.03 per 20 minute session for 1 GB.Full pricing detail

OpenAI's platform for developers building their own agents on its API. The Agents API, in beta, runs a managed Codex harness with durable sessions, subagents, sandboxes, MCP tools, browser control, approvals, cron automations and tracing; the open source Agents SDK builds agents in code; ChatKit embeds agent chat in an app. File search, data residency by project and enterprise access controls come with the API, and enterprise customers can add managed red teaming of their agents. Usage is billed at model, tool and container rates.

The OpenAI Agents platform is the part of OpenAI's API that developers use to build, run and govern agents of their own, as distinct from OpenAI's finished agents in ChatGPT and the Codex coding agent. It brings together the Agents API, the Responses API and its hosted tools, the open source Agents SDK for Python and TypeScript, and ChatKit for embedding an agent's chat and widgets in a product.

The visual Agent Builder, once sold under the AgentKit name, was deprecated in June 2026 and is scheduled to shut down on 30 November 2026, with a migration path to the Agents API, and the Evals dashboard and API follow the same timeline. Promptfoo, the evaluation framework OpenAI owns, still sells under its own name as a separate product.

The Agents API, in beta, gives an application the Codex harness as a managed service: OpenAI runs sessions, orchestration, context compaction and recovery while the developer supplies tools and picks an execution environment. An agent definition sets the model, instructions, tools and MCP servers; a session is a durable unit of work made of turns; and an environment can be an OpenAI hosted sandbox or a machine on E2B, Daytona, Blaxel, Cloudflare, AWS Lambda MicroVMs, Databricks or DigitalOcean.

Agents call functions and MCP servers, delegate to subagents that work in parallel with their own context, drive a browser in an OpenAI hosted environment, raise approval requests that an application or an automatic review policy answers, start on cron schedules or schedule their own follow ups, and leave traces of every model response, tool call and delegation. Amazon Bedrock Managed Agents runs on the same API.

There is no subscription. Model calls bill at each model's API rates, hosted tools at their own rates (web search $10 per 1,000 calls, file search storage $0.10 per GB a day after 1 GB free) and sandboxes at container rates from $0.03 for 1 GB to $1.92 for 64 GB per 20 minute session. Access runs through organization and project roles, custom roles, groups, service accounts, IP allowlists and Private Link. OpenAI's SOC 2 Type 2 report and ISO 27001, 27017, 27018 and 27701 certificates cover the API platform. Projects can be pinned to a data residency region, with a 10 percent uplift on eligible newer models, and approved customers can turn on zero data retention.

The platform fits engineering teams that want a managed agent runtime with sandboxes, approvals and tracing from the model maker, and teams already building on the Responses API or the Agents SDK. It fits less well for buyers who need a no code builder, since Agent Builder is closing, or who want a managed runtime that runs other makers' models, since only the open source SDK reaches models from other providers.

Vendor details

Canonical URL

https://developers.openai.com/api/docs/guides/agents

Category

Agent infrastructure

Subcategory

Managed agent runtime, agent SDK, hosted agent tools and embeddable agent chat from a model maker

Funding status

A product line of OpenAI; company funding is outside the scope of this record.

Company status

first party product

Use cases & customers

Primary use cases

running durable cloud agents on a managed Codex harness with sandboxes and MCP toolsdelegating work to parallel subagents and combining their resultsstarting agent sessions on cron schedules and reacting to session webhooksletting agents operate a browser with approvals for each website and sign inbuilding multi agent workflows in code with the open source Agents SDK

Target customers

engineering teams building their own agents on OpenAI modelsproduct teams embedding an agent chat in their app with ChatKitplatform teams that need sandboxed agents with approvals, schedules and tracingenterprises that need project level access control, data residency and zero data retention

Deployment options

OpenAI hosted API with OpenAI hosted sandboxesAgent environments on the customer's own sandbox provider or cloud (E2B, Daytona, Blaxel, Cloudflare, AWS Lambda MicroVMs, Databricks, DigitalOcean)Project level data residency regionsAmazon Bedrock Managed Agents running on the Agents APIOpen source Agents SDK run wherever the customer deploys it

Integrations

Remote MCP servers and MCP servers inside the session environment, function tools, hosted web search, file search, shell, code interpreter and computer use; sandbox providers E2B, Daytona, Blaxel, Cloudflare, AWS Lambda MicroVMs, Databricks and DigitalOcean; Amazon Bedrock Managed Agents; the Agents SDK with Any-LLM and LiteLLM adapters for other providers; OTLP trace export; Promptfoo for evaluation.

In practice

A platform team defines a release review agent on the Agents API with read access to a repository through an MCP server. Each night a cron automation starts a session; the agent hands three changelogs to parallel subagents, combines their findings, and raises an approval request before it posts anything, which the team's app shows to an engineer.

A support product embeds ChatKit so customers chat with an agent built on the Agents SDK. The agent searches the company's help center through file search over a vector store, and every run's model calls, tool calls and handoffs appear as traces the team exports to its own observability stack.

A QA team gives an agent a browser in an OpenAI hosted environment to test a checkout flow. The agent asks before visiting each new website origin, hands sign in back to a person when an account is needed, and the team scores the run with a Promptfoo eval before rolling out a prompt change.

Agentic Index coverage score

12.5 / 14 capabilities · 89%

Integrations & Tool Calling Full

Agents act in outside systems through function tools the developer defines, which pause the turn until the application returns a result, and through MCP servers, either remote ones reachable from OpenAI or servers started inside the session's own environment over HTTP or stdio, with tools discovered and called by the platform. Hosted tools add web search, file search, a shell and a code interpreter, so one agent can look something up, read company files and run code in the same turn.

Sourcedevelopers.openai.com/api/docs/guides/agents-api/tools/mcpread 2026-11-09

Workflow Orchestration Full

In the Agents API, in beta, OpenAI runs the orchestration: a session is a durable unit of work made of turns, and the platform handles compaction and recovery across long tasks. A main agent can delegate independent tasks to subagents, each with its own context, that work in parallel while the main agent coordinates and combines their results, such as comparing several release notes at once. Teams building in code get the same multi agent patterns, handoffs between agents and agents used as tools, in the open source Agents SDK.

Sourcedevelopers.openai.com/api/docs/guides/agents-api/multi-agentread 2026-11-09

Knowledge Grounding & RAG Full

File search lets an agent search a company's own files for relevant passages before it answers. Documents are uploaded once into vector stores that persist and are billed for storage by the gigabyte per day, with the first gigabyte free, so the index outlives any single run and grows past what fits in a prompt. Embeddings are also available directly for teams that run their own retrieval, and files placed in a session's environment give an agent working material for a task.

Sourcedevelopers.openai.com/api/docs/guides/tools-file-searchread 2026-11-09

Human Oversight & Guardrails Full

Agents in the Agents API, in beta, raise approval requests that wait as required actions until the application answers them, so a person can approve or reject a step before it runs. Automatic review can approve or deny supported requests by policy for the main agent and every subagent, can change between tasks, and never overrides the environment's network restrictions. Browser tasks ask before visiting each new website and hand sign in back to a person, and the Agents SDK adds guardrails and human review for agents built in code.

Sourcedevelopers.openai.com/api/docs/guides/agents-api/sessions/approvalsread 2026-11-09

Security, Identity & Governance Full

Role based access governs both the dashboard and the API: organization roles reach every project, project roles stay inside one, custom roles carry exactly the permissions a team chooses, and groups, project service accounts and Admin API keys round out who can do what. Organizations and projects can restrict API calls to allowlisted IP ranges or Azure Private Link. OpenAI's SOC 2 Type 2 report and its ISO 27001, 27017, 27018 and 27701 certificates cover the API platform, alongside ISO 42001 and CSA STAR.

Sourcedevelopers.openai.com/api/docs/guides/rbacread 2026-11-09

Observability & Auditability Full

Tracing is on by default for Agents API sessions, in beta. Each session lists its status, model, turns and token usage, and each turn's trace shows the model responses, tool calls and work delegated to other agents in order, so a team can see why an agent did what it did. Traces can be read in the dashboard or exported through the API as OTLP JSON into the team's own observability stack, and agents built with the Agents SDK record model calls, tool calls, guardrails and handoffs the same way.

Sourcedevelopers.openai.com/api/docs/guides/agents-api/tracingread 2026-11-09

Memory & State Persistence Full

Sessions in the Agents SDK carry an agent's conversation memory across separate runs, stored and read back automatically under a session ID in a backend the team chooses: SQLite, Redis, SQLAlchemy, Dapr, MongoDB, encrypted storage or OpenAI's Conversations API. Memory operations let the application read, correct or clear one session's history without touching other data. In the Agents API, sessions stay durable across turns with automatic compaction, and saved work can be deleted when a task ends.

Sourceopenai.github.io/openai-agents-python/sessionsread 2026-11-09

Deployment & Data Residency Full

Data residency is a project setting: a team selects the region where customer content is stored at rest, and in regions that support it, where inference runs, after confirming eligibility with sales, with a 10 percent uplift on eligible newer models. Agent work can run in an OpenAI hosted sandbox or on the customer's own environment provider, E2B, Daytona, Blaxel, Cloudflare, AWS Lambda MicroVMs, Databricks or DigitalOcean, and approved customers can switch on zero data retention.

Sourcedevelopers.openai.com/api/docs/guides/your-dataread 2026-11-09

Prebuilt Agents / Templates / Packs Partial

Ready made material comes as parts to assemble rather than agents to switch on. Complete examples show an agent writing and running a script in a hosted sandbox, comparing release notes with subagents and working with policy skills and specialist agents, ChatKit ships widgets and actions for building an agent's chat interface, and the cookbook covers agents, evals and multimodal patterns. Agent Builder's starting templates go away when that product closes, and its workflows move to the Agents API.

Sourcedevelopers.openai.com/api/docs/guides/agents-api/overviewread 2026-11-09

Triggers & Channel Coverage Full

Scheduled automations in the Agents API, in beta, start a new session or continue an existing one from a cron expression and time zone, with no request from the application, and an agent given the automations tool can schedule its own follow up work in the middle of a task. Session webhooks report lifecycle changes so the developer's systems react when a session needs input or finishes, and applications can also start sessions from any backend event through the API.

Sourcedevelopers.openai.com/api/docs/guides/agents-api/sessions/automationsread 2026-11-09

Model Flexibility & Routing Partial

Agents on the Agents API and the hosted tools run on OpenAI's own models, with the team choosing the model per agent and paying that model's API rate, and Amazon Bedrock Managed Agents runs the same API on AWS rather than adding other model makers. The open source Agents SDK is the route to other providers: it can mix models across makers in one workflow through Any-LLM and LiteLLM adapters, so choice across makers reaches agents built in code but not the managed service.

Sourceopenai.github.io/openai-agents-python/modelsread 2026-11-09

APIs / SDKs / MCP Extensibility Full

Everything on the platform is an API first. The REST reference covers agents, sessions, turns, environments and automations alongside the Responses API, official client libraries wrap them, the open source Agents SDK in Python and TypeScript builds agents in code, and ChatKit offers a frontend kit plus an advanced mode that connects to the team's own server. Admin APIs and Terraform resources manage projects, roles, service accounts, rate limits and spend.

Sourcedevelopers.openai.com/api/docs/guides/agents-api/overviewread 2026-11-09

Testing, Debugging & Optimization Partial

OpenAI Red Teaming is OpenAI's own offer for new evaluation work: a managed service, sold to enterprise customers, that probes a team's AI applications and agents with adversarial, abusive and unexpected inputs before deployment and supports coordination, review and reporting on the findings. Promptfoo, the open source eval and red teaming framework that OpenAI owns, is a separate product sold under its own name with its own enterprise plans. The Evals dashboard and API, with their graders, trace grading and prompt optimizer, are read only and shutting down, so they take no new work.

Sourcedevelopers.openai.com/api/docs/guides/red-teamingread 2026-11-09

Browser / Computer-use Full

Agents navigate websites and work through browser interfaces in a browser OpenAI hosts: the application starts a browser session, sends a task and follows events while the agent decides each next step from what it sees, asking for access to each new website and handing sign in to a person when an account is needed. The computer use tool also runs browser or desktop tasks through the SDKs, or connects to the customer's own runner for its own machines.

Sourcedevelopers.openai.com/api/docs/guides/agents-api/tools/computer-useread 2026-11-09

The Agentic Index coverage score grades every vendor Full, Partial or Not documented against the same 14 buyer facing capabilities, from public evidence only. Each capability links to how all vendors in the index score on it. How this evidence is graded

Pricing

Usage based: model tokens at each model's API rate, hosted tools at their own rates, and sandboxes from $0.03 per 20 minute session for 1 GB.

Tokens per model, tool calls and storage per hosted tool, and container time per 20 minute session by memory size

Included quota

No included usage beyond 1 GB of free file search storage.

What is public

Per model token rates, hosted tool rates, container rates and the data residency uplift.

Billing mechanics

Pay as you go API billing per organization, with organization and project spend limits.

Cost watchouts

Subagents, browser sessions and long sessions each add model tokens and container time; search content tokens bill on top of web search calls; data residency adds 10 percent on eligible newer models.

Variable cost rationale

Every model call, tool call and sandbox session bills by use, and long running agents with subagents multiply all three, so spend follows how much work the agents do.

Additional watchouts

Agent Builder and the Evals platform shut down on 30 November 2026, so workflows built there need migrating.

Overage / add-ons

Not applicable; every call and session bills at the published rate, within organization and project spend limits the team sets.

Sales call required

Mixed (some tiers require a call)

Free / trial

The Agents SDK and ChatKit are free to use; file search includes 1 GB of storage free. API usage is paid from the first call.

Lowest paid plan

No plan; pay as you go API usage at model, tool and container rates

Commercial notes

The Agents SDK and ChatKit are free; the platform earns on model, tool and sandbox usage.

Key ambiguities

The Agents API is in beta and has no separate price list beyond model, tool and container rates; enterprise terms and data residency eligibility go through sales.

Missing data

Enterprise discounts and contract terms.

Agentic Index verified 2026-11-09

Alternatives to OpenAI Agents platform

The closest documented capability profiles to OpenAI Agents platform among agent infrastructure platforms tracked by Agentic Index, ordered by similarity on the same 14 point evidence the rankings use. No vendor pays for placement.

  • Cloudflare13.0 / 14Fuller documented coverage on Model Flexibility & Routing
  • Momentic12.5 / 14Fuller documented coverage on Testing, Debugging & Optimization
  • Mastra14.0 / 14Fuller documented coverage on Prebuilt Agents, Templates & Packs and Model Flexibility & Routing
  • Unblocked12.0 / 14Fuller documented coverage on Prebuilt Agents, Templates & Packs
  • xpander.ai12.0 / 14Fuller documented coverage on Model Flexibility & Routing
  • Kestra12.5 / 14Fuller documented coverage on Prebuilt Agents, Templates & Packs and Model Flexibility & Routing

Similarity is computed from each vendor's Agentic Index coverage score evidence, axis by axis, not from the totals. How this evidence is graded

Contact us

Found a vendor we missed? Have feedback on the index? We'd love to hear from you.