OpenAI Agents SDK (Python)

The basic unit is an Agent: a model with instructions, tools, guardrails and a list of agents it may hand off to. Runner.run() (or run_sync / run_streamed) drives the loop: call the model, execute tool calls, follow handoffs, and stop when an agent produces final output.

The docs describe two main multi-agent patterns. With handoffs, a triage agent routes the conversation to a specialist, and that specialist takes over for the rest of the turn. With agents as tools, a manager agent calls specialists via Agent.as_tool() and composes their results itself. The two can be combined, and flows can also be orchestrated in plain Python by chaining runs or running agents in parallel.

Runs hold no memory by default. Sessions persist conversation history client-side (SQLite, Redis, SQLAlchemy and others), or the app can use OpenAI's server-managed continuation (previous_response_id, conversation_id) instead. A paused run can be serialized as RunState and resumed later. Tracing records each model call, tool call and handoff as spans.

Tools declare needs_approval=True, or pass an async function that decides per call. This is available on function tools, Agent.as_tool, ShellTool and ApplyPatchTool; local MCP servers take require_approval and hosted MCP tools a require_approval tool config. When approval is needed, the run stops and the result lists pending approvals as interruptions. The application approves or rejects each item on the RunState, which can be serialized and stored, and then resumes the original run. Approvals raised inside handoffs or nested agent tools surface on the outer run. Some tool types also accept programmatic approval callbacks so the run continues without pausing.

pip install openai-agents

from agents import Agent, Runner

billing = Agent(name="Billing agent",
                instructions="Answer billing questions in two sentences.")
tech = Agent(name="Tech support agent",
             instructions="Answer technical questions step by step.")
triage = Agent(
    name="Triage agent",
    instructions="Decide who should answer and hand off to that agent.",
    handoffs=[billing, tech],
)

# needs OPENAI_API_KEY in the environment
result = Runner.run_sync(triage, "I was charged twice this month.")
print(result.last_agent.name)  # the specialist that answered
print(result.final_output)

• Python 3.10 or newer is required.
• Set OPENAI_API_KEY before running; other providers need the model adapters described on the models page.
• Voice and Redis sessions are optional extras: openai-agents[voice], openai-agents[redis].
• Versions follow 0.Y.Z: a minor bump (for example 0.21 to 0.22) may contain breaking changes, so pin the minor version.
• Tracing is on by default; set OPENAI_AGENTS_DISABLE_TRACING=1 to turn it off. It is not available to organizations under Zero Data Retention.
• A session cannot be combined with previous_response_id or conversation_id in the same run.

Yes, as a client. Agents connect to MCP servers over stdio, SSE or Streamable HTTP, and HostedMCPTool lets OpenAI's Responses API call a public MCP server directly.

No. A maintainer comment on issue #472 in August 2026 said OpenAI does not plan an SDK-owned A2A abstraction and showed how to wire the separate a2a-sdk manually.

The SDK is MIT-licensed. Model calls and hosted tools on OpenAI's API are billed under OpenAI API pricing; other providers are billed by those providers.

Yes. The README says the SDK is provider-agnostic, and the models page covers non-OpenAI providers through adapters such as any-llm and LiteLLM.

A handoff makes the specialist the active agent for the rest of the turn. With agents as tools, a manager agent calls the specialist and keeps control of the final answer.