Paper deep dive
Automating Cause-Effect Specification with Knowledge Graphs and Large Language Models
Javal Vyas, Milapji Singh Gill, Mehmet Mercangöz
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 98%
Last extracted: 7/5/2026, 7:25:04 AM
Summary
The paper proposes a semantic-AI framework to automate the generation of Cause-and-Effect (C&E) specifications for industrial processes. The framework uses a five-layer pipeline that integrates heterogeneous engineering data into a Knowledge Graph (KG) based on a modular alignment ontology (CPSMod). This KG combines functional (VDI 3682), structural (VDI 2206), behavioral (UML State Machine and OpenMath), and diagnostic (DIN 17359) knowledge. A constrained Large Language Model (LLM) then transforms the structured KG data into two complementary artifacts: human-readable operator narratives and machine-verifiable Semantic Web Rule Language (SWRL) rules. A case study on a modular process plant demonstrated that the system successfully generates consistent, semantically grounded, and conflict-free specifications, reducing manual engineering effort and improving traceability.
Entities (9)
Relation Signals (7)
LLM → generates → SWRL
confidence 100% · The LLM then transforms this information into... Semantic Web Rule Language (SWRL) rules
LLM → generates → Operator Narratives
confidence 100% · The LLM then transforms this information into operator-ready safety narratives
CauseEffectRow → hasfault → Fault
confidence 100% · :CauseEffectRow :hasFault (fault)
CauseEffectRow → hassubject → Equipment Item
confidence 100% · :CauseEffectRow :hasSubject (equipment item)
CPSMod → incorporates → DIN 17359
confidence 100% · Diagnostic concepts following ODP DIN 17359 formalize the relations between features, reference values, symptoms, and faults
CPSMod → incorporates → VDI 3682
confidence 100% · The alignment ontology (CPSMod (see Fig. 2) used in this work incorporates several complementary ODPs... Functional concepts, such as those derived from ODP VDI 3682
CPSMod → incorporates → VDI 2206
confidence 100% · Structural concepts, based on ODP VDI 2206, provide the system–module–component hierarchy
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Engineering specifications such as interlocks, alarm rationalization tables, and cause-and-effect (C&E) matrices remain central to process control and safety, yet their creation is still predominantly manual, document-driven, and prone to inconsistency. This paper presents a semantic-AI framework that automates the generation of C&E logic by combining a knowledge graph (KG) with a constrained large language model (LLM) layer. The KG builds on an established modular alignment ontology to represent process structure, operating modes, faults, symptoms, causes, and mitigation actions in a machine-interpretable form. The LLM then transforms this information into operator-ready safety narratives and Semantic Web Rule Language (SWRL) rules under strict ontology and vocabulary constraints, grounding the generated artifacts in the underlying semantic model. The workflow is demonstrated on a modular process plant, showing how engineering semantics, diagnostic relations, and machine-verifiable specifications can be generated from a unified knowledge representation with reduced manual effort.
Tags
Links
- Source: https://arxiv.org/abs/2606.31614v1
- Canonical: https://arxiv.org/abs/2606.31614v1
Trouble viewing inline? Open PDF directly →
Full Text
31,098 characters extracted from source content.
Expand or collapse full text
Automating Cause–Effect Specification with Knowledge Graphs and Large Language Models Javal Vyas,Milapji Singh Gill,Mehmet Mercang ̈oz Autonomous Industrial Systems Lab, Imperial College London, Imperial College Rd, South Kensington Campus, London, SW7 2AZ, United Kingdom Abstract:Engineering specifications such as interlocks, alarm rationalization tables, and cause- and-effect (C&E) matrices remain central to process control and safety, yet their creation is still predominantly manual, document-driven, and prone to inconsistency. This paper presents a semantic–AI framework that automates the generation of C&E logic by combining a knowledge graph (KG) with a constrained large language model (LLM) layer. The KG builds on an established modular alignment ontology to represent process structure, operating modes, faults, symptoms, causes, and mitigation actions in a machine-interpretable form. The LLM then transforms this information into operator-ready safety narratives and Semantic Web Rule Language (SWRL) rules under strict ontology and vocabulary constraints, grounding the generated artifacts in the underlying semantic model. The workflow is demonstrated on a modular process plant, showing how engineering semantics, diagnostic relations, and machine- verifiable specifications can be generated from a unified knowledge representation with reduced manual effort. Keywords:Autonomous Systems, Industrial AI, Generative AI, Knowledge Graphs. 1. INTRODUCTION Control logic, alarms, and safety instrumented functions form the backbone of industrial automation. Engineering artifacts such as interlock lists, alarm rationalization ta- bles, and cause-and-effect (C&E) matrices serve as the contractual specification between design, verification, and implementation (Fern ́andez Adiego et al. (2020)). Despite their critical role, these artifacts are typically produced through manual interpretation of P&IDs, control nar- ratives, and operational know-how (Thambirajah et al. (2009); Fern ́andez Adiego et al. (2020)). As a result, they often suffer from inconsistent semantics, limited trace- ability, and high maintenance overhead, particularly as process configurations change throughout the engineering life cycle. The increasing maturity ofsemantic technologiesand large language models (LLMs)offers a timely opportu- nity to modernize this specification workflow.Knowledge graphs (KGs), grounded in engineering ontologies, provide a machine-interpretable representation of process struc- ture, operating modes, diagnostic relations, and mitigation actions (Single et al. (2020); Gill et al. (2024)). LLMs, in turn, have shown strong capabilities in transforming structured engineering information into both formal and natural-language artifacts, with applications ranging from FMEA support (Xia et al. (2024)) to flowsheet correction (Balhorn et al. (2024)) and supervisory control in anoma- ⋆ The authors gratefully acknowledge the financial support provided by the Department of Chemical Engineering at Imperial College London for this work lous situations (Vyas and Mercang ̈oz (2025); Gill et al. (2025b)). However, KGs alone cannot autonomously derive specification logic, and free-form LLM outputs lack the guarantees of formal syntax and verifiability required for safety-critical automation. This paper addresses this gap by proposing a five-layer semantics-driven pipeline that turns heterogeneous en- gineering data into a coherent C&E specification. The pipeline produces three complementary, mutually consis- tent artifacts from a single semantic source: a formal C&E table, a set of operator narratives, and a machine-verifiable SWRL rule base. The aim is not to replace human ex- pertise but to reduce manual effort and ensure semantic coherence across these representations. The remainder of this paper is structured as follows. Sec. 2 reviews related work and outlines the research gap. Sec. 3 presents the proposed pipeline in detail. Sec. 4 introduces the case study, and Sec. 5 reports and discusses the results. Sec. 6 concludes the paper and provides an outlook on future research. 2. RELATED WORK 2.1 Semantic Models for Process and Diagnostic Knowledge Ontologies and KGs are increasingly used in process sys- tems engineering to formalize equipment hierarchies, op- erating modes, and diagnostic relations (Rupprecht et al. (2026)). Hildebrandt et al. (2020) introduced modular, standards-based Ontology Design Patterns (ODPs) for arXiv:2606.31614v1 [eess.SY] 30 Jun 2026 CPS, providing reusable building blocks for engineer- ing knowledge. Building on this, alignment ontologies grounded in established standards have been developed for corrective maintenance of CPS (Gill and Fay (2023); West- ermann et al. (2023)). At the application level, ontology- based reasoning has been used to automate HAZOP stud- ies (Single et al. (2020)). Earlier work has also lever- aged structured information models (e.g., CAEX-based plant connectivity) for plant-wide cause–effect analysis (Thambirajah et al. (2009)). More recently, the integra- tion of KGs with LLMs has supported broader process- engineering tasks such as flowsheet correction (Balhorn et al. (2024)), P&ID generation (Gowaikar et al. (2024)), and KG-driven task automation (Sakhinana et al. (2024)). Across these contributions, the focus has been on static knowledge capture or on isolated assistance functions. Limited effort has been directed toward generating ex- ecutable or machine-verifiable specification logic directly from the KG. 2.2 LLM-Based Generation of Formal Rules and C&E Logic Two research directions address the automation of formal specification artifacts. The first uses LLMs to translate domain knowledge into symbolic representations: Lau- renzi et al. (2024) show that LLMs can generate SWRL rules in enterprise settings when guided by ontology con- straints, and Soularidis et al. (2024) derive SWRL from domain texts, although without process-engineering se- mantics or KG-grounded context. Beyond rule generation, LLM agents have also been applied to related verification- oriented tasks such as PLC code synthesis (Liu et al. (2026)) and FMEA support (Xia et al. (2024)). The second targets C&E matrices directly. C&E tables remain the primary mechanism for documenting safety and interlock logic, with methodologies such as the CERN CEM-based specification (Fern ́andez Adiego et al. (2020)) providing rigorous semantics for manually authored matrices. Other automation efforts extract C&E content from P&IDs, HAZOP worksheets, or alarm databases using rule- or pattern-based techniques (Thambirajah et al. (2009); Sin- gle et al. (2020)), but rely on procedural heuristics that lack formal semantics and are therefore difficult to verify or reuse. SWRL in turn offers a reasoning-ready formalism that can be analyzed by standard engines (e.g., Jess, Drools) for conflicts, redundancies, and invariant viola- tions, yet it is rarely used as a unifying representation across system structure, diagnostic knowledge, and miti- gation logic. 2.3 Research Gap Three observations emerge: (1) ontologies provide formal models of process structure and diagnostics; (2) LLMs can synthesize symbolic artifacts and natural- language descriptions when constrained by such on- tologies; (3) C&E generation itself remains largely manual, with limited support for automated formal verification. To the authors’ knowledge, no existing framework in- tegrates these capabilities into a single workflow that automatically derivessemantically grounded,machine- verifiableC&E specifications from a process KG, while simultaneously generating operator-facing narratives and SWRL rules from the same semantic source. The present work addresses this gap by introducing a coherent pipeline. 3. PIPELINE 3.1 Overview The proposed pipeline for generating a C&E representa- tion integrates heterogeneous engineering data across five processing layers (see Fig. 1). TheData Layeraggregates distributed information from P&IDs, process documentation, PLC and control logic, simulation models, and equipment specifications. These artifacts jointly capture the functional, structural, behav- ioral, and diagnostic knowledge required to relate observ- able effects to underlying causes. In theMapping Layer, the artifacts are semantically lifted into RDF representations consistent with the align- ment ontology, using RML, R2RML, or custom mapping pipelines. This step normalizes the heterogeneous sources into a unified semantic format. The resulting RDF data is consolidated in theKnowledge Layer, where theCPSModalignment ontology integrates relevant knowledge based on established engineering and maintenance standards. The KG constructed in this layer serves as the semantic backbone of the pipeline. TheC&E Generation Layerderives a structured cause– effect representation from the KG through SPARQL queries that materialize C&E rows from the diagnostic re- lationships encoded in the ontology. The resulting C&E ta- ble is structured according to the ontology, which reduces ambiguities common in manually authored specifications. Finally, theValidation Layertranslates the formal C&E representation into operator-facing narratives and SWRL rules using a constrained LLM, and provides a human- in-the-loop review step in which domain experts inspect the generated artifacts and refine mappings or ontology assertions where necessary. The remainder of this section focuses on the two layers that constitute the principal methodological contribution: the alignment ontology underlying the Knowledge Layer (Sec. 3.2), and the methodology for C&E generation and validation (Sec. 3.3). The Data and Mapping Layers follow established practices for ontology-based data integration and are not described in further detail. 3.2 Alignment-Ontology C&E modeling in complex process plants requires a knowledge representation that goes beyond simple fault- symptom associations. To explain why certain effects occur in an engineered system, it is necessary to integrate mul- tiple forms of knowledge: how the system is functionally organized, how its components are structurally linked, how it behaves over time, and which physical laws govern its op- eration. A cause-and-effect model must therefore capture causal dependencies across several interconnected dimen- sions. Functional dependencies describe how process steps Fig. 1. Overview of the proposed C&E extraction pipeline. influence downstream operations. Structural relationships reveal how components interact and constrain one another. Behavioral dynamics determine how system states and transitions mediate effects and physical relations explain how changes in variables such as flow, level, or pressure propagate through the system. Diagnostic knowledge, fi- nally, provides the vocabulary for relating observable de- viations to underlying fault mechanisms. Such a multi-layered understanding of causation cannot be obtained from a single data artifact or modeling no- tation. Instead, it requires an integrated semantic repre- sentation that combines such knowledge into a coherent semantic model. To achieve this integration, we adopt an ontology-driven approach based on a set of ODPs aligned with established engineering and maintenance standards. These patterns provide reusable semantic building blocks that ensure conceptual consistency while allowing system knowledge to be formalized in a modular and extensible manner. In the context of this study, such an approach provides the foundation for deriving C&E representations in a principled manner: causal pathways can be extracted consistently from the ontology, and the resulting models reflect the underlying engineering semantics rather than relying on informal or heuristic interpretations. The alignment ontologyCPSMod(see Fig. 2) used in this work incorporates several complementary ODPs with re- gard to the C&E-Diagram. This alignment has been suc- cessfully applied in prior work on anomaly interpretation and knowledge-based diagnosis (Gill and Fay (2023); Gill et al. (2025a)). Functional concepts, such as those derived from ODPVDI 3682, capture the whole process, separate process operators as well as their input and output prod- ucts, energies and information, enabling the representa- tion of causal relations along the operational workflow. Structural concepts, based on ODPVDI 2206, provide the system–module–component hierarchy, which locates causal connections within the physical architecture and clarifies how failures can propagate across components. Diagnostic concepts following ODPDIN 17359formalize the relations between features, reference values, symptoms, and faults, thereby supporting the mapping between ob- servable effects and potential causes. To model both discrete and continuous behavior of the system, the alignment ontology integrates two complemen- tary behavioral ODPs. Discrete logic is represented using the ODPUML State Machine, which provides the state machine with all states, transitions, and events. These con- structs express state-dependent behavior through guard conditions and state-specific actions, enabling effects that arise only in particular operational modes to be captured explicitly. Continuous dynamics are described using the OpenMathODP, whose classes Application, Operator, and ObjectList allow mathematical relations to be encoded in structured form (Gill et al. (2025a)). Specific opera- tors are referenced viaOpenMathcontent dictionaries (e.g. calculus1withdifffor differentiation), so that complex behavior models can be represented asOpenMathapplica- tions linking actuator inputs to the evolution of measur- able outputs. Both behavioral layers are anchored in the functional model of ODPVDI 3682. A process operator (e.g., a filling step) references an associated state ma- chine for its discrete modes or attaches relevantOpenMath equations for its continuous dynamics. Process operator inputs and outputs are thereby connected to both state transitions and physical equations, yielding coherent C&E relations from manipulated variables to observable system responses. 3.3 Methodology for C&E Generation and Validation The methodology derives a machine-verifiable C&E rep- resentation from the KG. In detail the C&E generation happens with the help of theKnowledge Layer, theC&E Generation Layer, and theValidation Layer. Especially the following steps are relevant: (i) semantic modeling of diagnostic knowledge using the fault class, (i) automated materialization ofCauseEffectRowindividuals through SPARQL queries, and (i) transformation of these rows into human-readable narratives and SWRL rules using an LLM. Each step is detailed in the following. (i) Semantic Modelling of Faults, Causes, Symp- toms, and Actions:Rather than manually defining faults for each component, we use thefault classfrom ODP DIN17359 to capture recurring diagnostic patterns, including valve faults (partially open, stuck closed, leak- age), pump faults (derating, loss of prime, cavitation), VDI3682:isAssignedto VDI3682:Process Operator CPSMod:isCharacterizedByParameter VDI3682:State VDI3682:Product VDI3682:Energy VDI3682:Information VDI3682:hasOutput VDI3682:hasInput VDI3682:Process VDI3682:consistsOf VDI3682:consistsOf Process CPSMod:technicalResource Realizes VDI3682:Technical Resource VDI2206:consistsOfModule VDI2206:Mechatronic System VDI2206:Component VDI2206:consistsOfComponent VDI2206:Mathematical Model OM:Application CPSMod:consistsOf BehaviorModel CPSMod:consistsOf StrcutureModel CPSMod:SystemModel Behavior Model Function Model Structure Model Legend: VDI2206:Module VDI3682:consistsOf ProcessOperator owl:equivalent Class VDI2206:BasicSystem Diagnostic Model DIN17359:Feature DIN17359:SymptomIsExtracted FromFeature DIN17359:Symptom DescribesAnomaly DIN17359:Symptom DIN17359:Anomaly DIN17359:ParameterIsDescribed ByFeature DIN17359:Parameter DIN17359:FeatureIndicates Anomaly UMLStateMachine:UML StateMachine CPSMod:consistsOf FunctionModel DIN17359:Reference Value DIN17359:Feature IsComparedTo DIN17359:ParameterIsDescribed ByRefValue DIN17359:FaultIs Described BySymptom DIN17359:Fault DIN17359:Symptom IndicatesFault Fig. 2. Reused alignment ontology showing how process, structural, behavioural, condition, and diagnostic concepts are combined into a unified system model. pipe faults (clogging, partial obstruction), and operational anomalies (filling-time increase, emptying-time deviation). Each template specifies canonical links among faults (DIN17359:Fault), symptoms (DIN17359:Symptom), causes (DIN17359:Cause), and mitigation actions (instances of a :SafetyActionhierarchy). Templates are instantiated for concrete equipment items (e.g. inlet valves, pumps, bot- tling lines) through SPARQL UPDATE statements within theKnowledge Layer. (i) SPARQL-Based Construction ofCauseEffectRow Instances:The core of the method is the automatic construction of a formal C&E representation inside the KG. Each row is represented as an individual of class :CauseEffectRow, which connects the diagnostic and mit- igation semantics as follows: :CauseEffectRow :hasSubject (equipment item) :hasFault (fault) :hasSymptom (symptom) :hasCause (cause) :hasAction (safety action) :hasMode (operating mode) . These rows are not authored manually. Instead, a SPARQL CONSTRUCT rule traverses the diagnostic graph: •:SafetyActionindividuals are taken as entry points; •:mitigatesFaultlinks actions to the associated faults; •DIN17359:DiagnosticSubjectHasFaultidentifies the affected equipment item; •DIN17359:FaultIsDescribedBySymptomattaches symp- toms; •DIN17359:CausesFaultattaches root causes; •:occursInModeattaches operating modes (restricted to individuals of class:OperatingMode). A unique identifier is generated for each row, and the result is inserted into the KG. By construction, the resulting C&E representation: •istraceableto the underlying engineering semantics, •isconsistentwith the diagnostic and structural de- pendencies encoded in the KG, •containsno manually authored C&E logicbeyond the templates. (i) Tabular Export, Narrative, and SWRL Gen- eration:For compatibility with engineering workflows, a SPARQLSELECTquery extracts the C&E rows into a tab- ular structure with columns for diagnostic subject, fault, symptom, cause, action, and mode. Labels are resolved usingrdfs:labelor local-name extraction. Each row is then passed to an LLM under prompt constraints that pro- hibit the invention of new thresholds, tags, or equipment. The LLM produces two complementary outputs per row: a human-readable safety narrative describing the fault con- dition and the associated mitigation, and a corresponding SWRL rule that encodes the same C&E logic in a machine- processable form, referencing only classes, properties, and individuals defined in the ontology. The LLM’s role is thereforeinterpretiverather than generative: it reformu- lates the formally defined C&E logic into operator-facing text and into rule syntax while preserving the semantics encoded in the KG. 4. CASE STUDY The case study is based on a modular process plant com- posed of two interconnected production modules: a mixing module (B201–B204) for sequential filling, agitation, and transfer operations, and a bottling module (B401–B402) for buffering and dosing (see Fig. 3). Both modules consist of tanks, pumps, pipes, and valves that together implement the material flow from raw-material intake to final product dispensing. To support the evaluation, several complementary data sources are available: a simulation model providing phys- ical and control-logic behavior for nominal and faulty conditions, operational process data from real or emulated plant runs (sensor readings, actuator states, time-stamped events) stored in a relational database, and fault annota- tions in CSV format covering labels such as clogging, valve malfunction, and pump degradation. These datasets serve as input for the ontology-based integration and diagnostic reasoning steps. 5. RESULTS AND DISCUSSION The evaluation considers three aspects of the workflow: ex- traction of C&E relationships from the ontology, narrative generation, and SWRL synthesis. Each is discussed in turn before the overall findings are summarized. 5.1 C&E Extraction from the Knowledge Graph C&E relationships were extracted directly from the ontol- ogy using a SPARQL-based retrieval pipeline. The results are summarized in Table 1. A total of 15 C&E rows were obtained, covering all 8 distinct faults and all 8 diagnos- tic subjects contained in the KG population. Six unique mitigation actions were identified, including valve closures, pump trips, and fault-specific alarms. The average actions- per-fault ratio of 1.00 indicates complete mitigation cov- erage for all faults represented in the model. Table 1. C&E extraction and SWRL verifica- tion metrics. MetricValue Total C&E rows extracted from KG15 Distinct faults represented8 Distinct diagnostic subjects8 Distinct mitigating actions6 Average actions per fault1.00 Semantic grounding rate (KG entities)100% SWRL rules syntactically valid100% Detected action conflicts0 Unreachable or redundant rules0 These results confirm that the alignment ontology (CPSMod +DIN 17359+VDI 3682) provides a coherent and func- tionally complete representation of faults, symptoms, op- erating modes, and mitigation logic. Each extracted row corresponds to a meaningful causal pathway of the form Fault→Subject→Mitigating Action, which forms the foun- dation for the subsequent LLM and SWRL synthesis steps. 5.2 LLM-Generated Operator Narratives For each C&E row,gpt-4o-minigenerated a textual explanation describing the fault condition and the asso- ciated mitigation action. Because the model receives only the structured entities from the KG (fault label, subject, and required action), the generated narratives remain Fig. 3. Modular process plant used as the case study in this work, showing the main interconnected processing modules and shared utilities. grounded in the ontology and do not invent new causal relationships. A qualitative evaluation of the narratives showed that they accurately describe both the triggering condition and the intended operator response. Alarms were expressed in operational terms (e.g. “inlet valve partially open leading to increased filling time”), and shutdown actions were explained as protective safety interventions. No halluci- nated equipment or spurious failure modes were produced, demonstrating the effectiveness of constraining the LLM with KG-derived context. The narratives therefore serve as a readable companion to the formal C&E table, support- ing operator understanding and documentation workflows without compromising semantic correctness. 5.3 SWRL Rule Synthesis and Verification The final step translated each C&E row into a machine- verifiable SWRL rule. Every generated rule adhered to SWRL syntax and referenced only entities defined in the ontology, yielding a semantic grounding rate of 100%. Au- tomated verification checks were performed to detect logi- cal conflicts, such as contradictory commands on the same equipment item or rules with unsatisfiable antecedents. No conflicts, unreachable rules, or redundant rule patterns were identified. The SWRL layer therefore acts as a formal contract be- tween the KG and the final C&E table. Because each rule is both human-interpretable and machine-checkable, in- consistencies can be detected early in the workflow, before control logic is implemented in PLC or SIS hardware. This provides a level of validation that is typically unavailable in manual C&E table development. 5.4 Discussion Overall, the results demonstrate that the proposed hy- brid approach successfully unifies three traditionally dis- connected artifacts: structured engineering knowledge, human-readable narratives, and machine-verifiable SWRL specifications. Compared to classical workflows, where the matrix, its underlying risk rationale, and the operator- facing documentation are maintained as separate, man- ually synchronized artifacts, the proposed pipeline derives all three from a single semantic source. Consistency is therefore guaranteed by construction rather than enforced by review, and the diagnostic context (faults, symptoms, causes, modes) becomes part of the specification itself rather than an external annotation. The strong alignment across all three layers, with complete fault coverage, zero conflicts, and narrative consistency, suggests that the ap- proach is suitable for AI-assisted specification generation in industrial automation projects. 6. SUMMARY AND OUTLOOK This paper presented a hybrid framework that integrates a KG, LLMs, and SWRL-based reasoning to generate semantically consistent and machine-verifiable C&E spec- ifications for process automation. Engineering knowledge encoded in theCPSModalignment ontology is transformed into three complementary artifacts: a formally structured C&E table, operator-oriented natural-language narratives, and a conflict-free set of SWRL rules. The case study showed full fault coverage, accurate narrative grounding, and complete syntactic and semantic validity of the gener- ated rules, illustrating the potential of combining semantic modeling and generative AI for more reliable and auditable specification workflows. Several avenues for future work remain open. First, ex- panding the ontology population to include additional pro- cess units and more complex fault-propagation pathways would allow the framework to be validated at larger scales. Second, integrating rule execution engines or temporal reasoners could enable simulation of SWRL-driven logic under dynamic operating conditions. Third, incorporating human feedback loops, for example through reinforcement learning or structured preference models, may further im- prove narrative clarity and reduce LLM-generated am- biguities. Finally, linking the generated specifications to downstream PLC or DCS implementation pipelines would close the engineering loop, enabling end-to-end traceability from high-level requirements to executable control logic. These extensions would further strengthen the role of hybrid knowledge- and AI-based methods in the design and verification of next-generation autonomous industrial systems. REFERENCES Balhorn, L.S., Caballero, M., and Schweidtmann, A.M. (2024).Toward autocorrection of chemical process flowsheets using large language models.In F. Ma- nenti and G.V. Reklaitis (eds.),Computer Aided Chem- ical Engineering, volume 53, 3109–3114. Elsevier. doi: 10.1016/B978-0-443-28824-1.50519-6. Fern ́andez Adiego, B., Blanco Vi ̃nuela, E., Bonet, M., Charrondiere, M., Hamisch, H., Speroni, R., and de Queiroz, M. (2020).Cause-and-Effect Matrix Specifications for Safety Critical Systems at CERN. In17th International Conference on Accelerator and Large Experimental Physics Control Systems.doi: 10.18429/JACOW-ICALEPCS2019-MOPHA041. Gill, M.S. and Fay, A. (2023). Utilisation of semantic technologies for the realisation of data-driven process improvements in the maintenance, repair and overhaul of aircraft components.CEAS Aeronautical Journal, 15(2), 459–480. doi:10.1007/s13272-023-00696-5. Gill, M.S., Jeleniewski, T., Gehlhoff, F., and Fay, A. (2025a). Representing Time-Continuous Behavior of Cyber-Physical Systems in Knowledge Graphs. In2025 IEEE 30th International Conference on Emerging Tech- nologies and Factory Automation (ETFA), 1–8. IEEE. doi:10.1109/ETFA65518.2025.11205677. Gill, M.S., Vyas, J., Markaj, A., Gehlhoff, F., and Mer- cang ̈oz, M. (2025b). Leveraging LLM Agents and Dig- ital Twins for Fault Handling in Process Plants. In 2025 IEEE 30th International Conference on Emerging Technologies and Factory Automation (ETFA), 1–8. doi: 10.1109/ETFA65518.2025.11205597. Gill, M.S., Westermann, T., Steindl, G., Gehlhoff, F., and Fay, A. (2024). Integrating Ontology Design with the CRISP-DM in the Context of Cyber-Physical Systems Maintenance. In2024 IEEE 29th ETFA, 1–8. IEEE. doi:10.1109/ETFA61755.2024.10710898. Gowaikar, S., Iyengar, S., Segal, S., and Kalyanaraman, S. (2024). An Agentic Approach to Automatic Creation of P&ID Diagrams from Natural Language Descriptions. URLhttps://arxiv.org/pdf/2412.12898. Hildebrandt, C., K ̈ocher, A., Kustner, C., Lopez-Enriquez, C.M., Muller, A.W., Caesar, B., Gundlach, C.S., and Fay, A. (2020).Ontology Building for Cyber– Physical Systems: Application in the Manufacturing Domain.IEEE T-ASE, 17(3), 1266–1282.doi: 10.1109/TASE.2020.2991777. Laurenzi, E., Mathys, A., and Martin, A. (2024). An LLM- Aided Enterprise Knowledge Graph (EKG) Engineering Process.Proceedings of the AAAI Symposium Series, 3(1), 148–156. doi:10.1609/aaaiss.v3i1.31194. Liu, Z., Zeng, R., Wang, D., Peng, G., Liu, X., Liu, Q., Liu, P., Wang, W., and Wang, J. (2026). Agents4PLC: Au- tomating Closed-loop PLC Code Generation and Veri- fication in Industrial Control Systems using LLM-based Agents.IEEE Transactions on Software Engineering, 1–16. doi:10.1109/TSE.2026.3667895. Rupprecht, S., Gao, Q., Karia, T., and Schweidt- mann, A.M. (2026).Multi-agent systems for chem- ical engineering: a review and perspective.Current Opinion in Chemical Engineering, 51, 101209.doi: https://doi.org/10.1016/j.coche.2025.101209. Sakhinana, S.S., Sri Vaikunth, V., and Runkana, V. (2024). Knowledge Graph Modeling-Driven Large Lan- guage Model Operating System (LLM OS) for Task Automation in Process Engineering Problem-Solving. Proceedings of the AAAI Symposium Series, 4(1), 222– 232. doi:10.1609/aaaiss.v4i1.31796. Single, J., Schmidt, J., and Denecke, J. (2020). Ontology- based computer aid for the automation of HAZOP studies.Journal of Loss Prevention in the Process Industries, 68, 104321. doi:10.1016/j.jlp.2020.104321. Soularidis, A., Kotis, K., Lamolle, M., Mejdoul, Z., Lortal, G., and Vouros, G. (2024).LLM-Assisted Generation of SWRL Rules from Natural Language. In2024 International Conference on AI x Data and Knowledge Engineering (AIxDKE), 7–12.doi: 10.1109/AIxDKE63520.2024.00008. Thambirajah, J., Benabbas, L., Bauer, M., and Thorn- hill, N.F. (2009).Cause-and-effect analysis in chemical processes utilizing XML, plant connectiv- ity and quantitative process history.Comput- ers & Chemical Engineering, 33(2), 503–512.doi: 10.1016/j.compchemeng.2008.10.002. Vyas, J. and Mercang ̈oz, M. (2025). Autonomous Indus- trial Control using an Agentic Framework with Large Language Models.IFAC-PapersOnLine, 59(6), 349–354. doi:10.1016/j.ifacol.2025.07.170. Westermann, T., Gill, M.S., and Fay, A. (2023). Rep- resenting Timed Automata and Timing Anomalies of Cyber-Physical Production Systems in Knowledge Graphs. In2023 IEEE 49th IECON, 1–7. IEEE. doi: 10.1109/IECON51785.2023.10312156. Xia, Y., Jazdi, N., and Weyrich, M. (2024). Enhance FMEA with Large Language Models for Assisted Risk Management in Technical Processes and Products. In 2024 IEEE 29th International Conference on Emerging Technologies and Factory Automation (ETFA), 2024, 1– 4. doi:10.1109/ETFA61755.2024.10710996.