betaFeedback

WorksComputer Science

An LLM-Agentic Framework for Intelligent Work Order Management in Industrial Maintenance

Abstract

This paper presents an AI-driven framework, CodeReAct agent, designed to enhance industrial equipment maintenance through natural language (NL) interactions. The framework employs an advanced AI agentic approach to interpret human instructions, providing knowledge extraction, asset status summarization, and work order recommendations. It identifies patterns and trends and predicts work orders by standardizing industrial data into business objects (BOs) and utilizing analytical function API calls. The AI agent operates through a Thought-Action-Observation process similar to human problem-solving, automating complex analytical tasks typically performed by data scientists. Notably, the Action phase generates executable code, replacing manual coding efforts. A case study focusing on chiller maintenance demonstrates the framework's capability to analyze multiple years of work orders, and alerts and anomalies are presented. The results indicate that the AI agent framework effectively processes human utterances to analyze data, extract valuable insights, and support informed decision-making, reducing the need for data scientist involvement. By recontextualizing NLP agent frameworks in industrial engineering, the approach enables autonomous function generation and task execution across a range of domain-specific maintenance scenarios, with chillers used as a representative case study.

Introduction

Industrial asset management is a systematic approach to managing and maintaining assets such as equipment, machinery, and infrastructure to ensure optimal performance, reliability, and longevity. As industrial systems grow more complex, engineers face increasing challenges in maintaining machinery reliability and efficiency. A key concern is understanding the asset’s health and accurately predicting maintenance needs, thereby minimizing unplanned downtime and optimizing operational performance [18]. Traditional strategies, such as scheduled preventive maintenance, often fall short of these demands, as they may lead to unnecessary downtime or fail to detect emerging issues that could escalate into critical failures [7]. To address these limitations, there is a growing need for data-driven analytics [3] to support condition-based management ([5, 6]) rather than relying solely on fixed schedules based on expert recommendations.

As highlighted in Figure 1, modern IoT systems leverage sensor technology to generate vast amounts of data, creating opportunities to enhance predictive maintenance while introducing data integration and interpretation challenges. This data comes from diverse sources, including OEM alerts, AI/ML-generated statistical anomalies [12], work order requests from site engineers, and subsequent maintenance actions such as repairs or replacements performed by technicians. Integrating both digital and manually generated information presents unique challenges, such as accurately labeling work orders to reflect required maintenance, associating operational alerts and anomalies with specific sensors to derive actionable insights, and linking disparate events to improve decision-making.

Unified View of the AI Agent-Driven Framework for Event Forecasting and Predictive Maintenance in Industrial Environments

Figure 1. Unified View of the AI Agent-Driven Framework for Event Forecasting and Predictive Maintenance in Industrial Environments

Researchers in data mining and data science have developed analytical tools such as frequent/periodic pattern mining [16, 18], association rule discovery, and event prediction [25] to extract engineering and business insights. In industrial asset management, these techniques aid in analyzing maintenance trends, work order variations, and scheduling inefficiencies. For instance, understanding relationships between maintenance tasks involves recognizing recurring patterns, assessing scheduling dependencies, and optimizing task bundling to minimize downtime [15]. Additionally, linking alerts and anomalies to corrective actions is crucial for proactive condition-based maintenance [5, 6], enabling early intervention to prevent failures.

Despite the availability of advanced analytical tools [14], effectively utilizing them remains challenging—particularly when combining multiple tools for tasks beyond their original scope. Building adaptive systems that integrate new functions and handle evolving data often requires dedicated data science teams due to limitations in flexibility and scalability [21]. Recently, LLM-supported AI agents have begun transforming operations by automating workflows, such as SWE-Agent for GitHub issue resolution [20, 10, 11]. In industrial settings, LLM agents can support engineers by answering natural language queries (e.g., “How does my asset pump operate?”) and performing repetitive analysis across domains. However, challenges persist, including hallucinations, tool misuse, domain-specific language barriers, and lack of analytical grounding. Addressing these limitations is key to recontextualizing NLP agents for robust, cross-domain decision-making in industrial environments.

AI Agent in Industrial Setting

The framework illustrated in Figure 1 presents a proposed AI agent-driven system for industrial environments. The upper section of the diagram highlights key stakeholders—Facility Manager, Reliability Engineer, and Operational Engineer—who interact with the AI agent (depicted as a robot icon) via natural language (NL Utterance). The agent operates within a “Think, Act, Observe, Finish” cycle, mirroring human problem-solving while leveraging automation to enhance decision-making and streamline processes. Among the various tasks the AI agent performs, the “Event Forecasting” module is central to the system, represented by a time-series graph and a bell curve symbolizing predictions (e.g., “Today 0°”).

The bottom partition of the diagram illustrates the data flow and highlights two critical building blocks of the system. Sensor data from industrial equipment (e.g., chillers) triggers events, alerts, and maintenance actions, categorized into a “Business Object Catalog” (Events, Work Orders, Alerts, Anomalies, Failure Codes, and their mappings). Business Objects (BOs) define domain entities and enable interoperability between analytic functions. Due to the complexity of these entities, it is challenging for LLMs to comprehend them fully without structured information. However, structured BOs improve message exchange with the AI agent, enhancing data interpretation and insights. The AI agent processes this data through the “Analytical Function Catalog,” which includes domain-specific techniques such as rule-based analysis, event correlation, pattern recognition, statistical analysis, and forecasting. This processed information supports the agent’s decision-making functions and enables actionable insights that optimize maintenance strategies and operational efficiency.

In this research, we develop and validate the AI agent framework, referred to as a CodeReAct agent, through a case study in chiller maintenance. While chillers are used as a representative example, the framework generalizes across asset types such as AHUs, pumps, and generators. Our key contributions are summarized as follows: 1. Agentic Workflow Perspective: We extend the ReAct framework (Thought-Action-Observation) with coding capability to support asset-intensive analytics. The resulting agent architecture is domain-agnostic and applicable to diverse industrial scenarios requiring extensive data processing; 2. Application Perspective: By structuring industrial data into Business Objects (BOs) and applying event-driven Analytical Functions, we build a system that allows stakeholders to directly query operational insights without continuous data science support. The framework supports online deployment for periodic monitoring and proactive alerting and recommendations; 3. Algorithmic Perspective: To enhance the agent’s performance, we introduce an external reflection mechanism that integrates feedback from execution failures, enabling dynamic system prompt refinement. Additionally, an adaptive model temperature strategy improves task completion and system reliability.

Related Work

AI Agents and Action-Oriented Frameworks

The evolution of AI agents has seen significant advancements, particularly with frameworks like ReAct ([24]), which introduced reasoning-then-action strategies for structured decision-making. However, traditional approaches often rely on static output formats, such as JSON or predefined text, which limit flexibility in multi-tool integration. Similarly, LangChain has facilitated tool-based solutions for natural language processing tasks but struggles with dynamic task management in complex environments.

The CodeAct framework ([22]) advances these approaches by enabling Large Language Models (LLMs) to generate and execute Python code as actions. This innovation allows for seamless integration with Python’s ecosystem, enabling dynamic workflow adjustments and real-time multi-tool reasoning. CodeAct enhances adaptability and precision, making it especially effective in industrial applications such as predictive maintenance, where flexibility and task automation are critical.

In addition, OpenHands ([23]), provide an open platform for AI software agents that interact with digital tools in a more generalized and adaptable manner. OpenHands enables AI-driven workflows that involve web interaction, code execution, and command-line operations, extending the capabilities of existing agent-based frameworks.

Industrial Asset Event Analytics

