FacProcessTwin: An LLM-Based System for Process Twin Development

FacProcessTwin is an LLM-based system that significantly accelerates the development of process twins by automatically generating accurate process models from documentation and binding them to live data, while employing human-in-the-loop governance to ensure safety-critical decision accuracy in real-world manufacturing environments.

The Gist

Imagine a factory floor as a giant, complex recipe book. Every time a product is made—whether it's a jar of sauce, a frozen meal, or a carton of milk—there is a specific sequence of steps, machines, and settings required to make it safely.

For a long time, creating a "Process Twin" (a digital, real-time copy of this entire recipe) has been like trying to build a perfect map of a city by hand, one street at a time. It's slow, expensive, and requires experts to sit down and manually write down every detail of how the machines talk to each other. If the recipe changes, you have to redraw the whole map.

FacProcessTwin is a new system that acts like a super-smart, fast-reading assistant who can look at the factory's messy, human-written instruction manuals and instantly build that digital map for you.

Here is how it works, broken down into simple parts:

1. The Problem: The "Lost in Translation" Gap

Factories have two types of information:

• The Manuals: Written documents (PDFs, Word files) that describe how to make products. These are written for humans, full of sentences and tables, not code.
• The Machines: Real-time data streams (temperatures, speeds, pressures) coming from the actual equipment.

The hard part has always been connecting the two. You need to take a sentence like "Heat the mixture to 80 degrees" and link it to the specific sensor on the specific machine that measures that heat. Doing this manually is tedious. Doing it automatically with AI is risky because if the AI guesses wrong on a critical safety step (like sterilization), it could be dangerous.

2. The Solution: The "Smart Chef" Assistant

FacProcessTwin uses a Large Language Model (LLM)—think of it as a very advanced, super-fast reader—to solve this.

• Reading the Recipe: Instead of needing perfect, machine-readable diagrams, the system reads the factory's normal documents (prose and tables) just like a human would.
• Drawing the Map: It figures out the steps (e.g., "Wash," "Cook," "Pack") and draws a flowchart.
• Connecting the Dots: It looks at the live data coming from the machines and tries to match the right data point to the right step on the map.

3. The Safety Net: The "Human-in-the-Loop"

This is the most important part. The system knows it isn't perfect.

• The "Guessing" Trap: If the AI is 100% sure, it connects the data automatically.
• The "Pause" Button: If the AI sees something ambiguous (e.g., "There are two temperature sensors here; which one belongs to this step?"), it stops. It doesn't guess. Instead, it turns to a human factory operator and asks, "Hey, which one is it?"

Think of it like a self-driving car that knows when it's confused. Instead of swerving blindly, it asks the passenger for directions. This ensures that dangerous mistakes never happen silently.

4. The Results: Fast, Accurate, and Safe

The researchers tested this system on a real Australian food factory with 16 different production lines (making chilled, frozen, and shelf-stable foods).

• Speed: It built a complete digital twin in about 5 minutes per process. Doing the same thing by hand took about 32 minutes. That's a six-fold speed-up.
• Accuracy: The digital maps it created were 95% accurate compared to the "ground truth" (the perfect, known-correct models).
• Safety: When the system faced a confusing choice between two sensors, a standard AI (without the human safety net) would guess wrong 75% of the time. FacProcessTwin, by asking the human, got it 0% wrong.

The Bottom Line

FacProcessTwin proves that you don't need expensive, perfect engineering diagrams to create a digital twin of a factory. You just need the normal documents the factory already has and a smart system that knows when to ask a human for help. It turns a weeks-long, expensive project into a quick, safe, and automated task.

Technical Summary

Technical Summary: FacProcessTwin

