All lessons › Function E — The Agentic SOC › Respond — From a Conclusion to the Actor Stopped
E4.2

Runbook tiers — fully automated, human in the loop, manual

E4
▶
Lightboard recording

Not recorded yet. The lesson below is complete and runnable today — the video is added later without touching this page.

Video placeholderpublishes automatically from recordings/E4.2.mp4
Risk

Everything is written as fully automated because that is the impressive demo, and the first wrong action is unrecoverable.

Control

Tier assigned from the remediation policy, with the human-in-the-loop tier carrying a real decision point rather than a confirmation dialog.

The lab

Take one incident and run its response at all three tiers, comparing what each costs and what each risks.

◉Use case relevance

Fully automated contains in fourteen seconds and is wrong eight times in a hundred. Manual is almost never wrong and takes thirty-four minutes, against a breakout time of twenty-nine. Neither of those is the safe option; they fail differently.

At CyberTravels. decision_point() asks three questions of a human-in-the-loop runbook: does it say what it will do specifically, what it cannot undo, and does it offer something narrower. Without the third the choice is act or abandon the incident, and act always wins. A runbook that fails is tiered manual instead.

◴What this lesson is — Day 0, Day 1, Day 2

What separates a human-in-the-loop tier from a confirmation dialog: specificity, an explicit statement of what cannot be undone, and a narrower option, so the choice is not act-or-abandon.

Day 0 — why

"Automate everything" and "keep a human in it" are both asserted constantly and neither is a position.

Day 1 — how

Time all three tiers against one incident, with the cost of acting on a bad signal beside the time to contain.

Day 2 — measure

14 seconds at 8 errors per hundred, against 2,072 seconds at 0.2, against a measured breakout of 1,740. The manual tier is a risk decision, not the safe one.

Measure this

what to measuredenominator or target
time to contain, per human-in-the-loop tier14 seconds at 8 errors per hundred, 2,072 seconds at 0.2, against a measured breakout of 1,740

▦The framework, and how it works

   one incident, three tiers

   tier                 decide      contain      wrong / 100
   automated                1s          14s              8.0
   human in the loop      240s         253s              1.2
   manual                1800s        2072s              0.2
                                        ^
                        breakout time is 29 min = 1740s
                        manual contains AFTER the attacker finished

   deliberately no fourth column ranking these: seconds of exposure and
   wrongly-contained agents are different units, and any single score
   has an exchange rate hidden in it that somebody chose

The three tiers are not levels of ambition. They are three different trades between time to contain and the cost of acting on a bad signal — and which trade is right depends on the detection's measured false-positive rate, not on taste.

There is no single score that ranks them, and this lesson refuses to print one. Seconds of exposure and wrongly-contained agents are in different units. Any number that ranks them has an exchange rate hidden inside it, chosen by whoever wrote the formula.

Anchor → E1.0. Three tiers are three contain intervals at three different costs of being wrong: 14 seconds at eight errors per hundred, 2,072 seconds at 0.2, against a measured breakout time of 1,740. The manual tier is a risk decision, not the safe one.

2 · Both tiers fail; they fail differently

Fully automated contains in fourteen seconds and is wrong eight times in a hundred, with nobody between the mistake and the estate.

Manual is wrong far less often and takes thirty-four minutes — which, against a 29-minute breakout time, means containment lands after the attacker has finished. "Keep a human in it" is a risk decision too. It is just usually an unstated one.

3 · One incident, three tiers

Two columns, deliberately unranked. Choose the exchange rate openly, per incident class, or do not choose it.

▶Real time execution as skill

The skill — skills/response/runbook-tier-assignment/SKILL.md

name: runbook-tier-assignment
description: >-
  Run one incident's response at fully automated, human-in-the-loop and manual
  tiers, and compare time to contain against wrong actions. Use when choosing a
  runbook's tier, when justifying automation to a risk function, or when
  "automate everything" and "keep a human in it" are both being asserted.
allowed-tools: Read, Grep, Glob

Three tiers, three ways of being wrong

The tiers are not levels of ambition. They are three different trades between time to contain and the cost of acting on a bad signal — and which trade is right depends on the detection's false-positive rate, not on taste.

There is no single score that ranks them. Seconds of exposure and wrongly contained agents are in different units; any number that ranks them has an exchange rate hidden inside it. Choose that rate openly, per incident class, or do not choose it.

When to use this

When assigning a tier to a new runbook, and when reviewing an existing one after its detection's false-positive rate has been measured. The tier should move when the rate moves.

Step-by-step

1 — Take the tier from remediation-policy-check as the ceiling. This skill chooses within what policy permits, never above it.

2 — Time each step at each tier honestly. The decide step is where the tiers actually differ; the mechanical steps barely move.

3 — Bring the detection's measured false-positive rate. Without it this is an argument about feelings.

4 — Report both costs side by side, unranked. Resist the composite score.

5 — Choose, and write down the exchange rate you used. The next person needs to know what you traded, not just what you picked.

Example

Input — one incident, five steps, three tiers, in scripts/runbook_tier_assignment.py.

Output — a real run:

tier                   contain   reaches the estate wrongly / 100
automated                  14s                                8.0
human-in-the-loop         253s                                1.2
manual                   2072s                                0.2

Manual contains after 34 minutes, against a 29-minute breakout time.

Output contract

{
  "tiers": [{"tier": "str", "seconds_to_contain": 0, "wrong_actions_per_100": 0.0}]
}

Common edge cases

  • The detection has no measured rate. Then no tier can be justified; measure first.
  • The human is not actually available. A human-in-the-loop tier with a four-hour on-call response is a manual tier wearing a badge.
  • The confirmation dialog. A HITL step nobody can meaningfully refuse is an automated step with extra latency.

Failure modes

  • Composite scores. They always favour whichever axis the author weighted.
  • Automating on an unmeasured detection. The fastest possible way to break production on a false positive.
  • Manual as the safe default. On a 29-minute breakout time, slow is a risk decision too — just an unstated one.

Three ways to do this lesson. Pick one. They run the same procedure against the same code — what changes is who drives it, and how much you see.

1In your AI agent — you are taught

The agent reads the lesson, explains the idea, fetches the code, runs the check and answers your questions as you go. This is the one to take if you are here to learn.

Install it, once. From the folder you cloned. --all does every agent it finds on your machine:

python3 scripts/install_skills.py --all --lessons E4.2

Then restart your agent and open it in that folder. On Windows, if python3 says Python was not found, use python instead.

Then pick e4-2-runbook-tiers:

agentinstall just for this agentstart it
Claude Codepython3 scripts/install_skills.py --tool claude --lessons E4.2type /e4-2-runbook-tiers
GitHub Copilot (VS Code)python3 scripts/install_skills.py --tool copilot --lessons E4.2type /e4-2-runbook-tiers in Chat
Cursorpython3 scripts/install_skills.py --tool cursor --lessons E4.2type / in Agent chat and search for it
Codexpython3 scripts/install_skills.py --tool agents --lessons E4.2type $e4-2-runbook-tiers, or run /skills

2As one Python command — you just run it

No agent, no conversation. The same lesson executes and prints the same readback. Take this one if you have no assistant, if you are reviewing rather than learning, or if you want the result without the teaching around it.

python3 scripts/lesson.py E4.2

3Read the code, and the difference — nothing runs

Neither of the above, and no model needed. The first command writes CyberTravels exactly as it stood at the end of this lesson; the second prints the diff — the lines this lesson added or changed, and nothing from any later one.

python3 scripts/checkpoint.py --at E4.2 --out work/cybertravels
python3 scripts/checkpoint.py --at E4.2 --diff

On Windows, type python wherever these say python3 — and use \ instead of / in the paths. Everything else is identical. A0.0 step 2 explains why.

Ways 1 and 2 need a model; way 3 does not. A signed-in Claude Code CLI needs no API key, and any OpenAI-compatible endpoint works too. With neither, the audit exits 2 and says so rather than inventing an answer. A0.0 sets this up.

Ways 1 and 2 both end with the same readback: What I did, What changed, The number and Read this next. A step that was skipped or refused is reported as exactly that, never as a pass.

If you did the last lesson’s challenge, expect this to stop. Most challenges ask you to edit the code, and ways 1 and 2 will not overwrite your edits: you get stopped, not a failure, with two options — --out for a fresh folder that keeps your work, or --force to discard it and start this lesson clean.

✓What you just proved

14s / 253s / 2072s to contain, against 8.0 / 1.2 / 0.2 wrong actions per hundred — and no third column ranking them.

✎Your turn

Put your own detection's false-positive rate in and see whether the tier you already ship still looks right.

Tools used

kagent

Skill source: skills/response/runbook-tier-assignment

← PreviousE4.1 · Remediation policy — what may be done without asking