1 Introduction↩︎

Modern cloud-based AI systems support a wide range of mission-critical services, from online inference to large-scale distributed data processing, where even short interruptions can translate into substantial service degradation and economic loss [1], [2]. In practice, these systems are increasingly built on microservices, and their reliability hinges on heterogeneous components (e.g., container orchestrators, inference accelerators, caches, and load balancers) that are loosely coupled in implementation yet strongly dependent in execution [3], [4]. As a result, local anomalies may propagate through dependency chains and trigger cascading failures, making real-time fault management particularly challenging [5], [6]. Despite extensive efforts, accurately capturing such graph-like dependencies and their time-varying interactions remains an open problem in production-scale environments [7]–[9].

Fast and reliable recovery therefore becomes a core requirement for keeping these services available and for controlling operational costs [10]. However, the fault space in cloud AI systems is not only large but also heterogeneous: symptoms are distributed across logs, metrics, and alarms, and the mapping from observations to root causes is often non-bijective and context-dependent [11], [12]. For example, a memory leak can be reported as elevated CPU usage, request timeouts, or abnormal garbage collection behavior, depending on workload and resource contention [13]. Traditional rule-based approaches typically rely on static thresholds or keyword patterns to trigger predefined scripts; while simple and efficient, they often fail to generalize to evolving deployments and unseen fault patterns [14]. Model-based techniques (e.g., Bayesian networks or Petri-net variants) attempt to encode system dynamics explicitly, but their accuracy and maintenance cost become prohibitive as the system grows and changes over time [15].

Recently, combining Large Language Models (LLMs) with Deep Reinforcement Learning (DRL) has attracted attention as a potential route toward more adaptive fault management: LLMs provide semantic abstraction over unstructured observability signals, and DRL can optimize decisions through interaction. Nonetheless, most existing hybrids remain sequential and loosely coupled—the LLM is used primarily as a state interpreter, and the DRL agent operates as a downstream policy that selects actions from a predefined (often hierarchical) action space [16]. This design has two practical limitations. First, it underutilizes the LLM as an active planner capable of composing multi-step strategies. Second, without a dedicated pre-execution verification stage, the system may execute brittle or inconsistent recovery actions, especially under novel fault conditions.

To address these issues, we present PASE (Planning-Aware Semantic self-hEaling engine), a planning-centric framework for autonomous fault recovery. PASE organizes recovery into a closed loop that integrates planning, verification, and adaptation. Specifically, (i) an LLM serves as a Plan Synthesis Engine to generate structured recovery plans by composing semantic primitives; (ii) a Neural-Symbolic World Model evaluates the feasibility of candidate plans via lightweight simulation before execution; and (iii) a DRL-based Meta-Prompt Optimizer learns prompt embeddings to steer the LLM toward higher-quality plans as the environment changes. The overall workflow is illustrated in Fig. 1.

The main contributions of this work are summarized as follows:

• We formulate cloud fault recovery as a neuro-symbolic program synthesis problem and propose PASE, which shifts the decision unit from single-step action selection to multi-step plan generation.

• We design a verified planning loop that couples an LLM-based plan synthesizer with a neural-symbolic world model for feasibility screening, improving reliability prior to executing recovery actions.

• We introduce a DRL-based meta-prompt optimizer that adapts prompting in a continuous embedding space, enabling more efficient online adaptation to previously unseen fault types, and validate the approach on a real-world cloud fault injection dataset.

2 Related Work↩︎

2.1 AI for Self-Healing Systems↩︎

The pursuit of autonomous self-healing systems has leveraged various AI techniques to enhance fault tolerance and reduce manual intervention. Karamthulla et al. [17] provided a comprehensive analysis of machine learning and neural network applications in self-healing mechanisms, highlighting persistent challenges in scalability, adaptability, and robustness. Vemula [18] explored AI-enhanced cloud architectures that integrate real-time anomaly detection, diagnosis, and remediation to ensure data integrity and operational efficiency. These works underscore the shift from reactive to proactive and adaptive system management.[19]–[24]