Langbridge et al. [12] propose a novel approach leveraging Optimal Transport for efficient and unsupervised anomaly detection in industrial datasets. Their methodology enhances detection accuracy and scalability, addressing challenges in analyzing complex, high-dimensional data typical of industrial environments.

Event prediction has been central to industrial maintenance strategies, relying on advanced models to anticipate equipment failures and optimize maintenance schedules. Allen’s temporal logic ([1]) and Bayesian networks have been widely used to model dependencies between events and quantify uncertainty in predictions. Additionally, frameworks like TEILP ([26]) utilize temporal knowledge graphs to enhance event reasoning.

The integration of AI for predictive maintenance is further explored in event-driven approaches, such as those leveraging probabilistic models ([16]). Probabilistic Signal Temporal Logic (PrSTL) extends traditional temporal logic frameworks by incorporating stochastic behaviors into event analysis ([17]). Similarly, Uncertainty-Aware Signal Temporal Logic (STL-U) accounts for variability in system trajectories, enabling robust fault prediction and proactive interventions in real-world systems ([2]). These methodologies emphasize the importance of analyzing event dependencies under uncertainty to enable proactive decision-making.

Frameworks like CodeAct demonstrate how LLMs can autonomously implement predictive models and incorporate uncertainty-aware reasoning, streamlining deployment and enhancing accuracy in industrial scenarios.

Conditional-Based Management for Industrial Assets

AI-driven approaches to predictive maintenance have shown significant promise across industries. For example, Jakubowski et al. [9] highlight the role of AI in optimizing workflows and preventing equipment failures in the steel industry [9]. Adaptive conditional-based management systems, such as STL-U [2], further extend the capabilities of AI by integrating probabilistic reasoning and temporal logic into decision-making processes. STL-U enhances fault detection and maintenance scheduling by accounting for uncertainties in operational data, making it an invaluable tool for managing complex industrial systems.

Business Objects and Analytic Functions

In this section, we focus on the Business Object and Analytic Function catalogs for industrial asset management, as illustrated in Figure 1. Using a specific type of chiller — a closed-loop water-cooled chiller — as a practical example, we demonstrate how to define business objects annotated with natural language (NL) expressions. Additionally, we show how analytical functions operate on these objects to facilitate knowledge extraction, statistical analysis, and decision support, including maintenance predictions and recommendations. The efforts presented in this section lay the foundation for developing the agent-oriented solution.

Figure 2(b) provides a schematic overview of the key concepts. An equipment or asset, such as a chiller (shown in Figure 2a), consists of multiple components and typically is part of a larger system. This equipment is monitored by IoT sensors and evaluated using various metrics (e.g., performance KPIs), which help detect undesired performance or operational issues. For instance, SkySpark [19] is an IoT repository that stores sensor and meter values while generating alerts for predefined conditions. In our study, we utilize real datasets collected from 11 chillers, which serve as the foundation for developing our application.

Asset management for chiller, showing the chiller diagram, key elements of chiller asset management, standardized failure and maintenance codes, and work order events

Figure 2. (a) Chiller Diagram showing its three main components of the refrigerant cycle. (b) Key Elements of Chiller Asset Management. (c) Standardized failure or maintenance Code - Seven Categories and Total 137 Failure and Maintenance Codes. (d) Work Order Events in 2017 for Chiller 9: Preventive Maintenance (Blue - Relative Evenly Distributed) vs. Corrective Maintenance (Red - Clustered in Summer). This pattern suggests periodicity in preventive work orders and seasonal clustering of corrective maintenance tasks.

Business Objects Identification and Categorization

Business objects serve as structured entities that encapsulate domain-specific data, enabling seamless operations and efficient interactions with a Large Language Model (LLM). Defined as Python classes, these objects include detailed descriptions (Docstring), maintain standardized attributes, enforce data integrity through validation mechanisms, and provide readable string representations (__str__) to facilitate effective LLM interaction, as LLM interactions are represented as text strings.

To systematically organize business objects, they are categorized based on their role within the application ecosystem. The primary categories, with examples shown in Table 9 of Appendix § 10, include: Content Objects: Represent fundamental sequences of operational data, such as work orders, alerts, and events over time; Meta/Profile Objects: Store reference information, including asset details, failure modes with corresponding codes, and textual descriptions of failure symptoms; Relationship/Causality Objects: Capture dependencies between events and system behaviors; and Recommendation Objects: Provide suggested work orders with actionable insights and rations to support decision-making (More details can be found at Appendix § 10).

Business ObjectSourceRoleCount
Content Objects
WorkOrderMaximo ManageTracks scheduled and unscheduled maintenance tasks, categorized as preventive or corrective.4392
Alert EventsSkySparkLogs real-time alerts triggered by IoT sensors based on predefined conditions.1995
Anomaly EventsML GeneratedDetects KPI deviations using machine learning for predictive maintenance.542
EventAggregated by AuthorsConsolidates event logs for tracking and decision-making.6929
Meta/Profile Objects
ISO_Failure_CodeDeveloped by AuthorsStandardizes failure classification for structured maintenance analysis.137
ISO_Primary Failure_CodeDeveloped by AuthorsDefines primary failure categories and links related secondary codes.68
AlertRuleSME ProvidedSpecifies conditions for triggering alerts based on system behaviors.77
EquipmentSME ProvidedRepresents industrial assets, including status and specifications.22
Relationship/Causality Objects
Alert-Rule MappingRelationshipLinks alert rules to failure codes for automated diagnostics.46
Anomaly MappingRelationshipAssociates anomalies with failure-codes for predictive insights12
Recommendation Objects for Work Order Assignment
RecommendationRecommendationSuggests maintenance actions based on historical patterns.N/A

Table 9. Summary of Business Objects, Source, Role, and Number of Records

Key Business Objects

Among all business objects, we focus on three in detail: Failure and Maintenance Codes, which provide structured classification labels; Work Orders, which encompasses all work orders, and Events, which contains all recorded events.

Failure and Maintenance Code Objects:

Currently, many work orders (WOs) in industrial asset management are created manually, including those related to the chillers examined in this research. These WOs lack proper labeling, relying instead on unstructured descriptions that often contain jargon and may be incomplete.

Leveraging Large Language Models (LLMs) and the ISO standard document [8], we generate failure and maintenance codes for closed-loop water-cooled chillers. Appendix § 7 provides more details on creating failure codes. These codes serve as a standardized classification system for unstructured work orders. Since existing WOs are uncategorized, performing advanced analytical analysis without classification is challenging. Standardized failure codes ensure uniformity in maintenance records. Each failure code includes following: Category: A broad classification of maintenance activities (e.g., Maintenance and Routine Checks); Primary Code: A high-level failure category within the broader classification (e.g., Major Overhaul); Secondary Code: Specific failure details within the primary category (e.g., Compressor Overhaul); and corresponding Description: A brief explanation of the primary or secondary code.

Work Order Objects Work orders document maintenance activities—whether preventive or corrective—while providing essential details such as issue descriptions, associated equipment, priorities, and estimated versus actual labor hours. These objects originate from the work order management system in Maximo Manage ([13]). To enable analytical analysis, we developed a method to label previously “unlabeled” work orders with failure and maintenance codes (Appendix § 7). This classification enhances data structure, enabling more effective insights and decision-making.

Event Objects Event objects consolidate operational occurrences, including maintenance interventions, equipment failures, and system alerts. Unlike isolated work orders or alerts, event objects offer

a holistic view of system behavior by aggregating time-series data from multiple sources. These objects serve as a crucial link between individual maintenance tasks and broader operational trends. Analyzing event objects allows us to identify recurring patterns, correlate alerts and anomalies with failures, and refine maintenance strategies. Such event-based insights enhance failure prediction and provide contextual awareness, supporting proactive maintenance planning.

