Teach on Udemy

Turn what you know into an opportunity and reach millions around the world.

Learn More

Your cart is empty.

Keep shopping

Mastering AI Agents with the OpenAI Agents SDK

Name: Mastering AI Agents with the OpenAI Agents SDK
Rating: 3.6 (8 reviews)

Build real, tool-using AI agents with the OpenAI Agents SDK — from design to triage, handoffs, guardrails, and eval.

Created byPramod Kumar Singh

Last updated 10/2025

English

What you'll learn

Design a clear mental model of Agentic AI and explain how it differs from code-driven and LLM-only approaches.
Build working agents using the OpenAI Agents SDK: configure models, tools, handoffs, hooks, guardrails, and context/memory.
Implement the Agent Loop (Observe → Think/Plan → Act → Reflect) and constrain it for reliable, auditable behavior.
Create real tools (Python functions) for external systems and ensure the agent performs side-effecting work only via tools.
Orchestrate multi-agent workflows (triage → specialists), including handoff hooks to pass state safely.
Add evaluation (eval) harnesses that verify routing, tool usage, confirmations, and safety—and catch regressions automatically.
Run agents with both OpenAI-hosted models and local/OpenAI-compatible backends (e.g., vLLM/Qwen in Colab), swapping endpoints without code changes.
Ship a small front end (Gradio) and basic observability (traces/logs), turning a notebook prototype into a demo-ready application.

Course content

7 sections • 16 lectures • 1h 44m total length

Introduction2:32
Agenda1:05
In this course, we’ll go from first principles to a working, testable AI agent system.
We’ll start by building a mental model for Agentic AI — what an “AI agent” actually is, how it differs from a normal LLM chatbot, and when you should (and should not) use an agent. We’ll compare three styles of building intelligent behavior: classic code-driven automation, pure LLM prompting, and agentic systems where the model can plan, act with tools, and reflect.
Then we’ll get hands-on with the OpenAI Agents SDK. You’ll learn the core building blocks: Agents, Runner, Tools (Python functions exposed to the model), Handoffs between agents, Hooks for side effects, Guardrails for safety and policy, and Context/Memory. We’ll also walk through the Agent Loop (Observe → Think/Plan → Act → Reflect), which gives the model a repeatable “sense–decide–do–reflect” workflow instead of just answering once.
From there, we’ll build a full multi-agent application: an airline customer support assistant. You’ll implement a triage agent, specialized agents for FAQs, seat changes, and cancellations/rescheduling, tool calls that actually update state, and handoff logic that passes control between agents. We’ll also add a simple front end (Gradio UI) so you can interact with it like a real support assistant.
Finally, we’ll make it production-minded. You’ll add lightweight evaluation (eval) to automatically test routing, tool usage, confirmation flow, and policy compliance. You’ll also see how to point the same agent code at either OpenAI models or an OpenAI-compatible local model, so you’re not locked in.
By the end, you’ll have not just code snippets, but an end-to-end mental model and a working reference implementation you can adapt to your own org, your own data, and your own workflows.

Rule based, Vs LL based Vs Agentic approach6:55
In this chapter, we’ll look at three different ways teams try to “add AI” to a product:
Code-driven automation – Classic engineering: you write logic, you control every branch, it’s deterministic. Great for well-defined flows, terrible when the user request is messy or the path changes in the middle.
LLM-driven assistants – You point a large language model at the problem and let it respond in natural language. Fast to prototype, but it struggles with guarantees, multi-step procedures, state, compliance, or doing real work through your systems.
Agentic systems – You give the model a job, tools, memory, and boundaries. The model plans, chooses actions, and can hand off to other agents or escalate to a human. You get flexibility like an assistant, but you also get structure, auditability, and control.
We’ll talk about when each approach is appropriate, and more importantly, when an “AI agent” is actually justified. You’ll learn the 5-question test for deciding if your use case really needs agentic behavior (planning, tool use, memory, handoff, autonomy) or if a simpler approach is safer and cheaper.
By the end of this chapter, you’ll have a mental decision tree:
– When do I keep it simple?
– When do I just use an LLM?
– When do I invest in a true agent?
That design instinct — choosing the right level of intelligence and control up front — is what prevents you from overbuilding a chatbot that can’t be trusted, or overspec’ing an agent for a problem that didn’t need one.