2.2 Machine Learning for Fault Detection and Recovery↩︎

Machine learning, particularly deep learning, has been widely adopted for fault detection and prediction. Pentyala [25] proposed an AI framework employing ML/DL models to analyze system telemetry for real-time anomaly identification and automated remediation. Similarly, Li et al. [26] developed an Automated Intelligent Healing System (AIHS) for cloud data centers, combining ML techniques for scalable fault detection and repair. Nama et al. [27] demonstrated the role of AI in enhancing software testing and fault prediction accuracy. These approaches, however, often treat detection and recovery as separate tasks and rely on extensive labeled data for training.

2.3 Integration of LLMs and DRL in Autonomous Systems↩︎

The convergence of LLMs and DRL represents a frontier in building more generalizable and reasoning-capable autonomous systems. Prior work has utilized LLMs for semantic interpretation of system states and DRL for optimizing recovery policies [16]. Feng et al. [28] combined multi-agent systems (MAS) with AI algorithms for fault diagnosis and recovery in critical infrastructure, showcasing the potential of collaborative AI agents. However, these integrations typically maintain a modular separation, where the LLM’s output is a static encoding for the DRL agent, limiting the LLM’s active participation in strategic planning and the system’s ability to generate novel action sequences.

2.4 Neuro-Symbolic AI and Program Synthesis↩︎

Neuro-symbolic AI, which combines neural networks with symbolic reasoning, offers a promising direction for complex decision-making tasks. Recent efforts have explored using LLMs for program synthesis and planning in various domains [29]. The concept of a world model for plan verification draws from model-based reinforcement learning and symbolic reasoning traditions. Our PASE framework contributes to this line of research by applying neuro-symbolic program synthesis specifically to the domain of cloud fault recovery, integrating an LLM-based planner with a learned world model and a meta-optimization loop.

In contrast to existing work, PASE moves beyond using LLMs as passive encoders or DRL as a mere policy selector. Instead, it positions the LLM as the core planning engine, actively generating structured recovery programs, while DRL meta-optimizes the planning process itself. This creates a more tightly integrated, adaptive, and generative self-healing architecture.

3 Methodology↩︎

We propose the Planning-Aware Semantic self-hEaling engine (PASE), a paradigm shift from the sequential perception-then-action pipeline. PASE reconceptualizes fault recovery as a neuro-symbolic program synthesis problem, where a large language model (LLM) acts as a planner, a learned world model serves as a verifier, and a deep reinforcement learning (DRL) agent meta-optimizes the planning process itself. This creates a tight “reason-plan-verify-adapt” loop.

3.1 Unified Semantic Observation and Plan Synthesis↩︎

Let the raw heterogeneous system observation at time \(t\) be \(\mathcal{O}_t = \{ \mathbf{L}_t, \mathbf{M}_t, \mathbf{A}_t \}\), representing log snippets, metric time series, and alarm vectors, respectively. Unlike the prior approach that encodes \(\mathcal{O}_t\) into a fixed-dimensional state vector, PASE first maps it into a structured semantic scene description \(D_t\) using an LLM with a fixed template prompt \(\mathcal{P}_{\text{desc}}\): \[D_t = \text{LLM}(\mathcal{P}_{\text{desc}}; \mathcal{O}_t),\] where \(D_t\) is a natural language paragraph summarizing fault symptoms, affected components, and system topology context. This preserves relational and causal information often lost in vectorization.

