STAR Framework: Enabling Self-Correction in AI for Microservice Fault Diagnosis

Against the backdrop of complex microservice architectures, traditional manual root cause analysis (RCA) is time-consuming and labor-intensive, while LLM-driven intelligent diagnostic agents often fail due to single-point errors in their reasoning chains. The STAR framework significantly improves the reliability and debuggability of agents through mechanisms such as four-stage workflow decomposition (evidence package, hypothesis set, analysis structure, decision report), fast/slow routing resource allocation, counterfactual evaluation to locate faulty stages, and stage-specific repair (patching and replaying). Experiments verify that it outperforms baselines in root cause localization and fault classification, and most errors can be corrected with 1-2 rounds of repair.

Microservice architectures split into multiple services, so fault root cause investigation requires processing massive amounts of data, and manual methods are inefficient. Although LLM agents have potential, single-point errors in evidence collection, hypothesis generation, or causal analysis within the reasoning chain can propagate, leading to diagnostic failure; moreover, the black-box nature of agents makes it difficult to locate faults and optimize debugging.

The STAR framework decomposes the RCA workflow into four stages: Evidence Package (collecting fault-related data), Hypothesis Set (generating potential root cause hypotheses), Analysis Structure (constructing propagation paths via causal reasoning), and Decision Report (outputting root causes and classifications). It introduces fast/slow routing: first, quickly audit the quality of each stage; if passed, proceed, otherwise switch to slow mode for in-depth analysis. It locates critical faulty stages through counterfactual evaluation (testing the impact of modifying a stage's output on the result), then uses a patching and replaying strategy to repair specific stages, avoiding redundant computations.

The research team cross-validated STAR on public benchmarks and real production datasets using two RCA workflows and three base models. The results show: STAR outperforms strong baselines in root cause localization and fault classification tasks; it can identify critical faulty stages with high accuracy; most initial incorrect diagnoses can be corrected within 1-2 rounds of replay repair.

STAR is built based on LangGraph. Its graph structure adapts to phased design, where each stage corresponds to a node and data flow is defined via edges, bringing advantages such as modularity (independent development and testing), observability (clear execution traces), scalability (easy insertion of new strategies), and reproducibility (deterministic execution paths). Insights for agent design: Explicit structures are better than implicit processes; local repair is better than global retries; counterfactual reasoning is a powerful diagnostic tool; resource budget awareness enhances practicality.

The current stage division of STAR is targeted at microservice RCA; extending it to other fields requires adjusting stage definitions. The computational cost of counterfactual evaluation increases with the number of stages and candidates, so complex workflows need optimization. Future research can explore technologies such as automated stage division, learning optimal fast/slow routing strategies, and integrating self-reflection or multi-agent collaboration.

The STAR framework transforms the black-box end-to-end reasoning of LLM agents into a white-box phased process, improving the accuracy of microservice fault diagnosis and providing a systematic method to understand, debug, and improve agent behavior. In today's era where AI is deeply integrated into critical business scenarios, such explainable, debuggable, and self-repairable capabilities are crucial, pointing the way for building more reliable AI systems.