Agents That Run Your Week:
What They Did While You Weren’t Watching
Agents That Run Your Week: What They Did While You Weren’t Watching
Agents That Run Your Week • 4 Hours • 2 Live Sessions, Days Apart
The interesting failures happen when nobody’s looking. You’ll leave three agents running for a week, then come back and read what went wrong.
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.
There are things you check every week because nobody else will.
Whether that page changed. Whether anything came in that needs you. Whether the numbers moved. Whether you’re on track with the thing you said you’d do.
None of it takes long. All of it takes attention, and it comes back every week.
You’ve probably thought about handing some of it over. The bit that stops most people isn’t the automation — it’s that a timer can only tell you something happened. What you actually want is somebody to look at it and decide whether it’s worth your attention.
That decision is the only part a script can’t make for you, and it’s the part this course is about.
There’s a second problem underneath it, and it’s the one that catches people out.
An agent working while you’re asleep fails differently. It doesn’t crash in front of you. It stops sending reports and you notice two weeks later. It says “nothing to report” when it actually looked at nothing. Its advice gets vaguer week by week. Or it runs up a bill nobody was watching.
None of that can be demonstrated in an afternoon. So we don’t demonstrate it.
What Makes This Course Different
Two Sessions, Days Apart. The Gap Is the Course.
In the first session you build three small agents and set them running. Then everyone goes away for a few days.
You’ll get their reports while you’re doing something else. Some will be useful. Some will be noise. At least one will do something you didn’t expect, and one of them may well stop without telling anybody.
That’s the material for the second session.
We open it by reading real logs from real runs, yours included if you want to share them. Nothing about that part is rehearsed, and it doesn’t need to be — across a room of people with three agents each, running for a week, every failure worth knowing about will have happened to somebody.
Here’s what you build. One runner, typed out by hand in the first forty minutes: it gathers something, it asks a model to make a judgment about it, and it sends you a report. That’s the whole pattern, and you’ll use it three times.
Then the parts that make it safe to walk away from:
- a spending cap that fails closed rather than asking permission to continue
- a report that arrives whether or not anything was found, so silence always means something is wrong
- a small fourth agent whose only job is to notice when one of the others goes quiet
By the end of the first session you have three agents working and something watching them. By the end of the second you know what they get wrong, and how to say what you want clearly enough that they stop.
Course Curriculum
Two live 2-hour sessions on Zoom, held several days apart. That gap isn’t scheduling convenience, it’s where the second session’s material comes from.
Session 1: Build Three, Set Them Running
By the end of this session you'll have three agents working on a schedule on your own machine, and a fourth one watching them.
What you'll build: One runner — gather, judge, report — used three times, plus caps and a heartbeat.
What you'll learn:
- The three parts of a scheduled agent, and why the judging step is the only one worth paying for
- The watcher: something public changes, and your agent decides whether it matters to you
- The log reader: a plain-text file you write one line a day into, and an agent that reads the whole thing and tells you something useful about it. You pick what it's about
- The briefing: two sources, your own rules, five lines of output
- Why a report that only arrives when something happened is worse than useless
- Spending caps, iteration caps, and the small agent that notices when another one stops
Session 2: What Actually Happened
By the end of this session you'll have read a week of real output, found what went wrong in it, and rewritten the instructions that caused it.
What you'll build: Better judgment. The fixes for four failures you'll have seen for yourself by then.
What you'll learn:
- Silent death — reports stop, and how long it takes anyone to notice
- Success on nothing — "task completed", from an agent that looked at nothing
- Drift — week one was useful, week three is generic, and what changed
- Runaway — cost, loops, and why a cap you can raise in the moment isn't a cap
- How to rewrite "tell me only if it matters", now that you've seen a week of what your first attempt let through
- What it would take to point one of these at your email, your calendar or your work tools — and how to do that safely later, on your own
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
- Hand a weekly chore to an agent and leave it running, without wondering what it might cost or whether it quietly stopped
- Write the sentence that decides what's worth telling you about, and sharpen it once you've seen a week of what it let through
- Recognize the four ways unattended work goes wrong, and build against each one before it happens
What You’ll Receive
- 2 live 2-hour sessions via Zoom, held days apart
- Cohort forum with the instructor and your peers, open across the gap between sessions
- Three agents running on your own machine, on a schedule, capped and reporting, plus the fourth one watching them
- The runner: forty lines you typed, which every future job reuses
- The job template — what it gathers, how it judges, what the report says, what it costs, what happens if it goes quiet — and a guide to pointing one at your own accounts safely
- Lifetime access to the recordings and materials
Who This Course Is For
#1
Weekly Checkers with a routine of looking at things that rarely change, who'd rather be told than go look
#2
Conversational AI Users who've only ever used an assistant by asking it things, and have never had one do anything unprompted
#3
Reluctant Scripters who automated something once and found the hard part wasn't the automation — it was deciding what deserved their attention
You Don’t Have to Be a Developer for This One
Most of our live courses assume you write software. This one doesn’t.
You need to be able to install a package and run a Python script, and that’s the whole bar. You don’t need to know anything about how agents work, and you won’t be writing much code — the runner is about forty lines and we type it together.
If you work in finance, operations, research, teaching or anywhere else with a weekly rhythm of checking things, this was written with you in mind as much as anyone.
Who Should Not Take This Course?
Anyone wanting to build agent systems for a living. This course is about putting agents to work on your own weekly tasks, not building agent products for others.
Anyone who needs this running somewhere permanent. Your agents run on your own machine, so they stop when it does. Moving them somewhere always-on is a deployment problem and it’s out of scope here.
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
Unattended work can’t be taught in an afternoon, because the things worth learning about it take days to happen.
A course held in one sitting has to describe the silent failure, or simulate it. Describing it teaches nothing, and a simulated one is just a slide with a story attached. You nod, you forget.
So we wait instead. Three agents each, a room full of people, several days: something will stop without saying so, something will report success after looking at nothing, and somebody’s advice will get blander every morning. We don’t have to arrange any of it.
And it lands differently because it’s yours. Nobody argues with a log from an agent they built themselves. The strongest possible version of “an agent without a budget and a heartbeat has been abandoned rather than deployed” is realizing your own agent stopped four days ago and you hadn’t noticed.
About Your Email, and Everything Else Private
The best uses for this are the private ones. An agent that reads your inbox and tells you what actually needs you is more useful than anything we’ll build together, and it’s usually the first thing people ask about.
We don’t connect anything like that during the course, and that’s deliberate.
Your inbox is probably the most sensitive thing you own. A live session with a room full of strangers watching is the wrong place to be granting access to it, even read-only, and doing it properly takes longer than we’d have.
So everything we build runs against public sources or against a plain text file you wrote yourself, on your own machine. Nothing you’d mind sharing, and nothing to authorize.
The private jobs get their own attention instead. In session 2 we work through what each one would actually need — email, calendar, work chat, your repositories, your money, your health data. What access it wants, what the narrowest version of that access looks like, where the secret lives, and what happens on the day it misbehaves.
You leave knowing how you’d do it, and whether you want to.
Frequently Asked Questions
You should be able to install a package and run a Python script. That’s genuinely the whole bar.
You don’t need to know how AI agents work, you don’t need to have used one for anything beyond asking it questions, and you won’t be writing much code. The runner we build is around forty lines and we type it together.
Fair question, and worth answering directly.
A scheduled script can tell you that something changed. It can’t tell you whether the change matters to you, and that’s usually the thing you actually want. The agent reads what came back and makes a call against criteria you wrote.
The honest version of the boundary: if a job doesn’t need a judgment, it shouldn’t be an agent, and we’ll say so in the first ten minutes. Two of the three jobs we build are interesting precisely because that judgment is hard to write down, and the first session is largely about getting it right.
Because that’s where the second session’s content comes from.
Agents working unattended fail in ways you can’t stage: they stop quietly, they report success after finding nothing, their judgment drifts, they cost more than expected. All of those need time to pass. So we build in session 1, everyone leaves their agents running, and we spend session 2 reading what actually happened.
It means you have to come back, which we know is a commitment. It also means session 2 works on real evidence instead of a worked example.
That happens, and it’s still useful. An agent that stopped is the single best demonstration in the course, and we’ll work out together why it did.
Session 2 also reads the room’s output collectively rather than requiring everyone to bring their own, and the instructor’s three run throughout. Nobody is left with nothing to look at.
No. Nothing we build during the course touches your email, your calendar, your work tools or any account you’d have to log in to.
Everything runs against public sources or a plain text file you wrote yourself. There’s a section further up this page explaining why, and session 2 covers how you’d connect something private later, on your own, safely.
Three shapes rather than three fixed projects, so they fit whatever you actually do:
- A watcher — something public changes, and your agent decides whether it matters to you
- A log reader — you write a line a day into a text file and the agent tells you something useful about the whole thing. Training, study, reading, expenses, work notes, a project journal. You pick
- A briefing — two sources, your own rules, five lines of output
Plus a fourth tiny one that watches the other three and shouts if one goes quiet.
On your own machine, on a schedule. We’ll be straight about the limit: your laptop stops, the schedule stops.
What you leave with — the schedule, the caps, the report format — is yours in a repository, so it moves with you if you later put it somewhere permanent. Doing that properly is a deployment question and it’s out of scope for this course.
Very little. Each run is a small judgment rather than a coding session, so we’re talking about a few hundred tokens at a time.
You’ll build hard spending caps in the first session, before anything is scheduled, precisely so this stays predictable while you’re not watching. We’ll confirm the exact setup and run a supported setup week before the course.
Both are recorded. Session 1 matters most to attend live, since you’ll be building alongside everyone else and you need your agents running before the gap starts.
The cohort forum is open throughout, and the gap between sessions is exactly when you’ll want it. Stephen is based in UTC+1 and monitors it through his working day.
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