The core of PASE is the Plan Synthesis Engine (PSE), which is the LLM tasked to generate a recovery plan \(\Pi_t\) directly from \(D_t\) and a library of Recovery Primitives \(\mathcal{R}\). Each primitive \(r \in \mathcal{R}\) is a parameterizable atomic action with a semantic signature (e.g., Restart(service_id), ScaleOut(resource_type, count), Reroute(traffic, from, to)). The PSE operates under a meta-prompt \(\mathcal{P}_t^{\text{plan}}\), which structures the planning task: \[\Pi_t = \text{PSE}( D_t, \mathcal{R}; \mathcal{P}_t^{\text{plan}} ) = \text{LLM}( \mathcal{P}_t^{\text{plan}}(D_t, \mathcal{R}) ).\] The output \(\Pi_t\) is a structured list or a graph of primitives \((r^{(1)}_{\theta_1}, r^{(2)}_{\theta_2}, ...)\), where \(\theta_i\) are instantiated parameters. This approach bypasses the rigid hierarchical action space, enabling the dynamic generation of novel, multi-step recovery procedures tailored to the specific fault context.

3.2 Neural-Symbolic World Model for Plan Verification↩︎

To address the hallucination and inconsistency risks of LLM-generated plans, PASE incorporates a Neural-Symbolic World Model (NSWM). The NSWM learns the stochastic dynamics of the cloud system at the level of recovery primitives. Let \(s_t\) be a latent system state. The NSWM predicts the state transition and the expected change in key health indicators \(\Delta \mathbf{H}\) when a primitive \(r_\theta\) is applied: \[\hat{s}_{t+1}, \widehat{\Delta \mathbf{H}} = \text{NSWM}(s_t, r_\theta; \phi),\] where \(\phi\) are the model parameters. The NSWM is trained on historical interaction data to minimize the prediction error of \(\Delta \mathbf{H}\).

Given a candidate plan \(\Pi_t = (r^{(1)}, r^{(2)}, ..., r^{(K)})\), the NSWM performs rollout simulation: \[(\hat{s}_{t+k}, \widehat{\Delta \mathbf{H}}_{t+k})_{k=1}^{K} = \text{Rollout}_{\text{NSWM}}(s_t, \Pi_t).\] The simulated trajectory yields a Plan Feasibility Score \(F(\Pi_t)\), defined as the negative weighted sum of predicted resource violation risks and the expected residual fault severity after plan execution: \[F(\Pi_t) = -\mathbb{E}_{\text{rollout}} \left[ \lambda_1 \cdot \text{Risk}(\hat{s}_{t+K}) + \lambda_2 \cdot \text{Severity}(\widehat{\Delta \mathbf{H}}_{t+K}) \right].\] This score provides a computationally efficient, model-based critique of the LLM’s proposed plan before any real (and potentially costly) execution.

3.3 Meta-Prompt Optimization via Reinforcement Learning↩︎

The quality of the generated plan \(\Pi_t\) critically depends on the meta-prompt \(\mathcal{P}_t^{\text{plan}}\). Instead of using a fixed prompt or fine-tuning the entire LLM for each new fault pattern—a costly and slow process—PASE employs a DRL agent as a Meta-Prompt Optimizer (MPO). The MPO learns to generate a compact, continuous prompt embedding \(\mathbf{p}_t\) that conditions the PSE. The state for the MPO is the semantic description \(D_t\), and its action is \(\mathbf{p}_t\): \[\mathbf{p}_t = \text{MPO}_{\psi}(D_t),\] where \(\psi\) denotes the MPO’s policy parameters. This prompt embedding is then injected into the PSE’s forward pass, effectively guiding its reasoning trajectory. The recovery plan is now generated as \(\Pi_t = \text{PSE}(D_t, \mathcal{R}; \mathbf{p}_t)\).

