No, it is a new business action. Compensation can be imperfect, delayed, and independently fallible.

A saga is a sequence of local transactions with explicit compensating operations. Orchestration uses a coordinator that records progress and commands the next step; choreography reacts to events and can distribute control but make the overall workflow harder to follow. Define idempotency, timeouts, ownership, durable state, and manual reconciliation. Avoid calling compensation a guarantee that every effect vanishes. The synchronous model below demonstrates order and reverse-order compensation only; real sagas need durable coordination and recovery.

What the function promises: Each step is (do, compensate). Successful earlier steps are compensated in reverse order if a later do raises. A failed do is assumed to leave no committed effect. Compensation errors are collected, not hidden.

def run_saga(steps):
    completed = []
    try:
        for do, compensate in steps:
            do()
            completed.append(compensate)
        return True, []
    except Exception as failure:
        errors = [failure]
        for compensate in reversed(completed):
            try:
                compensate()
            except Exception as error:
                errors.append(error)
        return False, errors

log = []
def fail_shipping():
    raise RuntimeError("Shipping unavailable")
ok, errors = run_saga([
    (lambda: log.append("reserve"), lambda: log.append("release")),
    (fail_shipping, lambda: log.append("cancel shipping"))
])
assert not ok and len(errors) == 1
assert log == ["reserve", "release"]

Work and storage: O(number of steps plus attempted compensations), excluding service work. Real durable workflow history grows with operations and retries.

When to recognize it: Store workflow state, retry safely, and make unresolved cases visible. A saga does not make intermediate states invisible to everyone.

Check before applying it: Sagas need durable progress and uncertain-outcome handling; compensation can itself fail.

No. Query or reconcile by stable operation ID before choosing compensation or retry. An uncertain timeout is not proof that the failed step had no effect.