
Runbook execution with a human gate on destructive steps
Runbooks are written down, then run by hand in the middle of the night, because nobody trusts automation with the step that deletes something. An agent runs the safe steps and stops at every destructive one until a named person approves it.
The short answer
An agent runs a runbook by working through its written steps in order: it performs the read-only checks and safe actions itself, records each result, and stops at every step that deletes, restarts, rolls back or changes production.
A named person reviews that step and approves or refuses it. The agent never improvises a step the runbook does not contain.
Why are runbooks still run by hand?
The runbook exists. It was written after the last incident, and it lists the checks, the commands and the order. But the person on call still runs it by hand, line by line, because one of the steps restarts a database or clears a queue, and nobody wants automation doing that unsupervised. So the safe steps wait on a tired human too, and the whole procedure takes as long as the slowest person at the keyboard.
Who is this for?
An IT lead, operations engineer or managed services lead whose team keeps written runbooks for recurring operations: clearing disk space, rotating credentials, restarting a stuck service, failing over a replica. It suits teams whose runbooks are specific enough that two people would run them the same way. Writing and changing runbooks, and deciding when to run them, stay with the team.
What changes when the safe steps run themselves?
| Part of the run | Run by hand | Run by an agent with gates |
|---|---|---|
| Read-only checks | Typed one by one | Run in order, with each result recorded |
| Destructive steps | Run by whoever is at the keyboard | Held for a named person's approval |
| What the approver sees | Whatever they check themselves | The step, its target and every check result so far |
| An unexpected result | Handled on instinct | The run stops and pages the on-call person |
| The record | Shell history, if anyone saves it | Every step, result and approval, with names and times |
How it works, step by step
The runbook is the program and the gates are where people decide. The agent runs nothing that is not written down.
Label each step by risk
Start the run on a trigger you approve
Run the checks and safe steps in order
Stop when anything is unexpected
Human gate: a named person approves each destructive step
Record the run
Flag runbooks that need work
What does the agent never do in a runbook?
Improvise
It runs only the steps written in the runbook.
Skip a gate. Gated steps wait for approval every time.
Approve itself
Approval comes from the named person, not from a timeout.
Change the runbook
Owners edit runbooks, and a change takes effect only once approved.
Replace on-call. Being on-call stays with people. The same book calls it a critical duty that many operations and engineering teams must undertake in order to keep their services reliable and available.
Where this fits
Running one runbook from trigger to record is a single process: Tier 1, Automate a Workflow. Runbooks specific enough to run the same way twice are what the readiness checklist looks for. A good way to start is shadow mode: the agent runs only the read-only checks beside your engineer and its results are compared before any safe step is handed over. Alerts that trigger runbooks often come from exception detection and routing across your ops stack. More in the use case library.
How do safe steps differ from gated steps?
| Question | Safe or read-only step | Gated step |
|---|---|---|
| Examples | Check disk usage, read logs, list processes | Delete files, restart a service, fail over, roll back |
| Who runs it | The agent | The agent, only after approval |
| What happens if it is wrong | Nothing changes | Something important can break |
| Who labels it | Your team | Your team, gated by default when unsure |
Related reading
- Shadow mode: how an agent earns each step before it runs it.
- Approval gates: how one named approval keeps the risky step safe.
- Exception detection and routing across your ops stack: where the alerts that start a run come from.
