An LLM-Assisted Multi-Agent Control Framework for Roll-to-Roll Manufacturing Systems

This paper presents an LLM-assisted multi-agent framework that automates the design, tuning, and adaptation of control systems for roll-to-roll manufacturing, significantly reducing manual effort while ensuring safety and maintaining high-quality tension and velocity regulation under model uncertainty.

The Gist

Imagine a massive, high-speed factory machine that unspools a giant roll of material (like a very long, thin sheet of plastic or metal) and winds it back up onto another roll. This is called Roll-to-Roll (R2R) manufacturing. It's used to make everything from flexible solar panels to printed sensors.

The biggest challenge? Keeping the "web" (the material) perfectly tight.

• Too loose: The material wrinkles, tears, or gets misaligned.
• Too tight: The material snaps or the motors burn out.

Traditionally, getting this machine to work perfectly required a highly experienced human engineer. They would spend days or weeks manually tweaking knobs and dials, guessing what the machine needed, and hoping for the best. It was slow, expensive, and prone to human error.

This paper introduces a new "AI Co-Pilot" system that automates this entire process. Think of it not as a single robot taking over, but as a team of specialized AI assistants working together, guided by a super-smart "Chief Engineer" (a Large Language Model, or LLM).

Here is how this team works, explained through simple analogies:

1. The Team of AI Specialists

Instead of one giant brain trying to do everything, the system uses five specialized "agents" (AI workers), each with a specific job:

• The Detective (System ID Agent): Before the machine can be controlled, the AI needs to understand how it behaves. The Detective looks at the machine's past data and physical rules to build a digital "twin" (a simulation) of the machine. It's like a mechanic listening to an engine to figure out exactly how it runs before trying to fix it.
• The Architect (Initial Control Agent): Once the AI understands the machine, the Architect designs the control strategy. It looks at three different "blueprints" (PID, MPC, and LQR—types of control math) and picks the best one. It's like a chef tasting three different recipes and choosing the one that will make the perfect dish.
• The Pilot (Adaptation Agent): This is the most critical part. The AI takes its "perfect" design from the computer simulation and tries it on the real machine. But here's the catch: The Pilot never flies without a safety net.
• The Safety Inspector (Safety Filter): Before the Pilot can touch the real machine, the Safety Inspector runs a thousand simulations in a split second. It asks: "If we change this setting, will the machine break? Will the tension snap the material?" If the answer is "maybe," the change is rejected. This ensures the AI never makes a dangerous mistake.
• The Watchman (Monitoring Agent): Once the machine is running, the Watchman never sleeps. It monitors the machine 24/7. If the performance starts to drift (like a car engine getting slightly rough), it diagnoses why. Is it a loose belt? A worn-out sensor? Or just a change in the material? It tells the human operators exactly what to do.

2. The "Sim-to-Real" Dance

The paper highlights a major problem in AI: The Simulation Gap.
Imagine you learn to drive in a video game (the simulation). You might be perfect there. But when you get into a real car (the real factory), the wind, the road texture, and the weight of the car are different. You might crash.

This framework solves that by using a "Practice Loop":

1. The AI proposes a change in the simulation.
2. The Safety Inspector checks it.
3. If safe, the AI tries it on the real machine.
4. If the real machine acts differently than expected, the AI analyzes the difference, learns from it, and proposes a new change.
5. It repeats this cycle until the real machine performs as well as the simulation.

3. The Results: Faster, Safer, Smarter

The researchers tested this on a lab-scale machine. Here is what happened:

• The Old Way: A standard computer controller (MPC) struggled to keep the tension steady, resulting in errors.
• The AI Way: The AI team started with a basic setting, then iteratively "tuned" itself.
• The Outcome: The AI system reduced errors by 55% to 82% compared to the standard controller. It learned to handle the machine's quirks much faster than a human could.

The Big Picture: Why This Matters

Think of this framework as giving a factory machine a "self-driving" mode for its own maintenance and tuning.

• No more "Black Boxes": Unlike some AI that just gives an answer, this system explains why it made a change (e.g., "I increased the tension because the material got thinner").
• Safety First: It treats safety as a non-negotiable rule. The AI can't just "guess"; it must prove its ideas are safe in a digital sandbox first.
• Democratizing Expertise: You don't need a PhD in control theory to run this factory. The AI brings the expert knowledge, allowing the factory to run efficiently even if the human operators are less experienced.

In short, this paper presents a way to let AI handle the complex math and dangerous trial-and-error of factory tuning, while keeping humans in the loop to oversee the process. It turns a slow, expert-dependent process into a fast, automated, and safe one.

Technical Summary

1. Problem Statement

Roll-to-Roll (R2R) manufacturing is critical for producing flexible electronics and functional films but faces significant challenges in maintaining precise web tension and velocity control.

• Complexity: The system involves strongly coupled tension-velocity dynamics, time-varying parameters (e.g., changing roll radii), and material property variations.
• Current Limitations: Traditional commissioning and controller tuning rely heavily on manual intervention by expert engineers. This process is time-intensive, prone to human error, and difficult to scale when transitioning between product grades or commissioning new lines.
• The AI Gap: While Large Language Models (LLMs) show promise in code generation and reasoning, their direct application to industrial control is hindered by:
  • Lack of safety guarantees (probabilistic outputs).
  • The "sim-to-real" gap (models often fail on physical hardware).
  • Lack of transparency in decision-making required for regulatory compliance.