Analytic Functions

We develop a set of analytic and operational functions (also refer to Appendix § 11) tailored for work order applications, leveraging diverse business objects. Firstly, we created Knowledge Extraction Functions. These functions include retrieving work orders and events, filtering preventive and corrective work orders, and categorizing them based on specified equipment and date ranges. For event extraction, the function retrieves events associated with the selected equipment, event types, and time frame, outputting the results as a string or a pickle path for the agent to process.

Secondly, we developed Statistical Functions. Those functions in the framework analyze historical maintenance data to extract insights that enhance predictive maintenance, optimize asset reliability, and support data-driven decision-making.

Work order distribution analysis quantifies the frequency of failure codes across equipment and time periods, helping prioritize recurring issues and allocate resources efficiently. Temporal relationship identification applies Allen’s Interval Algebra to classify maintenance event sequences (e.g., before, after, overlaps), providing a structured understanding of event dependencies and enabling proactive interventions when alerts consistently precede failures. Additionally, repeated work order pattern detection identifies cyclic failure intervals, ensuring preventive maintenance schedules align with actual degradation trends rather than fixed time-based schedules. These statistical functions integrate seamlessly into the event-driven framework, allowing AI-driven agents to analyze event sequences, predict upcoming maintenance needs, and refine scheduling strategies. The experiments completed in § 5 demonstrates their impact in improving failure forecasting, reducing maintenance costs, and enhancing overall system reliability.

Thirdly, we had Decision Support Functions - (more details available at Appendix § 11). These functions are designed to optimize decision-making by enabling predictive work order generation, alert-and anomaly-based recommendations, and bundled work order identification. Prediction of Future Work Orders Utilizes historical maintenance data to forecast the likelihood of various work order types within a specific timeframe, supporting proactive scheduling and resource planning; Work Order Recommendations from Alerts Analyzes rule-based alerts, mapping them to failure categories and prioritizing based on alert frequency and severity to ensure timely preventive maintenance; Work Order Recommendations from KPI Anomalies: Generates corrective maintenance actions by linking key performance indicator anomalies (high or low and frequency) to predefined failure categories and descriptions; and Identification of Work Order Bundles: Suggest grouping related work orders within a set period to consolidate tasks, reduce redundancy, and optimize resource utilization. The next section discusses integrating the BOs and analytic functions into a CodeReAct agent framework.

Solution Framework - Integration with CodeReAct Agent

Our solution is built upon the CodeReAct framework that integrates the Thought-Act-Observation process over a large language model (LLM) agent. Unlike the typical ReAct agent, our CodeReAct agent functions as a mini-programmer to glue an utterance, BOs, and analytical functions together to complete a task.

Framework of CodeReAct Agent

We introduce the key concepts of the framework as follows:Utterance: An utterance is a written query that serves as an input for task requirements (examples are available in Table 10). To ensure clarity and efficiency, each utterance must include: 1) an asset specification, 2) an intended action (e.g., retrieval, summarization, analysis, prediction), 3) a defined time frame (required), and 4) relevant constraints (optional); System Prompt: To ensure that CodeReAct agents can correctly execute an utterance, we integrate business objects and analytic function API knowledge into the system prompt (as shown in Figure 3b). Additionally, the inclusion of a block Python code guides the agent’s Thought-Action-Observation process, detailing how to: 1) analyze information, 2) execute actions (via API calls or code), and 3) observe results and generate a final response; and Agent Process Flow: Figure 3a illustrates the CodeReAct agent’s workflow, highlighting its interactions with user input, system prompts, memory, application functions, and business object (BO) data to produce structured outputs. The workflow integrates intermediate reasoning steps within the LLM and employs a code generation and execution step (“Action”) to dynamically process tasks.

Overview of CodeReAct Agent, Agentic Process, and Online Agent Deployment

Figure 3. Overview of CodeReAct Agent, Agentic Process, and Online Agent Deployment

UtteranceCategoryExampleCount [IDs]
Get Work Orders"I would like to check the work order distribution for the equipment labeled as CU02013 for the year 2017 based on primary code." (ID: 1) "I would like to retrieve the corrective work order details for the equipment labeled as CU02013 for the year 2017." (ID: 3)4 [0, 1, 2, 3]
Summarize Events"Provide a summary of all events for equipment CU02009 in June 2020, categorized by work order, alert, and anomaly." (ID: 5)7 [4, 5, 6, 7, 8, 9, 10]
Find Important Alerts"Given that 80% of alerts are likely spurious, can you identify the meaningful 20% for further analysis for any chillers?" (ID: 27)1 [27]
Review Past Issues"In May and June 2020, numerous anomalies and alerts were reported for Chiller 9 (equipment ID CU02009). Could you review them and suggest appropriate work orders or actions?" (ID: 21)4 [20, 21, 22, 23]
Detect Early Failures"We are developing an early detection system for potential condenser waterside fouling in Chiller 9. Monitor Chiller 9 at the POKMAIN site from 2020-04-20T12:30:00 to 2020-05-12T19:30:00, identify anomalous behaviors, and provide a work order recommendation if no corrective work order has already been created." (ID: 34)3 [30, 33, 34]
Predict Work Orders"Assuming the current date is 2018-01-02, can you predict the next work order probability for equipment CU02009?" (ID: 14)3 [12, 13, 14]
Recommend Work Orders"An anomaly, ’KPI Cooling Load above upper bound,’ has been detected for equipment CU02009. Can you recommend the top three work orders to address this issue?" (ID: 17)5 [15, 16, 17, 18, 19]
Bundle Work Orders"Can you provide guidance on bundling corrective work orders to optimize the maintenance schedule for Chiller 9 (equipment ID CU02009) for the years 2017, 2018, and 2019? Each bundle should occur within two weeks, include at least two work orders, and detail each bundle’s specifics." (ID: 24)2 [11, 24]
Analyze Anomalies and Alerts"How can I analyze anomalies across multiple KPIs to better diagnose the root cause of these issues?" (ID: 25)5 [25, 26, 28, 29, 35]

Table 10. Categorization and Examples of Utterances

A natural question arises: what are the advantages of CodeReAct compared to regular ReAct when interacting with pre-defined tools? As illustrated in Figure 3a, Figure 3b, and Figure 3c, CodeReAct first annotate system prompt with Python code block instruction. This is followed by a run-time Python code block generation and execution during the utterance processing. Such Python code blocks enhance efficiency, facilitate seamless data exchange, and improve flexibility, making CodeReAct superior to text-based ReAct for multi-step reasoning and analytics. We summarize the advantages as follows: (1) Functions as ReAct Tools, acting as dynamic, reusable operations; (2) **Seamless MultiTool Integration, combining APIs, business logic, and analytics in a single step; (3) Self-Sufficient Execution, enabling code generation and execution on demand; (4) Reduced LLM Calls, allowing complex reasoning within one call; (5) Supports Multi-Entity Operations, such as batch processing; and (6) Facilitates Data Integration & Exchange, including string-based BOs, Pickle serialization, and Python-based object exchange.

An illustrated example of run-time flow is provided in Figure 3c to outline the CodeReAct process, which follows the inner loop of Thought-Action-Observation with outer iteration(s), concluding with a final review. To enhance transparency, we present the detailed algorithm in Algorithm 1 (detailed in Appendix § 8). To ensure accurate responses to utterances while balancing computational resource requirements, we introduce several innovative enhancements into Algorithm 1. These include: a) detecting deadlocks in the inner loop, b) incorporating a review agent to evaluate and categorize outcomes, c) dynamically refining the system prompt for subsequent iterations, and d) adjusting the LLM model’s temperature across iterations to optimize response diversity and stability.

