Workflow Rollback and Compensation Prompt

This prompt is for platform engineers implementing saga patterns across multi-agent workflows. Use it when you need an LLM to generate a structured compensation plan for each step in an agent execution graph, including undo actions, state reversal logic, and ordering constraints for rollback. The primary job-to-be-done is converting a failed workflow state into an executable, ordered set of compensating transactions that return the system to a consistent state without manual intervention. The ideal user is an orchestration engineer or reliability engineer who already has a defined workflow DAG with unique step identifiers, recorded execution context per step, and a known failure point. You should reach for this prompt only after a step failure is detected and before rollback execution begins—it belongs in the error-recovery path of a workflow orchestrator, not in the happy-path execution flow.

This is not a prompt for simple retry logic or idempotency keys. If your failure mode can be resolved by replaying the same step with the same inputs, use a retry-with-backoff pattern instead. Do not use this prompt when the workflow is stateless, when all steps are read-only, or when you lack a complete execution trace showing which steps succeeded and what side effects they produced. The prompt assumes you can provide: a list of workflow steps with their types and identifiers, the execution status of each step (completed, in-progress, not-started), the step where the failure occurred, the error payload, and any recorded state mutations or external calls made by completed steps. Without this context, the LLM cannot produce a safe compensation plan—it will hallucinate undo actions or miss irreversible side effects entirely.

Before wiring this prompt into production, ensure your workflow orchestrator can enforce the compensation plan it receives. The LLM's output is a plan, not an execution—your system must validate that every compensation step maps to a real handler, that the ordering constraints are satisfiable, and that no compensation step introduces new side effects that themselves require rollback. For high-risk workflows involving financial transactions, provisioning, or data deletion, always route the generated compensation plan through a human approval step before execution. The next section provides the exact prompt template you can adapt and the harness logic required to make it production-safe.

This prompt template is designed to be injected into your orchestrator's error-handling path when a workflow step fails and a saga-based rollback is required. It instructs the model to analyze the failed step, the preceding successful steps, and the overall workflow context to produce a structured compensation plan. The plan must include undo actions, state reversal logic, and strict ordering constraints to safely return the system to a consistent state. The prompt uses square-bracket placeholders so you can wire in dynamic context from your workflow engine, state store, and agent logs.

textCopy
You are an expert workflow reliability engineer. Your task is to generate a precise compensation and rollback plan for a failed agent workflow step.

# WORKFLOW CONTEXT
- Workflow ID: [WORKFLOW_ID]
- Workflow Definition (DAG): [WORKFLOW_DEFINITION]
- Current Execution State: [EXECUTION_STATE]

# FAILURE DETAILS
- Failed Step ID: [FAILED_STEP_ID]
- Failure Reason: [FAILURE_REASON]
- Error Payload: [ERROR_PAYLOAD]

# COMPLETED STEPS (in execution order)
[COMPLETED_STEPS_LIST]

# CONSTRAINTS
- [CONSTRAINTS]

# INSTRUCTIONS
1. Analyze the failed step and all preceding completed steps.
2. For each completed step that produced a side effect, define a corresponding compensation action (an undo operation).
3. If a completed step is irreversible, flag it explicitly and propose a manual intervention or notification action.
4. Define the strict reverse-order sequence for executing compensation actions.
5. Identify any state variables that must be rolled back to their pre-workflow values.
6. Output the plan as a valid JSON object conforming to the schema below.

# OUTPUT SCHEMA
{
  "rollback_plan": {
    "workflow_id": "string",
    "failed_step_id": "string",
    "compensation_steps": [
      {
        "step_id": "string",
        "original_action": "string (description of what the step did)",
        "compensation_action": "string (description of the undo operation)",
        "is_reversible": boolean,
        "irreversibility_reason": "string | null (explain if not reversible)",
        "required_state_rollback": {
          "key": "string",
          "previous_value": "string"
        } | null
      }
    ],
    "execution_order": ["string (ordered list of step_ids to execute compensation)"],
    "final_state_assertions": ["string (list of conditions that must be true after rollback)"]
  }
}

# RISK LEVEL
[RISK_LEVEL]

To adapt this template, replace the placeholders with live data from your workflow engine. The [WORKFLOW_DEFINITION] should be a serialized representation of your agent graph, and [EXECUTION_STATE] should capture the current values of all relevant state variables. The [COMPLETED_STEPS_LIST] must include the step ID, its input/output payload, and a description of any external side effects (e.g., database writes, API calls). Before deploying, test this prompt against a golden dataset of known failure scenarios to ensure the generated compensation steps are correct and that the JSON output strictly conforms to the schema. For high-risk workflows, always route the generated plan to a human approval queue before execution.

This prompt is not a standalone utility; it is a critical safety component inside a saga orchestrator. The harness must call this prompt before any agent step executes, generating a compensation plan that is stored alongside the step's execution context. The plan must be treated as a required artifact—if the prompt fails to produce a valid plan, the step should not proceed. The harness is responsible for mapping each compensation action to a concrete, idempotent function (e.g., a refund API call, a state reversion in a database, a cancellation message to a downstream agent). The prompt produces the what and why; the harness enforces the how and when.

To integrate this prompt, wrap it in a pre-execution hook within your workflow engine. The hook should provide the prompt with the proposed step's intent, the current system state, and the list of available compensation tools. The output must be validated against a strict JSON schema that includes: a step_id, an ordered list of compensation_actions (each with a tool_name, payload, and idempotency_key), and a rollback_ordering_constraint (e.g., 'strict_reverse' or 'parallel'). If validation fails, the harness must retry the prompt once with the validation errors injected into the [CONSTRAINTS] block. After a second failure, the workflow must halt and escalate to a human operator via the escalation queue, as proceeding without a valid compensation plan violates the saga's safety guarantees.

For irreversible side effects (e.g., sending an email, invoking a physical process), the prompt should flag them with a compensation_type of manual or irreversible. The harness must enforce a policy check here: if an irreversible action is detected, the workflow must pause and request explicit human approval before executing the step, even if the compensation plan is otherwise valid. Log every generated plan, validation result, and approval decision to an immutable audit store. This trace is essential for debugging failed rollbacks and proving to auditors that the system followed its defined safety procedures. Do not rely on the model's memory of prior plans; always pass the full workflow context and previously executed steps into the prompt to prevent context drift.