Skip to content

Event-Triggered Escalation Rule

Governance rule — instantiates Tempo-Matched Response Governance

Pre-wires the condition that flips a decision onto a faster authority track the instant an environmental event crosses a set tempo threshold — so no meeting is needed to decide to hurry.

Deciding to go fast is itself a decision, and in a fast-moving situation it is often the slowest one — the meeting about whether to convene the meeting. Event-Triggered Escalation Rule removes it. It settles, in advance and in calm, the exact observable condition under which a decision leaves the normal deliberate track and drops onto a faster authority path: fewer approvals, wider latitude, quicker cadence. Its defining move is that the switch is pre-made and automatic — the environment's own behavior trips it, not a judgment call in the moment. It governs when the tempo regime changes, which is a different thing from what the fast track is allowed to do (Preapproved Response Playbook) and from who holds the compressed authority (Queue-Jump Authority). Argue the threshold once, so you never have to argue it during the run.

Example

A district fire crew works a new ignition under normal authority: the duty officer approves resources, briefs up the chain, waits for sign-off. That cadence is fine for a quarter-acre creeping fire. An Event-Triggered Escalation Rule pre-wires the moment it stops being fine — if the fire crosses, say, ≈100 acres, or its rate of spread doubles, or it jumps a containment line, the incident automatically steps up a management type: a larger team mobilizes and pre-delegated authority lets the incident commander commit aircraft and order evacuations without routing each call back up the chain.

Nobody convenes a meeting to decide whether to escalate; the fire's own behavior trips the switch. The threshold — 100 acres, doubled spread, a jumped line — was argued once, in the calm, precisely so it need not be argued in the smoke. And because the rule also names the conditions for stepping back down, the incident doesn't stay locked in crisis posture after the fire is boxed in.

How it works

  • Define the trigger as an observable event, not a judgment. A number crossed, an event seen — something that can fire without deliberation, because deliberation is the delay being removed.
  • Bind the trigger to a tempo change, not just an alert. Crossing it moves the decision to a faster authority path — fewer sign-offs, wider latitude — rather than merely notifying someone.
  • Set the threshold against the environment clock. It should fire early enough that the fast track still has lead time to matter, which means placing it relative to a real Environmental Time-Constant Estimate, not a gut number.
  • Make it symmetric. Define de-escalation as explicitly as escalation, or the system ratchets permanently into crisis mode and never relaxes.

Tuning parameters

  • Threshold level — how extreme the event must be to fire. Low fires often (fast, but noisy and prone to alert fatigue); high fires rarely (quiet, but risks reacting after the window closes).
  • Hysteresis — the gap between the escalate point and the de-escalate point. Too little and the system flaps between tracks on noise; too much and it stays escalated long after the event has passed.
  • What escalation changes — how much faster the fast track actually is: which approvals are dropped, how much latitude granted. More compression buys speed at the cost of oversight.
  • Trigger observability — whether the trigger reads an automatic signal or a human call. Automatic is fast and objective but only as good as its sensor.
  • Switch vs. advise — does crossing the threshold flip the track or merely recommend it? Advisory keeps a human in the loop but reintroduces the very deliberation delay the rule exists to remove.

When it helps, and when it misleads

Its strength is that it removes the slowest step in going fast — the deliberation about whether to go fast — by pre-settling it, so the response clock can compress the instant the environment demands it. It is what lets a single system carry both a slow track and a fast one and move between them in time rather than in hindsight.[1]

Its failure modes cluster around a threshold left untended. Set once and never revisited, it drifts out of step with a changed environment — too high, it fires after the window has closed; too low, it cries wolf until people mute it. Because escalation buys speed by dropping oversight, a rule with no de-escalation condition quietly normalizes the fast track as the default and spends its safety margin all the time. And it is gameable — thresholds tuned to dodge the paperwork of escalation, or invoked to bless a fast-track someone wanted anyway. The discipline is to revisit the threshold against the current environment clock, always define the relax-back condition, and audit each firing so drift and abuse are visible.

How it implements the components

Event-Triggered Escalation Rule fills the governing components that decide when tempo changes:

  • tempo_fit_threshold — it holds the explicit threshold separating "current cadence still fits the environment" from "the environment has outrun us and the track must change."
  • cadence_adaptation_rule — it is the rule that changes cadence when that threshold is crossed, stepping the decision from the deliberate track to the fast one and, symmetrically, back.

It decides when to switch tracks, not what the fast track may do — the envelope of pre-authorized fast actions is Preapproved Response Playbook's — nor who wields the compressed authority, which is Queue-Jump Authority's.

Notes

The rule fires the switch; it does not itself hold the authority the switch grants or the plays it runs. It works only as one of a trio — the trigger that says when, the standing authority (Queue-Jump Authority) that says who may, and the playbook that says what. A trigger with no pre-delegated authority behind it simply escalates into the same queue it was trying to skip, and the speed it promised evaporates.

References

[1] In John Boyd's OODA loop (observe–orient–decide–act), advantage goes to whoever cycles faster than the situation can adapt. An escalation rule is a way to shorten your own loop on demand: by pre-deciding when to speed up, it removes an entire orient-and-decide cycle from the path exactly when time is scarcest. ↩