This flexible approach serves as the foundation for our experiments in the next section.

System for Automated Real-Time Work Order Management

Building on these advantages, we implement an online work order management system to operationalize CodeReAct’s capabilities in real-time asset management. This agent automates work order processing by integrating real-time data analytics and asset management insights (Figure 3d). Operating within a structured process flow defined by a configuration template, it delivers prioritized tasks, failure insights, and maintenance recommendations. A selected set of utterances ensures meaningful insights, aligning with the needs of the facility manager, reliability engineer, and operation engineer. The system’s workflow consists of the following steps as shown in Figure 3d.

Experiments

This section evaluates the proposed framework through structured experiments, assessing its capabilities based on various combinations of parameters (Table 1), focusing on utterance design and performance analysis. Additional details of the machine used and utterance execution time can be found at Appendix § 15.

ParameterCandidateDescription
CodeReAct ModelGranite, Mistral-LargeThe LLM are used for processing input questions, generating solutions, and executing actions.
Review ModelGranite, Mistral-LargeThe LLM is used to review the trajectory of a whole iteration and decide whether the task is completed.
Inner Loop10, 20Number of steps in the inner loop of iteration
LLM Temperature0, 0.1, 0.3, 0.5Controls thought-act-observation process; A higher values expected to break the deadlock of execution.
Outer loop1, 3, 5Maximum number of reflections to refine execution with update system prompt if iteration > 1.

Table 1. Experiment Parameters

Utterance Selection and Category

Thirty-six utterances have been carefully crafted to encompass various chiller maintenance tasks, as outlined in Table 10 (See Appendix § 10), while incorporating the utilization of BOs and analytical functions discussed in § 3.2. To ensure clarity and efficiency, each utterance must include key elements such as asset specification, intended action (e.g., retrieval, analysis, prediction), a defined time frame, and relevant constraints if required.

Table 10 categorizes representative natural language utterances related to work order analysis into nine distinct types, including requests to retrieve, summarize, or predict work order data. These categories capture user intents such as getting or reviewing work orders, detecting failures early, analyzing anomalies, and recommending actions. Each category is illustrated with examples and mapped to a set of labeled IDs, providing a foundation for training intent classification or response generation models in industrial asset management scenarios.

Experiment Results

The evaluation consists of three set of experiments. 1) Problem-Solving Evaluation, which assesses the framework’s ability to generate appropriate and insightful responses using the utterances in Table 11; 2) Adaptive Capability Assessment, which evaluates the framework’s capabilities in address an utterance task with the absent of analytic function APIs; and 3) Business Applicability Validation, which focuses on a real-world chiller maintenance scenario. Table 1 outlines the parameters used in these experiments.

UtternanceContext and Additional Information
Utternance 1: “Given the recent maintenance history of Chiller 13 and the last two years of work order data, what is the most likely next work order type within the next two months?”• Context Definition: Recent maintenance actions on Chiller 13, including routine checks and specific repairs. • Event Specification: Focuses on predicting the next work order type based on historical data. • Temporal Frame: Two-month forecast period. • Prediction Request: Most likely next work order type. • Expected Output Format: A ranked list of work order types with probabilities.
Utternance 2: “What has been the distribution of work event types for Chiller 13 over the past year, and how might this inform the scheduling of future maintenance?”• Context Definition: Operational context of Chiller 13 over the past year, including all recorded WOs. • Event Specification: Analysis of the distribution of WO event types (e.g., routine maintenance, emergency repairs, system alerts). • Temporal Frame: The past year. • Insight Request: Analysis to inform future maintenance scheduling. • Expected Output Format: Summary report or visualization showing the frequency and types of WO events.
Alert Type (Occurrences)Work Orders (Occurrences and Percentage)
CR00007 - Load Low (11)MT011: Calibration (12, 31.58%), MT010: Oil Analysis (11 occurrences, 28.95%), MT013: Vibration Analysis (11, 28.95%), MT004: Refrigerant Addition (4, 10.53%)
CR00008 - Evaporator Approach High (183)MT013: Vibration Analysis (301, 37.30%), MT011: Calibration (213, 26.39%), MT010: Oil Analysis (110, 13.63%), MT004: Refrigerant Addition (105, 13.01%), MT001: Routine Maintenance (64, 7.93%), MT009: Refrigerant Transfer (7, 0.87%), MT003: Lubrication (5, 0.62%), E006: VFD (Variable Frequency Drive) Failure (2, 0.25%)
CR00012 - Chiller Cycling (77)MT010: Oil Analysis (68, 31.34%), MT004: Refrigerant Addition (42, 19.35%), MT001: Routine Maintenance (40, 18.43%), MT013: Vibration Analysis (29, 13.36%), MT003: Lubrication (26, 11.98%), MT011: Calibration, (9, 4.15%), M009: Actuator Failure, (3, 1.38%)

Table 11. Example Utterances

Problem-Solving Capability

In this study, we evaluate the framework’s ability to complete tasks specified by the thirty-six utterances. First, we employ a review agent to assess the response of a task. The review agent classifies the response to Accomplished, Partial Accomplished and Not Accomplished. If the review result is classified as Accomplished, we then examine the execution trajectory to verify that the correct functions are invoked with the appropriate parameters. Tasks that do not meet these criteria are listed in Table 2 and Table 3. Our experiments show that CodeReAct’s performance can be progressively enhanced by leveraging outer iterations, where new reflections are incorporated into subsequent iterations through the updated system prompt. The results are summarized in Figure 4. Additionally, the total number of Thought-Act-Observation steps follows a long-tail distribution, as shown in Figure 5a, primarily due to deadlocks and difficulties in breaking out of repetitive loops.

ID-Review Message
1PReturned file path instead of JSON output.
11NSyntax errors prevented work order retrieval.
13NIncorrect date types and insufficient data.
15NMontuned string error blocked execution.
17NUndefined functions and classes caused failure.
24NFailed to bundle work orders due to missing var.
27NDid not identify faults due to improper filtering.
29NInvalid code blocked warning message generation.
30NImport error prevented execution of functions.
33NNo relevant data found for work order reco.

Table 2. Granite-8-1-8b Unaccomplished Tasks (Success rate 72%, without Extra Outer Iteration/Reflection)

IDSReview Message
2NSyntax errors in JSON caused looping.
3NDatetime handling led to repetitive failures.
4NRepeated syntax errors prevented valid JSON.
8PLooping errors in JSON formatting.
9NIncomplete code execution with syntax errors.
11NIncorrect file path returned not the bundled WOs.
12NUnterminated string literal caused repetitive failures.
13NJSON formatting errors led to invalid responses.
15NLooping due to undefined variable ’total_work_orders’.
17NFailure to initialize ’recommended_primary_codes’ correctly.
18NIncorrect API handling caused repeated failures.
20NLooping in JSON formatting.
24NFailure to execute ‘find_bundles‘ function correctly.
31NSyntax error in JSON formatting caused looping.
34PFailure to check corrective WOs and recommend one.

Table 3. Mistral-Large Unaccomplished Tasks (Success rate 56%, without Extra Outer Iteration/Reflection)

Distribution of # Steps Utilized for Utterances and Temperatures/Reflections on Performance

Figure 5. (a) Distribution of # Steps Utilized for Utterances (T=0, Iteration=5); (b) Temperatures/Reflections on Performance (Mistral-Large)

Impact of Outer Reflection

