OOpenAI Agents SDK

OpenAI gives the OpenAI Agents SDK away under the MIT license, and more than 30,000 developers have starred it on GitHub. The bill comes from what agents built with it consume: model tokens, $10 for every 1,000 web searches on most models and up to $1.92 per 20-minute container session. For Python teams building on OpenAI models, it is one of the most direct ways to ship agents that use tools, hand work to each other and, since April 2026, run code in sandboxes.

It suits developers who want a small, code-first framework with tracing and guardrails included, and who are comfortable writing Python. It is a library rather than a finished product: there is no visual builder, and the new sandbox harness shipped in Python before TypeScript. The SDK itself is free, and we rate it 8.6/10 on our scale. We have not used it ourselves; this review is based on OpenAI’s GitHub repository, announcement and published API pricing.

Repository, Launch Post and API Price Data

OpenAI publishes few adoption figures for the SDK, but its repository, launch post and API price list show how widely it is used and what running it costs.

Two things matter for a buyer. The star count puts the SDK in the same league as the most popular agent frameworks, which means plenty of examples, issues and community answers when something breaks. And the cost structure is unusual: the framework is free, but its most useful built-in tools are metered by the call, so the price of an agent depends on how many searches, file lookups and container sessions it triggers per task.

The Oscar Health example matters because healthcare records work is a hard test of reliability. It is one customer quote rather than a published metric, but it signals that OpenAI is positioning the SDK for regulated production work, not only demos.

Building Blocks and a Runner That Loops to Completion

The SDK gives developers a small set of building blocks and a runner that loops until an agent finishes its task. Everything is defined in Python code.

The Core Building Blocks

• Agents: a model plus instructions, tools and a list of other agents it can hand off to. Agents can also be called as tools by other agents.
• Tools: Python functions, hosted OpenAI tools such as web search and file search, and MCP servers.
• Handoffs: one agent passes the conversation to a specialist, for example a triage agent routing a billing question to a billing agent.
• Guardrails: checks on inputs and outputs that can stop a run when a rule is broken.
• Human in the loop: points where a run pauses for a person to approve an action.
• Sessions: stored conversation history, so an agent remembers earlier turns.
• Tracing: a record of every step in a run, used to view, debug and tune workflows.

Sandbox Agents and the Harness

The April 2026 release added a model-native harness so agents can work across files and tools on a computer. It includes Codex-like filesystem tools, a shell tool, an apply-patch tool, configurable memory and standard support for MCP, skills and AGENTS.md files. A Manifest describes the agent’s workspace: which local files to mount, where outputs go and which cloud storage to pull from.

Harness and compute are separate. The agent loop and its credentials stay on your side, while model-generated code runs in a sandbox from Blaxel, Cloudflare, Daytona, E2B, Modal, Runloop, Vercel or your own provider. If a container fails or expires, built-in snapshots let the run restart in a fresh container from its last checkpoint. A run can use one sandbox or many, start them only when needed and send subagents to isolated environments.

Installing on Python 3.10 and Adding a Model Key

1. Install: run pip install openai-agents (or uv add openai-agents) on Python 3.10 or newer.
2. Add a model key: connect the OpenAI API, or add LiteLLM or any-llm to use another provider.
3. Define agents: write instructions, attach tools and list handoff targets.
4. Add controls: set guardrails, approval steps and a session store.
5. Optional sandbox: write a Manifest and pick a sandbox provider for agents that need files and a shell.
6. Run and trace: start the runner and use tracing to inspect each step before going to production.

Developers Set Tool Access and Approval Stops

Developers decide what each agent may do, which tools it can reach and when it must stop for approval. Someone has to write and maintain the guardrails, review traces, set spending limits and host the application. The SDK does not include a hosted dashboard for business users or a no-code editor, so changes to agent behavior go through code.

Free Code, Standard OpenAI API Rates

The SDK is free. Agents built with it pay standard OpenAI API rates for tokens and tool use, or the rates of whichever model and sandbox providers you choose. The figures below are from OpenAI’s API pricing page in October 2026.

Token and Tool Costs for a Support Triage Agent

These examples use OpenAI’s published prices. Run counts and token sizes are our own illustrative assumptions, and real agents vary widely.

• A support triage agent: 20,000 runs a month, each using about 3,000 input and 500 output tokens on gpt-6.1-terra, plus one file search. Tokens cost $60 for input and $50 for output, file search adds $50 and 3 GB of stored documents adds $6 (2 GB billable for 30 days), for about $166 a month.
• A research agent: 2,000 runs a month, each making 10 web searches and using 50,000 input and 5,000 output tokens on gpt-6.1-sol. Searches cost $200, input tokens $200 and output tokens $100, for about $500 a month before any search content tokens.
• A coding agent in hosted containers: 1,000 sessions a month on 4 GB containers costs $120 in container time, plus the tokens the agent uses to read and write code.

Other costs to plan for: retries and long reasoning chains multiply token use, multi-agent handoffs send context to more than one model call, and search content tokens are billed on top of the per-call search fee. Hosting the application, storing sessions and any third-party sandbox are also separate. Set per-run limits and watch traces during testing to see where tokens go.