What is AI Agent5:36
This chapter, “AI Agents for Agentic AI,” is where we define what an agent actually is — and when you actually need one.
We start by making “agent” concrete. An AI agent isn’t just a chatbot with a fancy prompt. It’s a system that can do four things in a loop:
Observe what’s going on,
Think/Plan the next step,
Act by calling tools and touching real systems, and
Reflect on whether the goal is done or if it needs to continue.
That loop is what makes the behavior agentic instead of just conversational. The agent is moving toward an outcome, not just answering a question.
We also unpack the traits of a real agent: it can take actions through tools (not just talk), it can carry context and memory across turns, it can follow policy and escalate, and it can even hand off to a different specialized agent or a human when it’s out of scope. In other words: it’s not just talking — it’s participating in the workflow.
Then we go one level deeper and tackle a critical question: Do you even need an agent here?
This is where we introduce the “agent or not?” decision test. We’ll walk through how to look at a use case and ask:
Is there a goal that requires multiple steps and judgment, not just a single answer?
Will it need to call tools or APIs to actually get something done?
Does it need to track state or memory across steps?
Is there a need to route or hand off (for example, to billing vs support vs ops)?
Do we want it to act with some autonomy — or is this just a one-shot prompt?
If the answer to most of those is “yes,” you’re in agentic territory. If not, you might be better off with a simpler assistant or even a traditional API workflow.
By the end of this chapter, you’ll be able to do two things:
Explain what makes something an AI agent in practical, implementation terms.
Look at a real problem and decide honestly: is this an agentic use case, or am I overengineering it?
That decision is the difference between building something reliable and shippable vs. building something overly clever that no one will put in production.

Introduction1:33
Creating OpenAI agent SDK setup & building our first AI agent2:37
Lecture: Environment Setup & Your First AI Agent
In this lecture, we’ll get hands-on and actually build our first working AI agent using the OpenAI Agents SDK.
We’ll start by setting up the environment so everyone can run the same code:
Installing the required libraries
Configuring the OpenAI client (or your local model) and API key safely
Verifying that the SDK can talk to a model
Then we’ll create a minimal agent from scratch — just a name, basic instructions, and a model — and call it with Runner.run(...). You’ll see how little code it takes to get an LLM-powered agent to respond.
By the end of this lecture:
You’ll have a runnable notebook / environment
You’ll understand the two core building blocks (Agent and Runner)
You’ll be able to ask your own agent questions and get answers back
This sets the foundation for everything else in the course: tools, handoffs, memory, guardrails, evaluation, and full multi-agent systems.
Model Settings — Controlling Your Agent’s Behavior1:16
Tools — Hosted Tools, Function Tools, and Agent-as-a-Tool10:18
Handoffs & Handoff Hooks — Routing to the Right Specialist in multi-agent system4:26
Enforcing Agents for Structured Output1:59
Guardrails — Enforcing Safety, Policy, and Control4:18
Hooks for Observability4:01
Memory & Conversation State — Letting the Agent Stay Consistent5:15

Requirements

Basics of Python
Basics of LLM

Description

Build AI agents that don’t just talk — they act.

Most teams stop at “ChatGPT inside a UI.” That’s not an agent.

This course teaches you how to design, build, and evaluate real AI agents using the OpenAI Agents SDK. You’ll learn how to give models tools, memory, policy boundaries, and the ability to route work — so they can solve real problems like customer support, operations, and workflow automation.

Instead of slideware, we build a full end-to-end system together: an airline customer support assistant that can route requests, answer policy questions, change seats, handle cancellations and reschedules, respect business rules, and escalate when needed. You’ll also learn how to test it, monitor it, and plug it into a simple UI.

What you’ll learn

The difference between traditional automation, LLM “assistants,” and true agentic systems — and when you should use which.
How to decide if your use case actually needs an agent (or if a single LLM call is enough).
How the Agent Loop works (Observe → Think/Plan → Act → Reflect) and how to force the model to operate step-by-step instead of hallucinating.
How to expose real tools (Python functions / APIs) to the model so it can look up data, take actions, and update systems — safely.
How to build multi-agent systems with triage and handoffs (for example: FAQ agent, seat booking agent, cancellation and rebooking agent).
How to attach guardrails for policy, confirmation, and safety.
How to persist context and memory across turns.
How to evaluate the agent’s behavior automatically — routing, tool usage, escalation, and confirmation gates — using a lightweight JSONL eval harness.
How to run your agent against both OpenAI models and OpenAI-compatible local models (e.g. self-hosted / vLLM / Qwen-style endpoints).
How to wrap it in a front end (Gradio) so stakeholders can try it like a real support assistant.

How the course flows

1. Mindset and architecture
We start by building a mental model of Agentic AI. You’ll learn what an AI agent actually is in practical terms: a system that can observe what’s happening, plan the next step, call tools to act, and reflect on whether it’s done — not just answer in plain text. We compare code-driven automation, pure “chatbot-style” LLMs, and agentic designs.

We also walk through a 5-question test you can use with any new idea to decide: “Is this really an agent use case, or am I overcomplicating it?”

2. Core building blocks of the OpenAI Agents SDK
You’ll get hands-on with the SDK primitives you’ll use every day:

Agent: the brain with instructions and role.
Runner: the execution engine that drives turns.
Tools: Python functions the model can call to get facts or take actions.
Handoffs: how one agent can delegate to a more specialized agent.
Hooks: how to inject state or perform setup logic right when a handoff happens.
Guardrails: how to block unsafe input or enforce policy around output.
Context & memory: how the agent carries knowledge through a conversation.
The Agent Loop (Observe → Think/Plan → Act → Reflect): how to orchestrate multi-step work.

You’ll see minimal “hello world” versions of each concept and then gradually stack them into something production-like.

3. Real project: Airline Customer Support Agent
Next, we build a working multi-agent support system. This includes:

A Triage Agent that decides what the user is asking and routes to the right specialist.
An FAQ Agent that answers policy questions from a controlled knowledge base.
A Seat Booking Agent that can take a confirmation number and change a seat — via a tool call, not just text.
A Cancellation & Rescheduling Agent that can fetch fare rules, present rebooking options, and apply cancellation policy safely (with explicit confirmation before doing anything irreversible).

You’ll learn how agents hand off to each other, how they populate context (like confirmation numbers or flight IDs), and how guardrails prevent them from doing unauthorized work.

4. Observability and UI demo
We build a tiny front end in Gradio so you (and your stakeholders) can chat with the system like a real airline support bot. You’ll also see how to log tool calls, handoffs, and decisions for debugging and auditability.

5. Evaluation and safety
Finally, you’ll learn how to test agents like software. We’ll build a small evaluation harness that:

feeds in realistic customer prompts,
checks whether the right agent took control,
verifies that the correct tools were called (and forbidden tools were not),
enforces that certain actions require confirmation.

We’ll generate a pass/fail scorecard so you can see if you broke routing, safety, or policy after making changes. This is the difference between “cool demo” and “something you could actually deploy.”

Who this course is for

AI/ML engineers and LLM developers who want to go beyond chat interfaces.
Backend / platform / ops engineers who want safe, automatable agents that touch real systems.
Product engineers / founders building internal copilots and support bots.
Technical leads who need to evaluate whether “agentic AI” is real or hype.

You should be comfortable with basic Python. You do not need to be a deep learning researcher.

Why this matters

Most companies are about to wire LLMs into critical workflows — support, operations, monitoring, onboarding, billing. Doing that safely requires more than a prompt. It requires agents that have roles, memory, tools, guardrails, escalation, and evaluation.

By the end of this course, you’ll know how to build that. And you’ll walk away with working, inspectable code you can adapt to your own use case.

Who this course is for:

AI/ML engineers and LLM developers who already know how to call an LLM API (OpenAI, local models, etc.) and now want to build multi-step, tool-using, policy-aware agents.
Backend / platform / automation engineers who currently build internal tools or ops automations and want to layer intelligent triage, decision-making, and self-service on top of existing systems.
Founders and product engineers working on AI products (support copilots, monitoring/ops assistants, internal copilots) who need to understand how to safely wire LLMs to business logic, APIs, and data.
Technical team leads / architects evaluating “agentic AI” claims and looking for a practical, observable, testable architecture that won’t blow up in production.

Mastering AI Agents with the OpenAI Agents SDK

What you'll learn

Explore related topics

Course content

Introduction2 lectures • 4min

Design approach when building AI system1 lecture • 7min

AI Agents for Agentic AI1 lecture • 6min

Building Agentic Solution using OpenAI Agent SDK9 lectures • 36min

Hands-on : Airline Support Agent - an agentic approach1 lecture • 43min

Evaluation or Eval for Agentic Solution1 lecture • 10min

Thank you1 lecture • 1min

Requirements

Description

Who this course is for: