Home/Courses/Viable Agents
Viable Agents · a course, not a feature tour

Build your own agent harness.

Most agent courses teach you the buttons. This one teaches the control system, and you leave holding a harness you wrote yourself: regulator. Each module opens with a regulatory question an autonomous agent forces on you, derives the mechanism that answers it, then shows the Pi feature and the typed treatment underneath regulator, the control plane the course is built against.

Prompts advise. Types describe. Gates enforce.
The premise the whole course is organized around
Why cybernetics

Agents need a regulator, not just a good prompt.

The Viable System Model is Stafford Beer's answer to an old question: what does any system, whether an organism, a company or an autonomous agent, need structurally to stay viable while its environment keeps generating more variety than anyone predicted? Ashby's Law gives the constraint. Only variety can absorb variety, so a regulator with fewer possible responses than the disturbances it faces will eventually fail somewhere it can't see.

A model plus a good prompt is not a regulator. It is a hope, and hope doesn't survive contact with a real codebase, a real filesystem, or real money moving. This course treats the harness itself as the regulator: explicit functions, typed channels, and gates that hold when the prompt is ignored or the model changes, and even when the task has nothing to do with code.

Who it's for

Not a prompt pack, not a persona library.

If you've used an agent for real work and hit its limits, this course gives you the vocabulary and the mechanism to fix that inside a harness you write yourself.

WhoWhat this course gives you
Senior and staff engineers running agents on real codebasesA principled reason for every guardrail, and a harness tuned to their repository.
Platform and DevEx teamsA design method for an internal agent platform, plus the evaluation machinery to prove it helps.
Agent-tool buildersDeep Pi extension and SDK competence, and a structural critique of "five agents in a trench coat."
Technical leaders evaluating autonomyA vocabulary for where autonomy is safe, and what evidence would demonstrate it.

Prerequisites. Comfortable TypeScript, Node 22.19 or later, git, a terminal, a key for at least one model provider, and having used some coding agent for real work. No cybernetics background: the primer teaches every term the lessons rely on, with figures, before any code.

Outcomes

By the end, you can

  • Describe an agent harness as a control system: what regulates what, over which channel, with what authority, closing which feedback loop.
  • Apply the mechanism hierarchy, type → gate → typed tool → model judgment → prompt, instead of solving every problem with prompt text.
  • Extend Pi confidently: typed tools, the tool-call lifecycle, context shaping, per-phase model routing, SDK and RPC, packaging.
  • Design work units as contracts, with each decision marked fixed, delegated within bounds, or unresolved.
  • Build audit that does not depend on the executor's self-report.
  • Keep system identity durable and version-controlled instead of trapped in a context window.
  • Decide when a human must be interrupted, and build the channel that does it.
  • Measure whether your regulation actually improved outcomes, with a control arm.
Three ways to take it

The same curriculum, three envelopes.

About 40 hours + capstone Self-paced

The repository, the written modules, recorded walkthroughs and graded labs. Ends at reference-build checkpoint 14.

You leave withregulator at checkpoint 14
6 weeks Cohort

Two 90-minute live sessions a week, labs between, design reviews, and a capstone crit.

You leave withA capstone harness and a viability case
2 days, on-site or remote Team intensive

Modules 01, 02, 03, 09 and 10 only, with the labs run on the team's own repository.

You leave withA guardrail layer for your codebase
Syllabus

A primer, fifteen modules, six parts.

Every module is a fixed unit: question → concept → Pi mechanism → build step → break it → field study → checkpoint. The "break it" drill is how the regulatory need becomes felt rather than asserted.

Part 0 · Framing
00
A primer on cyberneticsWhy describe a harness in the language of control, and what does the vocabulary buy?
01
The harness is the regulatorWhy doesn't a good model plus a good prompt suffice?
02
Anatomy of a turnWhere exactly can I intervene?
Part 1 · S1 Operations
03
Tools as the variety interfaceHow does the agent act on the world, and how narrowly?
04
Capability profiles and the advisory layerHow do I specialize work without roleplay, and what should prompts still carry?
Part 2 · S2 Coordination
05
Isolation, leases, and the anti-oscillation problemWhat stops two operations from fighting?
Part 3 · S3 Control
06
Work contracts: what you are actually authorizingWhat am I actually authorizing this run to decide?
07
Context and budget as regulated resourcesWhat do I spend, and on what?
08
Failure, recovery, and the retry latticeWhat happens on attempt two, and on attempt six?
Part 4 · S3* Audit
09
Evidence, not claimsHow do I know the work is done?
10
Authority boundaries and protected stateWhat must the agent never be able to change?
Part 5 · S4 Intelligence and S5 Identity
11
Environmental intelligenceHow does the system learn about its world?
12
Durable identity and policyWhat keeps the system itself from drifting?
13
Algedonic channelsWhen must a human be interrupted?
Part 6 · Operating
14
Observability, evals, driftDid any of this actually help?
15
Packaging and operatingHow does my team run this on Monday?
—
CapstonePresent a viability case for your harness.

The full module descriptions, the premise and the reference build are on the course's public page; the product it builds is regulator.

Request access

The pilot is small on purpose.

Tell us which format you want, what you run agents on today, and what went wrong last time. We reply to every request, and we'll say plainly if the course isn't the right fit.

Already enrolled? Open the course site with the password you were given. The course material is private and licensed to enrolled participants; the product it builds, regulator, is open source.
Request access to Viable Agents