💻 computer science

Logic-Based Verification of Task Allocation for LLM-Enabled Multi-Agent Manufacturing Systems

This paper proposes a control architecture that ensures safety in flexible, LLM-enabled multi-agent manufacturing systems by verifying task allocations using temporal logic and discrete event systems, as demonstrated in a multi-robot assembly case study.

Original authors: Jonghan Lim, Mostafa Tavakkoli Anbarani, Rômulo Meira-Góes, Ilya Kovalenko

Published 2026-04-21

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Jonghan Lim, Mostafa Tavakkoli Anbarani, Rômulo Meira-Góes, Ilya Kovalenko

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine a busy, high-tech factory floor where a team of robots works together to build custom products. In the past, these robots followed a strict, pre-written instruction manual. If a customer wanted something new, the engineers had to stop everything, rewrite the manual, and restart. This was slow and inflexible.

Now, imagine giving these robots a super-smart AI assistant (a Large Language Model, or LLM) that can read a customer's request in plain English and instantly figure out how to build the product. "Hey robot, build a red gear and a blue pin, but make sure you don't drop the pin on the floor!" The AI is great at understanding the request and coming up with a creative plan.

The Problem:
The AI is creative, but it's also a bit of a daydreamer. It might forget that two robots can't grab the same heavy part at the exact same time, or it might tell Robot A to move a table while Robot B is standing underneath it. In the real world, these "daydreams" lead to crashes, broken parts, or even dangerous situations. We can't just trust the AI's first guess because safety is non-negotiable.

The Solution: The "Safety Inspector" Architecture
This paper proposes a new way to run the factory that combines the creativity of the AI with the rigid logic of a safety inspector. Think of it as a three-step dance:

1. The Creative Planner (The AI)

When a new order comes in, the AI (acting as a "Product Agent") reads the instructions and sketches out a plan. It's like a chef writing a recipe for a new dish. It knows what ingredients (parts) are needed and what tools (robots) are available. It draws a map of the steps, but this map is just a rough draft.

2. The Safety Inspector (The Logic Engine)

Before the robots start moving, the plan is handed to a "Central Controller" (the Safety Inspector). This isn't a human; it's a strict logic machine that speaks a special language called Temporal Logic.

The Analogy: Imagine the AI's plan is a movie script. The Safety Inspector is a film editor who checks the script against the "Safety Rules of the Universe."
How it works: The Inspector translates the safety rules (e.g., "Robot A must finish picking before Robot B starts moving") into a strict flowchart (an automaton). It then runs the AI's plan through this flowchart like a simulation.
The Catch: If the AI's plan tries to do two things that conflict (like two robots trying to use the same hallway at once), the Inspector spots the crash before it happens. It doesn't just say "No"; it points exactly where the script goes wrong.

3. The Feedback Loop (The "Do-Over")

If the Inspector finds a mistake, it doesn't throw the plan in the trash. Instead, it sends a structured note back to the AI.

The Note says: "Hey, your plan says Robot A moves the table while Robot B is under it. Here is the exact moment that happens. Please fix it."
The AI reads the note, understands the context, and rewrites the plan to fix that specific error.
The new plan goes back to the Inspector. If it passes, the robots execute the task. If it fails again, the loop repeats until the plan is perfect.

Why This Matters

The researchers tested this system in a simulated factory with different numbers of robots and rules.

Without the Inspector: The AI got the safety rules right only about 50% to 75% of the time. It was too eager and made mistakes.
With the Inspector: The success rate jumped to over 85% to 92%. The system caught the dangerous ideas and forced the AI to fix them before any real damage could occur.

The Big Picture

This paper is essentially building a guardrail for AI in manufacturing. It allows factories to be flexible and adapt to new products instantly (thanks to the AI) without sacrificing safety (thanks to the Logic Inspector).

It's like having a brilliant, fast-thinking architect (the AI) design a house, but requiring a strict building code inspector (the Logic Engine) to sign off on the blueprints before a single brick is laid. This ensures the house is both beautiful and safe, even if the design is brand new and never built before.

1. Problem Statement

Manufacturing systems are increasingly facing demands for high product variability and personalization, requiring flexible control strategies. While Multi-Agent Systems (MAS) offer decentralized decision-making, traditional approaches rely on predefined task models that struggle to adapt to unforeseen requirements.

Large Language Models (LLMs) have been introduced to enhance adaptability by interpreting natural language (NL) requirements and generating dynamic task plans. However, a critical gap exists: LLMs lack inherent guarantees of safety. They may generate plans that violate critical constraints such as collision avoidance, task precedence, or mutual exclusion of shared resources.

