The Multi-Agent Fault Localization System Based on Monte Carlo Tree Search Approach

Rui Ren

REVIEW 4 major objections 5 minor 43 references

The Multi-Agent Fault Localization System Based on Monte Carlo Tree Search Approach

T0 review · 4 major / 5 minor · reviewed 2026-08-06 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read Root cause analysis improves by 49-128% when LLM agents explore a fault tree via Monte Carlo search.

desk verdict A genuinely new integration of MCTS, a Fault Mining Tree, and verifier-rewarded agents for LLM-based RCA, but the headline accuracy numbers rest on under-specified baseline re-implementations and need artifacts, error bars, and calmer claims. read the letter →

arxiv 2507.22800 v1 pith:3224IF4B submitted 2025-07-30 cs.SE

Rui Ren This is my paper

classification cs.SE

keywords RootcauseanalysisMonteCarloTreeSearchLLMmulti-agentsystemFaultlocalizationMicroservicereliabilityKnowledgebaserewardMiningAIOps

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

KnowledgeMind is a multi-agent LLM system for root cause analysis in microservice systems, built around a Monte Carlo Tree Search over a Fault Mining Tree. The paper's central claim is that checking services one at a time, scoring each step with knowledge-base rules, locates the failing service and fault type far more accurately than single-shot or ReAct-style LLM agents. On two public microservice fault datasets, the authors report a 49.29% to 128.35% relative improvement in root cause localization accuracy over mABC and RCAgent, while consuming roughly one-tenth the maximum context window per inference step. If true, this would make LLM-based diagnosis feasible for large systems whose alarm data would overflow a single context window.

What carries the argument

The central mechanism is the Fault Mining Tree, constructed by the Alarm Graph Agent: it takes the service dependency graph, keeps only services that are alarmed or ancestors of alarmed services, merges subtrees, and connects their roots to a virtual root. MCTS then traverses this tree service by service. At each expansion, Metric, Log, and Trace Agents summarize one service's anomaly evidence; the Verifier Agent, using expert rules and, when available, similar cases retrieved by the Knowledge Base Agent, scores each child from 0 to 10. Simulation uses a greedy rollout that checks the knowledge base and counts anomalies in calling services; backpropagation updates node values. This replaces a single black-box judgment over all alarms with many small scored steps, which is what cuts hallucination and context length.

What would settle it

A rerun of both datasets that uses the original published RCAgent and mABC code, or exactly specified detector configurations, and reports per-fault FL@1 and FT@1 numbers; if the relative improvement over mABC and RCAgent does not fall in the 49.29% to 128.35% range, the paper's central claim is refuted.

Watch

Extended reading notes

Core claim

The paper claims that hallucination and fault-propagation errors in LLM root cause analysis can be tamed by replacing open-ended reasoning with a service-by-service search over an alarm propagation tree. KnowledgeMind builds a Fault Mining Tree from the service dependency graph and the set of alarmed services, then runs MCTS: at each node, Metric, Log, and Trace agents summarize that service's anomalies, and a Verifier Agent assigns a score from expert rules and similar cases in a knowledge base. The highest-scoring path, after simulation and backpropagation, is returned as the root cause service, and a Service-Pod Agent refines it to pod level. The authors report that on the AIOPS 2022 dataset (dataset A) and the TrainTicket benchmark (dataset B), KnowledgeMind beats CoT, mABC, and RCAgent by 49.29% to 128.35% on fault service and fault type localization, and that its maximum tokens per inference step is about one-tenth of the ReAct-based baselines. They also report ablation results: removing the Metric Agent drops FL@1 from 0.724 to 0.180 on dataset A, and removing the Log Agent drops it to 0.611.

Load-bearing premise

The comparison assumes the authors' re-implementations of RCAgent and mABC, which inject anomaly-detection algorithms "similar to those in the Metric Agent and Log Agent" without specifying them, capture those baselines' real performance; if those injected detectors are weaker than KnowledgeMind's, the reported 49.29% to 128.35% improvement is inflated.

Editorial extensions

If this is right

The per-step token budget stays roughly constant as the system grows, because only one service's evidence is loaded at a time; the paper reports max token consumption of 4,362 for KnowledgeMind versus 29,324 for RCAgent and 34,348 for mABC.
Because each step is scored and visible, an SRE can correct a faulty rule or case and rerun only the affected reasoning, rather than trusting a one-shot answer.
Ablation results identify the Metric Agent as the largest contributor: removing it drops FL@1 from 0.724 to 0.180 on dataset A, while removing the Log Agent drops it to 0.611.
KnowledgeMind's accuracy varies little across base LLMs on dataset A, suggesting the rule-and-knowledge scaffold, not the base model's reasoning, drives the result.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

