STEAD THE SCHOOL

THE STEAD SCHOOL · TWO ON-RAMPS, ONE MEMBERSHIP

Learning to run your whole life with agents.

The guided path to running your whole life with agents: build the machine, boot your workspaces, author the skills and routines, and end with a week that carries itself. You do it with people walking the same road, not alone.

ONE MEMBERSHIP · ONE PRICE

$99/month

One membership, everything in it: all nine modules, the deep end, the community room. Cancel anytime.

Month to month, no lock-in. You pay for the month you're in, and you can leave whenever you want. The free product stays yours either way.

Stead runs on your own Claude Code plan (Pro or Max), and that subscription is separate. The $99 covers the school and the community, not the AI.

Join the school See what's inside

ON-RAMP 1 · BEHIND AND OVERWHELMED Start at M0. We walk you from a blank file to a life that runs. $99/mo, cancel anytime. START AT THE BEGINNING · SAME MEMBERSHIP ON-RAMP 2 · ALREADY BUILDING Jump to the deep end. You build with this stuff already, you just never operationalized it. $99/mo, same room. JUMP TO THE DEEP END · SAME MEMBERSHIP

There are two ways in, and they land in the same membership. Same price, same room, same course. It's two on-ramps, not two products.

WHY A SCHOOL EXISTS AT ALL

The skills are free. What you pay for is the path and the room.

Stead ships as free open-source software. You can install it in two minutes with npm create stead and never pay for anything. That's not a hook; it's a design decision. The product is free and always will be.

But standing up a whole agentic life-OS on your own is a lot: five workspaces, a memory, skills, routines, and the judgment to know what to automate and what to keep in your own hands. That's the gap the school closes.

So here's the honest version of what you're buying. What you're actually paying for is the guided path through all of it, plus a room of people doing the same work you are. The skills themselves are free. You can grab them off the open community shelf, and the lessons teach you to build your own. Nobody gates a commodity. What can't be forked is the sequenced way through and the people walking it beside you. I keep the course current as the field shifts, because that's the minimum, not the pitch.

There are two ways in, and they land in the same membership. Pick the on-ramp that matches where you are right now. It's two on-ramps, not two products.

ON-RAMP 1 BEHIND AND OVERWHELMED? START AT M0.

From a blank file to a life that runs.

For people who installed Stead and are staring at the blank page. Or people who haven't installed it yet and want the floor under their feet first. You start at M0 and we walk you the whole way.

You go module by module, and every module ends with something real on your own data, not a demo. Module 0 maps what's in your house and lands a first win before the lesson is over. By the time you reach the capstone, you've designed a week that runs on its own, and you can narrate it to someone who has never heard of Stead.

You don't do it alone. The community carries the room. The proof that this works isn't me running a polished setup, it's seeing someone who was exactly as behind as you are make it through. Peers answer faster than any instructor could, and they're the reason the room stays alive between course updates.

WHAT YOU BUILD, IN ORDER

A map of what's actually in your house, plus a real first win in Module 0, something fires, using your own data, before the lesson is over.

One room that actually knows you, with a context brief you wrote by hand, not a template I handed you.

Your first reusable skill, authored off a worked example, run cold in a fresh session before it ships.

Your first multi-step workflow, a real one, on a real tomorrow's meeting prep, not a demo scenario.

Your first agent, built under an approval rule you wrote before you wrote the agent (that order is the whole lesson).

Two weeks of the OS running daily while you check in on it. This is the Landing, and it's how you know you built something real.

WHO THIS IS FOR

You're comfortable enough to install a CLI and let agents touch your calendar and inbox. You've got the tools but not the operating discipline. You want it sequenced for you, start to finish, with a room of people doing the same work alongside you.

WHERE YOU LAND

You finish where the other on-ramp starts: a running OS, agents under approval rules, and a weekly review that fires on its own. Then the deep-end course content is right there, same membership.

PACE

Your pace, not a calendar's. The full curriculum is visible upfront and open from day one. Everything is unlocked from the start, and nothing waits on a start date.

