Build a Slack agent\nyour team will actually keep using.
A 6-module hands-on course on building production Slack agents. From the OAuth dance to multi-agent workflows in a real channel — every lesson runs in your OpenClaw sandbox connected to a real Slack workspace. By the end you've shipped one that your team won't mute.
Why Slack is the best home for a real agent — and the things you have to know before you ship one to a channel with humans in it.
The auth dance, what scopes to request (and not), and how to manage tokens like a grown-up. The token-management pattern that doesn't bite you.
The four interaction shapes: slash command, mention, thread reply, modal. When to use each. The patterns the best Slack apps share.
The Events API, when to listen vs poll, and the consent UX that keeps you out of the privacy doghouse. Catching every relevant message without storing the wrong ones.
Two agents in one channel without stepping on each other. Handoffs, mentions, and the patterns that scale to 5+ agents in the same room.
Slack's rate limits, the retry pattern, the deploy story, and the things that go wrong at scale that you'd never guess from the docs.
Modules covering the full Slack-agent stack
Lessons that all run in a real workspace
Of guided build time, sandbox-to-production
Slack agents shipped by course graduates
Because real practice needs a real computer.
Most courses teach you to call an API, then leave you on your own. The OpenClaw Slack Agent 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. You do real work, not pretend work.
A real linux box per lesson.
Every lesson in The OpenClaw Slack Agent Course 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. Hermes 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 the time you hit Module 04 you're connecting your work to your real tools, your real data, your real environment. The course doesn't end with a toy demo — it ends with something you actually use, every day.
Six modules. One real thing 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 shipping from your own terminal.
Slack as an agent runtime
Why Slack is the best home for a real agent — and the things you have to know before you ship one to a channel with humans in it.
- 01The agent in the channel: a model for what good looks like
- 02Why Slack beats email and the dashboard for almost every internal agent
- 03The 'don't get muted' rules — what 6 months of real bots taught us
- 04Workspaces, channels, threads, and where each kind of message belongs
- 05Lab: a hello-world agent in your sandbox-connected workspace
OAuth, scopes, and the bot user
The auth dance, what scopes to request (and not), and how to manage tokens like a grown-up. The token-management pattern that doesn't bite you.
- 01The OAuth flow, in plain English with a diagram you can trust
- 02The minimum scope set for an agent that triages messages
- 03Token storage: the three patterns and the one to actually use
- 04Refreshing tokens without 3am pages
- 05Lab: install your bot in a real workspace and post your first message
Slash commands, threads, and modal flows
The four interaction shapes: slash command, mention, thread reply, modal. When to use each. The patterns the best Slack apps share.
- 01The slash command pattern (and why the response shape matters)
- 02Threads as memory: how to use them, when to ignore them
- 03Modals: the right way to gather structured input
- 04Block kit, ephemeral messages, and the buttons that don't lie
- 05Lab: build a 4-button triage flow that ships to a real channel
Listening (with consent) and triggering
The Events API, when to listen vs poll, and the consent UX that keeps you out of the privacy doghouse. Catching every relevant message without storing the wrong ones.
- 01Events API vs RTM vs polling: pick the right one
- 02Consent UX: how to ask without making people roll their eyes
- 03Filtering: the regex you'll regret and the better pattern
- 04Storing only what you need (and forgetting on a schedule)
- 05Lab: an agent that summarises a channel's day at 5pm without ever reading a DM
Multi-agent flows in a real channel
Two agents in one channel without stepping on each other. Handoffs, mentions, and the patterns that scale to 5+ agents in the same room.
- 01The 'agents talking past each other' problem and the simple fix
- 02Mention chains as a coordination protocol
- 03Shared memory: when to use it, when it's overkill
- 04Failure modes and how to debug a multi-agent thread
- 05Lab: a triage + on-call + escalation trio in one #incidents channel
Production: rate limits, retries, deploy
Slack's rate limits, the retry pattern, the deploy story, and the things that go wrong at scale that you'd never guess from the docs.
- 01Slack's rate limits, decoded — and the retry pattern that respects them
- 02Idempotency: what it means for a bot that posts to channels
- 03The deploy path: from your sandbox to a real production worker
- 04Monitoring + on-call: the dashboard that's worth keeping
- 05Lab: ship your final bot to production with rollback in 6 minutes
Watch a lesson run.
This is Module 04 · Lesson 03 — listening without overstoring — Hermes walks a student through a real problem in their OpenClaw sandbox. Reads the code, runs it, sees the failure, shows the fix.
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 things you'll keep using after the course is over.
Module 01 graduation project
The first thing you'll ship in The OpenClaw Slack Agent Course. A small but real artifact that proves the foundation lessons stuck. Runs in your OpenClaw sandbox by the end of week one.
A working artifact you'll keep using after the course is over — not a notebook, an actual tool.
Module 03 graduation project
The mid-course project. By Module 03 you've got enough of the core down to ship something with real moving parts. The Tutor reviews every commit.
A working system with real parts — the kind of thing you'd put in a side-project portfolio.
Module 05 graduation project
The advanced project. Combines what you learned in Modules 04 and 05 into one real-world build. The kind of thing senior engineers actually ship.
A senior-level artifact: the system you'd talk about in an interview as 'the thing I built that taught me X'.
Module 06 capstone
The final project. End-to-end, production-shaped, deployed from your sandbox. The Tutor stays online while you ship it.
Your portfolio piece. Deployed, observable, and small enough that you actually understand every line.
Meet your instructor.
Hermes is an OpenClaw agent that runs alongside you in your sandbox. It's not a chatbot bolted onto a video — it actually reads your work, 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.
Hermes 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.
Hermes 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 something in Module 02, Hermes 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, Hermes slows down and adds practice exercises until the concept clicks.
Never says 'as an AI'.
Hermes 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 Hermes stays — paste any code into your sandbox and it'll review the same way it reviewed your homework.
From engineers who shipped.
From engineers who shipped a Slack agent their team kept using past week one — the actual hard part.
“I'd been 'going to take a course' for 8 months. The first module is free and 90 minutes long. By minute 45 I had a working artifact in my sandbox. Hermes catching my dumb 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 notebook that died when I closed the tab. Here I had a real linux machine with my own files, and Hermes was running my actual code. It feels like pair work with someone who's done this 1000 times.”
“Module 04 was the moment something clicked for real. I had a real artifact shipped by Friday afternoon. My team thought I'd been working on it for weeks. It was four lessons.”
“I almost quit in module 03. Hermes noticed I'd been re-reading the same lesson three times and offered me a different angle that fit how I think. Clicked instantly.”
“The thing nobody tells you about courses like this is how much production / real-world stuff most of them skip. Module 06 covers the parts that pay rent. That single module saved us from a surprise that would have cost a lot.”
“I run a 12-person team. We did the course as a group over 3 weeks. Every person shipped something real in their squad by the end. The ROI calc is going to look ridiculous when I write it up.”
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 person their own sandbox + group progress.
Module 01 + your own OpenClaw sandbox + Hermes for the first 5 lessons. Most people finish this in an evening.
- Module 01 (1h+, 5 lessons + lab)
- Your own private OpenClaw sandbox
- Hermes for the duration of Module 01
- Discord access
All 6 modules of The OpenClaw Slack Agent Course, unlimited sandbox time, Hermes for the full course, and Office Hours when you're stuck.
- All 6 modules
- Unlimited OpenClaw sandbox time
- Hermes for the full course
- Weekly Office Hours with the authors
- Lifetime updates as new modules ship
- Cert of completion + project showcase
For teams running The OpenClaw Slack Agent Course together. Per-person sandbox, group progress, and a private Slack with Hermes.
- Per-engineer OpenClaw sandbox
- Group progress tracking dashboard
- Private Slack channel with Hermes
- Custom labs tailored to your stack
- Volume discount at 10+ seats
- Priority Office Hours
Stop reading about it. Ship something this week.
Module 01 of The OpenClaw Slack Agent Course is free forever and most people finish it in an evening. Your sandbox spins up in 30 seconds. Hermes is online and waiting.
Start the course free