Problem Statement
While digital twins are increasingly deployed for monitoring individual assets, process twins—which provide real-time representations of entire production processes including steps, equipment, and variations—offer greater potential for efficiency gains. However, developing a process twin is currently costly and time-consuming. It requires two labor-intensive tasks: (1) modeling the production process from tacit knowledge and unstructured documentation (prose, tables), and (2) binding that model to live operational data. Prior automation efforts rely on structured engineering artifacts (e.g., P&IDs, AutomationML) that many plants lack, or they operate existing twins rather than developing them. Furthermore, automating the binding of data tags to process steps is hazardous; an autonomous agent guessing at ambiguous tags in safety-critical contexts can introduce silent errors that compromise the twin's validity and safety.

Methodology: FacProcessTwin
The authors present FacProcessTwin, an end-to-end system that leverages Large Language Models (LLMs) to develop process twins directly from a plant's narrative documentation and natural-language operator input. The system operates on the principle that process knowledge exists in plants but is dispersed across unstructured documents and operator tacit knowledge.

The system architecture follows a five-stage pipeline, executed within a human-in-the-loop (HITL) governance framework:

1. Ingestion: The system reads process documentation (PDF/DOCX), extracting text and tables to identify candidate product flows.
2. Process Graph Construction: An LLM recovers the sequence of process steps. A deterministic tool then computes the layout and renders an interactive process diagram.
3. Tag Discovery: The system connects to OPC UA servers to list available data tags, employing vendor-specific fallbacks to handle discovery failures.
4. Binding: This is the critical safety stage. The system attempts to bind OPC UA tags to process nodes.
   • Deterministic Logic: If a tag clearly matches a step, the binding is created.
   • HITL Governance: If a tag is ambiguous (e.g., multiple temperature tags for a single sterilization step), the system pauses and queries the operator rather than guessing.
5. Streaming: Once confirmed, the system subscribes to tags, streams live data to the diagram, and stores readings in a historian.

The design ensures safety by restricting the LLM's "free judgment" to proposing steps and bindings, while deterministic tools execute all changes. The system is extensible, allowing new document formats or protocols to be added as tools without altering the core loop.

Key Contributions

1. System Proposal: FacProcessTwin is the first system to develop a complete, data-bound process twin directly from narrative documentation and operator input, automating both process modeling and data binding.
2. Evaluation: The system was evaluated on a real-world dataset from an Australian food manufacturer, covering 16 production process flows (chilled, frozen, and aseptic) with known ground-truth models. The evaluation tested accuracy, safety-critical binding behavior, and development effort across four different LLM backbones.

Results

• Accuracy: FacProcessTwin generated process models with a mean Topology F1 score of 95.2% against ground truth. Sequence accuracy averaged 90.2%, and control-point accuracy (safety labels) was 96.4%.
• Safety and Governance: In a human-in-the-loop ablation study, a single-pass baseline (without HITL) mis-bound 75.0% of ambiguous, safety-critical tags. FacProcessTwin, by deferring these decisions to operators, reduced the false-mapping rate to 0% on these critical tags.
• Efficiency: The system reduced development time by approximately 83.6%, building a twin in roughly 5.2 minutes per flow compared to 31.8 minutes for manual modeling (a sixfold speed-up).
• Robustness: Results remained consistent (within ±1%) across different LLM backbones (Gemini, GPT, DeepSeek, MiniMax), indicating the system's performance is driven by the governance policy rather than a specific model.

Significance and Claims
The paper claims that FacProcessTwin makes process twin development practical for mid-sized manufacturers by:

• Lowering Barriers: Enabling the creation of accurate twins directly from existing, unstructured documentation without requiring pre-existing machine-readable engineering models.
• Ensuring Safety: Transforming the most dangerous failure mode (silent mis-binding at critical control points) into a bounded, manageable operator cost through HITL governance.
• Scalability: Demonstrating that high-fidelity twins can be built at a fraction of the manual effort, with the system's accuracy ceiling determined by the completeness of the source documentation rather than the LLM's capabilities.

The authors note limitations, specifically that the evaluation was confined to a single plant's Standard Operating Procedure (SOP) and that the operator effort required for deferrals warrants further study. Future work suggests integrating ERP/MES data to resolve ambiguities the documentation cannot answer.