Why This Matters

Until now, every action in your system starts with a human. A user types a request. The supervisor decomposes it. Workers execute. But production coding systems do not wait for humans. Code gets pushed, tests fail, PRs are opened, dependencies are updated — these events happen continuously, and the system needs to respond without someone typing "go."

Automations close this gap. An automation is a background workflow that triggers when an event occurs. When code_pushed fires, the automation loads the lint-and-test skill, creates a worker agent, and runs the checks. When test_failed fires, another automation loads the debug skill and investigates. No human in the loop. No blocking the main agent.

This is the difference between a tool and a system. Tools wait to be used. Systems respond to the world.

What You Will Build

An AutomationRunner that registers automations, listens for events, and executes triggered workflows in the background. Each automation specifies which event triggers it, which skills it needs, and what task to run.

  Event: "code_pushed"
         |
         v
  +------+----------+
  | AutomationRunner |
  | match triggers   |
  +------+----------+
         |
         | matched: "lint-on-push"
         v
  +------+----------+
  | Load skill:     |
  |   "lint-check"  |
  +------+----------+
         |
         v
  +------+----------+
  | Create agent    |
  | Execute task    |
  | (background)    |
  +------+----------+
         |
         v
  +------+----------+
  | Result:         |
  |   status: pass  |
  |   duration: 12s |
  +------------------+

What's Next

You have skills that inject capabilities on demand and automations that run workflows in response to events. But these are still individual pieces. The supervisor, the scheduler, the workers, the review queue, the handoff system, the skills, the automations — they all exist independently.

In Chapter 15, you will bring every component together into a complete system. The capstone assembly wires all the pieces you have built across 14 chapters into a single, functioning multi-agent coding platform.