Auto-Diagnose: Symptom-to-Cause Inference

• Auto-diagnose is a family of systems that infer fault causes from observable symptoms using diverse channels like audio, text, and telemetry.
• These systems integrate heterogeneous sensing, machine learning, and rule-based reasoning to address complex diagnostic challenges.
• Outputs include fault localization, actionable recommendations, and explanations, significantly reducing troubleshooting efforts in varied domains.

Searching arXiv for relevant papers on automatic diagnosis across domains. Auto-diagnose denotes automated diagnosis systems that identify a fault class, probable cause, or repair action from observable effects or symptoms. In the literature, the observation channel ranges from cough audio, automobile sounds, and multilingual textual claims to TCP packet traces, UDS responses, cloud telemetry, timed test traces, and simulation outputs; the output ranges from screening labels and ranked retrieval results to fault localization, mitigation actions, and reconfiguration diagnoses (Bales et al., 2020, Morrison et al., 2019, Pavlopoulos et al., 2022, Widanapathirana et al., 2012, Zhang et al., 2022, Demarne et al., 2024, Becker et al., 2022, Jiang et al., 13 Mar 2026). This suggests that auto-diagnose is best treated as a family of symptom-to-cause inference systems rather than as a single end-to-end model.

1. Scope and problem formulation

The core formulation is symptom-based: a diagnosis system identifies faults by investigating observable effects, categorizes the fault into a diagnosis class, and estimates a probable cause (0909.2375). The motivating pressure is consistent across domains. In complex cloud products, manual diagnosis does not scale because engineers must inspect many siloed tools, knowledge is fragmented across troubleshooting guides and dashboards, and incidents are repeatedly misassigned or rerouted across teams (Demarne et al., 2024). In autonomous driving and automotive software, diagnosis must account for heterogeneous components, timing requirements, inter-component dependencies, and vehicle state (Orf et al., 2024, Becker et al., 2022). In client-network settings and private clouds, troubleshooting is labor-intensive and often must proceed without privileged access to the endpoint (Widanapathirana et al., 2012, Widanapathirana et al., 2012). In respiratory screening, cough is an early common symptom but is not specific enough for a human listener to distinguish bronchitis, bronchiolitis, pertussis, or a non-cough event at home (Bales et al., 2020).

Across these settings, the hidden fault is not observed directly. What varies is the operational substrate: enterprise telemetry, ECU service responses, packet-level behavior, symptom text, audio events, timed traces, or simulation trajectories. The constant is the need to move from a partial symptom signature to an interpretable diagnosis.

2. Observation channels and representation layers

Auto-diagnose systems diverge first at the sensing and representation layer. The literature includes direct protocol queries, packet-trace statistics, text normalization pipelines, embedding-based audio retrieval, CNN-ready spectrograms, symbolic state sets, and dynamic dependency graphs (Zhang et al., 2022, Widanapathirana et al., 2012, 0909.2375, Morrison et al., 2019, Bales et al., 2020, Becker et al., 2022, Weiß et al., 25 Jul 2025).

Domain	Observation channel	Representation
Respiratory screening	Raw environmental audio and single cough events	Grayscale Mel-spectrograms from 5-second and 2-second clips (Bales et al., 2020)
Automotive sound diagnosis	User recording plus where/when context	960 ms slices at 16 kHz, VGGish two-layer features, cosine similarity (Morrison et al., 2019)
Automotive infotainment faults	Textual symptom descriptions	Stop-word removal, stemming, weighted term vectors, cosine similarity (0909.2375)
Client-network diagnosis	TCP packet traces at client and server	140 statistical parameters per trace, 280 combined features (Widanapathirana et al., 2012)
Vehicle ECU diagnosis	UDS request/response traffic	DTCs, additional fault parameters, sensor and ECU state (Zhang et al., 2022)
Connected and software-defined vehicles	Traces, metrics, logs, pod metadata	Dependency graphs, causal graphs, multimodal embeddings (Weiß et al., 25 Jul 2025, Weiß et al., 14 Jun 2026)

Text-centric systems show two distinct representation regimes. In automotive infotainment diagnosis, the text is reduced to a weighted occurrence vector after domain-specific stop-word removal and stemming (0909.2375). In multilingual fleet fault management, the input is a 1,357-way classification problem over 452,071 texts in 38 languages, handled by multilingual or translation-based Transformer models (Pavlopoulos et al., 2022). Network diagnosis uses per-connection statistical signatures rather than implementation-specific TCP internals, while UDS-based vehicle diagnosis relies on standardized diagnostic services such as session control, security access, and Read DTC Information (Widanapathirana et al., 2012, Zhang et al., 2022).

Graph-based systems add a structural layer above raw observability. SDVDiag continuously derives dependencies from traces and augments them with anomaly annotations and causal relations; the multimodal extension adds fused log-based and metric-based service representations before graph construction (Weiß et al., 25 Jul 2025, Weiß et al., 14 Jun 2026). Formal automotive test diagnosis instead represents execution as symbolic configurations and timed traces, with proof objects becoming diagnostic artifacts in their own right (Becker et al., 2022).

