💻 computer science

A Stability-Aware Event-Triggered Rescheduling Framework with Bounded LLM Judgment for Production Scheduling

This paper addresses the lack of stability measurement in LLM-driven production scheduling by proposing a hybrid, event-triggered rescheduling framework that combines deterministic stability-aware rules with bounded LLM judgment to select optimal recovery actions while ensuring feasibility and preventing decision thrashing.

Original authors: Jiun-Yan Shiau, Peng-Yu Chen, Chang-Yu Fan

Published 2026-10-07

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Jiun-Yan Shiau, Peng-Yu Chen, Chang-Yu Fan

Original paper licensed under CC BY 4.0 (https://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

In the heart of a factory, a production schedule is more than a list of tasks; it is a promise made to machines, materials, and people. It tells a worker which machine to stand at, a forklift driver when to arrive, and a customer when to expect a shipment. But the factory floor is rarely a place of perfect predictability. A machine might break down, a shipment of raw materials could arrive late, or a customer might suddenly need an order faster than expected. When these disruptions happen, a critical question arises: should the entire plan be thrown out and rewritten from scratch, or should the team simply adjust the timing of the current tasks?

Rewriting the whole plan often looks like the smartest move on paper because it can squeeze out maximum efficiency. However, in the real world, constantly changing the plan creates chaos. If a worker has already set up a machine for a specific job, only to be told to switch to a different one minutes later, it wastes time and causes confusion. This phenomenon, known as schedule nervousness, happens when the plan changes so frequently that the people and resources on the floor cannot keep up. The challenge for factory managers is finding the right moment to stop and ask: is this disruption big enough to justify the trouble of changing the plan, or can we simply absorb the delay without rewriting the future?

Researchers at the National Kaohsiung University of Science and Technology have developed a new way to answer this question. They created a decision-making system that acts as a gatekeeper for production schedules. Instead of automatically rewriting the plan every time something goes wrong, this system pauses to evaluate the situation. It considers three specific options for every disruption: ignore the event if the delay is small enough to be absorbed, make a local fix that shifts tasks slightly later without changing their order, or completely rewrite the future part of the schedule while keeping the immediate near-term plan frozen.

To make these decisions, the researchers built a framework that weighs two competing goals: performance and stability. Performance measures how well the factory meets its deadlines and uses its time. Stability measures how much the new plan differs from the old one, counting how many tasks are moved, how many machines are reassigned, and how much the sequence of work changes. The system calculates a score for each of the three options. If a disruption is minor, the system recommends ignoring it or making a small local repair. If the disruption is severe, it checks whether a full rewrite would recover enough lost time to justify the chaos of changing the plan. This check includes a "stability floor," a minimum level of calmness the new plan must maintain, and an "anti-thrashing" rule that prevents the system from flipping back and forth between different plans too quickly.

A key innovation in this work is how it uses artificial intelligence. While large language models are increasingly used to generate complex schedules, this study found that relying on them to make the final call is risky. In a review of 43 recent studies, the authors discovered that most systems using artificial intelligence either generated rules offline or tried to solve the scheduling problem directly, often producing plans that looked good but were impossible to execute. Furthermore, none of those studies measured how stable the resulting plans were. To address this, the new framework uses a local, on-site artificial intelligence model not to create the schedule, but to act as a second opinion. The AI looks at the same numbers and evidence as the main rule-based system and offers its own recommendation. However, the AI is strictly bounded: it cannot invent a new schedule, it must follow a strict format, and if it fails or gives a confusing answer, the system automatically falls back to the original rule-based decision. The final choice always remains with a human planner, who sees both the rule's advice and the AI's suggestion before acting.

The researchers tested this system rigorously using two different scenarios. First, they used a small, simple factory model with six jobs and six machines, where every number could be checked by hand. Then, they tested it on a much larger industrial dataset involving 312 operations and 63 machines. They simulated 27 different types of disruptions, including machine breakdowns, late materials, and urgent rush orders. In every single test, the system made the correct decision for the situation, correctly identifying when to ignore a problem, when to make a small repair, and when a full rewrite was necessary. The system also successfully handled cases where the artificial intelligence failed to connect or gave a bad answer, automatically switching to the safe, rule-based backup without any errors.

One of the most important findings concerned the "frozen horizon," a concept where the plan for the immediate future is locked in and cannot be changed. The study showed that the length of this frozen period is a delicate balance. A longer frozen period makes the plan more stable because fewer things change, but it also reduces the ability of the schedule to recover from a major disruption. The researchers found that the best length for this frozen period is not a fixed number, but rather the amount of time that is genuinely committed on the factory floor, such as the time it takes to prepare materials or set up machines.

The study concludes that the best way to handle disruptions is not to react to every single event with a full rewrite, but to have a structured way of deciding when a change is truly needed. By combining a clear, rule-based gate with a bounded artificial intelligence advisor, the system ensures that plans remain stable and workers are not constantly interrupted, while still allowing for full recovery when a crisis demands it. This approach moves beyond simply asking how to make a new schedule faster, to asking the more fundamental question of whether a new schedule is needed at all.

Technical Summary: A Stability-Aware Event-Triggered Rescheduling Framework with Bounded LLM Judgment

1. Problem Statement

Production schedules are frequently disrupted by real-world events such as machine breakdowns, operation delays, material shortages, and urgent order insertions. The core challenge addressed in this paper is not merely how to compute a new schedule, but when a released schedule should be revised and to what extent.

Existing literature often focuses on regenerating schedules immediately upon any disruption. However, the authors argue that frequent regeneration leads to "schedule nervousness," where operators, material handlers, and setup crews are forced to alter plans they have already acted upon, causing instability. Conversely, ignoring disruptions leads to uncontrolled tardiness. Furthermore, while Large Language Models (LLMs) are increasingly applied to scheduling, a structured review of 43 studies (2024–2026) reveals a critical gap:

Most LLM applications are offline generators of rules or heuristics, not online decision-makers.
Only 16% of studies complete the full event–decision–execution loop with measured results.
None of the studies that inject disruptions measure the stability of the released plan.
No study explicitly treats the choice between ignoring, locally repairing, and fully rescheduling as a distinct decision problem.

The paper proposes a framework to close this gap by introducing a stability-aware, event-triggered rescheduling gate that incorporates bounded LLM judgment.

2. Methodology

The proposed framework operates as a deterministic gate that evaluates each reported shop-floor event before any new plan is issued. It consists of four main components:

2.1 Candidate Reactions

For every event, the system constructs three candidate reactions of increasing invasiveness:

Ignore: The event is absorbed by existing slack. No new schedule is published; operations start as soon as they become feasible based on the original sequence.
Local Repair (Right-Shift): The machine assignments and sequences of the baseline are preserved. Operations are shifted to later times to accommodate the disruption (e.g., machine breakdowns or delays) without reordering. Rush orders are inserted greedily at the end of queues. This preserves the sequence stability.
Full Rescheduling (with Frozen Horizon): The near-term plan is "frozen" for a horizon $H$ (e.g., 8 hours) to protect committed resources (materials, setups, operators). Only operations outside this frozen set are re-optimized. The sub-problem is solved using a portfolio of dispatching rules (EDD, STR, SPT) or a mixed-integer model for small instances.

2.2 Evaluation Metrics

Each candidate is evaluated on two orthogonal axes:

Performance Cost ( $Z$ ): A weighted sum of total tardiness and makespan, reflecting the make-to-order context where delivery reliability is paramount.
Stability Score ( $SS$ ): A composite score (0–100) derived from five components:
1. Mean start-time shift.
2. Fraction of moved operations.
3. Fraction of machine reassignments.
4. Sequence similarity (Kendall's concordance).
5. Changes within the frozen window.
  The score penalizes changes that affect the most people and resources, with a specific penalty for altering the frozen near-term plan.

2.3 Rule-Based Decision Gate

A deterministic rule engine converts the metrics into a decision:

Ignore: Recommended if the event causes negligible performance damage (absorbed by slack).
Repair: Recommended if the event causes damage but a full reschedule offers insufficient recovery or violates stability constraints.
Full Reschedule: Recommended only if:
- The event is "severe" (e.g., creates new tardy jobs).
- The reschedule recovers a minimum percentage ( $\rho_{min}$ ) of the event-induced damage.
- The stability score of the new plan exceeds a minimum floor ( $SS_{min}$ ).
- An "anti-thrashing" interval has elapsed since the last full reschedule (unless the event is severe).

2.4 Bounded LLM Judgment

A locally hosted LLM acts as an independent advisor, not a solver.

Input: The LLM receives the same quantitative evidence (event details, baseline metrics, candidate performance/stability scores, rule reasons, and recent decision history) as the rule gate.
Constraint: It cannot generate schedules. It must output a decision (ignore, repair, full) within a strict JSON schema, citing concrete figures.
Fallback: If the LLM fails to produce valid output, times out, or produces an out-of-vocabulary decision, the system defaults to the rule-based decision. The human planner makes the final choice, seeing both recommendations side-by-side.

3. Key Contributions

Structured Review and Gap Analysis: The paper provides a systematic review of 43 recent studies, identifying that LLMs are rarely used for online decision-making in dynamic rescheduling and that stability is almost never measured in event-injection experiments.
Stability-Aware Gate Design: It introduces a mechanism that explicitly trades off performance recovery against schedule stability, using a frozen horizon and a multi-component stability score.
Bounded LLM Integration: It proposes a "bounded judgment" architecture where the LLM audits verified evidence rather than generating solutions, ensuring feasibility and safety through schema validation and deterministic fallbacks.
White-Box Validation: The framework is validated on a manually verifiable instance and an industrial-scale instance (312 operations), demonstrating that the system reaches expected decision branches without violating feasibility or stability invariants.

4. Results

The validation involved 27 event scenarios, 108 candidate schedules, and 9 LLM protocol scenarios.

Decision Correctness: The gate correctly identified when to ignore, repair, or fully reschedule across all scenarios, including edge cases involving rush orders, material delays, and bottleneck breakdowns.
Feasibility and Invariants: All 108 candidate schedules passed independent verification for machine overlap, routing order, and frozen horizon constraints.
Guard Mechanisms: The anti-thrashing interval successfully prevented unnecessary rescheduling for minor events shortly after a major one, while the severity override allowed rescheduling for critical disruptions.
Frozen Horizon Sensitivity: Experiments showed that a longer frozen horizon improves stability but reduces the ability of a reschedule to recover performance, confirming that the horizon should reflect genuine shop-floor commitments.
LLM Layer Robustness: The system handled various LLM failure modes (invalid JSON, authentication errors, timeouts) by falling back to the rule decision without halting the process. The LLM agreement rate with the rule was high, with disagreements occurring primarily in borderline cases.
Performance: Assessments took less than 1 second even for the industrial instance (312 operations), including the generation and verification of four candidate schedules.

5. Significance and Claims

The paper claims to advance the field of predictive-reactive scheduling by shifting the focus from "how to compute a schedule" to "whether to issue a new schedule."

Evidence-Based Decision Making: By requiring measured stability scores and damage recovery metrics, the framework moves beyond heuristic regeneration to explicit trade-off management.
Safe LLM Deployment: The "bounded judgment" approach addresses the reliability concerns of using LLMs in production. By restricting the LLM to auditing verified data and providing a deterministic fallback, the system ensures that the planner is never forced to act on an infeasible or hallucinated suggestion.
Human-in-the-Loop: The framework preserves human authority. The planner receives a structured recommendation with reasons from both a deterministic rule and an LLM, allowing for informed final decisions that can account for contextual factors (e.g., strategic customer importance) not captured in the metrics.
Practical Applicability: The validation on an industrial instance with 312 operations demonstrates that the approach is computationally feasible for real-time shop-floor use.

The authors conclude that while the framework successfully implements a stability-aware gate with bounded LLM judgment, future work is required to validate its comparative advantage over simpler policies (e.g., "always reschedule") on long-term event streams and to calibrate the gate parameters for specific industrial environments.