Learning Path
s01 to s19: build the agent system progressively across 4 stages
How to Use This Page
First Full Pass
Read top to bottom before jumping around. The first six chapters establish the main loop everything else depends on.
If Things Start to Blur
Do not stare at code first. Identify the stage, then use bridge docs to reset boundaries like task, runtime, teammate, and worktree.
If You Are Rebuilding It
After each stage, stop and rebuild the minimal version yourself instead of waiting until s19 to backfill everything at once.
Bridge Docs Worth Re-reading
When the middle and late chapters start to tangle, revisit these before forcing the next chapter.
The timeline shows both order and where to pause
After each stage, rebuild one working slice before entering the next stage
If you only keep scrolling downward, chapter boundaries will eventually blur. The safer reading move is to pause at `s06 / s11 / s14 / s19` and confirm that you can rebuild the working system slice for that stage.
Pause here and rebuild the single-agent system from scratch
What You Should Be Able To Rebuild Here
A single-agent harness that can survive multiple turns, call tools, keep a todo plan, delegate one-shot subtasks, load skills on demand, and compact context at the minimum useful level.
Stabilize the control plane before moving to the task runtime
What You Should Be Able To Rebuild Here
A single agent with a real control plane: execution gating, extension hooks, durable memory, input assembly, and recovery branches.
Build the work runtime before moving into teams
What You Should Be Able To Rebuild Here
A minimal runtime that can persist task goals, run slow work in the background, return results through notifications, and let time trigger new work.
The final stage: building the platform boundary
What You Should Be Able To Rebuild Here
An agent platform with persistent teammates, shared protocols, autonomous claiming, isolated execution lanes, and one control plane for native and external capabilities.
Stage Legend
Core Loop: build the smallest useful single-agent system first, including tools, planning, delegation, skills, and context compaction.
After this stage, you should be able to build a working single-agent harness on your own.
The Agent LoopMinimal Closed Loop
“An agent is just a loop: send messages, execute tools, feed results back, repeat.”
Learn MoreTool UseRoute Intent into Action
“Adding a tool means adding one handler. The loop never changes.”
Learn MoreTodoWriteSession Planning
“A visible plan keeps the agent on track when tasks get complex.”
Learn MoreSubagentFresh Context per Subtask
“A subagent is mainly a context boundary, not a process trick.”
Learn MoreSkillsDiscover Cheaply, Load Deeply
“Discover cheaply, load deeply -- only when needed.”
Learn MoreContext CompactKeep Active Context Small and Stable
“Compaction isn't deleting history -- it's relocating detail so the agent can keep working.”
Learn MoreSystem Hardening: move from 'it runs' to 'it runs safely and predictably' with permissions, hooks, memory, prompt assembly, and error recovery.
After this stage, you should know how to make the agent safer, steadier, and easier to extend.
Permission SystemIntent Must Pass a Safety Gate
“Safety is a pipeline, not a boolean: deny, check mode, allow, then ask.”
Learn MoreHook SystemExtend Without Rewriting the Loop
“The loop owns control flow; hooks only observe, block, or annotate at named moments.”
Learn MoreMemory SystemKeep Only What Survives Sessions
“Memory gives direction; current observation gives truth.”
Learn MoreSystem PromptAssemble Inputs as a Pipeline
“The model sees a constructed input pipeline, not one giant static string.”
Learn MoreError RecoveryRecover, Then Continue
“Most failures aren't true task failure -- they're signals to try a different path.”
Learn MoreTask Runtime: turn work from session-local planning into durable, background, and scheduled execution.
After this stage, you should be able to lift chat-level steps into a durable runtime task system.
Task SystemDurable Work Graph
“Todo lists help a session; durable task graphs coordinate work that outlives it.”
Learn MoreBackground TasksBackground Execution Lanes
“Background execution is a runtime lane, not a second main loop.”
Learn MoreCron SchedulerLet Time Trigger Work
“Scheduling is not a separate system -- it just feeds the same agent loop from a timer.”
Learn MoreMulti-Agent Platform: add persistent teammates, protocols, autonomy, isolated execution lanes, and MCP / plugin capability routing.
After this stage, you should be able to grow a single agent into a collaborative platform.
Agent TeamsPersistent Specialist Teammates
“Teammates persist beyond one prompt, have identity, and coordinate through durable channels.”
Learn MoreTeam ProtocolsShared Request-Response Rules
“A protocol request is a structured message with an ID; the response must reference the same ID.”
Learn MoreAutonomous AgentsSelf-Claim, Self-Resume
“Autonomy is a bounded mechanism -- idle, scan, claim, resume -- not magic.”
Learn MoreWorktree IsolationSeparate Directory, Separate Lane
“Tasks answer what; worktrees answer where. Keep them separate.”
Learn MoreMCP & PluginExternal Capability Bus
“External capabilities join the same routing, permission, and result-append path as native tools.”
Learn More