If the search-plus-scoring recipe is what matters, the same MCTS over a dependency tree could be applied to other propagative failure domains, such as network or cloud incident diagnosis, without retraining.
The supervised mode's large margin over unsupervised mode (FL@1 0.892 vs 0.724 on dataset A) leaves open how much of the headline gain is case-library memory rather than the search; a direct unsupervised-only comparison against mABC and RCAgent would settle it.
A cheap way to test the hallucination claim directly would be to measure answer consistency across repeated runs on the same fault; the paper argues MCTS scoring reduces randomness but does not report a consistency metric.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

The real novelty here is the orchestration: MCTS over a service dependency tree (the Fault Mining Tree) with service-by-service expansion, a rule-and-knowledge-base verifier reward, and a multi-agent pipeline that feeds the LLM only the relevant per-service slice. That is a sensible, clearly described integration of known pieces, and the paper does a good job explaining the prompts, the tree construction, and the agent responsibilities. The ablation is also informative, showing metric information dominates and the Log Agent matters for certain fault types. Credit where due: this is a solid systems-engineering idea, not a repackaging of prior work.

The soft spots are exactly where the stress-test note points. Section IV-A-3 admits that because RCAgent is not open-sourced and mABC lacks concrete detection methods, the authors injected anomaly detection algorithms "similar to those in the Metric Agent and Log Agent" into the baselines. But they never say which algorithms, which thresholds, or how they were integrated. Since those detectors are core contributions of KnowledgeMind, a weaker or differently tuned injection would handicap the baselines and mechanically inflate the 49–128% improvement. The missing specification also makes the comparison impossible to audit. This is not a fatal flaw, but it is an unverified degree of freedom in the only evidence for the headline claim.

Other issues are real but smaller. There are no error bars, no significance tests, and no code or data scripts released. The abstract's "one-tenth" context claim is actually about one-eighth by the paper's own Table II. The 128.35% figure comes from comparing against the weakest COT configuration, not a representative SOTA. The direction of the improvement is consistent across models and datasets, so I believe the method probably does help, but the magnitude is not established as claimed.

The paper itself flags the baseline modification, which is more honest than hiding it, and the central mechanism—service-by-service search with a reward—is well motivated. The math is simple but appropriate; no fitting-to-target issues.

Who is this for? Researchers and practitioners working on LLM-based RCA in microservices. It deserves a serious referee: a competent reviewer can push for artifact release, detailed baseline re-implementations, confidence intervals, and claim calibration. With those revisions it could be a useful contribution. As submitted, the empirical claims are not yet trustworthy enough to cite.

Referee Report

4 major / 5 minor

Summary. The paper proposes KnowledgeMind, a multi-agent root cause analysis (RCA) system for microservice systems. The method constructs a "Fault Mining Tree" from the service dependency graph and alarm information, then uses Monte Carlo Tree Search (MCTS) to perform service-by-service reasoning, with Metric, Log, Trace, Anomaly Alarm, Alarm Graph, Knowledge Base, Verifier, and Service-Pod agents. The authors claim that this structured reasoning reduces LLM hallucination and context-window usage, and report a 49.29%–128.35% improvement in root cause localization accuracy over existing LLM-based RCA frameworks on the AIOps 2022 and TrainTicket datasets, across five base LLMs.

Significance. If the reported gains are real, KnowledgeMind would be a meaningful step toward more interpretable and token-efficient LLM-based RCA, and the combination of MCTS with a knowledge-base reward mechanism is a reasonable design direction. The paper has useful strengths: it provides pseudocode for the main algorithm, includes prompt templates in the appendix, reports token/time consumption, and includes an ablation study. However, the headline empirical claim is currently not supported with sufficient rigor: the baseline re-implementations are not specified, the reported improvement range is not tied to a controlled comparison, and no statistical variability is reported. The central idea is defensible, but the evidence needs substantial strengthening before the claim can be accepted.

major comments (4)

[§IV-A-3] The re-implementation of the mABC and RCAgent baselines is underspecified and load-bearing for the headline claim. The paper states that anomaly detection algorithms "similar to those in the Metric Agent and Log Agent" were incorporated into these baselines to ensure fairness, but the exact algorithms, thresholds, prompt templates, and integration points are not given. Because the Metric and Log Agents are core components of KnowledgeMind, injecting weaker or differently tuned versions of these detectors into the baselines could mechanically inflate the reported 49.29%–128.35% improvement. The authors must specify the exact detector configurations, or better, use the original open-source implementations, and ideally release code so the comparison can be audited and reproduced.
[Abstract and Contribution 4, with Table IV] The reported improvement range of 49.29%–128.35% is not a controlled comparison. The lower value appears to come from comparing KnowledgeMind (QwenMax) with mABC (GPT-4-Turbo) on dataset A, while the upper value appears to compare the same KnowledgeMind configuration with the weakest COT configuration (Qwen-QwQ). The upper end is therefore not against a SOTA framework, and the range mixes different base LLMs and different datasets. Moreover, on dataset B the improvements are much smaller (for example, KnowledgeMind QwenMax FL@1 is 0.903 versus 0.848 for mABC QwenMax, a relative gain of about 6.5%). The manuscript should define a single comparison protocol and report the full pairwise delta matrix, and should not claim a range that is obtained by cherry-picking the best and worst cells from Table IV.
[§IV-B, Tables III and IV] All accuracy numbers are reported as single-point estimates without error bars, confidence intervals, or significance tests. Differences between base LLMs are often small (for example, KnowledgeMind FL@1 on dataset A is 0.724 for QwenMax and 0.718 for GPT-4-Turbo), and without repeated runs or statistical analysis it is impossible to tell whether these differences, or some of the baseline gaps, are meaningful. The authors should report the number of runs, standard deviations, and ideally pairwise significance tests for the main comparisons.
[Algorithm 2 and §III-A-8] The MCTS procedure is not specified precisely enough to reproduce. The Selection step uses UCT, but the Expansion step uses the Verifier Agent's greedy highest-score choice; the Simulation step uses either knowledge-base matching or anomaly counts of calling services; and the Backpropagation step updates Q(v) with a reward R, yet the paper never defines how R is computed from the verifier score or the anomaly count, nor the value of the exploration constant C, nor the number of simulations N used in the experiments. Without these details, the claimed benefits of the MCTS-based reasoning process cannot be independently reproduced or evaluated.

minor comments (5)

[Throughout] There are multiple typos and grammatical errors, such as "Beside" for "Besides", "pseudocodee" for "pseudocode", "drived" for "derived", and inconsistent capitalization of "KnowledgeMind" (e.g., "the KnowledgeMind is"). A careful proofreading pass is needed.
[Cross-references] Several cross-references are incorrect: in §IV-B-1 the text says "As the table III shown" for the time/token table, which is Table II; in §IV-A-1 the text refers to "Figure I" for fault types, but the fault types appear in Table I; and the caption of Table IV mentions "RL" and "RA" while the table columns are labeled FL and FT. These should be fixed.
[Table I] The caption says "Overview fault type of three datasets" but only two datasets, A and B, are described; the table also has mismatched row/column formatting. Please correct the caption and align the entries.
[Appendix A] The Verifier Agent prompt states that scores should range from 1 to 8 and that the highest score must be at least 2 points higher than the others, but the example output uses a score of 9. This inconsistency should be resolved.
[Equation (1)] In Equation (1), \(\hat{\sigma}_e\) is not defined, and the threshold \(\lambda\) is described only as set by expert experience. Since the anomaly detection components are central to the system, the exact definitions of these quantities should be stated.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: KnowledgeMind's accuracy claims are empirical evaluations on public datasets; the expert-rule rewards and scoring prompts are design choices, not fits to the reported metrics.

full rationale

The paper contains no derivation chain in which a predicted quantity is defined in terms of the target result. The FL@1 and FT@k numbers in Table IV are measured outcomes of running KnowledgeMind and the baselines on the public AIOPS 2022 and TrainTicket datasets. The Verifier Agent's scoring rules, the Metric Agent's ARIMA threshold, and the MCTS reward functions are fixed design choices described in Section III and the Appendix, not parameters fitted to the localization accuracy values. No equation in the paper defines the predicted root cause in terms of the reported accuracy, and no fitted input is renamed as a prediction. The self-citation [34] is used only as a reference for standard evaluation metrics and is not load-bearing; the core claim rests on the reproduced experiments and external datasets. The main validity concern is the modification of the RCAgent and mABC baselines by injecting anomaly detectors 'similar to those in the Metric Agent and Log Agent' (Section IV-A-3), since the exact detectors are unspecified. However, this is a comparability and reproducibility threat, not circularity, because the baselines' performance is not itself an input to KnowledgeMind's derivation or to the construction of its reward rules. The paper is self-contained in the circularity sense: its results are empirical comparisons rather than consequences of its own definitions or citations.

