Harmonizing Real-Time Constraints and Long-Horizon Reasoning: An Asynchronous Agentic Framework for Dynamic Scheduling

🕒 Published (v1): 2026-05-28 02:26 UTC · Source: Arxiv · link

Why this paper was selected

Asynchronous agent framework balancing reactive scheduling and long-horizon planning

Ask a follow-up

Open an assistant pre-loaded with this paper's context.

💬 Ask ChatGPT✦ Ask Claude

TL;DR

RACE-Sched is an asynchronous dual-stream agentic framework that resolves the temporal mismatch between millisecond-level industrial scheduling and second-to-minute LLM inference latency. A Reactive Stream executes low-latency symbolic heuristics in real time while a parallel Deliberative Stream runs an LLM-driven evolutionary loop that proposes, sandbox-validates, and hot-swaps improved rules without blocking the control loop. On GEN-Bench, MK-Bench, and JMS-Bench it outperforms both DRL and LLM-based baselines.

Problem

Dynamic Flexible Job Shop Scheduling (DFJSP) requires dispatching decisions within milliseconds, yet LLM inference takes 77–114 seconds per policy update. Existing approaches either freeze rules offline (no online adaptation) or force synchronous LLM calls that block the production line. No prior framework safely integrates continuous LLM-driven policy evolution into a live control loop without sacrificing real-time responsiveness or interpretability.

Method

RACE-Sched decouples execution from reasoning via a dual-stream architecture:

• Reactive Stream: executes the current symbolic priority function \(f_\phi\) (compiled Python) with sub-millisecond latency: \(a_t = \arg\max_{a \in A_t} f_\phi(s_t, a)\).
• Deliberative Stream (off critical path): an LLM-driven agentic loop with four sub-components:
• Strategic Planner: summarizes a sliding window of recent states into a compact bottleneck-aware directive \(S_\text{plan} \leftarrow \text{Planner}(s_\text{profile}, M_\text{obj})\).
• Syntactic Enforcer: converts the plan to executable Python PDR code with constrained imports and length limits.
• Simulation Validator: runs sandbox rollouts comparing candidate \(\phi_\text{cand}\) vs. incumbent \(\phi_\text{old}\) on evaluation pool \(D_\text{val}\); accepts only if relative improvement \(r_t \geq \epsilon_\text{rel}\), Cohen's \(d \geq d_\text{min}\), and Welch's \(T_t \geq T_\alpha\).
• Semantic Reflector: converts sandbox statistics into structured diagnostic feedback for the next iteration.

Triggering is either periodic (every \(K\) steps) or performance-based (metric drops \(\geq \epsilon\) below sliding-window best). Accepted rules are deployed via atomic pointer swap (hot-swap) so the Reactive Stream never waits.

A Rule Repository stores validated heuristics as tuples \(\langle m_i, \phi_i, v_i, C_i \rangle\) (metadata, code, performance, complexity). Warm-start retrieval scores \(S(T_i | m_\text{new}) = v_i - \lambda_1 D(m_\text{new}, m_i) - \lambda_2 \log(1 + C_i) + \delta_\text{match}\), where \(D\) penalizes job/machine cardinality mismatch.

Key Contributions

• Asynchronous dual-stream architecture that confines LLM deliberation entirely off the critical scheduling path, guaranteeing millisecond dispatching latency.
• Sandbox-based candidate validation with a three-criterion acceptance gate (relative improvement + Cohen's \(d\) + Welch's \(t\)-test) before atomic hot-swap deployment.
• Rule Repository with similarity-weighted retrieval enabling cross-scale warm-start initialization and lifelong knowledge retention.
• Evaluation on GEN-Bench, MK-Bench, JMS-Bench including machine-failure stress tests across seven LLM backends (Qwen3-8B to GPT-5 Nano, DeepSeek-V3.2).

Results

• GEN-Bench Normal: RACE-Sched (Qwen3-8B) achieves RPD 5.33% vs. best DRL baseline IDDQN at 9.82% — a 45.7% relative reduction; mean rank 6.75 vs. IDDQN rank 12.1.
• GEN-Bench Small: RACE-Sched (Qwen3-8B) RPD 9.54%, outperforms all LLM-Direct and ReflecSched variants.
• MK-Bench: RACE-Sched (Qwen3-8B) RPD 6.43%, rank 4.80, vs. IDDQN RPD 9.82, rank 12.10.
• JMS-Bench: RACE-Sched (Qwen3-14B) rank 6.10, matching GPT-5 Nano variant.
• Reactive Stream latency: sub-millisecond (<0.1 ms for DeepSeek-V3.2 / GPT-5 Nano backends).
• Deliberative Stream latency: 77–114 seconds per policy update (isolated off critical path).
• Token efficiency: ~60% reduction in input token consumption vs. LLM-Direct baseline (Qwen3-8B configuration) due to rule repository warm-start and policy-synthesis vs. per-step generation.

Limitations

• Deliberative Stream latency (77–114 s) means rule updates are infrequent; rapid transient disturbances may persist for many decision epochs before a new rule is validated and deployed.
• Sandbox rollouts replay a fixed evaluation pool \(D_\text{val}\); distribution shift between the pool and live environment may cause a validated rule to underperform in deployment.
• Rule Repository retrieval is based on coarse instance-level metadata (job/machine cardinality); structurally similar but semantically different problem variants may retrieve suboptimal priors.
• Ablation results are referenced but truncated in the provided text — the contribution of each sub-component is not fully reported here.
• Evaluated only on DFJSP; generalizability to other real-time control domains is unverified.

Relevance to Harnesses / Meta-Harnesses

RACE-Sched is a meta-harness for runtime policy synthesis: it wraps an LLM-driven agentic loop (plan → code → validate → reflect) as a background process that continuously evolves the policy executed by a lower-level reactive harness, mirroring the harness-within-harness pattern central to this research track. The sandbox Simulation Validator and Semantic Reflector constitute an automated evaluation-and-feedback sub-harness that screens candidate policies before promotion, directly analogous to meta-harness quality gates. The Rule Repository functions as a persistent knowledge layer across harness invocations, enabling cross-instance warm-start — a pattern of increasing importance in lifelong agentic systems. The atomic hot-swap deployment mechanism addresses a critical open problem in meta-harness design: how to update a running harness's control logic without downtime or safety compromise.