Plan Repair

This technique focuses the repair process on the gap between the current state and the desired goal state. Instead of blindly retrying or backtracking, the agent analyzes the unmet preconditions of the goal and generates a new, minimal sequence of actions to satisfy them.

• Core Mechanism: Uses a planner (e.g., a Hierarchical Task Network or PDDL-based planner) to solve for the missing steps.
• Example: An agent fails to book a flight because a seat is unavailable. Goal-directed repair might identify the goal as 'be in City X at time T' and generate a new plan involving a train or a different flight time.

A systematic, algorithmic approach where the agent reverses recent decisions to a prior choice point and explores an alternative execution path. It is a form of depth-first search through the space of possible actions.

• Implementation: Often uses a stack to record decision points. Upon failure, the agent pops the stack, undoes the effects of the last action (or triggers a compensating action), and tries a different option.
• Use Case: Ideal for problems with a clear sequence of discrete choices, such as solving a puzzle or navigating a maze with dead ends.

When a plan fails because it is over-constrained, this technique temporarily or permanently loosens the problem constraints to find a feasible, albeit potentially suboptimal, solution.

• Types of Constraints: Can include temporal deadlines, resource budgets, quality thresholds, or action preconditions.
• Process: The agent identifies the binding constraint causing the infeasibility, relaxes it (e.g., increases the budget, extends the deadline), and re-invokes the planner.
• Example: A delivery robot's plan fails due to a time constraint. Relaxing the delivery window by 15 minutes may allow a feasible route to be found.

A flexible planning paradigm where actions are arranged with only necessary sequencing constraints, creating a partial order rather than a rigid linear sequence. This inherent flexibility simplifies runtime repair.

• Key Feature: Actions without causal dependencies can be executed in any order or in parallel.
• Repair Advantage: If one action fails, only its dependent successors need reconsideration; independent actions can proceed. Repair often involves reordering actions or adding new causal links.
• Foundation: Underpins many modern task-oriented dialogue systems and flexible workflow engines.

This technique represents the plan as a mutable directed graph where nodes are actions and edges are dependencies. Repair is performed by directly editing this graph structure at runtime.

• Operations Include:
  • Node Substitution: Replacing a failed action node with a functionally equivalent one.
  • Edge Reconnection: Changing dependencies to allow parallel execution or new orderings.
  • Subgraph Insertion/Deletion: Adding a new sequence of actions to overcome an obstacle or removing redundant steps.
• System Context: Central to agentic frameworks where plans are first-class, inspectable objects that can be manipulated by a meta-cognitive layer.

A fundamental, reactive repair strategy for transient failures. When a specific action (e.g., an API call) fails, it is automatically re-executed after a delay, with the delay increasing exponentially after each subsequent failure.

• Mechanism: Implements a retry loop with a growing wait time (e.g., 1s, 2s, 4s, 8s). This gives a recovering external service time to stabilize.
• Key Enhancement: Often combined with fallback execution or parameter variation (e.g., trying a different API endpoint or using cached data) on later retry attempts.
• Purpose: Primarily handles intermittent network errors, timeouts, and temporary resource unavailability without triggering a full replan.

An AI orchestrator managing a global logistics network detects a port closure due to a storm. Its primary shipping route is now invalid. The system performs plan repair by:

• Substituting the ocean freight leg with a combination of rail and air cargo.
• Reordering customs clearance steps to occur at an alternate port of entry.
• Relaxing the delivery time constraint by 24 hours to find a feasible, cost-effective alternative. This dynamic adjustment prevents a cascade of warehouse stockouts and maintains service continuity.

A healthcare agent automating prior authorization submits a request that is rejected due to missing documentation codes. Instead of failing, it initiates a goal-directed repair:

• It backtracks to the data extraction step to identify the missing ICD-10 codes.
• It queries the Electronic Health Record (EHR) system using a different, more specific natural language prompt.
• It substitutes the original action of 'submit request' with a new sequence: 'retrieve missing codes → validate against policy rules → resubmit request'. This self-correction loop ensures the administrative task completes without requiring human intervention, accelerating patient care.

