OpenAI Agents SDK: Build Multi-Agent AI Systems in Python

Build LLM agent tools, multi-agent orchestration, guardrails, streaming, and tracing, then ship a real capstone project

New

Created byGopi Donthireddy

Last updated 8/2026

English

What you'll learn

Build and configure production-ready agents using the OpenAI Agents SDK in Python
Equip agents with function tools, hosted tools, and structured outputs to complete real tasks
Stream agent responses in real time and manage runs with RunConfig and context objects
Orchestrate multi-agent systems using handoffs, triage routing, and parallel execution
Protect agent pipelines with input and output guardrails that block invalid requests
Debug and monitor agents using built-in tracing, the OpenAI dashboard, and lifecycle hooks
Track token usage and cost across multi-agent runs to control spend in production
Build a complete multi-agent research assistant combining tools, handoffs, guardrails, and tracing

Course content

6 sections • 47 lectures • 9h 52m total length

What is the OpenAI Agents SDK? Context and motivation7:27
An introduction to the OpenAI Agents SDK: what an agent actually is, how it differs from a single LLM call, and why this course focuses on the Python SDK specifically.
From Swarm to Agents SDK: a brief history6:40
The story of how OpenAI's experimental Swarm project evolved into the production-ready Agents SDK, and why that history explains some of the SDK's design choices.
The four core primitives: Agents, Tools, Handoffs, Guardrails7:44
A conceptual walkthrough of the four building blocks every system in this course is made from, and how they fit together.
How the SDK relates to the Responses API under the hood5:55
An explanation of what the SDK is actually doing behind the scenes, how it relates to OpenAI's Responses API, and when you might use the Responses API directly instead.
Environment setup: Python, virtualenv, API key, pip install openai-agents8:35
Step-by-step setup of your Google Colab environment, including installing the SDK and securely configuring your OpenAI API key using Colab Secrets.
Your first agent: hello world in 10 lines7:27
You will write, run, and get a response from your very first agent in under ten lines of Python code.
Reading a RunResult: final_output, last_agent, usage8:00
A close look at everything a single agent run actually returns, including the final output, which agent produced it, and how many tokens it used.
How to access Course Resources and Notebooks8:26

Agent anatomy: name, instructions, model, tools, handoffs, guardrails9:28
A complete tour of every property the Agent class accepts, and what each one controls.
ModelSettings: temperature, top_p, tool_choice, max_tokens13:24
How to fine-tune the underlying model's behaviour using ModelSettings, including creativity, output length, and tool-calling controls.
Writing effective system instructions — dos and don'ts11:44
Practical guidance, with real examples, on writing agent instructions that actually produce reliable, predictable behaviour.
Dynamic instructions: injecting runtime context via a callback18:02
How to generate an agent's instructions dynamically at runtime, so the same agent can adapt based on live data or user context.
Structured outputs with Pydantic models and TypedDict15:16
How to make an agent return typed, structured data instead of plain text, so your code can reliably work with the result.
Cloning agents with .clone() for persona variants11:14
A fast, reliable way to create variations of an existing agent, such as different personas or tones, without duplicating configuration.
Forcing and controlling tool choice12:15
How to control whether, and which, tool an agent is required to call, using the tool_choice setting.
Tool use behaviour: run_llm_again vs stop_on_first_tool10:41
What happens after a tool call completes, and how to control whether the model gets the final word or the tool's raw output is returned directly.

Function tools: the @function_tool decorator10:55
How to turn any Python function into a tool an agent can call, using the @function_tool decorator.
Type annotations and automatic JSON schema generation10:32
How the SDK automatically converts your function's type hints into a schema the model can understand, and how to avoid common schema pitfalls.
Hosted tools: WebSearchTool, FileSearchTool, CodeInterpreterTool11:54
An introduction to OpenAI's built-in hosted tools, including live web search, file search, and code execution, with no extra infrastructure required.
Agents as tools: Agent.as_tool() and manager-style orchestration18:09
How to let one agent call another agent as if it were a tool, enabling a manager-style architecture where a central agent coordinates specialists.
Tool context: accessing run state inside a tool13:50
How to access shared context and run-time state from inside a tool function, so your tools can be aware of who's calling them and why.
Tool output types: returning images, files, and structured data10:37
How to return more than plain text from a tool, including images, files, and structured data the model can use directly.
Parallel tool calls and tool execution order11:37
How the SDK handles multiple tool calls in a single turn, including when they run in parallel and how execution order is determined.
Error handling inside tools15:07
Best practices for handling errors inside your tools gracefully, so a single failure doesn't crash the entire agent run.

RunResult in depth: new_items, input_items, usage, last_agent13:46
A deeper look at every property available on a RunResult object, including the full list of items generated during a run.
Streaming events in real time with async for10:05
How to stream an agent's response back to your application as it's generated, instead of waiting for the entire run to finish.
Streaming raw text deltas vs structured run item events9:04
The difference between raw token-level streaming events and higher-level structured run item events, and when to use each.
RunConfig: max_turns, model overrides, workflow_name12:06
How to control run-level settings such as maximum turns, model overrides, and workflow naming using the RunConfig object.
Context management: RunContextWrapper and dependency injection8:50
How to pass your own application state and dependencies into an agent run, and access it from anywhere in the run.
Handling exceptions: MaxTurnsExceeded, guardrail tripwires9:19
How to catch and handle the exceptions the SDK raises, including runs that exceed the maximum turn limit or trip a guardrail.
Token cost tracking and usage metadata9:02
How to track token usage and estimate the real dollar cost of a run, a skill essential for running agents in production.