START AT THE BEGINNING $99/MO · SAME MEMBERSHIP

ON-RAMP 2 ALREADY BUILDING? JUMP TO THE DEEP END.

Skip to the part you never operationalized.

For people who can already read a SKILL.md, open a terminal, and mostly know what they're doing, but never turned that fluency into a life that actually runs. You jump straight to the deep end. Same price, same room, same course as the other on-ramp, you just start further in.

THE DEEP END IS COURSE CONTENT

Scheduled automation, long-running background agents, multi-agent orchestration, and the reliability and escalation capstone. Plus the epistemic patterns: collaborative review, adversarial review, iterative looping, judge panel, completeness critic. It's the back half of one course, open the same day everything else is.

EVERYTHING IS OPEN FROM DAY ONE

All nine modules, front to back, open and yours from day one. The full curriculum is visible below precisely because your top objection is "I'll outgrow this in a week." Read it. You won't.

WHERE TO START

There's a short, honest self-check at the top of the deep end: is your OS actually running, with at least one agent under an approval rule? If yes, dive in. If a piece is missing, you'll see exactly which earlier module covers the gap. It's a signpost, not a wall.

WHAT KEEPS IT WORTH IT

The field moves quarterly. The harness changes, model behaviors shift, new patterns emerge. The course gets rewritten as the ground moves, and the community produces the vetted skills on the open shelf. The membership is what keeps you current.

JUMP TO THE DEEP END $99/MO · SAME MEMBERSHIP

SKILLS AND PACKS · FREE BONUS, NEVER A TIER

The skill shelf is open. That's a feature, not a leak.

Skills and packs are free or bonus, never a gated tier. The community skill shelf is open and stays open. You don't pay to unlock skills. The lessons teach you to build them yourself, and the community gives away the vetted ones.

ON THE SHELF

habit-streak

FREE

reads your local habit log, reports the streakscanned + reviewed

ON THE SHELF

occasion-keeper

FREE

tracks gifts, occasions, and events in a local ledgerscanned + reviewed

ON THE SHELF

subscription-watch

FREE

surfaces the charges that quietly repeat, from a local CSVscanned + reviewed

The shelf opens small on purpose: three seed skills today, every one of them scanned with an independent security scanner and reviewed before listing, with the scan result recorded in the registry. Every future submission clears the same gate before it appears. "Vetted" is a mechanical claim here, not a vibe.

The community skill shelf (skills contributed and vetted by members) is free for everyone, member or not. The lessons teach you to author your own, and the community gives away the vetted ones. Nobody gates a commodity. What the membership buys is the course that stays current and the room of people doing the work alongside you.

THE FULL CURRICULUM · VISIBLE UPFRONT · KEPT CURRENT

Both on-ramps run the same nine modules.

Every module is listed with its industry term and the metaphor we use for it in the room. The reason it's all visible upfront is simple: your biggest question is whether you'll hit the bottom in a week. You won't. Here's the whole thing.

CURRENT AS OF Claude Code 2.1 A version stamp sits at the top of the course so you always know what the lessons are tracking. Every lesson is dated, so you can see exactly when it was written and when it was last touched. When the ground moves, the rewrites show up in the changelog below.

STAGE 1 · BUILD THE OS

Modules 0 to 4, then the Landing.

MODULE 0Agentic OS Architecture(The Machine)

You arrive already installed. Module 0's job is to map what's actually in your house and land a first win before the lesson is over.

The constellation map: model, context window, memory, skills, connectors, and agents, and how delegation actually works
The guided first-fire: one workflow runs in your house, on your own data, made by you (not watched)
The never-delegate list that governs all of it, written before you automate a thing

Proof-of-work: "It just did that for me," your first thing that ran on its own.

LESSON WRITTEN 2026-04-02 · UPDATED 2026-07-02

PREREQUISITESStead installed (npm create stead) and your own Claude Code plan (Pro or Max). The membership doesn't include one.

