The hidden object is the next action set

A static decision table places actions in rows, possible states in columns, and utilities or losses in the cells. If the current belief about state θ is bₜ(θ), the familiar expected-utility calculation is:

Here a is an action, θ is an uncertain state of the world, bₜ(θ) is the current probability assigned to that state, and u(a, θ) is the utility produced by the action in that state. Raise the probability of fraud and release becomes less attractive. Raise the harm of a false decline and decline becomes less attractive. The equation is useful, but it silently assumes that the table contains everything the decision changes.

Irreversibility appears when an action also changes the decisions available later. Let Aₜ₊₁(a) be the feasible action set after choosing a. A dynamic comparison adds continuation value:

h is direct harm not captured by the headline benefit, r is the expected burden of recovery, β discounts later value, and Vₜ₊₁ is the best value achievable from the next belief and action set. If release removes the ability to stop settlement, the term changes. If a verified rollback keeps the previous state reachable, the term changes again. Bellman's dynamic-programming formulation made this recursive structure explicit: a present choice is valued partly by the decision problem it leaves behind.^[3]

Arrow and Fisher's analysis of uncertainty and irreversible environmental change, and Henry's related account of the irreversibility effect, established the economic importance of preserving future choice while information may arrive.^[1][2] The transferable intuition is simple: a choice may be expensive because it removes the ability to respond intelligently to tomorrow's evidence.

A precise distinction from ordinary risk aversion

Risk aversion says that a decision-maker can prefer a less variable payoff distribution even when two options have the same expected value. Irreversibility says something different. Two actions can have the same immediate payoff distribution and still differ because one preserves a future decision and the other eliminates it. A static utility function can represent that difference only if the future loss of choice has already been brought into the outcome description.

This yields a useful correction to casual language. A choice is not irreversible merely because it feels serious or because undoing it is annoying. It is operationally irreversible over a declared horizon when the original state, or an acceptably equivalent state, cannot be recovered with sufficient probability, within the required time, cost and authority boundary. Reversibility is therefore graded. A database write with a tested point-in-time restore is different from one with an untested backup. A transfer that can be recalled before clearing is different from one that has settled across jurisdictions.

Thought experiment 1: hold the first outcome constant

Imagine two migration procedures applied to identical copies of a data service. Each has a 90 per cent chance of immediate success and a 10 per cent chance of immediate failure. In the staged procedure, writes are shadowed, a snapshot is verified, and traffic can return to the old schema. In the destructive procedure, the old representation is overwritten and no verified restore exists. Tomorrow, the same new evidence reveals a hidden schema mismatch.

The initial probabilities, first-step rewards and first-step failures are deliberately matched. Only the next feasible set differs. The staged procedure can inspect, revise, roll back or continue. The destructive procedure can accept the damage or begin manual reconstruction with uncertain duration. A preference for staging cannot be explained by a different immediate risk distribution because none was supplied. It follows from continuation value.

A minimal worked example

A project can be committed now or held for one period. Its quality is equally likely to be good or bad. Committing produces a gain of £120 in the good state and a loss of £80 in the bad state, so its expected value is 0.5 × 120 + 0.5 × (−80) = £20. Holding costs £5. If a perfectly discriminating test arrives during the hold, the project is committed only in the good state. The value is 0.5 × 120 + 0.5 × 0 − 5 = £55. The option to wait is worth £35 relative to immediate commitment.

Now remove the test while leaving the hold cost unchanged. Nothing is learned and the same commitment decision remains. Holding is worth £20 − £5 = £15, so immediate commitment wins. Delay has no option value by itself. It acquires value only through a changed belief, a changed world state, a preserved action set, or some combination of the three.

That objection also marks a boundary. Ramani's re-examination showed that an irreversibility effect does not hold under every formalisation or sequence of choices.^[8] If future options are not materially different, if no relevant learning can occur, or if the supposed recovery path is equivalent in cost and reliability, invoking irreversibility adds theatre rather than information.

A consequence has depth, not just probability