The reward \(R_t\) for the MPO is a composite signal received after the plan \(\Pi_t\) is executed in the real environment (or a high-fidelity simulator). We define two efficiency metrics: recovery efficiency \(E_t^{\text{rec}}\) (inverse of time to restore service) and resource efficiency \(E_t^{\text{res}}\) (negative of extra resource cost incurred). The reward is then: \[R_t = \alpha_1 \cdot E_t^{\text{rec}} + \alpha_2 \cdot E_t^{\text{res}} + \alpha_3 \cdot \mathbb{I}\big(F(\Pi_t) > \tau\big),\] where \(\mathbb{I}(\cdot)\) is the indicator function. The last term provides a shaped reward if the NSWM’s pre-execution feasibility score exceeded a threshold \(\tau\), bridging the model-based verification with real-world outcomes. The MPO’s policy \(\pi_{\psi}\) is optimized using an advanced off-policy actor-critic algorithm (e.g., Soft Actor-Critic) to maximize the expected cumulative reward \(J(\psi) = \mathbb{E}[\sum_{t} \gamma^t R_t]\). This setup allows the system to rapidly adapt its planning strategy by learning how to prompt the LLM effectively, rather than relearning recovery policies from scratch.

3.4 Integrated Training and Execution Loop↩︎

The training of PASE involves three coordinated phases: 1. NSWM Pre-training: The world model is trained on historical system interaction logs to accurately predict primitive outcomes. 2. MPO Warm-up: The MPO is initially trained in a simulation environment where the PSE uses a fixed, reasonable base prompt. The NSWM provides the feasibility score \(F(\Pi_t)\) as part of the reward. 3. Joint Fine-tuning: The entire loop (MPO \(\rightarrow\) PSE \(\rightarrow\) NSWM verification \(\rightarrow\) Execution) is fine-tuned with real-world interactions, allowing the MPO to learn the correlation between its prompt embeddings, the PSE’s plan quality, and the NSWM’s predictions.

During online operation, for a new fault observation \(\mathcal{O}_t\), PASE executes: a) generate description \(D_t\), b) MPO produces prompt \(\mathbf{p}_t\), c) PSE synthesizes plan \(\Pi_t\), d) NSWM evaluates \(F(\Pi_t)\), e) if \(F(\Pi_t) > \tau\), execute \(\Pi_t\); otherwise, the process can be iterated with a refined prompt or a fallback mechanism logs the case for later analysis and MPO retraining. This framework fundamentally shifts the innovation from better state representation or policy search to learning how to optimally leverage a pre-trained LLM’s reasoning capability for dynamic plan synthesis in a validated loop.

4 EXPERIMENTS↩︎

4.1 Experimental Objectives and Evaluation Metrics↩︎

This experiment aims to evaluate the comprehensive performance of the proposed PASE framework in the task of cloud system fault self-healing. The core objectives are to validate the following hypotheses:

1. Planning and Synthesis Capability: Compared to methods that only select predefined actions, the Plan Synthesis Engine (PSE) in PASE can generate more flexible and context-adaptive recovery plans.

2. Value of Online Verification: The pre-execution verification provided by the Neural-Symbolic World Model (NSWM) can effectively screen high-quality plans, reducing ineffective or harmful recovery attempts.

3. Meta-Learning Adaptability: The Meta-Prompt Optimizer (MPO) can optimize prompts through reinforcement learning, enabling the system to improve its performance faster when encountering new types of faults compared to using static prompts or full model fine-tuning.

In addition to the conventional Fault Detection Accuracy and Average System Recovery Time, we introduce the following new metrics:

• Plan Feasibility Score: The simulation evaluation score \(F(\Pi_t)\) provided by the NSWM for a generated plan \(\Pi_t\), reflecting the expected safety and effectiveness of the plan.

• Average Plan Steps: The average number of “Recovery Primitives” contained in successful recovery plans, measuring the complexity and granularity of the plans.

• Meta-Prompt Convergence Steps: The number of environment interaction episodes required for the MPO’s reward \(R_t\) to stabilize at an optimal level when confronted with a newly injected, unseen fault type. This measures the system’s capability for rapid adaptation.

4.2 Experimental Setup↩︎

