Learn to build AI agentsthat ship real work.
A 6-module hands-on course where every lesson runs in a real OpenClaw sandbox — your own private linux, browser, and terminal. By the end you've shipped a real agent doing real work in your real stack. Not slides. Not toy notebooks. Production code.
Strip away the hype. An agent is a loop: model + tools + memory + a way to know when to stop. Build the smallest possible one from scratch in 40 lines.
An agent is only as useful as the tools you give it. Build a real toolbox — file system, shell, browser, HTTP — and learn the exact contract that makes a tool reliable.
A stateless agent is a goldfish. Build the three layers of memory — working, episodic, semantic — and make your agent remember what worked, what failed, and why.
Stop building toy demos. Wire your agent into your actual Slack, GitHub, and one CRM. Real auth, real webhooks, real responsibility.
One agent is a script. A team of agents is a system. Build a planner that hands work to specialist agents — and learn the four ways multi-agent setups fall over.
Agents in production are different animals. Logging, evals, cost tracking, retries, kill switches, and the deploy story — everything you wish someone had told you week one.
Hands-on modules covering the full agent stack
Lessons that compile and run, every one
Of guided build time, end-to-end
Engineers shipped a real agent so far
Because a real agent needs a real computer.
Most agent courses teach you to call an API. That's not building an agent — that's chatting with one. This course is built on OpenClaw because OpenClaw gives every student a real isolated machine: a browser, a terminal, a file system, and credentials to actual tools. Your agent does real work, not pretend work.
A real linux box per lesson.
Every lesson spins up your own private OpenClaw sandbox — a real Ubuntu machine with a real browser, real terminal, and a real home directory that persists. You write code that touches real files, opens real URLs, and ships real artifacts.
Your tutor IS an OpenClaw agent.
You're not watching videos. The tutor reads your code in real time, runs it in your sandbox, debugs alongside you, and asks the right next question. It remembers what you've already learned and what tripped you up last lesson.
Ship to your own stack.
By module 4 you're connecting your agent to your real Slack, real GitHub, real CRM. The course doesn't end with a toy demo — it ends with a deployed agent doing one real job for you, every day.
Six modules. One real agent shipped by the end.
Each module is self-contained but builds on the previous one. Start free with Module 01 — by Module 06 you're deploying to production from your own terminal.
Foundations — what an agent actually is
Strip away the hype. An agent is a loop: model + tools + memory + a way to know when to stop. Build the smallest possible one from scratch in 40 lines.
- 01What separates an agent from a chatbot (and why it matters for your bill)
- 02The agent loop: think, act, observe, repeat — by hand
- 03Tools, function calling, and the JSON shape that holds it all together
- 04Your first sandboxed agent: a 40-line bash assistant that survives mistakes
- 05Lab: break it five ways and learn what fails
Tool use — giving your agent hands
An agent is only as useful as the tools you give it. Build a real toolbox — file system, shell, browser, HTTP — and learn the exact contract that makes a tool reliable.
- 01The tool contract: name, schema, side-effects, idempotency
- 02Browser as a tool — Playwright behind a clean function call
- 03Shell as a tool — what to expose, what to never expose
- 04Reading and writing files without burning the world down
- 05Lab: build a research agent that opens 10 URLs and writes a real report
Memory — agents that get better over time
A stateless agent is a goldfish. Build the three layers of memory — working, episodic, semantic — and make your agent remember what worked, what failed, and why.
- 01Working memory: the rolling context window, done right
- 02Episodic memory: storing past runs as recallable experiences
- 03Semantic memory: embeddings, retrieval, and the trap of pure RAG
- 04Forgetting on purpose — and the math of doing it well
- 05Lab: an agent that remembers every customer call and surfaces the right one
Connecting to your real stack
Stop building toy demos. Wire your agent into your actual Slack, GitHub, and one CRM. Real auth, real webhooks, real responsibility.
- 01OAuth, scopes, and the token-management pattern that doesn't bite you
- 02Slack: the bot user, slash commands, threads, and how to listen without getting muted
- 03GitHub: PRs, comments, status checks — the agent as a teammate
- 04Hubspot / Salesforce / Linear: pick one and wire it up properly
- 05Lab: an agent that triages your inbox and posts a summary in Slack at 8am
Multi-agent + planning
One agent is a script. A team of agents is a system. Build a planner that hands work to specialist agents — and learn the four ways multi-agent setups fall over.
- 01Why most multi-agent demos are theatre — and the one pattern that isn't
- 02The planner / executor / critic loop, in 80 lines
- 03Handoffs, shared memory, and avoiding the infinite loop
- 04When to split and when to keep it monolithic (a flowchart)
- 05Lab: a 3-agent team that researches, writes, and fact-checks an article
Production — observability, evals, deploy
Agents in production are different animals. Logging, evals, cost tracking, retries, kill switches, and the deploy story — everything you wish someone had told you week one.
- 01Logs that tell you what happened (without 80MB of JSON)
- 02Evals: golden datasets, regressions, and the one chart that matters
- 03Cost: per-run accounting, budget caps, and how to not get fired
- 04Deploy: a real CI/CD path for your agent, with rollback
- 05Lab: ship your final agent to production from your own terminal
Watch a lesson run.
This is Module 03, Lesson 02 — the Tutor walks a student through implementing episodic memory. The Tutor is an OpenClaw agent reading your code in your sandbox in real time. It can run things, see the output, and show you exactly what's broken before you ask.
Four real things you'll have shipped.
Every module ends with a project that runs in your sandbox and produces a real artifact. Not toy demos — real working agents you'll keep using after the course is over.
The 40-line bash assistant
An agent that takes plain-English commands and runs the right shell incantation, asking before anything destructive. Module 01 graduation project.
A working CLI agent on your machine that you'll actually use to remember the rsync flag you forgot.
The research agent
An agent that takes a topic, opens 10 URLs in its own browser, reads them, and writes a 2-page brief with citations. Module 02 graduation project.
A real research agent you can point at any topic and get a brief — runs in your sandbox, ships the markdown to your inbox.
The inbox triage bot
An agent that reads your real inbox at 7:55am, sorts what matters from what doesn't, and posts a summary in Slack with one-click actions. Module 04 graduation project.
An agent running on a cron in your sandbox, posting to your real Slack at 8am every weekday.
The 3-agent research team
A planner / writer / fact-checker trio that produces a referenced 1000-word article from a single prompt — with the fact-checker actually reading the sources. Module 05 graduation project.
A multi-agent system you'll use as a template for your own production work — every lesson learned the hard way is already in there.
Meet your instructor.
The Tutor is an OpenClaw agent that runs alongside you in your sandbox. It's not a chatbot bolted onto a video — it actually reads your code, runs it, sees the failures, and shows you the fix. Persistent memory means lesson 12 isn't lesson 1 all over again.
Reads your code in real time.
The Tutor watches your sandbox file system and your terminal output. When you save a file it's already up to speed before you click 'help'.
Runs your code for you.
The Tutor has its own shell in your sandbox. It can reproduce a bug in 4 seconds and tell you exactly which line is failing.
Remembers your past mistakes.
If you tripped over async in Module 02, the Tutor will quietly catch the same pattern in Module 04 and call it out before you even hit run.
Adapts the pace to you.
If you're flying, lessons get shorter and the labs get harder. If you're stuck, the Tutor slows down and adds practice exercises until the concept clicks.
Never says 'as an AI'.
The Tutor has a personality — direct, dry, allergic to hedging. It tells you your code is wrong when your code is wrong, and tells you when you've done something clever without flattery.
Lives in your sandbox forever.
After the course ends the Tutor stays — paste any agent code into your sandbox and the Tutor will review it the same way it reviewed your homework.
From engineers who shipped.
The course has run for 2,400+ engineers so far. Here are six who built something they wouldn't have built without it — and a few who almost quit and didn't.
“I'd been 'going to learn agents' for 8 months. The first module is free and 90 minutes long. By minute 45 I had a working bash assistant on my laptop. The Tutor catching my dumb async mistake in lesson 02 was the moment I realised this was different.”
“The OpenClaw sandbox is the unlock. Every other course had me copy-paste into a colab notebook that died when I closed the tab. Here I had a real linux machine with my own files, and the Tutor was running my actual code. It feels like pair programming with someone who's done this 1000 times.”
“Module 04 — 'connect to your real stack' — was the moment I shipped my first agent for real. I had a Slack bot triaging on-call alerts by Friday afternoon. My team thought I'd been working on it for weeks. It was four lessons.”
“I almost quit in module 03 because memory was confusing. The Tutor noticed I'd been re-reading the same lesson three times and offered me a different angle — 'you're a database person, here's the same idea as a write-ahead log'. Clicked instantly.”
“The thing nobody tells you about agent courses is how much production stuff they skip. Module 06 covers cost tracking, evals, and the deploy path. That single module saved us from a $4,200 surprise bill last month.”
“I run a 12-person eng team. We did the course as a group over 3 weeks. Every engineer shipped a real agent doing real work in their squad by the end. ROI calculation is going to look ridiculous when I write it up next quarter.”
Questions before you start.
Free to start. Pay when you ship.
Module 01 is free forever — no credit card. Pro unlocks the rest. Team gives every engineer their own sandbox + group progress.
Module 01 + your own OpenClaw sandbox + the Tutor for the first 5 lessons. Most people finish this in an evening.
- Module 01 (1h 24m, 5 lessons + lab)
- Your own private OpenClaw sandbox
- Tutor agent for the duration of Module 01
- Discord access
All 6 modules, unlimited sandbox time, the Tutor for the full course, and Office Hours when you're stuck.
- All 6 modules · 11h 19m of content
- Unlimited OpenClaw sandbox time
- Tutor agent for the full course
- Weekly Office Hours with the authors
- Lifetime updates as new modules ship
- Cert of completion + project showcase
For engineering teams running it together. Per-engineer sandbox, group progress, and a private Slack with the Tutor.
- Per-engineer OpenClaw sandbox
- Group progress tracking dashboard
- Private Slack channel with the Tutor
- Custom labs tailored to your stack
- Volume discount at 10+ seats
- Priority Office Hours
Stop reading about agents. Ship one this week.
Module 01 is free forever and most people finish it in an evening. Your sandbox spins up in 30 seconds. The Tutor is online and waiting.
Start the course free