BEGINNER0 views

openai-agents-python

A lightweight, powerful framework for multi-agent workflows

View Repository Live Demo

openai-agents-python

A lightweight, powerful framework for multi-agent workflows

What is this?

A lightweight, powerful framework for multi-agent workflows

What problem does it solve?

Traditional LLM applications often follow a simple pattern:

User → Prompt → AI → Response

That works well for questions and simple conversations, but it becomes difficult when an AI needs to perform real tasks, use external tools, maintain context, make decisions, or coordinate multiple specialized agents.

The OpenAI Agents SDK provides a structured way to build these systems. It allows developers to connect AI models with tools, instructions, handoffs, guardrails, sessions, and execution workflows, making it possible to build applications where AI can do more than generate text.

How does it work?

The OpenAI Agents SDK organizes an AI application around an agent that can receive a task, decide what actions are needed, use available tools, and return a final result.
User gives a task
↓
AI Agent
↓
Understands the task
↓
Does it need a tool?
↙ ↘
Yes No
↓ ↓
Call a tool Generate answer
↓
Receive result
↓
Continue processing
↓
Final response

Repository Structure

openai/openai-agents-python/
├── 📁 .agents
├── 📄 .gitattributes
├── 📁 .github
├── 📄 .gitignore
├── 📄 .prettierrc
├── 📁 .vscode
├── 📄 AGENTS.md
├── 📄 CLAUDE.md
├── 📄 LICENSE
├── 📄 Makefile
├── 📄 PLANS.md
├── 📄 README.md
├── 📄 SECURITY.md
├── 📁 docs
├── 📁 examples
├── 📁 integration_tests
├── 📄 mkdocs.yml
├── 📄 pyproject.toml
├── 📄 pyrightconfig.json
├── 📁 src
├── 📁 tests
├── 📄 uv.lock

Top-level files and directories from the main branch.

Key Features

🤖 AI Agents

Create agents with specific instructions, capabilities, and responsibilities instead of building everything around a single LLM request.

🔧 Tool Calling

Give agents access to tools and functions so they can retrieve information or perform actions beyond generating text.

🔀 Agent Handoffs

Transfer a task from one specialized agent to another, making it possible to build multi-agent systems.

🛡️ Guardrails

Validate inputs and outputs and add rules that help keep agent behavior within defined boundaries.

🧠 Sessions & State

Maintain relevant conversation and execution state so agents can work across multiple interactions.

👤 Human-in-the-Loop

Allow people to review, approve, or intervene when an agent reaches an action that requires human control.

📊 Tracing & Observability

Track agent runs, tool calls, handoffs, and other execution details to help developers understand and debug their systems.

🔗 MCP Support

Connect agents with tools and external capabilities through the Model Context Protocol (MCP)

What You'll Learn

Write learning outcomes here...

README

<details> <summary>Click to expand README</summary>

OpenAI Agents SDK

The OpenAI Agents SDK is a lightweight yet powerful framework for building multi-agent workflows. It is provider-agnostic, supporting the OpenAI Responses and Chat Completions APIs, as well as 100+ other LLMs.

[!NOTE]
Looking for the JavaScript/TypeScript version? Check out Agents SDK JS/TS.

Core concepts:

Agents: LLMs configured with instructions, tools, guardrails, and handoffs
Sandbox agents: Agents preconfigured to work with a container to perform work over long time horizons.
Realtime agents: Build powerful voice agents with gpt-realtime-2.1 and full agent features
Voice agents: Build voice pipelines that combine speech-to-text, an agent workflow, and text-to-speech
Agents as tools / Handoffs: Delegating to other agents for specific tasks
Tools: Various Tools let agents take actions (functions, MCP, hosted tools)
Guardrails: Configurable safety checks for input and output validation
Human in the loop: Built-in mechanisms for involving humans across agent runs
Sessions: Automatic conversation history management across agent runs
Tracing: Built-in tracking of agent runs, allowing you to view, debug and optimize your workflows

Explore the examples directory to see the SDK in action, and read our documentation for more details.

Get started

To get started, set up your Python environment (Python 3.10 or newer required), and then install OpenAI Agents SDK package.