Assumptions & free parameters 6 free parameters · 4 assumptions · 1 invented entities

The central empirical claims rest on several untested assumptions: that the dependency graph is complete, that caller anomalies reliably indicate downstream root cause, and that the verifier's rule-based scoring is well-calibrated. Key hyperparameters such as lambda, UCT constant C, simulation count N, GMM components, and knowledge-base k are not reported, making the method under-specified.

free parameters (6)

Anomaly detection threshold lambda = not provided
Used in Eq. (1) to classify ARIMA residuals as SPIKE or DIP; set by expert experience, no value reported.
UCT exploration constant C = not provided
Used in Algorithm 2's UCT formula; no value given, affects exploration-exploitation balance.
Number of MCTS simulations N = not provided
Controls number of search iterations; no value given, directly affects result stability.
Log template filtering keywords = e.g., 'exception', 'error'
Hand-selected to prioritize templates; dataset-specific and not systematically justified.
GMM number of components = not provided
Used for log clustering in the Log Agent; number of components is not specified.
Knowledge base top-k cases = not provided
Knowledge Base Agent retrieves top-k similar cases via Jaccard similarity; k is not specified.

assumptions (4)

domain assumption The service dependency graph captures all relevant fault propagation paths.
Algorithm 1 builds the propagation topology from the dependency graph; failures propagating through unmodeled channels (shared hosts, queues, configs) would break the Fault Mining Tree's completeness. Section III-A-6.
domain assumption When a root cause service fails, all caller services also become abnormal.
Used in Algorithm 2's Simulate function: reward is based on the anomaly count of services that call the candidate. Not true for all failure types. Section III-A-8.
domain assumption The Verifier Agent's expert rules and prompt constraints yield scores that rank services by true root cause likelihood.
The verifier's scores (1-10) drive selection and reward; the rule that the top score must be at least 2 points higher is a prompt constraint, not empirically validated. Appendix A.
domain assumption The FT@k metric is conditionally on correct service localization and the top-3 ranking is meaningful for fault type evaluation.
FT@k is defined as accuracy given correct service localization, but the conditional probability is not reported separately. Section IV-A-2.

invented entities (1)

Fault Mining Tree
purpose: A tree-structured representation of service dependencies with a virtual root, used to constrain the search space in MCTS.
Introduced in this paper; no external validation beyond the paper's own experiments. Its usefulness is asserted, not proven by an independent benchmark.

how reviews work

0 comments

Cite this review

Pith. "Pith review of The Multi-Agent Fault Localization System Based on Monte Carlo Tree Search Approach." pith.science (2026). https://pith.science/paper/3224IF4B

@misc{pith2026250722800,
  author       = {Pith},
  title        = {Pith review of: The Multi-Agent Fault Localization System Based on Monte Carlo Tree Search Approach},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/3224IF4B}},
  note         = {Machine review of arXiv:2507.22800}
}

read the original abstract

In real-world scenarios, due to the highly decoupled and flexible nature of microservices, it poses greater challenges to system reliability. The more frequent occurrence of incidents has created a demand for Root Cause Analysis(RCA) methods that enable rapid identification and recovery of incidents. Large language model (LLM) provides a new path for quickly locating and recovering from incidents by leveraging their powerful generalization ability combined with expert experience. Current LLM for RCA frameworks are based on ideas like ReAct and Chain-of-Thought, but the hallucination of LLM and the propagation nature of anomalies often lead to incorrect localization results. Moreover, the massive amount of anomalous information generated in large, complex systems presents a huge challenge for the context window length of LLMs. To address these challenges, we propose KnowledgeMind, an innovative LLM multi-agent system based on Monte Carlo Tree Search and a knowledge base reward mechanism for standardized service-by-service reasoning. Compared to State-Of-The-Art(SOTA) LLM for RCA methods, our service-by-service exploration approach significantly reduces the burden on the maximum context window length, requiring only one-tenth of its size. Additionally, by incorporating a rule-based real-time reward mechanism, our method effectively mitigates hallucinations during the inference process. Compared to the SOTA LLM for RCA framework, our method achieves a 49.29% to 128.35% improvement in root cause localization accuracy.

