CSE Roadmap

Core tier · about 4 hours · 12 parts

Part 6 of 12 · 3 min read

What the example found

Harm leaked by gating policy with and without fatigue, load sensitivity, and blocking versus pausing.

How to read the policy table: each row is a gating policy; columns show requests sent per task, the simulated catch probability under fatigue, and harm leaked per 1,000 tasks under fatigue and under full attention (93.5 harmful actions occur per 1,000 tasks regardless of policy).

Policy Requests per task Catch probability (fatigued) Harm leaked, fatigued Harm leaked, full attention Good actions rejected
none 0 n/a 93.5 93.5 0
all 6.0 0.23 70.8 9.5 120
irreversible 1.8 0.47 60.4 29.2 35
risk score >= 0.5 1.0 0.60 45.1 22.3 19
irreversible or risk >= 0.7 1.9 0.46 57.0 19.5 38

What to notice: under full attention, "all" is clearly the best policy (9.5 leaked). Under fatigue, "risk score" becomes the best (45.1 leaked), while "all" falls to second-worst (70.8). The best policy on paper and the best policy with a real, finite-attention reviewer are not the same policy. This is the single most important finding in this table.

How to read the load table: each row is a different task arrival rate; columns compare harm leaked under the gate-everything and irreversible-only policies.

Tasks per hour Harm leaked (gate everything) Harm leaked (irreversible only)
2 39.9 39.4
10 70.8 60.4
40 86.7 79.4

What to notice: at low load (2 tasks/hour) the two policies are nearly tied (39.9 vs 39.4). But the gap widens steadily as load rises. Targeting fewer, better-chosen requests matters more exactly when the reviewer is busiest. That is the opposite of when most teams think to narrow their gate.

How to read the blocking-versus-pausing table: each row is a different mean wait for a decision; columns are total minutes to finish 50 tasks under each worker mode.

Mean wait for approval Blocking worker Pausing worker
5 minutes 486 250
30 minutes 1,663 272
120 minutes 5,904 713

What to notice: the pausing worker's time barely grows with the wait (250 to 713 minutes as the wait grows 24x). The blocking worker's time grows almost in direct proportion to the wait (486 to 5,904). Pausing does not just save some time. It decouples the worker's throughput from how long people take to decide.

How to read the timeout table: each row is a different timeout, all at a 30-minute mean wait.

Timeout Share of requests that exceed it
30 minutes 36.8%
60 minutes 13.5%
120 minutes 1.8%

What to notice: even at 120 minutes, four times the mean wait, 1.8% of requests still time out. That is the concrete reason a default-deny rule has to exist. It cannot be treated as a rare corner case.

{{svg:gate|A gated step pauses and saves state, waits for a person, re-checks the premise and then executes with an idempotency key.}} {{svg:results|Harmful actions leaked under five gating policies, with and without fatigue, and time to finish 50 tasks with blocking and non-blocking waits.}}

Five properties make a gate work. The first is a risk rule that decides what to gate. The second is a durable pause (module 7). The third is a useful request: what, why, what changes, how to undo it, and the option to edit. The fourth is a re-check on resume. The fifth is an idempotent execution (module 6).