OpenAI Agents SDK Compared With LangGraph, Google ADK and CrewAI

All four are free, open-source frameworks for developers. They differ in how much structure they impose and how closely they tie you to one model vendor’s cloud.

The OpenAI Agents SDK is the quickest of the four to learn if you already use OpenAI’s API: a handful of concepts, a runner and tracing included. LangGraph gives more control over every step at the cost of more code. Google ADK covers more languages and adds graph workflows and managed hosting on Google Cloud. CrewAI is the choice when the mental model of a team of role-based agents fits the problem. For TypeScript teams, Mastra and Microsoft Agent Framework for .NET are worth a look. Browse more options in our agent frameworks and multi-agent guides.

Python Teams Already on the Responses API

• Python teams already on the OpenAI API: the SDK maps directly onto the Responses API and its hosted tools, so there is little glue code to write.
• Builders of agents that touch files and code: the sandbox harness, shell tool, apply-patch and snapshots are designed for long-running work on a computer.
• Teams that want tracing from day one: every run is recorded step by step without adding a separate observability library.
• Developers who prefer a small API: agents, tools, handoffs, guardrails and sessions cover most needs without a graph language.
• Regulated teams that need separation of duties: keeping credentials in the harness and code in the sandbox fits security reviews, as the Oscar Health example suggests.

No-Code Teams and TypeScript-First Shops

• Non-technical teams: there is no visual builder; a no-code agent builder will be faster.
• TypeScript-first teams that need the sandbox harness now: OpenAI shipped it in Python first and lists TypeScript support as planned.
• Teams committed to another cloud’s model stack: non-OpenAI models work through LiteLLM or any-llm, but hosted search and file tools are OpenAI API features.
• Projects that need strict, deterministic workflows: a graph framework such as LangGraph or Google ADK 2.0 gives more control over each transition.
• Buyers who want a fixed monthly price: costs scale with tokens, tool calls and container time.

Separately Billed Tools and Usage Planning

• Metered tools: a single run can trigger several web searches, file lookups and container sessions, each billed separately from tokens.
• Python first: the April 2026 harness launched for Python; code mode and subagents are listed as planned for both Python and TypeScript.
• Vendor lean: the framework is provider-agnostic, but its most useful hosted tools only run on the OpenAI API, so switching models can mean rebuilding tools.
• Infrastructure: hosting, session storage, monitoring and spending limits stay with your team.
• Model-written code: sandboxes reduce risk, but you still decide what files and data each Manifest exposes and which actions need human approval.
• Fast change: a major capability update arrived about a year after launch, so pin versions and read release notes before upgrading.

Sandbox Execution and the April 2026 Harness

• April 15, 2026: OpenAI announced the next evolution of the Agents SDK, adding a model-native harness, native sandbox execution with seven providers, a Manifest abstraction and snapshot-based recovery, generally available through the API at standard pricing.
• October 2026: the openai-agents-python repository listed sandbox, realtime and voice agents among its core concepts, with about 30,400 stars.

A Solid Choice for Python Developers on OpenAI Models

For Python developers building on OpenAI models, yes. The OpenAI Agents SDK scores 8.6/10 on our scale: strong on autonomy, integrations and pricing value, with a code-only setup and public user ratings still to come as the main considerations. It gives you agents, handoffs, guardrails, sessions and tracing in a small package, and the April 2026 sandbox harness makes it a serious option for agents that work with files and code.

The trade-off is dependence on metered OpenAI tools and a Python-first roadmap. Before committing, build one agent, run it on real tasks for a week and use the traces to count tokens, searches and container sessions per task. Multiply by your expected volume, and compare with LangGraph or Google ADK if you need stricter workflow control or a different cloud.

Using Claude or Gemini, and What Sandbox Agents Are

Is the OpenAI Agents SDK Free?

Yes. The SDK is open source under the MIT license and installs with pip. You pay for what agents use: OpenAI API tokens and hosted tools such as web search at $10 per 1,000 calls, or the rates of other model and sandbox providers.

Can the OpenAI Agents SDK Use Claude, Gemini or Other Models?

Yes. OpenAI describes it as provider-agnostic, supporting its Responses and Chat Completions APIs and more than 100 other LLMs through the optional LiteLLM and any-llm integrations. Hosted tools such as file search and web search remain OpenAI API features.

What Are Sandbox Agents in the OpenAI Agents SDK?

Sandbox agents run model-generated code and file operations inside an isolated container from providers such as E2B, Modal, Daytona, Cloudflare or Vercel. The agent loop and credentials stay outside the sandbox, and snapshots let a run resume in a new container if the first one fails.

How Does the OpenAI Agents SDK Compare With LangGraph?

The OpenAI SDK has fewer concepts and includes tracing, guardrails and sandboxes out of the box. LangGraph models agents as graphs with explicit state and checkpoints, which gives more control over each step but takes more code. Both are free; LangGraph’s hosted tooling, LangSmith, starts at $39 per seat a month on the Plus plan.

Does the OpenAI Agents SDK Support TypeScript?

The April 2026 harness and sandbox features launched in Python first. OpenAI said TypeScript support for them is planned for a future release, along with code mode and subagents for both languages.