Seventeen lessons · about two hours
From first launch to running fleets.
A complete course in orchestrating coding agents. It starts with what an Agent Development Environment even is and ends with tournaments, agent-driven sub-fleets and review-driven iteration. No prior Asylum experience assumed.
Work along, don't watch. Use a small throwaway git repo for every exercise — worktrees and merges stay cheap, a bad merge costs nothing, and you can be reckless enough to actually learn something.
You will need one agent CLI on your PATH. Lesson 02 covers
installing and verifying one, so start there if you have none.
Part one — the basics
Open a repository, race your first agents, and read what comes back.
Welcome to Asylum
What an ADE is, and why one agent per prompt is a bad bet. Worktree isolation, and the compare-and-merge loop the whole app is built around.
Install and first launch
Get Asylum running and tour the window: the activity rail, the surfaces, and where everything lives.
Open a project and pick agents
Open a repository, edit settings.json, and verify your agent CLIs are found and authenticated. The setup doctor tells you what is missing before you waste a run finding out.
Your first fan-out
Compose a prompt, race two agents, and watch the runs spin up in isolated worktrees. Learn why a small, verifiable prompt beats an ambitious one.
Reading semantic states
Status is the process lifecycle; activity is what the agent is doing right now. The difference is how you spot the one agent blocked waiting on you.
Part two — judging the work
Reviewing, scoring and landing what the fleet produced.
Review: diffs, checks and annotations
The annotatable diff, per-hunk staging, PASS/FAIL checks against the project's own tooling, and inline comments shipped back to an agent as feedback.
Merge the winner
Choosing a winner, the guarded merge preflight, opening a pull request instead, and what happens to the branches that lost.
Layouts and presets
duel, triad and swarm — named sets of agents you race in one pick — plus defining your own so a project's roster travels with the checkout.
Part three — the environment
Everything around the fleet: knowledge, integrations, and the tools in the window.
Notes and knowledge
The Markdown vault: wiki links, backlinks, tags and templates — and attaching a note to a task so it becomes context the agent actually receives.
Integrations
Browsing GitHub pull requests and issues in-app, turning an issue straight into a worktree, and the same for Linear.
Terminal, editor, preview, browser
Splittable GPU terminals with persistent scrollback, the editor and file tree, Markdown/image/PDF previews, and the browser's design mode — click an element, send its HTML and CSS to an agent.
Part four — driving it yourself
The CLI, agents that orchestrate other agents, and the patterns that scale.
The CLI tour
Every asylum subcommand: worktrees, runs, search, secrets, layouts, plugins, and the aggregated MCP gateway.
The agent control surface
A running agent orchestrating the fleet from inside its own worktree — spawning a helper run, reading a sibling's work, running checks, reporting its state, and waiting on another run. With a worked demo.
Agents that remember, and work that starts without you
Naming an agent so it stops starting from nothing: a brief, a memory that survives the task, and the agent writing to that memory itself as it works. Then scheduling a task on a cadence, and recording a workflow once to replay it thereafter.
Mobile companion and events
The opt-in companion server and its event stream: following the fleet, and sending a follow-up to a live run, from a phone.
Plugins
plugin.toml, the process runtime versus the sandboxed WASM one, installing from GitHub — and building a simple plugin end to end.
Expert workflows
Tournaments, agent-driven sub-fleets, review-driven iteration, and the practices that hold up once you are running fleets rather than pairs.
How the lessons are built
Every lesson tracks the Asylum book, so the course and the written documentation stay in step rather than drifting apart. Each one states what you will learn, what it assumes, and roughly how long it takes, and ends by pointing at the chapter that goes deeper.
Video recordings are in production. The written lessons above are complete and usable today — the docs carry the reference material each one builds on.