Saga Pattern

Compensating transactions are the core idea of the Saga pattern, undoing the side effects of non-rollback-able steps by executing logically inverse operations.

The Saga pattern differs from two-phase commit (2PC) in that it does not require resource locking, making it more suitable for cross-service scenarios involving external APIs, but it can only guarantee eventual consistency, and the compensating actions themselves must also be idempotent.

The Saga pattern was first proposed by Garcia-Molina and Salem in 1987 to solve the problem that long transactions in distributed systems cannot rely on a single database transaction to guarantee atomicity.

To implement Saga in a state machine framework like LangGraph, the key is to maintain an ordered list of "completed forward nodes" and to ensure that each compensation handler can determine from the idempotency key whether it has already been executed.

The compensation handler adopts the Saga pattern, executing compensating actions in reverse order when a subsequent node fails, undoing steps that have already taken effect (such as releasing an already-occupied quota or revoking a notification).

An atomic transaction requires a set of database operations to either all succeed or all roll back, and typical implementations rely on the ACID properties of relational databases; in distributed environments, two-phase commit (2PC) or the Saga pattern must also be introduced to coordinate cross-service transactions.

Currently no mainstream Agent framework natively implements the Saga pattern with compensation for LLM workflows.

The engineering alternative to strict atomicity usually adopts the Saga pattern or compensating transactions, recording the success/failure status and corresponding cost of each step.

A compensating transaction is the standard pattern in distributed systems for handling non-rollbackable operations, originating from the Saga pattern, which offsets the effects of each completed step by performing a semantically opposite operation.

The Saga pattern has two common implementation styles: orchestration (directed by a central coordinator) and choreography (services triggering each other through events).

The Saga pattern is a common solution for handling cross-service data consistency in distributed systems, breaking a long transaction into a series of local transactions equipped with compensating operations.

The Saga pattern was first proposed by Hector Garcia-Molina and Kenneth Salem in 1987 to solve the problem that long transactions are difficult to keep atomic in distributed databases.

Saga's compensation is not a physical rollback and cannot restore side effects already consumed by external systems; it can only perform semantically equivalent reverse operations.

The Saga pattern breaks a large transaction into a series of local transactions T1…Tn, each Ti paired with a compensating transaction Ci; on failure, the compensation actions are executed in reverse order to return the whole to a consistent state.

The Saga pattern was proposed by Hector Garcia-Molina of Princeton University in 1987.

AgentWall provides a rollback hook mechanism that executes registered compensating actions in reverse order when a session fails, a design inspired by the Saga pattern.

"Transactions" in agent systems often span multiple heterogeneous services (LLM APIs, tool calls, database writes), making traditional transaction models difficult to apply directly and requiring the introduction of distributed transaction solutions such as the Saga pattern.

Saga模式起源于1987年Hector Garcia-Molina和Kenneth Salem的论文，最初用于解决数据库长事务问题