MODULE 1Context Engineering(First Boot)FREE MODULE

M0 borrowed someone else's script. M1 is yours.

Authoring a context brief that turns a generic workspace into one that answers as only your tools could
Editing the memory file by hand: what you withhold on purpose and why
Re-run the M0 win with a room that now knows you; the difference is the lesson

Proof-of-work: the first room that actually knows you.

LESSON WRITTEN 2026-04-05 · UPDATED 2026-07-02

PREREQUISITESNo prerequisites beyond Module 0.

MODULE 2Skills Authoring(Skills)

A briefing you give three times is a procedure. This module is where you stop repeating yourself.

The graduation rule: when a repeated briefing becomes worth a reusable markdown skill file
Shelving it with provenance so you know where it came from and what it's allowed to do
Running it cold in a fresh session before it ships
The overreach drill: spot the line you'd strike in a skill that wants more than its job requires

Proof-of-work: a skill on the shelf, run cold.

LESSON WRITTEN 2026-04-09 · UPDATED 2026-07-02

PREREQUISITESAssumes Module 1 complete. No prior skill-authorship experience required.

MODULE 3Connectors and Workflows(Doors & Recipes)

Connectors, deterministic workflows, and the workflow-vs-agent hinge.

Wiring MCP connectors with scoped keys, one scope at a time, spoken aloud
The revoke drill: what you'd do if you needed to cut access immediately
Building a deterministic, multi-step workflow that runs end to end on your real tomorrow
Where a workflow ends and an agent begins: the hinge taught as a decision, not a definition

Proof-of-work: workflow output on a real tomorrow.

LESSON WRITTEN 2026-04-14 · UPDATED 2026-07-02

PREREQUISITESAssumes Module 2 complete (a skill on the shelf). One connector installed.

MODULE 4Agent Design and Permission Rules(First Agent)

The order matters here: approval rule before agent build, always.

Designing an agent that exercises judgment, not a script
Writing the approval rules (may do, must ask, may never) and sandbox boundaries before a line of config
The log-review habit: reading what your agent did and catching the first edge case
The Manual as OS spec v1: your OS, documented by you

Proof-of-work: your approval rule plus a narration of your agent's first log.

LESSON WRITTEN 2026-04-18 · UPDATED 2026-07-02

PREREQUISITESAssumes Module 3 complete. A running workflow is a hard prerequisite: the agent orchestrates the tools you've already wired, not hypothetical ones.

THE LANDINGAfter Module 4

No new content. The OS runs daily for two weeks. Week 1 and week 3 check-in threads. Fix one stall each week. The only job here is "let it run and notice what breaks."

This is the bridge into the deep end, and the self-check for anyone who jumps straight there. The 14-day streak is a real signal: if it's still running after two weeks, you built something real.

STAGE 2 · THE DEEP END · COMPOSE THE OS

Modules 5 to 8.

This is the deep-end on-ramp's starting point and where the first on-ramp lands. Open from day one, no waiting period. It's the back half of one course, open the same day Stage 1 is.

MODULE 5Scheduled Automation(Routines)

Work on a clock. This module puts a workflow on a recurring schedule.

The 6:30 morning briefing routine: built and running before the module ends
The Friday review: the weekly cadence that keeps the OS honest
The inheritance rule: a routine never exceeds the permissions of what it runs
"What it may do while you sleep": the intent declaration that precedes any unattended run

Proof-of-work: NEXT RUNS populated.

LESSON WRITTEN 2026-04-23 · UPDATED 2026-07-02

PREREQUISITESAssumes the Landing complete (14-day streak). At least one agent under an approval rule is a hard prerequisite. You cannot wire a trigger to a tool that isn't yet trusted.

MODULE 6Long-Running and Background Agents(Overnight)

A single job too big for one sitting, dispatched and audited later.

Dispatching the first background job: what makes a safe candidate
Tracking its milestones overnight while you're not watching
The audit drill: three seeded flaws planted in a log, you catch two (the third teaches what the log misses)
Your spot-check rule, written before the overnight run