Dataset: We utilize the OpenStack-based cloud fault injection dataset “Failure-Dataset-OpenStack”. It encompasses various fault types such as instance, network, and storage faults, along with dependency information, making it suitable for evaluating the synthesis of complex recovery strategies.

Baseline Methods: For a comprehensive comparison, we select four representative baselines:

• IFSHM: The original two-stage LLM+DRL framework, serving as the core comparative baseline.

• Deformable DETR-FD & GCN-FR: State-of-the-art methods based on time-series anomaly detection and dependency graph reasoning.

• Rule-Based Expert System: A rule-based expert system representing traditional methods.

PASE Implementation Details: The PSE module is based on the LLaMA-2-7B model, fine-tuned efficiently using LoRA. The NSWM is a 3-layer MLP pre-trained on historical fault trajectories. The MPO employs the Soft Actor-Critic (SAC) algorithm. All experiments are conducted on an NVIDIA A100 GPU cluster, with each configuration repeated 5 times to ensure statistical significance.

4.3 Main Results↩︎

4.3.1 Fault Detection and Recovery Efficiency↩︎

As shown in Table 2, PASE leads comprehensively in core operational metrics. It achieves the highest detection accuracy, benefiting from the deep semantic fusion of multi-modal observations by the PSE. More importantly, PASE demonstrates the shortest average recovery time, and its optimization margin significantly exceeds that of IFSHM and other baselines as the number of experimental episodes increases. This proves that the paradigm of “plan generation + simulation verification” can find high-quality recovery paths more efficiently than the “state classification + action selection” paradigm.

4.3.2 Analysis of Recovery Plan Quality↩︎

We further analyze the quality of plans in successful recovery cases. Plans generated by PASE contain an average of 3.2 steps, significantly more than the single action (1 step) or two-level “action-parameter” structure of IFSHM. These multi-step plans can combine several “Recovery Primitives” (e.g., first isolating the faulty instance, then scaling out the backup service group, and finally rerouting traffic), thereby addressing the root cause more precisely. The feasibility score from the NSWM shows a 92% correlation with the actual success rate of the plans in the real environment, demonstrating the effectiveness of simulation verification.

4.3.3 Rapid Adaptation Capability to Novel Faults↩︎

We injected a novel, previously unseen “hybrid CPU-Memory deadlock fault” during the mid-phase of the experiment. As shown in Figure 4, the PASE framework (via MPO adjusting prompts) rapidly increased its recovery success rate from an initial 40% to over 80% within approximately 15 interaction episodes. In contrast, IFSHM required triggering its full prompt-tuning pipeline, which took longer and converged at a final performance of 75%. The static rule-based system failed completely. This experiment validates the effectiveness of the MPO in quickly guiding the PSE to adjust its reasoning strategy by optimizing the “meta-prompt,” achieving online, low-cost adaptation.

4.4 Ablation Study↩︎