Figures

Figures reproduced from arXiv: 2507.22800 by the authors.

**Figure 2.** The Pipeline of KnowledgeMind. detection methods(e.g., LSTM, GRU), presenting the results as ”anomaly existing” or ”anomaly unexisting” to the LLM. et = yt − yˆt zt = et σˆe |zt| > λ (1) 3) Trace Agent: The Trace Agent does not involve graphrelated analysis. The Trace Agent primarily focuses on analyzing the invocation latency and communication status of individual services. It is used to detect whether there is a… view at source ↗

**Figure 3.** The Construction of Fault Mining Tree. tiple regions. The microservices in these regions might not necessarily be invoked by the same services, thereby forming multiple anomalous subgraphs. Therefore, we decompose this original alarm graph into multiple tree-structured subgraphs based on services’ dependent relationship, named Sub-Tree. Please note that the Sub-Tree is constructed based on the service granularity, … view at source ↗

Figures from the paper (1 more)

**Figure 4.** Figure 4: The Procedure of Fault Reasoning Step-By-Step. [PITH_FULL_IMAGE:figures/full_fig_p006_4.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

43 extracted references · 31 canonical work pages

[1]

Seer: Leveraging big data to navigate the complexity of performance debugging in cloud microservices,

Y . Gan, Y . Zhang et al. , “Seer: Leveraging big data to navigate the complexity of performance debugging in cloud microservices,” in Pro- ceedings of the twenty-fourth international conference on architectural support for programming languages and operating systems , 2019, pp. 19–33

work page 2019
[2]

An open-source benchmark suite for microservices and their hardware-software implications for cloud & edge systems,

——, “An open-source benchmark suite for microservices and their hardware-software implications for cloud & edge systems,” in Proceedings of the Twenty-Fourth International Conference on Architectural Support for Programming Languages and Operating Systems, ASPLOS 2019, Providence, RI, USA, April 13-17, 2019 , I. Bahar, M. Herlihy, E. Witchel, and A. R. Le...

arXiv 2019
[3]

µ suite: a benchmark suite for microservices,

A. Sriraman and T. F. Wenisch, “ µ suite: a benchmark suite for microservices,” in 2018 IEEE International Symposium on Workload Characterization (IISWC). IEEE, 2018, pp. 1–12

work page 2018
[4]

Graph-based root cause analysis for service-oriented and microservice architectures,

´A. Brand ´on, M. Sol ´e, A. Hu ´elamo, D. Solans, M. S. P ´erez, and V . Munt´es-Mulero, “Graph-based root cause analysis for service-oriented and microservice architectures,” Journal of Systems and Software , vol. 159, p. 110432, 2020

work page 2020
[5]

Beyer, C

B. Beyer, C. Jones, J. Petoff, and N. R. Murphy, Site Reliability Engineering: How Google Runs Production Systems , 2016. [Online]. Available: http://landing.google.com/sre/book.html

work page 2016
[6]

Boosting coverage-based fault localization via graph-based representation learning,

Y . Lou, Q. Zhu, J. Dong, X. Li, Z. Sun, D. Hao, L. Zhang, and L. Zhang, “Boosting coverage-based fault localization via graph-based representation learning,” in Proceedings of the 29th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering , 2021, pp. 664–676

work page 2021
[7]

Fault localization via efficient probabilistic modeling of program semantics,

M. Zeng, Y . Wu, Z. Ye, Y . Xiong, X. Zhang, and L. Zhang, “Fault localization via efficient probabilistic modeling of program semantics,” in Proceedings of the 44th International Conference on Software Engi- neering, 2022, pp. 958–969

work page 2022
[8]

Micro- diag: Fine-grained performance diagnosis for microservice systems,

L. Wu, J. Tordsson, J. Bogatinovski, E. Elmroth, and O. Kao, “Micro- diag: Fine-grained performance diagnosis for microservice systems,” in 2021 IEEE/ACM International Workshop on Cloud Intelligence (Cloud- Intelligence). IEEE, 2021, pp. 31–36

work page 2021

Show all 43 references

[9]

Rex: Preventing bugs and misconfiguration in large services using correlated change analysis,

S. Mehta and R. Bhagwan, “Rex: Preventing bugs and misconfiguration in large services using correlated change analysis,” in 17th USENIX Symposium on Networked Systems Design and Implementation (NSDI 20), 2020, pp. 435–448. 11

2020
[10]

Rapid detection of maintenance induced changes in service performance,

A. Mahimkar, “Rapid detection of maintenance induced changes in service performance,” in Proceedings of the Seventh COnference on Emerging Networking EXperiments and Technologies , 2011, pp. 1–12

2011
[11]

The potential of one-shot failure root cause analysis: Collaboration of the large language model and small classifier,

Y . Han, Q. Du, Y . Huang, J. Wu, F. Tian, and C. He, “The potential of one-shot failure root cause analysis: Collaboration of the large language model and small classifier,” in Proceedings of the 39th IEEE/ACM International Conference on Automated Software Engineering, 2024, ...

2024
[12]

Automated root causing of cloud incidents using in-context learning with gpt-4,

X. Zhang, S. Ghosh, C. Bansal, R. Wang, M. Ma, Y . Kang, and S. Ra- jmohan, “Automated root causing of cloud incidents using in-context learning with gpt-4,” in Companion Proceedings of the 32nd ACM International Conference on the Foundations of Software Engineering , 2024, pp...

2024
[13]

Exploring llm-based agents for root cause analysis,

D. Roy, X. Zhang, R. Bhave, C. Bansal, P. Las-Casas, R. Fonseca, and S. Rajmohan, “Exploring llm-based agents for root cause analysis,” in Companion Proceedings of the 32nd ACM International Conference on the Foundations of Software Engineering , 2024, pp. 208–219

2024
[14]

Llexus: an ai agent system for incident management,

P. Las-Casas, A. G. Kumbhare, R. Fonseca, and S. Agarwal, “Llexus: an ai agent system for incident management,” ACM SIGOPS Operating Systems Review, vol. 58, no. 1, pp. 23–36, 2024

2024
[15]

Llmparser: An exploratory study on using large language models for log parsing,

Z. Ma, A. R. Chen, D. J. Kim, T.-H. Chen, and S. Wang, “Llmparser: An exploratory study on using large language models for log parsing,” in Proceedings of the IEEE/ACM 46th International Conference on Software Engineering, 2024, pp. 1–13

2024
[16]

Prometheus,

“Prometheus,” https://prometheus.io/, 2023

2023
[17]

Elasticsearch,

“Elasticsearch,” https://www.elastic.co/, 2023

2023
[18]

Jaeger: open source, end-to-end distributed tracing

“Jaeger: open source, end-to-end distributed tracing.” https://www. jaegertracing.io/, 2023

2023
[19]

High-quality, ubiquitous, and portable telemetry to enable effective observability

“High-quality, ubiquitous, and portable telemetry to enable effective observability.” https://opentelemetry.io/, 2023

2023
[20]

Monitorassistant: Simplifying cloud service monitoring via large language models,

Z. Yu, M. Ma, C. Zhang, S. Qin, Y . Kang, C. Bansal, S. Rajmohan, Y . Dang, C. Pei, D. Pei et al. , “Monitorassistant: Simplifying cloud service monitoring via large language models,” in Companion Proceed- ings of the 32nd ACM International Conference on the Foundations of Sof...

2024
[21]

Automatic root cause analysis via large language models for cloud incidents,

Y . Chen, H. Xie, M. Ma, Y . Kang, X. Gao, L. Shi, Y . Cao, X. Gao, H. Fan, M. Wen et al., “Automatic root cause analysis via large language models for cloud incidents,” in Proceedings of the Nineteenth European Conference on Computer Systems , 2024, pp. 674–688

2024
[22]

Rcagent: Cloud root cause analysis by autonomous agents with tool-augmented large language models,

Z. Wang, Z. Liu, Y . Zhang, A. Zhong, J. Wang, F. Yin, L. Fan, L. Wu, and Q. Wen, “Rcagent: Cloud root cause analysis by autonomous agents with tool-augmented large language models,” in Proceedings of the 33rd ACM International Conference on Information and Knowledge Managemen...

2024
[23]

mabc: multi-agent blockchain-inspired collaboration for root cause analysis in micro-services architecture,

W. Zhang, H. Guo, J. Yang, Y . Zhang, C. Yan, Z. Tian, H. Ji, Z. Li, T. Li, T. Zheng et al. , “mabc: multi-agent blockchain-inspired collaboration for root cause analysis in micro-services architecture,” arXiv preprint arXiv:2404.12135, 2024

2024 arXiv
[24]

React: Synergizing reasoning and acting in language models,

S. Yao, J. Zhao, D. Yu, N. Du, I. Shafran, K. Narasimhan, and Y . Cao, “React: Synergizing reasoning and acting in language models,” arXiv preprint arXiv:2210.03629, 2022

2022 arXiv
[25]

Assess and summarize: Improve outage understanding with large language models,

P. Jin, S. Zhang, M. Ma, H. Li, Y . Kang, L. Li, Y . Liu, B. Qiao, C. Zhang, P. Zhao et al. , “Assess and summarize: Improve outage understanding with large language models,” in Proceedings of the 31st ACM Joint European Software Engineering Conference and Symposium on the Fou...

2023
[26]

Xpert: Empowering incident management with query recommendations via large language models,

Y . Jiang, C. Zhang, S. He, Z. Yang, M. Ma, S. Qin, Y . Kang, Y . Dang, S. Rajmohan, Q. Lin et al., “Xpert: Empowering incident management with query recommendations via large language models,” in Proceedings of the IEEE/ACM 46th International Conference on Software Engineer- ...

2024
[27]

Drain: An online log parsing approach with fixed depth tree,

P. He, J. Zhu, and Z. Zheng, “Drain: An online log parsing approach with fixed depth tree,” in 2017 IEEE international conference on web services (ICWS). IEEE, 2017, pp. 33–40

2017
[28]

Aiops 2022 championship,

“Aiops 2022 championship,” https://competition.aiops.cn/, 2022

2022
[29]

Gaussian mixture models

D. A. Reynolds et al. , “Gaussian mixture models.” Encyclopedia of biometrics, vol. 741, no. 659-663, 2009

2009
[30]

Inverse document frequency (idf): A measure of deviations from poisson,

K. Church and W. Gale, “Inverse document frequency (idf): A measure of deviations from poisson,” in Natural language processing using very large corpora. Springer, 1999, pp. 283–295

1999
[31]

Fault analysis and debugging of microservice systems: Industrial survey, benchmark system, and empirical study,

X. Zhou, X. Peng et al., “Fault analysis and debugging of microservice systems: Industrial survey, benchmark system, and empirical study,” IEEE Transactions on Software Engineering, vol. 47, no. 2, pp. 243–260, 2018

2018
[32]

Actionable and interpretable fault localization for recurring failures in online service systems,

Z. Li, N. Zhao, M. Li, X. Lu, L. Wang, D. Chang, X. Nie, L. Cao, W. Zhang, K. Sui, Y . Wang, X. Du, G. Duan, and D. Pei, “Actionable and interpretable fault localization for recurring failures in online service systems,” in Proceedings of the 2022 30th ACM Joint Meeting on Eur...

2022
[33]

Sage: Using unsupervised learning for scalable performance debugging in microservices,

Y . Gan, M. Liang et al. , “Sage: Using unsupervised learning for scalable performance debugging in microservices,” arXiv preprint arXiv:2101.00267, 2021

2021 arXiv
[34]

Slim: a scalable light- weight root cause analysis for imbalanced data in microservice,

R. Ren, J. Yang, L. Yang, X. Gu, and L. Sun, “Slim: a scalable light- weight root cause analysis for imbalanced data in microservice,” in Proceedings of the 2024 IEEE/ACM 46th International Conference on Software Engineering: Companion Proceedings , 2024, pp. 328–330

2024
[35]

Practical root cause localization for microservice systems via trace analysis,

Z. Li, J. Chen et al., “Practical root cause localization for microservice systems via trace analysis,” in 2021 IEEE/ACM 29th International Symposium on Quality of Service (IWQOS) . IEEE, 2021, pp. 1–10

2021
[36]

Microrank: End-to-end latency issue localization with extended spectrum analysis in microservice environments,

G. Yu, P. Chen et al., “Microrank: End-to-end latency issue localization with extended spectrum analysis in microservice environments,” in Proceedings of the Web Conference 2021 , 2021, pp. 3087–3098

2021
[37]

Chain-of-thought prompting elicits reasoning in large language models,

J. Wei, X. Wang, D. Schuurmans, M. Bosma, F. Xia, E. Chi, Q. V . Le, D. Zhou et al. , “Chain-of-thought prompting elicits reasoning in large language models,” Advances in neural information processing systems , vol. 35, pp. 24 824–24 837, 2022

2022
[38]

Adaptive mixtures of local experts,

R. A. Jacobs, M. I. Jordan, S. J. Nowlan, and G. E. Hinton, “Adaptive mixtures of local experts,” Neural computation, vol. 3, no. 1, pp. 79–87, 1991

1991
[39]

Qwen2. 5 technical report,

A. Yang, B. Yang, B. Zhang, B. Hui, B. Zheng, B. Yu, C. Li, D. Liu, F. Huang, H. Wei et al. , “Qwen2. 5 technical report,” arXiv preprint arXiv:2412.15115, 2024

2024 arXiv
[40]

The llama 3 herd of models,

A. Dubey, A. Jauhri, A. Pandey, A. Kadian, A. Al-Dahle, A. Letman, A. Mathur, A. Schelten, A. Yang, A. Fan et al. , “The llama 3 herd of models,” arXiv preprint arXiv:2407.21783 , 2024

2024 arXiv
[41]

Gpt-4 technical report,

J. Achiam, S. Adler, S. Agarwal, L. Ahmad, I. Akkaya, F. L. Aleman, D. Almeida, J. Altenschmidt, S. Altman, S. Anadkat et al. , “Gpt-4 technical report,” arXiv preprint arXiv:2303.08774 , 2023

2023 arXiv
[42]

Qwen max,

“Qwen max,” https://qwenlm.github.io/blog/qwen2.5-max/, 2022

2022
[43]

Deepseek-v3 technical report,

A. Liu, B. Feng, B. Xue, B. Wang, B. Wu, C. Lu, C. Zhao, C. Deng, C. Zhang, C. Ruan et al., “Deepseek-v3 technical report,” arXiv preprint arXiv:2412.19437, 2024. 12

2024 arXiv

Pith tools

Reviewed August 6, 2026 · model on record in the stance chip above.

[1] [1]

Seer: Leveraging big data to navigate the complexity of performance debugging in cloud microservices,

Y . Gan, Y . Zhang et al. , “Seer: Leveraging big data to navigate the complexity of performance debugging in cloud microservices,” in Pro- ceedings of the twenty-fourth international conference on architectural support for programming languages and operating systems , 2019, pp. 19–33

work page 2019

[2] [2]

An open-source benchmark suite for microservices and their hardware-software implications for cloud & edge systems,

——, “An open-source benchmark suite for microservices and their hardware-software implications for cloud & edge systems,” in Proceedings of the Twenty-Fourth International Conference on Architectural Support for Programming Languages and Operating Systems, ASPLOS 2019, Providence, RI, USA, April 13-17, 2019 , I. Bahar, M. Herlihy, E. Witchel, and A. R. Le...

arXiv 2019

[3] [3]

µ suite: a benchmark suite for microservices,

A. Sriraman and T. F. Wenisch, “ µ suite: a benchmark suite for microservices,” in 2018 IEEE International Symposium on Workload Characterization (IISWC). IEEE, 2018, pp. 1–12

work page 2018

[4] [4]

Graph-based root cause analysis for service-oriented and microservice architectures,

´A. Brand ´on, M. Sol ´e, A. Hu ´elamo, D. Solans, M. S. P ´erez, and V . Munt´es-Mulero, “Graph-based root cause analysis for service-oriented and microservice architectures,” Journal of Systems and Software , vol. 159, p. 110432, 2020

work page 2020

[5] [5]

Beyer, C

B. Beyer, C. Jones, J. Petoff, and N. R. Murphy, Site Reliability Engineering: How Google Runs Production Systems , 2016. [Online]. Available: http://landing.google.com/sre/book.html

work page 2016

[6] [6]

Boosting coverage-based fault localization via graph-based representation learning,

Y . Lou, Q. Zhu, J. Dong, X. Li, Z. Sun, D. Hao, L. Zhang, and L. Zhang, “Boosting coverage-based fault localization via graph-based representation learning,” in Proceedings of the 29th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering , 2021, pp. 664–676

work page 2021

[7] [7]

Fault localization via efficient probabilistic modeling of program semantics,

M. Zeng, Y . Wu, Z. Ye, Y . Xiong, X. Zhang, and L. Zhang, “Fault localization via efficient probabilistic modeling of program semantics,” in Proceedings of the 44th International Conference on Software Engi- neering, 2022, pp. 958–969

work page 2022

[8] [8]

Micro- diag: Fine-grained performance diagnosis for microservice systems,

L. Wu, J. Tordsson, J. Bogatinovski, E. Elmroth, and O. Kao, “Micro- diag: Fine-grained performance diagnosis for microservice systems,” in 2021 IEEE/ACM International Workshop on Cloud Intelligence (Cloud- Intelligence). IEEE, 2021, pp. 31–36

work page 2021