The phrase “high risk” compresses several unlike quantities. A 5 per cent chance of a £1,000 loss, a 0.05 per cent chance of a £100,000 loss, and a 5 per cent chance of a recoverable service delay may share the same expected monetary loss. They should not automatically receive the same authority, monitoring or recovery design. The shape of the loss and the system's ability to contain it matter.

A practical decision record should separate four objects:

Direct consequence

The benefit or harm produced before any recovery, including effects on people, systems, obligations and third parties.

Tail exposure

The severity and probability of the bad end of the distribution, including clustered, correlated or threshold effects.

Recovery distribution

The probability, time, cost, residual harm and authority required to reach an acceptable postcondition after failure.

Option-set delta

The future actions lost, made slower, made costlier, or transferred to a different principal by the current transition.

Expected loss remains the foundation because it forces probabilities and consequences into the same calculation. Yet a mean can hide a rare destructive branch. Conditional value at risk, or CVaR, summarises the average loss within a selected worst tail. Rockafellar and Uryasev developed a tractable optimisation treatment of CVaR and distinguished it from a percentile threshold that says nothing about loss beyond the threshold.^[6]

For a transparent operating score, one may write:

L(a) is the full loss distribution for action a; α defines the tail, such as 95 per cent; λ is an explicitly governed tail weight; and Ω(a) is the continuation loss from destroyed options when it has not already been modelled inside L. Increasing λ makes the decision more sensitive to severe tail outcomes. Increasing Ω penalises a transition that closes valuable future responses.

This is a decision instrument, not a universal law. Monetary conversion can be inappropriate for rights, safety constraints or legal prohibitions. Tail probabilities may be too uncertain to support a precise scalar. Correlations may invalidate an independently sampled loss distribution. In those cases the same decomposition still helps, but hard constraints, scenario dominance, robust bounds or accountable judgement should replace a falsely precise score.

Thought experiment 2: change only recovery

Consider two document stores with the same probability of corruption and the same immediate impact if corruption occurs. Store A has a continuously tested snapshot, a 99.9 per cent restore success rate, a ten-minute recovery objective and a verified readback test. Store B has a nominal backup that has never been restored, no measured recovery time and manual reconstruction from downstream copies. The probability of first failure is held constant.

The stores should not share the same action threshold. In A, an automated migration may be acceptable within a bounded window because recovery is a measured transition. In B, “we have backups” is not a recovery distribution. It is an unsupported proposition. A staging gate, human approval or smaller batch is rational even before changing the corruption probability.

Recoverability is a causal capability that must be demonstrated, not a comforting noun in an architecture diagram. It requires an initiating principal, sufficient authority, a known target state, a bounded time, an effect receipt, and independent evidence that the intended postcondition now holds. A compensating transaction is also not the same as reversal: it may create a new state while fees, disclosures, downstream decisions or human harms remain.

Why familiar alternatives are not enough

Prospect theory describes systematic departures from expected-utility behaviour, including sensitivity to reference points and different treatment of gains and losses.^[7] Those findings matter when predicting human choice and designing review interfaces. They do not by themselves determine what authority a machine should receive. A person may overweight a vivid loss, underweight a slow-moving harm, or frame the same outcome differently. Governance cannot simply inherit those biases.

Minimax regret is useful when probabilities are deeply contested. It compares each action with the best action that would have been chosen in hindsight, then minimises the worst missed opportunity.^[5] It can expose brittle probability estimates, but it may also recommend extreme caution when a modest evidence-gathering step would resolve the uncertainty. Regret also needs a time horizon and a definition of feasible alternatives. Without them, the very options destroyed by an action disappear from the comparison.

A precautionary rule can be justified where possible harm is grave and evidence is weak, but “irreversible” must not become an all-purpose veto. Some delays are themselves irreversible. A held medical intervention can allow disease progression. A delayed fraud block can let funds disperse. A postponed security patch can preserve attacker access. The relevant comparison is among complete trajectories, including the harm of inaction.

flowchart TD
  A["The payment that was easy to<br/>send and hard to retrieve"] --> B["The hidden object is the next<br/>action set"]
  B --> C["A consequence has depth, not<br/>just probability"]
  C --> D["Waiting must earn its place"]
  D -. "re-test" .-> A
  classDef first fill:#0a1424,stroke:#5B5CF6,stroke-width:2px,color:#e6f3ff
  classDef step fill:#0a1424,stroke:#3f7da0,stroke-width:1px,color:#e6f3ff
  class A first
  class B,C,D step

Waiting must earn its place

“Gather more information” sounds prudent because it postpones commitment. It is only a good action when the evidence can alter a later choice and its benefit exceeds acquisition, delay and expiry costs. Information value theory formalises this by comparing the best expected value before observation with the expected best value after observation.^[4]

y is a possible signal, the first maximum selects the best action after seeing that signal, the second selects the best action now, and the two costs account for acquisition and waiting. In an ideal single-decision model, free information that may be ignored cannot reduce value. In an operating system, however, evidence may arrive late, be noisy, trigger mandatory process, consume scarce review capacity, or change other actors' behaviour. Those effects belong in the model.

Recent work on costly sequential information acquisition treats reversible and irreversible product choices as nested stopping problems, making the timing, quality and cost of learning part of the decision rather than an afterthought.^[9] The lesson is not “always wait”. It is to define the evidence arrival process and the deadline at which the option disappears.

The production-shaped payment calculation

The opening case can now be stated as a complete scenario tree. The fraud state has prior probability 0.05. Immediate release loses £8,840 in that state and £0 otherwise. Immediate decline loses £40 in the fraud state and £360 in the legitimate state. Hold adds a fixed £25 check cost and state-dependent delay, then chooses the lower expected-loss action after the signal.

A suspicious signal has posterior fraud probability 32.62 per cent. At that belief, expected release loss is about £2,883.97, while expected decline loss is about £255.60, so the policy declines. A reassuring signal has posterior fraud probability 0.47 per cent. Expected release loss is then about £41.16 versus £358.51 for decline, so the policy releases.

Across all branches, hold and check has expected loss £130.15. Its CVaR95 is £1,096.40, higher than decline's £360 tail because a false reassuring signal can still release a fraudulent payment. Yet it is far below release's £8,840 tail. With the declared tail weight, the risk-adjusted scores are £2,121.60 for release, £347.20 for decline and £323.40 for hold. The precise winner depends on policy weight, but the action-set mechanism is visible before any weight is selected.

Negative control: evidence that cannot change the decision

To test whether “hold” has been smuggled in as the preferred answer, degrade only the evidence path and its delay. Set sensitivity and specificity to 55 per cent, raise legitimate delay harm to £200 and fraud delay harm to £20. Both possible signals now lead to decline. The check does not change the final action, so it has no decision value. It merely adds cost.

The expected loss of hold rises to £560, compared with £344 for immediate decline. Its CVaR95 becomes £585 and its risk-adjusted score £565. The model correctly refuses to wait. This negative control is important because it distinguishes option preservation from indecision. A reversible intermediate state is useful only when it supports a materially better later policy.

When more information can be worse

The usual non-negative value-of-information result relies on assumptions that are easy to forget: one decision-maker, correct modelling, an observation that can be ignored, and no strategic reaction to the observation process. A recent preprint studies dynamic games with hidden states and absorbing failure, and reports environments in which greater informational precision increases collapse probability because belief-driven actions operate near a viability boundary.^[13] This is a specialised theoretical result, not evidence that opacity is generally desirable.

Its value here is diagnostic. In a multi-actor system, information can change action, coordination and disclosure obligations. A fraud alert sent to the wrong party can help an adversary adapt. A market signal can cause synchronised exits. A system may be unable to ignore a legally material observation once acquired. Therefore the information action needs its own purpose, authority, recipients and release rule.

Turn the choice into an operating contract

A decision model becomes useful in production only when its variables bind to system state and accountable principals. “Risk is high” is not an action contract. Neither is “the agent decided to hold”. The system must say whose purpose is being served, what state was observed, which evidence was applicable, who may execute each transition, and how the effect will be verified.

The following ten-part cut keeps unlike objects separate:

This structure prevents an LLM's fluent proposal from acquiring ambient power. The model may estimate fraud probability, explain influential evidence and propose hold. A deterministic authority kernel checks identity, entitlement, purpose, amount, deadline and policy. A workflow engine records the hold, acquires the authorised signal, applies a versioned release rule and executes at most one effect. An independent readback verifies the resulting payment state.

Learning agents need a recovery policy, not only a task policy

Simulation often conceals irreversibility because a failed episode ends with a free reset. A physical or enterprise environment has no such guarantee. A robot can push an object beyond reach, an agent can delete the evidence needed to diagnose its own error, and a transaction can cross a settlement boundary. Optimising task reward while treating reset as an environmental constant therefore overstates the policy's real continuation value.

Several reinforcement-learning studies make parts of this problem explicit. Grinsztajn and colleagues estimate approximate action reversibility from temporal ordering and use it to modify exploration and control in constructed environments.^[10] Xie and colleagues study agents that identify unknown irreversible states and request human intervention when recovery requires external help.^[11] Shperberg and colleagues model catastrophic state-action pairs and use a shield to prevent a learned system from repeating recorded catastrophic mistakes.^[12] These are useful mechanism demonstrations. They do not establish that one reversibility estimator, help policy or shield transfers unchanged to an open production environment.

The architectural synthesis is stronger than any one learning algorithm. Keep at least three policies distinct. The task policy proposes progress towards the goal. The containment policy blocks transitions that exceed authority or enter a known catastrophic region. The recovery policy returns the system to a verified safe state or requests a principal with the missing capability. Combining them in one opaque model makes it difficult to know whether success came from competent planning, conservative refusal or a forgiving environment.

A useful evaluation therefore removes the free reset. Charge time and cost for intervention, withhold recovery authority from the task policy, and introduce states from which only another principal can recover. Measure task value, catastrophic entries, unnecessary interventions, recovery success, residual harm and option-set contraction separately. This turns “safe behaviour” from a final score into an observable division of labour.

The irreversibility decision contract

The article's practical contribution is a compact worksheet that can be attached to an architecture decision record, a high-consequence tool contract or an approval case. It does not replace domain policy. It exposes the fields that a static action score tends to hide.

The worksheet supports three decision rules. Release now when direct and tail harm are within tolerance, the authority is valid, and recovery plus outcome verification are credible. Stage or check when a bounded intermediate state preserves options and expected evidence value exceeds acquisition and delay cost. Decline or escalate when the action crosses a hard constraint, the tail is unacceptable, the evidence path cannot repair the uncertainty, or the required principal is unavailable.

These rules also clarify an “unknown outcome”. Suppose an executor times out after accepting a release command. Retrying may duplicate the payment, while assuming failure may leave the obligation unpaid. The decision is no longer release versus decline. It is reconcile versus compensate versus escalate. The workflow must stop ordinary retries, query an independent source of record, and record whichever state is proven. This is why idempotency and effect verification are decision-theoretic controls, not plumbing.

Official risk practice points in the same operational direction. The NIST AI Risk Management Framework playbook asks organisations to prioritise risk by impact and tolerance, document responses, consider non-automated alternatives, and maintain monitoring, incident response and recovery mechanisms.^[14] NIST's incident-response guidance likewise treats preparation, detection, response and recovery as connected risk-management activities.^[15] These sources do not prescribe the worksheet above. They support the need to make consequence, treatment and recovery explicit.

Recovery claims need their own evidence

A design often calls an action reversible because an inverse command exists. That is too weak. Sending a refund does not undo a missed deadline, a disclosure, a customer decision made on the first message or the operational work triggered downstream. Recovery is a distribution over time, cost, residual harm and authority. It must be measured from the state the first action actually creates, including states in which the outcome is not yet known.

Three tests make the recovery claim concrete. First, rehearse compensation against a synthetic but realistic case and record whether the intended business state is restored. Second, inject an unknown outcome after the executor accepts the command but before the caller receives a response. The system must reconcile before it retries. Third, withdraw the principal or permission required for compensation. This reveals whether recovery belongs to the acting system or depends on an unrecorded external rescue.

The comparison should preserve denominators. Report the share of actions that needed recovery, the share successfully restored within the decision horizon, the residual loss after restoration and the cases that required a different principal. A fast recovery rate over easy cases can hide a small set of irreversible failures. Conversely, one expensive recovery exercise can justify a narrow boundary without proving that the action is unacceptable everywhere.

The causal question is whether preserving the next action set changes the eventual loss. A staged action earns its place only if it creates useful evidence, keeps recovery available or limits the tail. If staging merely delays the same irreversible commitment, it adds latency without option value. If extra evidence cannot change the selected action, waiting is not caution; it is cost. These controls turn irreversibility from a rhetorical property into an experiment with observable branches.

The final check is temporal. A recovery that works after thirty days may be useless for a decision whose harm becomes fixed after an hour. Record both the probability of restoration and its completion-time distribution against the actual consequence horizon. That comparison separates a nominal inverse from an operationally meaningful escape route in practice.

Executable decision laboratory

The following Python programme reproduces the positive payment case and its negative control using only the standard library. It enumerates the exact discrete loss branches, computes expected loss and CVaR95, applies the declared tail weight, and asserts that useful evidence selects hold while weak, slow evidence selects decline.

Assumptions: the prior and signal error rates are known; branch losses are additive; the signal does not change the underlying state; either signal may be acted on; and the risk-adjusted score is a transparent policy choice rather than an empirical law. Expected output follows the code.

from dataclasses import dataclass, replace

@dataclass(frozen=True)
class Scenario:
    p_fraud: float = 0.05
    amount: float = 9600.0
    recovery_rate: float = 0.10
    fraud_admin: float = 200.0
    decline_fraud: float = 40.0
    decline_legit: float = 360.0
    sensitivity: float = 0.92
    specificity: float = 0.90
    check_cost: float = 25.0
    delay_fraud: float = 10.0
    delay_legit: float = 35.0
    tail_weight: float = 0.20


def mean(dist):
    return sum(loss * probability for loss, probability in dist)


def cvar95(dist):
    remaining, total = 0.05, 0.0
    for loss, probability in sorted(dist, reverse=True):
        take = min(remaining, probability)
        total += take * loss
        remaining -= take
        if remaining <= 1e-12:
            break
    return total / 0.05


def evaluate(s):
    fraud_loss = s.amount * (1 - s.recovery_rate) + s.fraud_admin
    release = [(fraud_loss, s.p_fraud), (0, 1 - s.p_fraud)]
    decline = [(s.decline_fraud, s.p_fraud),
               (s.decline_legit, 1 - s.p_fraud)]

    branches = [
        ("fraud", "+", s.p_fraud * s.sensitivity),
        ("fraud", "-", s.p_fraud * (1 - s.sensitivity)),
        ("legit", "+", (1 - s.p_fraud) * (1 - s.specificity)),
        ("legit", "-", (1 - s.p_fraud) * s.specificity),
    ]

    policy = {}
    for signal in "+-":
        mass = sum(p for state, seen, p in branches if seen == signal)
        posterior = sum(p for state, seen, p in branches
                        if seen == signal and state == "fraud") / mass
        release_mean = posterior * fraud_loss
        decline_mean = (posterior * s.decline_fraud
                        + (1 - posterior) * s.decline_legit)
        policy[signal] = "release" if release_mean <= decline_mean else "decline"

    hold = []
    for state, signal, probability in branches:
        delay = s.delay_fraud if state == "fraud" else s.delay_legit
        if policy[signal] == "release":
            action_loss = fraud_loss if state == "fraud" else 0
        else:
            action_loss = s.decline_fraud if state == "fraud" else s.decline_legit
        hold.append((s.check_cost + delay + action_loss, probability))

    result = {}
    for action, dist in {"release": release, "decline": decline, "hold": hold}.items():
        expected = mean(dist)
        tail = cvar95(dist)
        score = expected + s.tail_weight * (tail - expected)
        result[action] = expected, tail, score
    return result, policy


def chosen(s):
    result, policy = evaluate(s)
    action = min(result, key=lambda name: result[name][2])
    return action, result, policy