venv

python -m venv .venv
source .venv/bin/activate  # On Windows: .venv\Scripts\activate
pip install openai-agents

For voice support, install with the optional voice group: pip install 'openai-agents[voice]'. For Redis session support, install with the optional redis group: pip install 'openai-agents[redis]'.

uv

If you're familiar with uv, installing the package would be even easier:

uv init
uv add openai-agents

For voice support, install with the optional voice group: uv add 'openai-agents[voice]'. For Redis session support, install with the optional redis group: uv add 'openai-agents[redis]'.

Run your first agents

The SDK supports four primary ways to run agents. Set the OPENAI_API_KEY environment variable before running any of these examples.

Run a text agent

Use a text Agent for workflows that do not need a persistent realtime connection or a sandbox workspace.

from agents import Agent, Runner

agent = Agent(name="Assistant", instructions="You are a helpful assistant")

result = Runner.run_sync(agent, "Write a haiku about recursion in programming.")
print(result.final_output)

# Code within the code,
# Functions calling themselves,
# Infinite loop's dance.

(For Jupyter notebook users, see hello_world_jupyter.ipynb)

Run a sandbox agent

Use a SandboxAgent when the agent needs to inspect files, run commands, apply patches, or preserve workspace state across longer tasks.

This example uses UnixLocalSandboxClient, which is supported on macOS and Linux. On Windows, use DockerSandboxClient with the openai-agents[docker] extra or a hosted sandbox client instead; see Sandbox clients for setup details.

from agents import Runner
from agents.run import RunConfig
from agents.sandbox import Manifest, SandboxAgent, SandboxRunConfig
from agents.sandbox.entries import GitRepo
from agents.sandbox.sandboxes import UnixLocalSandboxClient

agent = SandboxAgent(
    name="Workspace Assistant",
    instructions="Inspect the sandbox workspace before answering.",
    default_manifest=Manifest(entries={"repo": GitRepo(repo="openai/openai-agents-python", ref="main")}),
)

result = Runner.run_sync(
    agent,
    "Inspect the repo README and summarize what this project does.",
    run_config=RunConfig(sandbox=SandboxRunConfig(client=UnixLocalSandboxClient())),
)
print(result.final_output)

Run a realtime agent

Use a RealtimeAgent for low-latency, server-side voice and multimodal experiences over WebSocket.

import asyncio
from agents.realtime import RealtimeAgent, RealtimeRunner

async def main() -> None:
    agent = RealtimeAgent(name="Assistant", instructions="You are a helpful voice assistant. Keep responses short.")
    runner = RealtimeRunner(starting_agent=agent)
    session = await runner.run()

    async with session:
        await session.send_message("Say hello in one short sentence.")
        async for event in session:
            if event.type == "audio":
                # Forward or play event.audio.data.
                pass
            elif event.type == "history_added":
                print(event.item)
            elif event.type == "agent_end":
                break

if __name__ == "__main__":
    asyncio.run(main())

Run a voice agent

Use a VoicePipeline to turn audio into text, run an agent workflow, and stream generated speech.

import asyncio

import numpy as np

from agents import Agent
from agents.voice import AudioInput, SingleAgentVoiceWorkflow, VoicePipeline


async def main() -> None:
    agent = Agent(name="Assistant", instructions="You are a helpful voice assistant.")
    pipeline = VoicePipeline(workflow=SingleAgentVoiceWorkflow(agent))
    audio_input = AudioInput(buffer=np.zeros(24000 * 3, dtype=np.int16))

    result = await pipeline.run(audio_input)
    async for event in result.stream():
        if event.type == "voice_stream_event_audio":
            # Forward or play event.data.
            pass


if __name__ == "__main__":
    asyncio.run(main())

Explore the examples directory to see the SDK in action, and read our documentation for more details.

Acknowledgements

We'd like to acknowledge the excellent work of the open-source community, especially:

This library has these optional dependencies:

We also rely on the following tools to manage the project:

[uv](https://github.com/a

README truncated...

</details>

agentsaiframeworkharnessllmopenaipython