Core Component Necessity Analysis. Our neural-symbolic world model achieves optimal Plan Feasibility AUC (0.92) and state prediction MSE (0.014) while maintaining balanced inference time (42ms) and memory use (128MB). In comparison, the pure symbolic (rule-based) approach is fastest (18ms) and most memory-efficient (12MB) but struggles with complex dynamics (AUC 0.76, MSE 0.145). The pure neural (MLP) method improves prediction (MSE 0.032) but lacks symbolic constraints (AUC 0.81, safety violations). LSTM and Transformer models leverage temporal and attention mechanisms for higher performance (AUC 0.88-0.90) at greater computational cost (58-112ms). Although the ensemble method nears our AUC (0.91), its high overhead (156ms, 432MB) precludes real-time use, confirming that our hybrid architecture best balances verification accuracy, efficiency, and resource consumption by combining neural pattern learning with symbolic safety guarantees.
World Model Architecture Comparison. Figure 6 compares world model architectures, showing our neural-symbolic model achieves the best verification accuracy (Plan Feasibility AUC 0.92, prediction MSE 0.014) with balanced efficiency (42ms inference, 128MB memory). Pure symbolic (rule-based) models are fastest and leanest (18ms, 12MB) but inaccurate (AUC 0.76, MSE 0.145), while pure neural (MLP) methods improve prediction (MSE 0.032) yet lack safety constraints (AUC 0.81, safety violations). Advanced models like LSTM and Transformer leverage temporal or attention mechanisms for higher AUC (0.88–0.90) at greater cost (58–112ms, 210–385MB), and ensemble methods near our AUC (0.91) but are impractical for real-time use due to high overhead (156ms, 432MB). These results confirm that our neural-symbolic fusion optimally balances accuracy, efficiency, and resource use by combining neural pattern learning with symbolic safety guarantees.
Meta-Prompt Optimization Strategy Evaluation. Figure 3 evaluates meta-prompt optimization strategies, showing our SAC-based MPO excels in final reward (8.72), convergence speed (15 episodes), and generalization (gap 12.3%) at moderate computational cost. Baselines like random search (reward 6.23, 65 episodes), evolutionary strategy (high cost, 18.9% gap), and gradient methods (reward 7.89, 25 episodes) perform worse. Other RL algorithms—REINFORCE (reward 7.68, high variance) and PPO (reward 8.15, 20 episodes)—are inferior in stability or speed. While directly fine-tuning the LLM yields high reward (8.41) and small gap (13.5%), its very high cost and slow convergence (50 episodes) are impractical; adapter-based tuning improves but still needs 35 episodes. Our method efficiently explores the prompt embedding space, leveraging SAC’s exploration and entropy regularization for robustness, demonstrating that meta-optimizing prompts is a more efficient and practical adaptation strategy for rapid-response cloud recovery.

4.5 Discussion↩︎

The experiments confirm the three-fold advantages of the PASE framework: superior recovery efficiency, higher-order planning capability, and stronger rapid adaptability. The performance gains primarily stem from elevating the LLM’s role from a “feature extractor” to a “planning engine,” complemented by model verification and meta-optimization.

However, PASE currently incurs slightly higher computational overhead than IFSHM, mainly due to the multiple simulation rollouts by the NSWM. Future work will focus on optimization through lightweight world models and distillation techniques. Furthermore, PASE may still generate risky plans for extremely rare fault types due to limited experience, pointing to future research directions involving safety constraints and human feedback (RLHF).

5 CONCLUSION↩︎

In conclusion, this paper presents PASE, a novel planning-aware semantic self-healing framework for cloud AI systems. PASE unifies LLM-driven plan synthesis, neural-symbolic verification, and meta-prompt optimization into a closed-loop “reason–plan–verify–adapt” architecture, advancing beyond conventional sequential LLM–DRL pipelines. Extensive experiments on real OpenStack fault injection data demonstrate that PASE significantly outperforms existing methods in both fault detection accuracy and recovery efficiency, particularly under unseen failure scenarios. Nonetheless, our work has several limitations. First, the LLM-based planner currently relies on offline fine-tuning, which may hinder real-time adaptation to emerging fault patterns. Second, the meta-prompt optimizer requires considerable interaction data for effective generalization, posing a cost challenge in high-availability production environments [30]. Furthermore, PASE assumes centralized access to system observability data, which may not align with federated or privacy-sensitive deployment settings. Future research will focus on: (1) enabling online continual learning for the LLM planner to support real-time adaptation; (2) exploring model compression and quantization techniques for efficient deployment in edge–cloud hybrid infrastructures [31]; (3) extending PASE to federated multi-cloud environments with privacy-preserving coordination mechanisms [32]; and (4) improving optimization stability via advanced non-convex training algorithms [33], [34]. Additional directions include zero-shot recovery capability, adaptive policy distillation, and the integration of multi-agent collaboration mechanisms to further enhance the robustness and precision of LLM-guided fault recovery [35]–[40].

References↩︎