Orchestration patterns: LLM-driven vs code-driven5:50
A conceptual comparison of letting the model decide what happens next versus controlling the flow yourself in code, and when to use each approach.
Handoffs: conversation delegation to specialist agents12:21
How to let one agent hand off an entire conversation to a specialist agent, transferring full control and context.
Handoff input filters: controlling what the next agent sees23:03
How to filter and shape exactly what conversation history a specialist agent receives after a handoff.
Agents as tools pattern vs handoff pattern - Choosing the right one7:47
A direct, practical comparison of the two multi-agent patterns covered in this course, with guidance on choosing the right one for your use case.
Building a triage agent with multiple handoff targets11:27
You will build a working triage agent that intelligently routes a conversation to one of several specialist agents.
Deterministic pipelines: chaining agents in code8:53
How to chain multiple agents together in a fixed, predictable sequence controlled entirely by your own Python code.
Parallelisation with asyncio.gather6:55
How to run multiple agents at the same time using asyncio.gather, dramatically reducing total run time for independent tasks.
Input guardrails: Validating user messages before the run9:12
How to validate, and if necessary block, a user's message before it ever reaches your main agent.
Output guardrails: Validating agent responses before delivery8:53
How to check an agent's final response against your own rules before it's shown to the user.
Guardrail tripwires and execution modes (blocking vs parallel)24:19
A deeper look at how guardrails actually execute, including the real latency and cost trade-offs between blocking and parallel execution.

Built-in tracing: traces and spans in every run15:03
An introduction to the SDK's built-in tracing system, and the discovery that every run you've made so far has already been recorded.
Viewing traces in the OpenAI Dashboard16:28
A hands-on walkthrough of the OpenAI traces dashboard, showing you exactly how to read and debug a real multi-agent run.
The trace() context manager for custom workflow names16:31
How to group multiple related agent runs into a single named trace using the trace() context manager.
Lifecycle hooks: RunHooks and AgentHooks for logging16:05
How to hook into an agent run's lifecycle events for custom logging, monitoring, and per-agent cost tracking.
Agent visualisation tool for debugging multi-agent graphs11:50
How to generate a visual diagram of any multi-agent system, making complex handoff and tool structures easy to understand at a glance.
CAPSTONE — Multi-agent research assistant1:00:32
The course capstone: you will build a complete multi-agent research assistant from scratch, live, combining everything taught in the course into one real, working system.

Requirements

Basic Python. Comfortable with variables, functions, loops, and classes. No async/await experience required; it's introduced gradually as the course progresses.
A free OpenAI platform account with API access. Usage is pay-as-you-go and billed separately from Udemy; the full course typically costs only a few dollars in API calls.
A free Google account for Google Colab. Every notebook runs in the browser; no local Python install, IDE, or virtual environment needed.
Any computer with a modern browser and internet connection. No powerful hardware or GPU required.
No prior experience with AI agents, LLM frameworks, or the OpenAI API required. This course starts from your very first agent.

Description

Build Production-Ready AI Agents Using the OpenAI Agents SDK in Python

Most tutorials stop at a single agent calling a single tool. This course goes the other ninety percent of the way: multi-agent orchestration, guardrails, structured outputs, real-time streaming, and full observability, all in Python, all built on OpenAI's own official SDK.

You will start with your first agent and end by building a complete multi-agent research assistant, live, line by line, in the course capstone. Along the way you will learn how to equip agents with function tools and hosted tools, stream responses in real time, route conversations between specialist agents with handoffs and triage logic, protect your pipelines with input and output guardrails, and debug and monitor everything you build using the SDK's built-in tracing and the OpenAI dashboard.

Every lecture ships with a Google Colab notebook you run yourself. There is no local setup, no virtual environment, and no TypeScript; this course is Python only, from the SDK's own official Python interface.

Here is what you will be able to do by the end of this course:

Build and configure agents using the OpenAI Agents SDK, from your first agent through advanced configuration and structured outputs
Equip agents with function tools, hosted tools, and multi-agent handoffs to complete real, multi-step tasks
Stream agent responses in real time and manage runs with full control over configuration and context
Orchestrate multi-agent systems using handoffs, triage routing, and parallel execution with asyncio
Protect agent pipelines with input and output guardrails that block invalid requests before they cost you time or money
Debug and monitor agents using the SDK's built-in tracing, the OpenAI dashboard, and lifecycle hooks
Track token usage and cost across multi-agent runs, a skill most courses skip entirely
Build a complete multi-agent research assistant from scratch, combining every concept from the course into one capstone project

If you are a Python developer ready to move past single API calls and start building agents that actually coordinate, this course will take you there.

Who this course is for:

Python developers who want to move beyond single LLM API calls and build autonomous, tool-using agents
Backend or software engineers exploring agentic AI who want a structured, hands-on path instead of scattered tutorials
Developers already using the OpenAI API directly who want a framework that manages the agent loop, tool calls, and handoffs for them
AI or ML engineers moving from model training into agent orchestration, guardrails, and production observability
Anyone who has tried LangChain, CrewAI, or similar frameworks and wants to learn OpenAI's own first-party Python SDK instead

OpenAI Agents SDK: Build Multi-Agent AI Systems in Python

What you'll learn

Explore related topics

Course content

Introduction & Setup8 lectures • 1hr

Agents: Configuration & Behaviour8 lectures • 1hr 42min

Tools: Extending Agent Capabilities8 lectures • 1hr 43min

Running Agents, Results & Streaming7 lectures • 1hr 12min

Multi-Agent Orchestration & Guardrails10 lectures • 1hr 59min

Tracing, Observability & Capstone6 lectures • 2hr 16min

Requirements

Description

Who this course is for: