AI Agent Teams for Python Developers:
From Running Agents to Running a Team
AI Agent Teams for Python Developers: From Running Agents to Running a Team
Agent Teams • 8 Hours • 4 Live Sessions
You can hand-hold one agent. You can’t hand-hold three — so you’ll learn to write down what each one’s job is instead.
Hosted By
Core Team member at Real Python and the author of Object-Oriented Programming in Python. He teaches Real Python's Intermediate Python Deep Dive cohort and brings the same hands-on approach to this course.
You’ve gotten good at working with one agent. That part’s fine.
Then the job got bigger than one agent could hold.
“It started well and lost the thread around file five.”
“It came back and told me it was done. It wasn’t.”
“I’ve got three chat windows open and I’m copy-pasting between them like a human message bus.”
That last one is the symptom this course is named after, and it’s more common than people admit.
When we asked the developers who finished our Claude Code course what they wanted next, 22% of them asked for this without being prompted. One put it simply:
“The things that were just barely mentioned at the end: agents and agent teams.”
The share of our audience building with AI has gone from 10.9% to 16.3% in a year, and it’s the group most likely to be doing this at work rather than on the weekend.
Here’s the thing most people run into.
Splitting a job across several agents isn’t hard to start. You spawn a second one and it mostly works. What goes wrong is quieter than that: one agent fills up and its answers get worse without anything announcing it, a second reports back a summary that’s technically true and leaves out the one fact that mattered, and a third overwrites the file the first one just wrote.
None of those are bugs. They’re all the same missing decision, made three times.
What Makes This Course Different
You’ll Build the Team by Hand. Then You’ll Stop Building and Start Directing.
Most multi-agent material starts with a framework and a diagram of boxes with arrows between them. You learn the framework’s idea of a crew, a role, a task. Then when the thing misbehaves, you’re debugging the diagram.
This one runs the other direction.
In the first two hours you type out a parent agent and a subagent by hand. It turns out to be smaller than you expect:
A subagent is a tool whose body is another loop. That part is forty lines. Everything hard about teams is deciding what each agent is allowed to know.
Once it runs, we print both message lists side by side — the parent’s and the child’s — and that view stays on screen, in some form, for the next six hours. Every question from the room gets answered by pointing at it.
Nothing gets introduced before you’ve watched it break:
- one agent’s context fills up and the quality visibly falls, and then you hand the job to a fresh one
- a child does excellent work and describes it badly, the parent makes a bad call from a true summary, and then you start designing what comes back
- two agents write to the same file and the last one wins silently, and then you give each one its own territory
Halfway through, the course changes shape, because the subject forces it to:
You can hand-hold one agent. You cannot hand-hold three. From here we stop writing agents and start writing what they run on.
The second half is specifying rather than typing. You define what a reviewer agent has to reject and what it isn’t allowed to touch, an agent implements it, and you read the diff. By the end you leave with a team running on a schedule, with spending caps and a report it sends back whether it succeeded or not.
Course Curriculum
Four live 2-hour sessions on Zoom. You code along in real time, and questions are taken as they come rather than held to the end.
Session 1: One Loop, Then Two
By the end of this session, you'll have a parent agent and a subagent you typed yourself, and both their message lists on screen side by side.
What you'll build: A working single agent from scratch, then the forty lines that turn a tool into a second agent with its own separate conversation.
What you'll learn:
- Where an agent's memory actually lives, and why that's the whole story
- Why a subagent is a nested version of something you already have, rather than a new idea
- What the parent can and cannot see of what the child did
- Why the Task tool in Claude Code isolates context rather than making anything faster, which is what most people assume it's for
- What it means that the only thing coming back from a delegated job is what the child chose to tell you
Session 2: What Each Agent Is Allowed to Know
By the end of this session, you'll have watched three separate failures and realized they're all the same one.
What you'll build: Boundaries. A token counter you watch in real time, a designed return format, and agents scoped to their own directories.
What you'll learn:
- What a filling context window does to answer quality, at a point we can predict in advance
- Why a fresh agent beats a tired one, and why the reason isn't intelligence
- How to specify the format of what a child reports back, not just the job you gave it
- What happens when two agents write to the same file, and why the fix is scoping rather than locking
- The single design decision underneath all three, and how to make it deliberately
Session 3: Writing What the Agents Run On
By the end of this session, you'll have specified an agent well enough that another agent could build it — and then watched that happen.
What you'll build: An acceptance check that something other than the agent can run, and a reviewer agent built to a job description you wrote.
What you'll learn:
- How a perfectly reasonable instruction produces working code that does the wrong thing, and how to find the sentence responsible
- How to define "done" in a form a machine can check
- What belongs in an agent's job description: what it does, what it's allowed to touch, what it returns, and when it's finished
- How to direct an agent through building another agent, and what to look for in the diff
- Why writing this down stops being paperwork the moment there's more than one agent
Session 4: Off the Leash
By the end of this session, your team is running on a schedule, and it reports back after the session has finished.
What you'll build: A headless entry point, spending and iteration caps, an unconditional report, and a scheduled run on your own machine.
What you'll learn:
- Which roles on a team still work on a small local model and which ones don't, and why that's a cost decision rather than a capability one
- How to take the human out of the invocation entirely
- How to design against the failures nobody can watch: the silent death at 3am, the slow drift, the runaway bill
- Why an unattended agent without a budget and a heartbeat isn't deployed, it's abandoned
- The prediction test: five transcripts of multi-agent runs going wrong, and you name the missing boundary in each
Next cohort: dates to be announced
Join the Waitlist →Be First in Line When Dates Are Announced.
Real Python Satisfaction Guarantee
This course is backed by Real Python's guarantee. You can receive a full refund within 14 days after the course ends, provided you meet the completion criteria in our refund policy.What You’ll Be Able to Do
- Take a job that's too big for one agent and split it across several, each with a written job and a written boundary
- Say what a delegated agent has to report back, so a true but incomplete summary doesn't lead to a bad decision
- Leave an agent team running unattended without lying awake about what it might spend or quietly stop doing
What You’ll Receive
- 4 live 2-hour sessions via Zoom
- Cohort forum with the instructor and your peers, before and after the sessions
- The repository, with the full git history: your commits from the first half, the agents' from the second, each one carrying the prompt that produced it
- The role template: job, context boundary, return format and definition of done — one page you fill in for every future agent
- The decoder card: every piece you built next to the name it goes by in Claude Code and Codex
- Lifetime access to the recordings and materials
Who This Course Is For
#1
Daily Agent Users who have hit the point where one agent can't hold the whole job and aren't sure what to do about it
#2
Manual Message Buses who are copying context between chat windows by hand and know there has to be a better way
#3
Task Tool Watchers who have seen Claude Code spawn a subagent and want to know what actually happened in there
Who Should Not Take This Course?
This course is about designing and directing a team of agents, not building your own multi-agent framework to ship.
It’s also not about making agents faster. The agents run one after another, not in parallel, because the course is about what each agent knows, not how fast the team finishes.
It assumes Python proficiency. You should be comfortable writing Python and reading a traceback, and you should use an AI coding tool regularly. You need no knowledge of how agents work internally — session 1 builds that from scratch. If you’re still learning Python basics, start with Real Python’s Python Basics Learning Path instead.
Meet Your Instructor
Core Team member at Real Python and acclaimed Python educator who combines years of teaching expertise and storytelling techniques to make complex programming concepts clear, engaging, and unforgettable.
Stephen Gruppetta is a seasoned Python educator and author known for his engaging narrative approach to explaining complex concepts, drawing on his PhD in physics and years as a lecturer and technical writer.
With experience ranging from corporate training to creating accessible resources like The Python Coding Book, he’s dedicated to helping learners master Python with clarity and creativity.
Why Learn With Real Python?
Real Python started as a Kickstarter project in 2012. Today, over 1 million developers, data scientists, and ML engineers read it every month.
Our content goes through what very few Python resources match:
- Expert technical review for accuracy
- Teaching specialist evaluation for learning effectiveness
- Professional editing for clarity
Our live courses bring that same review process to an interactive, instructor-led format. You get the questions, the live discussion, and a community that’s been learning Python with us since 2012.
What Learners Say About
Stephen’s Courses
“I felt like I was a really well-studied Python beginner… But I couldn’t quite get out of there to the next level. And [Stephen's course] is helping because it’s all about that deeper understanding.”
“I can look at modules, I can look at other people’s code and I understand why they’re doing what they’re doing. And it’s not just taking things for granted anymore… I can go on and start exploring more complex things without immediately getting lost.”
— Jerry Wilson, Technical Lead at AIM EMS Software
“Ever since we’ve been taking the course, I’ve really changed a lot of the way that I’m programming.”
“It’s definitely given me more confidence to go deep dive into things I just took for granted… But after this course I feel much stronger in being able to understand the fundamentals of why things work in Python that it’s given me more confidence to go deeper.”
— Matt Thacker, Sr. Solutions Engineer at Eptura
Why This Course Works
Agent teams are hard to learn from documentation, because the failures are missing.
A tutorial can show you two agents cooperating. It rarely shows you the one that came back with a summary that was completely accurate and left out the fact the parent needed, which is the thing that will actually cost you an afternoon.
In this course, you get the before and after:
- one agent holding a job that’s too big for it, before you split it
- the context filling and the answers going soft, before you hand over to a fresh agent
- a true summary that causes a wrong decision, before you design what comes back
- two agents and one file, before each gets its own territory
- a reasonable instruction producing confidently wrong code, before you write an acceptance check
You’ll see each of these happen in the session, so you’ll recognize them the first time they show up in your own work.
You’ll leave with a team running, and with the judgment to decide what each agent on it is allowed to know.
Frequently Asked Questions
You should be comfortable with Python and able to read a traceback. Specifically:
- Writing and calling functions
- Working with dictionaries and lists
- Using modules, packages, and virtual environments
- Running Python scripts from the command line
You should also use an AI coding tool regularly, such as Claude Code, Codex, Cursor, or Copilot. You need no knowledge at all of how agents work internally — session 1 builds a working agent from scratch before anything else happens.
No. This course is self-contained. The first fifty minutes build a single agent loop from nothing, so that everyone starts session 2 from the same place, and only then does the second agent arrive.
If you already know how an agent loop works, that opening will be review. It moves fast, and the part the course actually rests on begins right after it.
Python 3.12 or newer, your editor of choice, and Zoom.
You’ll also need access to a model API to run your agents against. Several agents use noticeably more API calls than one, so we’ll confirm the exact setup and run a supported setup week before the course, and the caps you build in session 4 exist precisely so this stays predictable.
On your own machine. You’ll leave with the team scheduled, capped and reporting, and it will send its first report back after the session has ended.
We’ll be straight about the limit: a schedule on your laptop stops when your laptop does. Putting it somewhere always-on is a deployment question rather than an agent-design one, and it’s out of scope here. What you leave with — the schedule, the caps and the report format — is committed to your repository, so it moves with you when you do put it somewhere permanent.
Yes. You’ll keep:
- The complete repository, with the full git history of all four sessions
- The role template and the decoder card
- Session recordings
- The one-page list of what to change in your own work
Dates and times haven’t been announced yet. Join the waitlist and you’ll be the first to hear when they are, before the course is opened up more widely.
Each session is recorded and posted shortly afterward, so you can catch up on your own schedule. We recommend attending live when you can, since the value of a live course is asking questions in real time. But if work collides with a session, the recording will be ready before the next one starts.
You code along. The first half is you typing out the parent loop and the subagent by hand, and everything after it rests on that.
One block is a demonstration rather than a build-along: when we point the team at a small local model in session 4, one machine runs it and it’s ours. You watch and make the routing decision with us. Nobody has to install a model, and nobody gets stranded by a laptop that can’t run one.
No. You build the team in plain Python, because the framework’s abstractions are exactly what hides the decisions this course is about. We name where each piece shows up in the tools you already use — the Task tool, per-role instruction files, headless mode — so you can go back to those on Monday and recognize what you’re looking at.
No, and that’s deliberate. Children run one after another. Running them at the same time is an engineering problem that doesn’t change any of the design decisions here, and this course is about what each agent knows rather than how fast the team gets through the work.
Every cohort gets a dedicated forum that runs from before the first session through to after the last. Stephen is based in UTC+1 and monitors the forum throughout his working day, so you can ask questions, share what you’re building, and get unstuck without waiting for the next live session.
Yes. Select the number of seats you need on the booking page when the cohort opens. Each team member will receive their own access to the course materials and recordings.
This course is backed by Real Python’s satisfaction guarantee. You can receive a full refund within 14 days after the course ends, provided you meet the completion criteria in our refund policy.
Have another question? Email us at info@realpython.com