useful = Scenario()
weak_and_slow = replace(useful, sensitivity=0.55, specificity=0.55,
                        delay_fraud=20.0, delay_legit=200.0)

assert chosen(useful)[0] == "hold"
assert chosen(weak_and_slow)[0] == "decline"

for name, case in [("useful evidence", useful),
                   ("weak and slow evidence", weak_and_slow)]:
    action, metrics, policy = chosen(case)
    print(name, "->", action, policy)
    for candidate, values in metrics.items():
        print(candidate, tuple(round(value, 2) for value in values))

useful evidence -> hold {'+': 'decline', '-': 'release'}
release (442.0, 8840.0, 2121.6)
decline (344.0, 360.0, 347.2)
hold (130.15, 1096.4, 323.4)
weak and slow evidence -> decline {'+': 'decline', '-': 'decline'}
release (442.0, 8840.0, 2121.6)
decline (344.0, 360.0, 347.2)
hold (560.0, 585.0, 565.0)

accuracies = [0.60, 0.70, 0.80, 0.90]
best = []
for accuracy in accuracies:
    case = replace(useful, sensitivity=accuracy, specificity=accuracy)
    _, metrics, _ = chosen(case)
    best.append(min(values[0] for values in metrics.values()))

assert all(later <= earlier + 1e-9
           for earlier, later in zip(best, best[1:]))

The programme deliberately keeps the model small enough to inspect. A production implementation would replace scalar costs with a typed outcome model, calibrated intervals, correlated scenarios, policy constraints, evidence provenance and separate authority. It would also persist a decision receipt and compare the predicted postcondition with an independent readback.

stateDiagram-v2
  [*] --> Claim
  state "A precise distinction from<br/>ordinary risk aversion" as Claim
  state "Thought experiment 1: hold the<br/>first outcome constant" as Test
  state "A minimal worked example" as Revision
  Claim --> Test: expose mechanism
  Test --> Decision: evidence survives
  Test --> Revision: rival survives
  Revision --> Claim: narrow or rebuild
  Decision --> [*]

Compact glossary

Action-set delta

The future actions lost, degraded, delayed or transferred to another principal because of the current action.

Continuation value

The best expected value available from the state and feasible choices that remain after the current transition.

CVaR

The mean loss within a declared worst tail, such as the worst 5 per cent of outcomes, rather than the loss at one percentile.

Decision receipt

A durable record of intent, identity, evidence, beliefs, policy, authority, selected action and unresolved risk.

Effect receipt

The executor's record that a command was accepted or attempted. It is evidence, but not proof of the business outcome.

Irreversibility

Failure to recover the original or acceptably equivalent state within the declared probability, time, cost and authority boundary.

Readback

An independent observation of authoritative state used to verify that the intended postcondition holds.

Unknown outcome

A state in which command acceptance or timeout does not establish whether the effect occurred, requiring reconciliation before retry.

Choose the next recoverable state

Irreversibility does not invalidate expected utility. It reveals what the outcome description must contain. A present action changes direct utility, possible harm, recovery burden and the decision problem that remains. If the future action set is omitted, the model may prefer a locally attractive transition that destroys its ability to respond to later evidence.

The practical decision is therefore architectural as much as mathematical. Consequential agents should propose typed transitions into governed workflow states. The authority layer should prefer staging when useful evidence can arrive before an expiry, refuse staging when delay cannot earn its cost, and reserve irreversible effects for principals and policies that can carry the consequence. Execution should produce an effect receipt, followed by independent readback and an explicit unknown-outcome branch.

The preferred experiment also changes. Do not evaluate only final accuracy under clean inputs. Hold the first-step outcome distribution constant and vary rollback, evidence timing or recovery reliability. Inject a timeout after command acceptance. Remove the signal and confirm that waiting loses. These interventions test whether the supposed safeguard works through option preservation or merely adds ceremony.

The durable rule is to choose the next state from which a verified business outcome remains achievable under bounded authority. Sometimes that state is immediate release. Sometimes it is decline. Often it is a temporary hold with a real evidence plan. The decision is defensible only when the future choices, tail harm and recovery path are visible before the irreversible effect occurs.