2. Methodology

The authors propose an LLM-assisted Multi-Agent Control Framework that integrates Retrieval-Augmented Generation (RAG) with a rigorous simulation-based safety validation loop. The system operates through five distinct phases, orchestrated by specialized AI agents.

A. Core Architecture

• Multi-Agent System: Instead of a monolithic LLM, the framework uses five specialized agents:
  1. SysID Agent: System identification and model construction.
  2. Initial Control Agent: Controller selection and initial tuning.
  3. Adaptation Agent: Sim-to-real parameter adaptation.
  4. Monitoring Agent: Continuous diagnostics and root cause analysis.
  5. Code Agent: Executes simulations and validates code.
• RAG Integration: Agents access a hierarchical knowledge base containing control theory fundamentals, R2R best practices, and system-specific documentation. This grounds LLM reasoning in domain expertise, reducing hallucinations.
• Safety Filter (Constrained Autonomy): A critical component where no LLM-generated modification is deployed to physical hardware without passing a mandatory simulation validation. The filter checks for:
  • Constraint satisfaction (torque/velocity limits).
  • Performance improvement (vs. current state).
  • Stability margins (robustness under uncertainty).

B. Operational Phases

1. Phase 0 (System Identification): The SysID Agent uses historical operational data and physics-informed principles (nonlinear state-space models) to identify system parameters ($\theta$). It minimizes prediction error while regularizing toward physical priors to prevent overfitting.
2. Phase 1 (Controller Design): The Initial Control Agent evaluates three architectures (PID, MPC, LQR). It uses iterative reasoning to tune hyperparameters based on simulation performance metrics (RMSE, settling time, overshoot, energy consumption) and selects the optimal controller ($C^*$).
3. Phase 2 (Sim-to-Real Adaptation): The Adaptation Agent deploys $C^*$ to the real system. It analyzes the performance gap between simulation and reality, diagnoses root causes (e.g., model mismatch), and proposes parameter adjustments ($\Delta\phi$). These adjustments are only deployed if they pass the Safety Filter in simulation.
4. Phase 3 (Intelligent Monitoring): Once stable, the Monitoring Agent performs dual-layer analysis:
   • Layer 1: Detects performance degradation using statistical thresholds.
   • Layer 2: Diagnoses root causes (e.g., bearing wear vs. control gain drift) and distinguishes between issues requiring control adaptation vs. physical maintenance.
5. Phase 4 (Continuous Refinement): During downtime, accumulated operational data is used to re-identify the simulation model, ensuring the digital twin remains accurate for future runs.

3. Key Contributions

• Safety-First AI Framework: Introduces a "constrained autonomy" paradigm where LLMs propose strategies, but simulation acts as a hard safety gate before physical deployment.
• RAG for Control: Demonstrates how Retrieval-Augmented Generation can bridge the gap between general LLM reasoning and the strict mathematical requirements of control theory.
• Automated Sim-to-Real Adaptation: Provides a structured, iterative workflow for adapting controllers to significant model uncertainties without human intervention.
• Transparent Diagnostics: The framework generates human-readable diagnostic reports distinguishing between control-tunable issues and physical maintenance needs, addressing the "black box" concern of AI in manufacturing.

4. Experimental Results

The framework was validated on a lab-scale, 6-span R2R system with significant model uncertainty (simulation models had 8.3%–50% parameter deviations from the real system).

• Controller Selection: The LLM selected LQR as the optimal architecture over PID and MPC based on simulation metrics.
• Tension Control Performance:
  • The framework achieved a 55.7% reduction in RMSE compared to the initial deployment.
  • It outperformed a standard MPC baseline by 35.4% (RMSE: 1.04 N vs. 1.62 N).
• Velocity Tracking Performance:
  • Achieved an 82.4% reduction in RMSE during velocity ramping transients.
  • Outperformed the MPC baseline by 70.9% (RMSE: 0.29 N vs. 1.01 N).
• Adaptation Efficiency: The system successfully converged to stable operation through iterative adaptation (Adapt1 $\to$ Adapt2 $\to$ Adapt3), demonstrating robustness against large model mismatches.

5. Significance

This work represents a significant step toward autonomous manufacturing control.

• Reduced Commissioning Time: By automating the tuning and adaptation process, it drastically reduces the reliance on scarce expert engineers for new line setup.
• Scalability: The framework offers a practical pathway for integrating AI into industrial control systems by solving the safety and reliability barriers that have previously limited AI adoption in safety-critical environments.
• Future Impact: The approach is designed to be transferable to other manufacturing processes and can leverage learned configurations from one production line to accelerate commissioning on new lines with different materials or geometries.

In summary, the paper successfully demonstrates that LLMs, when constrained by rigorous simulation validation and guided by domain-specific knowledge (RAG), can effectively automate complex control design and adaptation tasks in high-precision manufacturing.