In a warehouse, an autonomous mobile robot (AMR) finds its planned path blocked by a fallen pallet. The robot's local planner fails to find a new route. The central multi-agent orchestration system performs context-aware replanning:

• It mutates the execution graph, instructing the blocked robot to perform a compensating action (back up to a holding node).
• It reassigns the task to a different AMR with a clear path, using partial order planning to reorder the fleet's collective task queue.
• It dispatches a third robot for cleanup (the fallback execution for the obstruction). This system-level repair maintains overall throughput despite local failures.

An algorithmic trading agent's order fails because a liquidity pool is exhausted. The agent's fault-tolerant design triggers a repair protocol:

• It first employs step retry logic with modified slippage tolerance parameters.
• If retries fail, it activates a contingency plan, splitting the large order into smaller chunks routed to alternative decentralized exchanges (pipeline bypass).
• It uses constraint relaxation, temporarily accepting a slightly higher average price to ensure the trade completes, as missing the execution window is costlier. This demonstrates graceful degradation of optimal price for the higher-priority goal of trade completion.

A customer service chatbot fails to process a refund because the user's session token expired. Instead of showing an error, the agent executes a self-healing sequence:

• It rolls back the failed API call and stores the request context.
• It initiates a compensating transaction to re-authenticate the user via a secure, out-of-band SMS code.
• It re-plans by resuming the refund workflow from the point of failure with the new valid token. This repair is invisible to the user, preserving the experience and successfully completing the long-running transaction.

An AI managing a power grid detects a transformer failure. Its initial plan to reroute power overloads another line. The system performs iterative refinement:

• It uses automated root cause analysis to confirm the overload is due to its own rerouting command.
• It then executes backtracking search, reverting the change and exploring a different topological configuration.
• The new plan involves dynamic replanning that includes shedding non-critical load (constraint relaxation) to stay within safe operating limits. This ensures fault-tolerant grid stability through autonomous, multi-step correction.

The real-time modification of an autonomous agent's sequence of actions in response to errors, changing conditions, or new information during execution. Unlike static planning, it operates on a live execution graph. Key characteristics include:

• Triggered by monitors for failure, timeout, or state deviation.
• Incremental: Often modifies the remaining plan, not the entire sequence.
• Context-sensitive: Uses the current world state as the new starting point.

A corrective strategy where an agent analyzes the gap between the current state and the desired goal to generate a new, minimal sequence of actions. It focuses on achieving the original objective rather than perfectly fixing the broken plan. This often involves:

• Recomputing a path from the current state to the goal.
• Subgoal identification to bridge the gap.
• Heuristic search (e.g., A*) to find the most efficient repair.

The runtime alteration of a directed graph representing an agent's planned actions. This is the data structure underpinning most plan repair. Mutations include:

• Node insertion/deletion: Adding or removing specific actions.
• Edge reconnection: Changing the order or dependencies between steps.
• Subgraph substitution: Replacing a faulty branch with a corrected sequence. Tools like NetworkX or custom DSLs often model this graph for manipulation.

An algorithmic approach to error recovery where an agent systematically reverses recent decisions to a prior choice point and explores alternative execution paths. It is a foundational technique for automated repair.

• Depth-first search through the space of possible actions.
• Maintains a stack of states and actions for reversal.
• Used in automated planners like STRIPS-based systems to recover from dead-ends. It ensures completeness but can be computationally expensive if not bounded.

A replanning technique where an agent temporarily or permanently loosens the requirements or boundaries of a problem to find a feasible solution. When a plan fails due to over-constraining, relaxation provides an escape hatch.

• Examples: Extending a deadline, increasing a budget threshold, accepting a lower-resolution output.
• Implemented via a utility function that ranks the importance of constraints.
• Critical for graceful degradation, allowing a system to deliver a result instead of failing completely.

A flexible planning paradigm where actions are arranged with only necessary sequencing constraints. This creates a plan with temporal flexibility, making it inherently more adaptable for repair.

• Advantage: Actions without dependencies can be reordered dynamically at runtime.
• Repair becomes simpler: Often involves adjusting causal links rather than a rigid sequence.
• Foundation for many real-world agent frameworks that handle uncertainty. It contrasts with total order planning, which has a fixed, linear sequence.