3. Inference architectures and formal mechanisms

The simplest auto-diagnose mechanisms are similarity-based. For automotive infotainment text, the chosen method is cosine similarity over weighted term vectors:

$$\text{Cos similarity}(A,B)= \frac{\sum_i a_i F_i(A)F_i(B)}{\sqrt{\sum_i a_i^2F_i(A)^2}\sqrt{\sum_i a_i^2F_i(B)^2}}$$

where $a_i$ are user-determined parameters or weights, approximately around 1 (0909.2375). OtoMechanic uses a related retrieval logic over audio: VGGish embeddings are averaged over slices, cosine similarity ranks database recordings, and optional where/when filters reduce the candidate set before retrieval (Morrison et al., 2019).

Classifier cascades are common when the diagnostic task decomposes naturally. The cough framework uses two separate CNNs rather than a single end-to-end network: a binary cough/non-cough detector on 5-second clips and a multiclass diagnosis CNN on 2-second cough events (Bales et al., 2020). The IACD system uses a two-stage inference pipeline with a Link Problem Detection classifier followed, only on healthy links, by a Client Fault Diagnostic network of binary soft-margin SVM classifiers (Widanapathirana et al., 2012). DeepDiagnosis instruments the training loop of a DNN through a callback in fit(), monitors eight symptom types, and invokes a decision-tree-based Mapping() procedure with 24 rules to map symptom, location, and layer to seven repair classes (Wardat et al., 2021).

Rule-based and expert-guided reasoning remain central when domain knowledge is explicit. Expert PC Troubleshooter stores production rules of the form “IF $A$ AND $B$ THEN $C > D$” and adds a fuzzy-logic module for POST beep errors plus an intelligent agent for knowledge acquisition (Bassil, 2012). ARCAS encodes troubleshooting logic as YAML-based Auto-TSGs modeled as directed acyclic graphs with triggers, checks, explanations, and actions; telemetry queries expand context, and equivalent steps can be deduplicated when their required context matches (Demarne et al., 2024). UDS-based diagnostic communication systems rely less on statistical inference than on standardized session, security, and service semantics (Zhang et al., 2022).

At larger scale, aggregation and causal reasoning dominate. The modular autonomous-driving framework aggregates local module states over

$$\delta = \{ OK,\ WARNING,\ ERROR,\ IGNORE,\ UNKNOWN \}$$

and makes aggregation both dependency-aware and state-aware (Orf et al., 2024). SDVDiag constructs runtime dependency graphs, causal graphs, and incident snapshots, then traverses them by first-order random walk, second-order random walk, or Fault Tree Analysis to rank likely causes (Weiß et al., 25 Jul 2025). The multimodal SDVDiag extension first fuses log and metric embeddings into a shared latent space and then reconstructs causal graphs by cosine similarity before RLHF-based refinement (Weiß et al., 14 Jun 2026).

Formal-methods approaches replace learned similarity with proof-theoretic diagnosis. The model-based classification algorithm for failing automotive software traces uses symbolic execution, Hoare logic, strongest postconditions, weakest preconditions, and proof templates to localize divergence, remove irrelevant witness segments, and classify explanations by equivalence of atomic clock constraints (Becker et al., 2022). For reconfiguration, FlexDiag defines a diagnosis as

$$\Delta \subseteq S \text{ such that } S - \Delta \cup C \cup R_\rho \text{ is consistent,}$$

and exposes an anytime trade-off through the granularity parameter $m$, which reduces consistency checks at the cost of minimality and accuracy (Felfernig et al., 2021). ADIOSS applies a different formalization to system simulations: module-version switches are embedded into a design of experiments, and faulty modules are isolated either through MixED-DMD with sparse corrective matrices and autoencoder latent spaces or through the simpler NoDyn regression workflow (Jiang et al., 13 Mar 2026).

4. Diagnostic outputs, explanation, and action

The output of auto-diagnose is rarely just a class label. OtoMechanic returns the top 3 most similar recordings, the diagnosis attached to each, a similarity/confidence estimate, and curated web links for follow-up research (Morrison et al., 2019). DeepDiagnosis reports the symptom type, affected layer, stage, and a directly actionable recommendation such as changing the activation function, learning rate, optimizer, initialization, loss function, layer number, or training data (Wardat et al., 2021). The PET scanner FDD system merges random-forest posterior probabilities with CLIPS-based rule explanations and adds a prioritization layer based on channel health and spatial clustering, with fuzzy cluster-size terms SMALL, MEDIUM, LARGE, and HUGE (Charest et al., 2014).

Operational systems frequently couple diagnosis with orchestration. ARCAS actions can modify incident state, route tickets, increase severity, create incidents, cancel a management operation, reboot processes, or apply feature switches; the LLM ranks Auto-TSG findings and decides what to show, hide, or trigger automatically (Demarne et al., 2024). UDS-based systems emphasize visual interpretation of DTCs, freeze-frame or contextual data, and live ECU parameters rather than opaque prediction alone (Zhang et al., 2022). In the AD shuttle framework, subsystem states are shown in the human-machine interface, and if an ERROR appears in critical maneuver components the vehicle decelerates immediately by $1\ \text{m/s}^2$ (Orf et al., 2024).

This suggests that auto-diagnose often includes explanation, prioritization, and intervention planning as first-class outputs. The diagnosis engine is therefore only one layer in a broader troubleshooting workflow.

5. Representative systems and reported performance

Reported performance varies with domain, supervision regime, and evaluation protocol, but several systems provide concrete evidence that automated diagnosis can outperform unaided manual reasoning or materially reduce troubleshooting effort.

System	Diagnostic task	Reported result
Cough-audio framework	Cough detection and three-way respiratory diagnosis	Detection accuracy 89.05%; diagnosis accuracy 89.60% (Bales et al., 2020)
OtoMechanic	Auditory automobile diagnosis with context-aware retrieval	Human baseline 37.2%; humans using OtoMechanic 57.0%; oracle 58.7% (Morrison et al., 2019)
IACD	Client-side network fault diagnosis from TCP traces	98% client-fault diagnosis accuracy in healthy links (Widanapathirana et al., 2012)
DeepDiagnosis	DNN fault detection, localization, symptoms, and fixes	46/53 buggy models identified; 34 fault locations; 37 symptoms; 28 actionable fixes (Wardat et al., 2021)
Automotive multilingual fault diagnosis	1,357-way fault classification from 38 languages	More than 80% for high-frequency classes; above 60% for above-low-frequency classes (Pavlopoulos et al., 2022)
LabPET FDD	Channel fault detection and diagnosis	Sensitivity of 99.3% for major faults; Balanced Accuracy of 92% (Charest et al., 2014)

System-level platforms report operational rather than purely classification-centric impact. By 2023, ARCAS had accumulated more than 1,000 total Auto-TSG steps, made thousands of API calls and tens of thousands of Auto-TSG executions in one month, and was estimated to save roughly 10–15 engineers for Azure Synapse and Microsoft Fabric Synapse Data Warehouse alone (Demarne et al., 2024). In software-defined vehicles, the multimodal SDVDiag pipeline produced sparser causal graphs than a metrics-only baseline, with 134 vs. 182 edges on average, and showed a 2.4-fold improvement in edge-weighted reward after 60 human-feedback queries; in an end-to-end fault-injection scenario it recovered a true root cause located two causal hops upstream of the observable symptom (Weiß et al., 14 Jun 2026).

6. Limits, misconceptions, and open problems

A recurrent misconception is that auto-diagnose necessarily means a fully autonomous end-to-end classifier. The literature contradicts that view. The cough system is presented as a screening aid rather than a definitive diagnostic tool (Bales et al., 2020). OtoMechanic is explicitly retrieval-based rather than a pure classifier (Morrison et al., 2019). ARCAS may skip actions or surface them as recommendations when confidence is low or findings conflict, and the online SDVDiag trigger defaults to an operator confirmation prompt after 5 seconds of sustained anomaly, although that confirmation can be disabled (Demarne et al., 2024, Weiß et al., 14 Jun 2026).

Another misconception is that more automation eliminates knowledge engineering. Several systems remain strongly dependent on curated knowledge. ARCAS is only as good as the Auto-TSGs written by humans (Demarne et al., 2024). Expert PC Troubleshooter relies on a rule-base, fuzzy rules, and a self-learning agent that acquires additional rules from web sources rather than learning diagnosis directly from raw operational data (Bassil, 2012). The automotive formal-methods classifier cannot detect bugs that depend solely on hidden internal ECU events not visible in traces, because the implementation handles such requirements by over-approximating with nondeterminism (Becker et al., 2022).

Data quality and evaluation scope remain major constraints. The cough diagnosis dataset is small and imbalanced, and the authors caution that recording-context bias may influence results (Bales et al., 2020). The IACD studies are performed in controlled environments and cannot diagnose unknown faults absent from the training signature database (Widanapathirana et al., 2012, Widanapathirana et al., 2012). The multimodal SDVDiag evaluation is conducted on a testbed with seven microservices and only one end-to-end fault trace, so scaling remains to be characterized (Weiß et al., 14 Jun 2026). The earlier SDVDiag platform reports that anomaly detection improved over time through feedback and retraining, but does not provide a precise false-positive rate (Weiß et al., 25 Jul 2025).

A final limitation is the persistent trade-off between speed, minimality, and completeness. FlexDiag makes this explicit: higher $m$ yields fewer consistency checks and faster execution, but diagnosis quality degrades in terms of minimality and, potentially, accuracy (Felfernig et al., 2021). Similar trade-offs appear implicitly in shallow CNNs chosen for computational efficiency, context filters used to shrink retrieval spaces, and causal-graph pruning steps used to suppress spurious paths (Bales et al., 2020, Morrison et al., 2019, Weiß et al., 25 Jul 2025).

Taken together, these systems indicate a broad technical convergence. Auto-diagnose increasingly combines heterogeneous observability, structured context, curated domain knowledge, and selective automation of action. This suggests that the dominant research direction is not a single universal diagnostic model, but integrated pipelines that couple sensing, representation, reasoning, explanation, and operational response.