Proof-of-work: the first morning your OS worked while you slept.

LESSON WRITTEN 2026-04-28 · UPDATED 2026-06-09

PREREQUISITESAssumes Module 5 complete. The morning briefing routine must be running and stable before anything runs unattended overnight.

MODULE 7Multi-Agent Orchestration(The Crew)

An orchestrator that manages subagents, supervised at the boundary.

The warrant test: when a goal fans out into independent sub-goals that each need their own worker (the only time to orchestrate)
Briefing one orchestrated job: the sequential case, then the parallel fan-out
Supervising at the boundary: reading an orchestrator's plan before it runs
The senior call: when a job does not need a crew at all

Proof-of-work: orchestrator's plan plus the result, narrated to a non-technical person.

LESSON WRITTEN 2026-05-04 · UPDATED 2026-06-09

PREREQUISITESAssumes Module 6 complete. Running overnight delegation is a hard prerequisite. Orchestration is the top of a ladder; skipping rungs produces agents nobody should have trusted.

MODULE 8Reliability and Escalation(The Self-Running Week)

The capstone. You designed this; I didn't.

The week map: every pillar lit, every routine wired, every overnight declared
Escalation tiers and graceful degradation: retries, flags held for review, what genuinely wakes you
The trust review cadence: your own schedule for reading the logs
The Manual v2: the OS documented as if you were handing it to a colleague

Proof-of-work: a two-minute Observatory tour narrated in your own words, for someone who has never heard of Stead. Every pillar lit, one of them deep.

LESSON WRITTEN 2026-05-11 · UPDATED 2026-06-12

PREREQUISITESAssumes Module 7 complete. All pillars standing is the graduation criterion; a half-built OS entering Module 8 means the earlier modules have work left.

THE COURSE CHANGELOG · REWRITES AS THEY HAPPEN

When the ground moves, the course moves. This is the public record of it.

2026-07-02 Rewrote the build lessons when the packs started shipping staffed: every workspace now arrives with an agent team and its skills fitted, so M2 checks the shelf before you author, M4 reads a shipped definition before you extend, and course work lives in a lab project that keeps your workspaces clean.

2026-06-12 Updated the memory module when the MCP surface changed, so the connector lesson tracks the current tool definitions.

2026-06-09 Rewrote M5 through M8 when subagents and background agents shipped, splitting the old automation block into scheduled, long-running, orchestrated, and reliability.

2026-05-30 Re-recorded the scheduled automation walkthrough against the new cadence registration flow.

2026-05-21 Revised M1 context engineering after the memory file format changed, so the hand-editing lesson matches what you'll actually see.

The dates above are real and the rewrites are real. Keeping the course current as Claude Code, the harness, and the patterns shift is the upkeep, not the sell. What you're here for is the path and the room; this is just the receipts that the path stays honest.

THE DEEP END · THE EPISTEMIC PATTERNS

How you reach a good, trustworthy answer.

These are deep-end course content, open from day one alongside Modules 5 to 8. Outcomes are what's listed here. The lab builds live in the lessons, and the vetted skills are free on the open shelf.

There's a difference between knowing how to route work to multiple agents (that's Module 7) and knowing how to use multiple passes or perspectives to reach a more trustworthy answer. The second one is what these patterns teach. You can run every one of them inside a single session if you want; the subagent version is just the parallelized, isolation-enforced implementation. But the concept comes first.

Honest prerequisite for all of these: a Stead OS that is actually running with at least one agent under an approval rule. You cannot run adversarial review against an OS you don't have. That's the same self-check the deep-end on-ramp opens with.

Collaborative review

Surface coverage your first pass missed by bringing N independent perspectives, each with its own lens, then synthesizing them. Practical cases: reviewing a document for both clarity and completeness, drafting a decision brief from multiple stakeholder angles, producing a weekly summary where each pillar gets its own read.

OUTCOMEBroader coverage without a broader workload. Each perspective brings something the others don't; the synthesis is where the value lands.