The core problem addressed is: How to generate adaptive, LLM-based task plans for multi-agent manufacturing systems that satisfy complex safety constraints without relying on rigid, predefined models?

2. Methodology

The authors propose a Control Architecture that integrates LLMs with formal verification methods (Temporal Logic and Discrete Event Systems). The system operates on a "generate-verify-repair" loop.

A. System Components

Product Agents (PA): Powered by LLMs, these agents interpret Natural Language (NL) product requirements and available resource capabilities to generate task plans. The output is a Directed Acyclic Graph (DAG) representing task dependencies and concurrency.
Central Controller Agent (CCA): Acts as a global verifier. It does not generate plans but validates them against safety constraints before execution.
Resource Agents (RA): Physical resources (e.g., robots) modeled as Finite State Automata (FSA).

B. Formalization Process

The framework translates informal requirements into rigorous mathematical models:

Natural Language to Structured Logic: NL safety rules are mapped to Atomic Propositions (AP) using a structured format: ap/process/product/resource/event/context.
LTLf Specification: These propositions are used to construct Linear Temporal Logic on Finite Traces (LTLf) formulas. These formulas encode constraints like ordering (e.g., "Task A must happen before Task B") and mutual exclusion (e.g., "Robot 1 and Robot 2 cannot hold the same part simultaneously").
Safety Automata: Each LTLf formula is translated into a Safety Automaton ( $A_s$ ) containing specific "violation states."

C. The Verification Workflow

Plan Compilation: The PA compiles the LLM-generated DAG into a global execution automaton ( $A_{plan}$ ) representing the joint behavior of all resources.
Reachability Analysis: The CCA performs a Depth-First Search (DFS) on the product of the plan automaton ( $A_{plan}$ $A_{pl an}$ ) and the safety automata ( $A_{safety}$ $A_{s a f e t y}$ ).
- It traverses states $(x, q)$ , where $x$ is the system state and $q$ is the safety automaton state.
- If the search reaches a violation state ( $Q_{v,s}$ ) in the safety automaton, the plan is flagged as unsafe.
Feedback and Replanning:
- If a violation is found, the CCA accumulates the witness trace (the specific sequence of events leading to the error).
- This trace, along with the violated constraint and execution context, is fed back to the LLM (PA) as a structured prompt.
- The LLM uses this feedback to replan, adjusting task ordering or resource allocation to avoid the violation.

3. Key Contributions

Control Architecture: A novel framework enabling the verification of LLM-generated task plans in Multi-Agent Systems, bridging the gap between flexible LLM reasoning and rigid safety requirements.
Verification Process: A method to evaluate task plans using LTLf represented as automata, allowing for formal execution-level checking of concurrency and resource conflicts.
Feedback Mechanism: A structured loop that utilizes formal verification results (witness traces) to guide the LLM in refining task plans, moving beyond simple error messages to actionable repair instructions.

4. Experimental Results

The framework was evaluated using a multi-robot assembly case study with three scenarios (S1, S2, S3) of increasing complexity (2 to 4 robots, 3 to 6 parts, and 2 to 4 safety rules).

Safety Compliance:
- Pure LLM Baseline: Satisfied safety rules only 50% to 75.93% of the time.
- Proposed Framework: Improved rule satisfaction to 86.25% to 92.50% across all scenarios.
Repair Efficiency: The system successfully repaired unsafe plans, though the number of repair attempts increased with scenario complexity (from 1.8 attempts in S1 to 3.9 in S3).
Computational Cost: Verification time scaled with system size (0.1s for S1 vs. 25.46s for S3) due to the exponential growth of the joint state space explored during DFS.
Outcome: The study demonstrated that unsafe task allocations can be formally detected and corrected before execution, preventing hazardous behaviors without sacrificing the adaptability of LLMs.

5. Significance and Future Work

Safety-Critical Adaptability: This work addresses a major bottleneck in Industry 4.0: enabling the use of generative AI for dynamic manufacturing while maintaining the rigorous safety standards required in physical environments.
Formal Guarantees: By using DES and Temporal Logic, the system provides mathematical guarantees that specific safety constraints are met, which pure LLM reasoning cannot achieve alone.
Scalability Challenges: The authors acknowledge that the centralized verification approach faces scalability limits as the number of agents grows (state space explosion).
Future Directions:
- Developing hierarchical or subsystem-level verification to reduce computational bottlenecks.
- Implementing online verification for runtime adaptation to unexpected events.
- Exploring fine-tuning methods to reduce reliance on manual expert validation of safety specifications.

In conclusion, the paper presents a robust hybrid approach where LLMs provide the "flexibility" to interpret new requirements, and logic-based verification provides the "safety" to ensure those interpretations are executable without causing accidents.