Figure 4. Impact of Outer Reflection (T=0, Inner step = 20)

To address these challenges, we incrementally increase the model temperature, which improves completion rates (Figure 5b) alongside additional iterations. These insights enable us to refine the execution algorithm (Algorithm 1) by introducing controlled variation in code generation (Action step) through a gradual increase in model temperature as iterations progress.

Code Adaptive Capability Assessment

The adaptability relies on the description of the system prompt (details in Figure 3b. This experiment introduces a structured methodology to assess the adaptability by updating the system prompt. We selected six tasks with varying levels of complexity, as shown in Table 4. The corresponding ut-

CategoryIDUU+U++
Get Work Orders (distribution)1Yes--
Get Work Orders (filtering)3Yes--
Summarize Events5Yes--
Bundle Work Orders324HallYes-Yes
Predict Work Orders414NoNoHall

Table 4. Code Adaptability Assessment5

Figure 5: Performances (T=0, Inner step = 20)

terances are presented in Table 10. To streamline the evaluation, we removed all analytical function descriptions, retaining only two essential functions for retrieving work orders and events, along with the descriptions of business objects (BOs).

Next, we introduce additional guidelines to two challenging utterances to assess CodeReAct’s capabilities to complete tasks without relying on predefined functions. We denote U as the original utterance, while U+ and U++ represent utterances with progressively detailed instructions (as shown in Table 5). The results, summarized in Table 4, indicate that CodeReAct, without assistance from analytical function APIs, successfully handles filtering and summarizing tasks. However, it encounters challenges in solving bundling and work order prediction tasks. By incorporating additional guidelines in the extended utterances, only the bundling task is effectively accomplished.

CategoryU+ UtteranceU++ Utterance (trimmed)
Bundle Work Orders (ID 24)(U) + Bundles should not have overlap.(U, U+) + Group corrective work orders based on actual finish dates within an allowed time gap. Discard bundles with only one work order.
Predict Work Orders (ID 14)(U) + Using a Markov approach and specify the state with the primary failure code.(U, U+) + Use a Markov model to forecast work orders based on state transitions from historical data and update predictions using transition probabilities.

Table 5. Updated Utterances

Ablation Study: Impact of the Act Only without Thought

To evaluate the role of reasoning in CodeReAct, we conducted an ablation by removing the Thought step, leaving only Act–Observe (akin to CodeAct).

Using the Granite-3.1-8b model and 36 utterances, we observed a sharp drop in task completion when reasoning was removed (Table 6). Each configuration was tested with a fixed temperature of 0.0, 20 inner-loop steps, and varying outer-loop iterations ({1, 3, 5}). This highlights that executable code alone is insufficient; intermediate reasoning is essential for grounding actions and improving reliability.

Outer ItersFullAct-OnlyDrop
12412-50%
32816-43%
52920-31%

Table 6. Task completion with and without Thought step

Conclusion

In this paper, we present CodeReAct, an LLM-driven agentic framework that automates industrial work order analytics through executable code generation and natural language interaction. The system reveals actionable maintenance patterns—such as seasonal trends, key alert impacts, and bundling opportunities—demonstrated through a chiller case study (Appendix F). While evaluated on chillers, the framework generalizes to AHUs, pumps, generators, and other industrial assets, illustrating its cross-domain applicability. By recontextualizing NLP agent frameworks for operational decision-making, CodeReAct shows how NLP advances can extend beyond traditional language tasks. Future work includes refining the business object and analytic function framework and conducting self-consistency testing to improve robustness across varied utterances and real-world settings.

Failure Code Generation and Work Order Normalization Categorization

CategoryDetails
Asset InformationAsset ID (equipment identifier), Location, and Site
Work DetailsWork Description (task explanation), Work Type (e.g., Emergency, Preventive, Predictive)
PrioritiesWork Priority (urgency of the task), Asset Priority (importance of the equipment)
SchedulingReported Date, Target Start/Finish, Actual Finish, Duration, Actual Labor Hours
Work StatusStatus of the task (e.g., Pending, Ready to Start, Completed)
Linked DataConnects to asset details for consistency (e.g., location, priority, attributes)

Table 7. Work Order Data Categories

This effort includes three steps. The first step is to prepare a consistent three-level hierarchical failure or maintenance code. This is followed by automatic work order labeling using the work order description and the failure or maintenance codes. Finally, based on the alert description, we associate each alert with the failure or maintenance codes.

As shown in Figure 6, the failure or maintenance code generation process begins with Large Language Models (LLMs) extracting knowledge from ISO 14224-2016 [8]. This knowledge is used to generate an initial set of failure or maintenance codes, organized into three level hierarchy (see Figure 2c).

failure or maintenance Code Generation with LLM

Figure 6. failure or maintenance Code Generation with LLM

The failure or maintenance codes generated using ISO document may not fully cover all client scenarios. To address this, the work order descriptions with low confidence in failure or maintenance code assignment is analyzed. The low-confidence cases prompt the generation of additional failure or maintenance codes, which are incorporated and refined through context-match comparisons.

To address this, we leverage large language model (LLM) to suggest potential failure or maintenance codes based on the descriptions of the rules triggering the alerts. The LLM analyzes the rule descriptions and context within the alerts, aiding in establishing a more precise link between the alert signals and the likely failure or maintenance code(s). For example, an alert indicating that a chiller’s load is too low may correspond to multiple potential failure or maintenance codes related to performance issues.

CodeDescription
MT006Major Overhaul
MT006aCompressor Overhaul
MT013Vibration Analysis
MT013bRoutine Vibration Analysis
MT014Filter Replacement
MT014cWater Filter Replacement

Table 8. Examples of Primary & Secondary Codes (Category: Maintenance and Routine Checks)

CodeReAct Algorithm with Outer Loop of Iteration for Refinement

The CodeReAct Algorithm (Algorithm 1) is designed to process natural language queries (utterances) by iteratively generating code, executing it, and refining the approach based on observations. A key feature of this algorithm is its ability to execute generated Python code, such as data processing and function API calls, during the Action Execution phase. The algorithm breaks the inner loop if a deadlock is detected in the thought-action-observation cycle. It proceeds to the review phase, updating the system prompt with reflections for the next iteration.

Algorithm 1 CodeReAct Algorithm with Outer
Loop of Iteration for Refinement

1: Input: query (Natural Language Utterance)
2: Parameters: LLM models, max_steps,
   max_reflection_loops, list of temperatures (optional)
3: Output: Final result (JSON or Pickle format)
4: Initialize the system prompt with query
5: for reflection_loop = 1 to max_reflection_loops do
6:   for step = 1 to max_steps do
7:     Thought Generation:
8:       Generate a structured thought based
       on the query and previous thought-act-
       observation step
9:       Plan coding actions needed to com-
       plete the task
10:    Action Execution:
11:      Execute the generated Python code
       (e.g., data processing), function API calls
12:    Observation:
13:      Analyze the output of the executed ac-
       tion
14:      Record observations (e.g., counts of
       work orders, alerts, anomalies, sugges-
       tions)
15:    if deadlock detected then
16:      Break the inner loop and proceed to the
       review phase
17:    end if
18:  end for
19:  Review the entire trajectory of this iteration,
    and classify results as: Accomplished, Par-
    tially Accomplished or Not Accomplished
20:  if result == Accomplished then
21:    Break the outer loop and proceed to final-
     ize output
22:  else
23:    Update the system prompt with reflec-
     tion
24:  end if
25: end for
26: Generate final output, save as JSON with op-

Prompt Design

To enable the CodeReAct agent to generate executable code in response to natural language queries, we adopt a few-shot prompting strategy. These few-shot examples serve as scaffolding, demonstrating how to decompose a user query into structured reasoning and corresponding code. This approach is crucial for grounding the agent’s behavior, ensuring that it produces valid, context-aware actions when solving domain-specific analytical tasks.

Each few-shot example is structured around the Thought-Action-Observation (TAO) framework, where the agent:

  • Interprets a natural language question.

  • Generates intermediate Thoughts to plan the task.

  • Produces executable Python Actions.

  • Observes execution outputs or errors (Observation).

  • Concludes with a structured Final Answer.

These few-shot trajectories are included in the system prompt to condition the language model and guide its reasoning and code generation. The following example illustrates how the agent processes a work order retrieval request:

Listing 1: Few-Shot Prompt Example: Preventive Work Order Retrieval

Question: I would like to retrieve the
preventive work order details
for the equipment labeled as CU02013 for
the year 2017.
Store the result in a file and provide a
pointer to the file.

Thought 1: Retrieve all work orders
using `get_work_orders`,
then filter for preventive ones with `
    filter_preventive_work_orders`.

Action 1:

equipment = Equipment(equipment_id="
    CU02013")
date_range = DateRange(start_date=Date("
    2017-01-01"), end_date=Date("
    2017-12-31"))

work_orders_pickle_path =
    get_work_orders(equipment,
        date_range)
with open(work_orders_pickle_path, "rb")
    as file:
    work_orders = pickle.load(file)

preventive_work_orders =
    filter_preventive_work_orders(
        work_orders)

Thought 2: Store the filtered results in a JSON file.

Action 2:

file_path = "
    preventive_work_orders_CU02013_2017.
    json"
preventive_work_orders_dict = [vars(pwo)
    for pwo in preventive_work_orders]

# Handle datetime serialization
for pwo in preventive_work_orders_dict:
    pwo['actual_finish'] = pwo['
        actual_finish'].strftime('%Y-%m
        -%d %H:%M:%S')

with open(file_path, "w") as file:
    json.dump(
        preventive_work_orders_dict,
        file, indent=4)

Thought 3: Return the file path as a structured final answer.

Action 3: Final Answer:

{
    "file_path": "
        preventive_work_orders_CU02013_2017
        .json"
}

This example demonstrates how few-shot prompts enable the agent to reason through multi-step queries, recover from execution failures (e.g., timestamp serialization), and produce valid structured outputs.

In addition, the system prompt provides the agent with contextual information, tool descriptions, iteration strategy, and formatting requirements. The agent is positioned as an expert analyst with access to APIs that retrieve and analyze industrial maintenance data. We define a standalone Python file that includes the domain-specific business object definitions (e.g., WorkOrder, Event, and FailureCode DateRange) and API function signatures used in the work order and alert analysis tasks. This file intentionally omits execution logic, serving instead as an interface specification that informs the language model of the available data types and callable operations. The file is embedded directly into the system prompt, enabling the agent to generate valid, type-aware Python code in alignment with the system’s analytical APIs. The detailed discussion of the Businsss objects and the functions can be found at Section 3 and Appendix D.

Summary and Categorization of Business Objects and Utterances

This appendix provides additional context on the business object taxonomy and utterance patterns used in the CodeReAct framework.

Business objects, summarized in Table 9, form a structured taxonomy for industrial asset management. They are categorized into four types: Content Objects, Meta/Profile Objects, Relationship/Causality Objects, and Recommendation Objects. These objects represent key entities such as work orders, alerts, equipment metadata, and failure codes, each playing a distinct role in data collection, standardization, event linking, and decision support.

Utterances, shown in Table 10, capture common natural language queries aimed at gaining insights into asset behavior. These include tasks such as reviewing past issues, detecting early failures, and recommending maintenance actions. Each utterance is tied to a specific analytic intent and typically involves the functional use of one or more business objects for reasoning, retrieval, or forecasting.

Together, the taxonomy of business objects and categorization of utterances define a unified framework for mapping user intents to structured analytic procedures in the CodeReAct system.

Event Representation and Analytic Functionalities

Machine learning and deep learning algorithms are widely used to predict and forecast water-cooled chiller power consumption, with ML offering simplicity and interpretability, while DL provides higher accuracy for complex, time-series data. Comparative studies highlight the trade-offs between these approaches and emphasize the importance of data quality, model design, and real-time

applicability [4]. We now define two building blocks for implementing LLM agentic workflow: a) Unified Events and b: Tasks (or Tools). Events represent the core data aspect, whereas tasks enable the extraction of descriptive, predictive, and relational insights from the events.

Unified Events Representation

We combined work order and alert events to create a richer dataset. Mathematically, we can define the unified event as follows:

e=(i,t,d,a,g,k)(1)e = (i,t,d,a,g,k) \tag*{(1)}
  • ii: Event ID

  • tt: Start timestamp of the event

  • dd: Duration of the event

  • aa: Asset, equipment or component

  • gg: Event group based on Preventive or Corrective Action or Allert, and Anomaly, (value of P, C, A1, An)

  • kk: Type of events (Failure/Maintenance code for repair or maintenance work order, alert rule for alerts)

This enriched dataset allows for comprehensive analysis and filtering, enabling the identification of patterns and relationships between different events. For example, it can reveal which alerts (g=ALERTg = ALERT) are most predictive of certain work orders (g=WORK_ORDERg = WORK\_ORDER), or the time intervals between recurring alerts and subsequent maintenance activities. Such insights are crucial for identifying the root causes of failures and enhancing the system’s ability to predict future maintenance needs.

Event Pair Relationship Formulation

By leveraging Allen’s Interval Algebra, we can deepen our understanding of event sequences, anticipate potential issues, and optimize the scheduling of maintenance activities. To better reflect practical scenarios, we will refine the logic of Allen’s Interval Algebra. This refinement ensures that relationships like “before” and “after” are evaluated within a time range, say Δ\Delta a month, that accurately mirrors the physical reality, thereby confirming that the events are genuinely related and relevant to the maintenance context. Let E={e1,e2,…,en}E = \{e_1, e_2, \ldots, e_n\} be the set of all events in a given context. For any two events e1=(i1,t1,d1,a1,g1,k1)e_1 = (i_1, t_1, d_1, a_1, g_1, k_1) and e2=(i2,t2,d2,a2,g2,k2)e_2 = (i_2, t_2, d_2, a_2, g_2, k_2) from EE, their temporal relationship can be described by Allen’s Interval Algebra. The three interesting relationships in our problem setting are:

  • Before: e1e_1 ends before e2e_2 starts.

e1 before e2⟺(t1+d1)<t2 and (t2−t1)≤Δe_1\ \text{before}\ e_2 \Longleftrightarrow(t_1 + d_1) < t_2\ \text{and}\ (t_2 - t_1) \le\Delta
  • Overlaps: e1e_1 starts before e2e_2, and e2e_2 starts before e1e_1 ends.

e1 overlaps e2⟺t1≤t2≤t1+d1e_1\ \text{overlaps}\ e_2 \Longleftrightarrow t_1 \le t_2 \le t_1 + d_1
  • During: e1e_1 starts after e2e_2 starts and ends before e2e_2 ends.

e1 during e2⟺t2≤t1 and t1+d1≤t2+d2e_1\ \text{during}\ e_2 \Longleftrightarrow t_2 \le t_1\ \text{and}\ t_1 + d_1 \le t_2 + d_2

In practice, this mathematical framework is applied to analyze the temporal sequence of maintenance work orders and sensor-generated alerts. For instance:

  • Before: If an alert (e.g., temperature exceeding a threshold) occurs before a maintenance work order, this may indicate a predictable sequence where the alert triggers maintenance.

  • Overlaps: If two work orders overlap, it may indicate simultaneous maintenance activities, which could require coordinated resource allocation.

  • During: An alert occurring during a work order may suggest the need for immediate attention or adjustment during maintenance activities.

Predicting the Next Work Order with Markov Approach

A key concern in asset management is anticipating the next necessary work orders. Various algorithms can be employed for this prediction. This task uses a Markov approach to leverage historical work orders to forecast the likelihood of upcoming work order types.

  • State Space: Let S={s1,s2,…,sn}S = \{s_1, s_2, \ldots, s_n\} be the set of all possible work order types.

  • Transition Probability Matrix: Define the transition probability matrix PP, where each element PijP_{ij} is given by:

Pij=Pr⁡(Xt+1=sj∣Xt=si)(2)P_{ij} = \Pr(X_{t+1} = s_j \mid X_t = s_i) \tag*{(2)}
  • Initial State: The initial state distribution π0\pi_0 is defined as:

π0(si)=Pr⁡(X0=si)\pi_0(s_i) = \Pr(X_0 = s_i)
  • Prediction of Next Work Order Type: Given the current work order type Xt=siX_t = s_i, the predicted next work order X^t+1\hat{X}_{t+1} is:

X^t+1=arg⁡max⁡sj∈SPij(3)\hat{X}_{t+1} = \arg\max_{s_j \in S} P_{ij} \tag*{(3)}
  • Recurrence Relation: The probability distribution over the next work order Xt+1X_{t+1} can be computed as:

πt+1=πt⋅P(4)\pi_{t+1} = \pi_t \cdot P \tag*{(4)}

Bundle Identification

We define the bundle identification process mathematically to group work orders based on their actual finish dates. The selected work orders (WO) are corrective ones.

Input Definitions

Let:

  • W={w1,w2,…,wn}W = \{w_1, w_2, \ldots, w_n\} be the set of corrective work orders, where each work order wiw_i has an associated completion date TiT_i.

  • TiT_i represents the actual finish date of work order wiw_i.

  • Δ\Delta represents the maximum allowable interval (in days) between consecutive work orders for them to be grouped in the same bundle.

  • BkB_k represents the kk-th bundle.

Sorting Step

The work orders are sorted in ascending order based on their actual finish dates:

T1≤T2≤⋯≤Tn.(5)T_1 \leq T_2 \leq\cdots\leq T_n. \tag*{(5)}

Bundling Process

The bundling process follows these steps:

  • Initialize the first bundle:

B1={w1},b1=1,(6)B_1 = \{w_1\}, \quad b_1 = 1, \tag*{(6)}

where b1b_1 is the bundle identifier.

  • For each work order wiw_i with i>1i > 1, compute the time difference between its finish time and that of the previous work order:

δi=Ti−Ti−1.(7)\delta_i = T_i - T_{i-1}. \tag*{(7)}
  • If δi≤Δ\delta_i \leq\Delta, add wiw_i to the current bundle:

Bk=Bk∪{wi}.(8)B_k = B_k \cup\{w_i\}. \tag*{(8)}
  • If δi>Δ\delta_i > \Delta, start a new bundle:

Bk+1={wi},bk+1=bk+1.(9)B_{k+1} = \{w_i\}, \quad b_{k+1} = b_k + 1. \tag*{(9)}

Filtering Step (Removing Single-Element Bundles)

After forming all bundles, remove any bundle BkB_k where:

∣Bk∣=1.(10)|B_k| = 1. \tag*{(10)}

Final Output

The algorithm returns a set of bundles:

B={B1,B2,…,Bm},(11)B = \{B_1, B_2, \ldots, B_m\}, \tag*{(11)}

where each bundle BkB_k contains at least two work orders grouped according to the interval constraint Δ\Delta, ensuring that single-element bundles are excluded.

Insight for the Chill Application

The utterance or utternance structure is designed to assess the capabilities of language models in forecasting maintenance events and analyzing work order distributions. This approach simulates real-world scenarios where predictions or insights are crucial for effective asset management. A typical utternance is structured as follows:

  1. Context Definition: Establish the operational context, such as the current status and maintenance history of a specific asset. For example, “Chiller 13 has undergone routine maintenance and a compressor overhaul in the past six months.”

  1. Event Specification: Specify the maintenance event or sequence of events to be predicted or analyzed, such as work orders or alerts. For instance, “Predict the next work order type based on recent maintenance activities and sensor alerts.”

  1. Temporal Frame: Define the period of interest, such as a retrospective analysis of the past year or a forecast for the next quarter. For example, “What is the likely next work order type within the next two months?”

  1. Prediction or Insight Request: Request a prediction or analysis, asking the model to forecast the next maintenance action or analyze the distribution of past work orders to identify patterns or inefficiencies. For instance, “Predict the next work order type for Chiller 13.”

  1. Expected Output Format: Specify the expected format of the output, such as a probability distribution, summary report, or list of maintenance recommendations. For example, “Provide a ranked list of likely work order types with associated probabilities.”

Similarly, the following utterances/results can be framed to leverage the capabilities of tools specified in Table 11.

  • Allen Relationship Identification:

    • Utternance: “What are the temporal relationships between recent work orders and alerts for Chiller 9?”

  • Result: The distributions of WOs (aggregated over alert types). Table 12 shows the results for Chiller 9.

  • Work Order Bundling:

    • Utternance: “Which corrective work orders for Chiller 9 can be bundled in the next maintenance window?”

    • Result: For Chiller 9 and 13, we found 5 and 4 bundles respectively with bundle size from 2 to 6. Within a bundle, the two consecutive WOs have their interval less than a week.

  • Identify Repeated Patterns for Work Orders:

    • Utternance: “Are there any repeated maintenance intervals for Chiller 13 that suggest recurring issues?”

    • Result: No obvious repeated pattern found for Chiller 9 and 13 for any failure/maintenance code.

Insights of Work Orders Management

As a business case, we analyze the maintenance patterns of Chiller 9 and 13 using historical work orders and alerts to assess the framework’s adaptability and predictive capabilities. Structured queries

(utterances) enable the system to identify maintenance trends, predict future work orders, and evaluate the impact of alerts on corrective actions.

Figures of 7a and 7b show the work order (WO) distributions for Chiller 9 and 13 and identify their different patterns. Chiller 9 has a more varied distribution, with "Freon Management" leading at 30.4% and several other tasks, like "Leak Detection" and "Calibration." In contrast, for Chiller 13, "Routine Maintenance" dominates WO activities at 68.3%, with "Leak Detection" and "Oil Analysis" each at 7.3%. These distributions highlight the emphasis on routine tasks in one scenario (Chiller 13), while the other (Chiller 9) shows a more varied maintenance approach with significant attention to multiple activities.

As shown in Figures of 7c and 7d, we benchmarked the performance of next WO type prediction for Chiller 9 and 13. The 29.4% (versus 65.4%) of the predictions correctly matched the immediate next work order for Chiller 9 (versus Chiller 13), with the accuracy decreasing as the sequence progressed. Notably, 14.7% (versus 8.6%) of work orders did not appear within the predicted list, indicated by a match position of -9, reflecting cases where the model failed to capture the actual next work order. To generate this result, We utilized a sliding window of two years of historical WO to create a WO-specific Markov model, allowing the model to adapt to potential changes in the chiller’s operation. We selected the previous two years of data for each work order in the dataset to build the Markov model, ensuring that the predictions reflected recent operational trends. The model was then used to predict the next work order type based on the current one.

Additional Implementation Details - Computing Environment and Runtime

All experiments were conducted on a MacBook Pro (16-inch, 2021) with an Apple M1 Max chip, 64 GB of unified memory, and macOS Sonoma 14.4.1. Each natural language utterance was processed through multi-step agent reasoning and code generation. The inference runtime varied by task complexity: standard queries typically completed in under 30 seconds, while more complex tasks requiring iterative Python code synthesis and validation could take up to 2 minutes. To reduce unnecessary computation, we implemented an early stopping mechanism to terminate the agent’s reasoning loop once valid output was produced. No large-scale training was performed, and energy usage was not directly measured, but the hardware and task scope result in moderate resource demand suitable for laptop deployment.

Distribution of WOs for Chiller 9

(a) Distribution of WOs for Chiller 9 (Total 69 WOs)

Distribution of WOs for Chiller 13

(b) Distribution of WOs for Chiller 13 (Total 82 WOs)

Matching Positions of Predicted WO Type(s) Versus True WO Type for Chiller 9

(c) Matching Positions of Predicted WO Type(s) Versus True WO Type for Chiller 9

Matching Positions of Predicted WO Type(s) Versus True WO Type for Chiller 13

(d) Matching Positions of Predicted WO Type(s) Versus True WO Type for Chiller 13

Figure 7. Visualization of the Distribution of Work Orders and Matching Positions for Next Work Order Prediction

References

  1. [1]James F. Allen. 1983. Maintaining knowledge about temporal intervals. Communications of the ACM, 26(11):832–843.
  2. [2]Nasim Baharisangari, Jean-Raphaël Gaglione, Daniel Neider, Ufuk Topcu, and Zhe Xu. 2021. Uncertainty-aware signal temporal logic inference. Preprint, arXiv:2105.11545.arxiv.org/abs/2105.11545
  3. [3]Farhad Balali, Jessie Nouri, Adel Nasiri, and Tian Zhao. 2020. Data Intensive Industrial Asset Management. Springer.DOI
  4. [4]Elsa Chaerun Nisa and Yean-Der Kuan. 2021. Comparative assessment to predict and forecast water-cooled chiller power consumption using machine learning and deep learning algorithms. Sustainability, 13(2):744.DOI
  5. [5]Chen Chuang, LU Ningyun, Jiang Bin, and Xing Yin. 2020. Condition-based maintenance optimization for continuously monitored degrading systems under imperfect maintenance actions. Journal of Systems Engineering and Electronics, 31(4):841–851.DOI
  6. [6]Deepam Goyal, Abhineet Saini, SS Dhami, BS Pabla, and 1 others. 2016. Intelligent predictive maintenance of dynamic systems using condition monitoring and signal processing techniques—a review. In 2016 international conference on advances in computing, communication, & automation (ICACCA)(Spring), pages 1–6. IEEE.
  7. [7]Ramesh Gulati and Ricky Smith. 2009. Maintenance and reliability best practices. Industrial Press Inc.
  8. [8]International Organization for Standardization (ISO). 2016. Petroleum and Natural Gas Industries — Collection and Exchange of Reliability and Maintenance Data. International Standard.
  9. [9]Jakub Jakubowski, Natalia Wojak-Strzelecka, Rita P. Ribeiro, Sepideh Pashami, Szymon Bobek, Joao Gama, and Grzegorz J Nalepa. 2024. Artificial intelligence approaches for predictive maintenance in the steel industry: A survey. Preprint, arXiv:2405.12785.arxiv.org/abs/2405.12785
  10. [10]Carlos E Jimenez, John Yang, Alexander Wettig, Xingyao Wang, Boxuan Li, Yufan Song, Frank F Xu, Shunyu Yao, Kexin Pei, Ofir Press, and Karthik Narasimhan. 2023. Swe-bench: Can language models resolve real-world github issues?, 2024. URL https://arxiv.org/abs/2310.06770.
  11. [11]Ricardo La Rosa, Corey Hulse, and Bangdi Liu. 2024. Can github issues be solved with tree of thoughts? arXiv preprint arXiv:2405.13057.
  12. [12]Abigail Langbridge, Fearghal O’Doncha, James T Rayfield, and Bradley Eck. 2024. Optimal transport for efficient, unsupervised anomaly detection on industrial data. In 2024 IEEE International Conference on Big Data (BigData), pages 2142–2151. IEEE.
  13. [13]Maximo Manage. 2024. Maximo manage. https://www.ibm.com/products/maximo. Accessed: 2024-09-02.
  14. [14]T McGuire, M Ariker, and M Roggendorf. 2013. Making data analytics work: Three key challenges. McKinsey & Company.
  15. [15]Leland Gerson Neuberg. 2003. Causality: models, reasoning, and inference, by judea pearl, cambridge university press, 2000. Econometric Theory, 19(4):675–685.
  16. [16]Petros Petsinis, Athanasios Naskos, and Anastasios Gounaris. 2021. Analysis of key flavors of event-driven predictive maintenance using logs of phenomena described by weibull distributions. Preprint, arXiv:2107.03033.
  17. [17]Dorsa Sadigh and Ashish Kapoor. 2016. Safe control under uncertainty with probabilistic signal temporal logic. In Proceedings of Robotics: Science and Systems XII.arxiv.org/abs/1510.07313
  18. [18]Oscar Serradilla, Ekhi Zugasti, Jon Rodriguez, and Urko Zurutuza. 2022. Deep learning models for predictive maintenance: a survey, comparison, challenges and prospects. Applied Intelligence, 52(10):10934–10964.
  19. [19]Skyspark. 2024. Skyspark. https://www.skyfoundry.com/product. Accessed: 2024-09-02.
  20. [20]Wei Tao, Yucheng Zhou, Yanlin Wang, Wenqiang Zhang, Hongyu Zhang, and Yu Cheng. 2024. Magis: Llm-based multi-agent framework for github issue resolution. arXiv preprint arXiv:2403.17927.
  21. [21]Abdel-Rahman H Tawil, Muhidin Mohamed, Xavier Schmoor, Konstantinos Vlachos, and Diana Haidar. 2024. Trends and challenges towards effective data-driven decision making in uk small and medium-sized enterprises: Case studies and lessons learnt from the analysis of 85 small and medium-sized enterprises. Big Data and Cognitive Computing, 8(7):79.
  22. [22]Xingyao Wang, Yangyi Chen, Lifan Yuan, Yizhe Zhang, Yunzhu Li, Hao Peng, and Heng Ji. 2024a. Executable code actions elicit better llm agents. arXiv preprint arXiv:2402.01030.
  23. [23]Xingyao Wang, Boxuan Li, Yufan Song, Frank F Xu, Xiangru Tang, Mingchen Zhuge, Jiayi Pan, Yueqi Song, Bowen Li, Jaskirat Singh, and 1 others. 2024b. Openhands: An open platform for ai software developers as generalist agents. arXiv preprint arXiv:2407.16741.
  24. [24]Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik Narasimhan, and Yuan Cao. 2022. React: Synergizing reasoning and acting in language models. ArXiv, abs/2210.03629.
  25. [25]Chenchen Ye, Ziniu Hu, Yihe Deng, Zijie Huang, Mingyu Derek Ma, Yanqiao Zhu, and Wei Wang. 2024. Mirai: Evaluating llm agents for event forecasting. Preprint, arXiv:2407.01231.
  26. [26]Zhuosheng Zhang, Aston Zhang, Mu Li, and Alex Smola. 2023. Automatic chain of thought prompting in large language models. In The Eleventh International Conference on Learning Representations.

Paper details

vlnc:W_7qt4afdq
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 10

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents