Paper deep dive
SyncPlan: Long-Horizon LLM Coordination with Explicit Synchronization and Adaptive Correction
Shen You, Xiaoming Zhu, Weining Weng, Hefei Mei, Weixuan Wang, Zhongshen Li, Zeji LI, Ye-Wen Wang, Zijun Liao, Juchao Zhuo, Yang Wei, Fuhao Qiu, Siqin Li, Zhenjie Lian, Danei Gong, Junkai Ji, Xiangtao Li, Qiuzhen Lin, Liang Wang, Ka-Chun Wong
Intelligence
Status: not_run | Model: - | Prompt: - | Confidence: 0%
Entities (0)
Relation Signals (0)
No relation signals yet.
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:LLM-based multi-agent coordination faces a fundamental trade-off between efficiency and adaptivity in dynamic environments. Existing approaches typically rely on repeated LLM invocations or multi-round communication to adapt decisions during execution, introducing substantial latency and making coordination vulnerable to asynchronous progress and environmental changes. Conversely, one-shot planning reduces coordination overhead but produces open-loop plans that can quickly become stale or fail when actions depend on other agents and the environment. We introduce SyncPlan, a plan-execute-correct framework for long-horizon coordination through explicit synchronization and adaptive correction. Given the state and team-level task, a centralized LLM coordinator generates per-agent action chains in a single planning call. During execution, explicit wait primitives and deadlock detection enforce inter-agent and agent-environment dependencies, while a lightweight Plan Staleness Detector continuously assesses the remaining plan and triggers replanning when environmental changes invalidate its assumptions. We further optimize the coordinator through SFT and planning-oriented RL with dense task progress and outcome-level execution feedback. Experiments on the public Overcooked benchmark and the complex Honor of Kings environment show that SyncPlan achieves state-of-the-art task success rates while using less than 0.05% of the wall-clock runtime compared with existing LLM-based coordinators. Code and datasets will be made publicly available.
Tags
Links
- Source: https://arxiv.org/abs/2608.01652v1
- Canonical: https://arxiv.org/abs/2608.01652v1
Trouble viewing inline? Open PDF directly →
Full Text
80,447 characters extracted from source content.
Expand or collapse full text
SyncPlan: Long-Horizon LLM Coordination with Explicit Synchronization and Adaptive Correction Shen You1,*, Xiaoming Zhu2,*, Weining Weng2, Hefei Mei1, Weixuan Wang2, Zhongshen Li1, Zeji Li1, Ye-Wen Wang2, Zijun Liao2, Juchao Zhuo2, Yang Wei2, Fuhao Qiu2, Siqin Li2, Zhenjie Lian2, Danei Gong1, Junkai Ji3, Xiangtao Li4, Qiuzhen Lin3, Liang Wang2,**, Ka-Chun Wong1,** Abstract LLM-based multi-agent coordination faces a fundamental trade-off between efficiency and adaptivity in dynamic environments. Existing approaches typically rely on repeated LLM invocations or multi-round communication to adapt decisions during execution, introducing substantial latency and making coordination vulnerable to asynchronous progress and environmental changes. Conversely, one-shot planning reduces coordination overhead but produces open-loop plans that can quickly become stale or fail when actions depend on other agents and the environment. We introduce SyncPlan, a plan-execute-correct framework for long-horizon coordination through explicit synchronization and adaptive correction. Given the state and team-level task, a centralized LLM coordinator generates per-agent action chains in a single planning call. During execution, explicit wait primitives and deadlock detection enforce inter-agent and agent-environment dependencies, while a lightweight Plan Staleness Detector continuously assesses the remaining plan and triggers replanning when environmental changes invalidate its assumptions. We further optimize the coordinator through SFT and planning-oriented RL with dense task progress and outcome-level execution feedback. Experiments on the public Overcooked benchmark and the complex Honor of Kings environment show that SyncPlan achieves state-of-the-art task success rates while using less than 0.05%0.05\% of the wall-clock runtime compared with existing LLM-based coordinators. Code and datasets will be made publicly available. 1 Introduction Large Language Models (LLMs) provide a flexible way to coordinate multiple agents toward shared objectives in game environments (Liao et al. 2025; Shridhar et al. 2023; Bolton et al. 2025). We study a centralized setting in which an LLM coordinator observes the environment state and generates high-level action chains for multiple low-level agents when given a team-level task. Example tasks include eliminating a designated enemy in a Multiplayer Online Battle Arena (MOBA) game or coordinating two agents to prepare and deliver a dish in Overcooked. These environments evolve continuously due to stochastic events, actions of non-controlled agents, and state changes of task-relevant entities, requiring adaptive coordination throughout execution. In this setting, Traditional Multi-Agent Reinforcement Learning (MARL) methods (Rashid et al. 2018; Yu et al. 2022; Kuba et al. 2022) require extensive task-specific interaction and careful reward engineering, while complex coordination preferences are difficult to encode as scalar rewards. Recent LLM-based coordinators (Guo et al. 2025b; Zhang et al. 2024) offer a more expressive alternative by interpreting task objectives and generating explicit team-level plans. However, they typically rely on repeated LLM invocations (Zhang et al. 2024) or multi-round communication (Guo et al. 2025b) during execution, introducing latency and cost that are acceptable in low-tempo settings but impractical for real-time multi-agent coordination. Figure 1: Core challenges of multi-agent coordination: real-time constraints, plan staleness, and coordination conflicts. As illustrated in Fig. 1, this setting introduces three main challenges: • Real-time Constraints. Real-time environments evolve at the frame level, while frequently invoking LLM coordination incurs intolerable computational overhead under limited response-time budgets. • Plan staleness. Environment changes may invalidate a joint plan. Delayed replanning causes agents to continue executing stale actions, whereas frequent or periodic replanning wastes computation when the plan remains valid. • Coordination conflicts. Asynchronous execution introduces temporal and conditional dependencies, such as waiting for teammates or environmental conditions. Yet LLM plans express them in free-form text that low-level executors cannot reliably verify or enforce. Therefore, the core issue is: How can LLM-based multi-agent coordination remain efficient, synchronized, and adaptive during execution? To address these challenges, we propose SyncPlan (Synchronized Planning), a plan-execute-correct framework for long-horizon multi-agent coordination. In one-time LLM calling, the coordinator produces a long-horizon joint plan comprising structured action chains that span multiple environment frames, amortizing planning cost over extended execution. A runtime executor advances these chains asynchronously and enforces inter-agent and agent-environment dependencies through executable synchronization primitives. These primitives make temporal dependencies explicit: an agent proceeds only after the required teammate milestone or environment condition is satisfied. The executor further monitors wait dependencies among agents and triggers replanning when cyclic dependencies cause execution to deadlock. To maintain plan validity as the environment evolves, SyncPlan introduces a lightweight Plan Staleness Detector (PSD) that evaluates the remaining plan against current entity states. It invokes the coordinator when the current plan becomes invalid, thereby retaining adaptivity without periodic LLM inference. We further optimize the coordinator through SFT and planning-oriented RL. SFT warm-starts the coordinator with structured multi-agent planning capabilities, while RL optimizes complete action chains using dense task progress and outcome-level execution feedback, alleviating long-horizon credit assignment and stabilizing policy optimization. On the public Overcooked benchmark, SyncPlan improves task achievement rate by an average of 12.2 percentage points over the strongest LLM-based baseline in each setting, while requiring less than 0.05% of their wall-clock runtime. On the substantially more complex Honor of Kings testbed, SyncPlan achieves 86.3% task achievement, surpassing DPT-Agent by 17.6 percentage points and reducing relative runtime by over 26×, enabling real-time coordination in a 5v5 MOBA environment. In summary, our main contributions are the following: 1. We introduce executable synchronization primitives that convert implicit coordination intent into explicit constraints for asynchronous execution. 2. We propose a lightweight PSD model that detects when the remaining plan becomes invalid and triggers on-demand replanning. 3. We propose progressive composite rewards that jointly optimize task effectiveness, execution correctness, and runtime efficiency, providing dense intermediate feedback to improve long-horizon reinforcement learning. 4. Experiments on Overcooked and Honor of Kings demonstrate state-of-the-art task achievement with substantially lower runtime, enabling real-time 5v5 coordination. 2 Related Work Multi-Agent Reinforcement Learning. MARL achieves coordination through joint policy optimization under CTDE, including value decomposition (QMIX (Rashid et al. 2018), QTRAN (Son et al. 2019)) and policy-gradient methods (MAPPO (Yu et al. 2022), HAPPO (Kuba et al. 2022)). Hierarchical variants such as HAVEN (Xu et al. 2023) and RHMC (Yu et al. 2024) introduce sub-goal or sub-action abstraction. LLM-Based Planning and Multi-Agent Coordination. Single-agent LLM planning has been studied in robotics (SayCan (Ahn et al. 2022), Inner Monologue (Huang et al. 2022)), open-world games (Voyager (Wang et al. 2023), SIMA 2 (Bolton et al. 2025)), and hero-level decision-making (TiG (Liao et al. 2025), SIMA (Bolton et al. 2025)). In particular, ReCAPA (Zeng et al. 2026) further performs hierarchical predictive correction through repeated LLM invocation, but focuses on a single agent and does not address concurrent multi-agent synchronization. For multi-Agent coordination, prior work spans dialogue-based consensus (CaPo (Guo et al. 2025b), MAGRPO (Liu et al. 2026)), hierarchical plan-then-execute pipelines (MindAgent (Gong et al. 2024), L2M2 (Geng et al. 2025)), world-model-based cooperation (COMBO (Zhang et al. 2025a)), and teammate modeling (ProAgent (Zhang et al. 2024)). Their coordination dependencies are generally implicit, while execution-time adaptation relies on repeated LLM invocation or lacks an explicit signal for when the joint plan should be revised. Figure 2: Overall framework. (A) SyncPlan forms a plan-execute-correct loop: collaborative planning generates per-agent action chains; runtime execution advances the chains and detects deadlocks; and the PSD monitors plan validity. (B–C) SFT warm-starts the coordinator with expert and distilled data, followed by planning-oriented RL with execution feedback. 3 Problem Formulation We consider a dynamic environment with N controlled low-level agents. At frame t, the environment state is in state st∈s_t and evolves according to the transition function st+1=(st,t,ξt)s_t+1=T(s_t,a_t, _t) (1) where :×N×Ξ→T:S×A^N× is the state transition function and t=atii=1Na_t=\a_t^i\_i=1^N denotes the joint low-level action of the controlled agents. And ξt∈Ξ _t∈ represents uncontrolled stochastic dynamics, such as actions of non-controlled agents and unexpected environment events, and ξt∈Ξ _t∈ is highly related to the state-dependent distribution ξt∼p(⋅|st) _t p(·|s_t). Each episode is associated with a team-level task e∈ℰe and a finite horizon Tmax(e)T_ (e) measured in environment frames. Let :×ℰ→0,1C:S×E→0,1 denotes the task-completion indicator, where (st,e)=1C(s_t,e)=1 if task e has been completed at frame t. The episode is successful if ∃t∈0,…,Tmax(e)s.t.(st,e)=1.∃\,t∈\0,…,T_ (e)\ .t. (s_t,e)=1. (2) Our objective is to enhance task success ratio across multiple episodes and reduce end-to-end wall-clock runtime. 4 Method 4.1 Overall Framework As illustrated in Figure 2, SyncPlan consists of three components: Collaborative Planning generates low-level action chains for multi-agents; Runtime Execution executes action chains while enforcing synchronization constraints; Adaptive Correction detects plan invalidation to selectively trigger replanning. To enable robust decision-making in complex, dynamic environments, the coordinator is optimized by SFT and RL with a well-designed composite reward function. 4.2 Collaborative Planning The objective of collaborative planning is to generate long-horizon low-level coordination plans for multi-agents. Different from single-agent planning, multi-agent coordination requires not only deciding what each agent should do, but also considering the collaboration between each agent. Formally, given a target task e and an environment state sts_t, the coordinator θD_θ generates a joint action-chain for N agents. Πt=θ(st,e)=πt1,…,πtN _t=D_θ(s_t,e)=\ _t^1,…, _t^N\ (3) where πti=[ui,1,…,ui,L] _t^i=[u_i,1,…,u_i,L] is the action chain assigned to agent i and L represents the maximum length of action chain. The action space is environment-specific, and the complete action definitions are provided in Appendix A.5. Explicit Synchronization Primitives. Existing work on multi-agent coordination largely relies on implicit cooperation, expressed through multi-turn dialogue (Feng et al. 2026) or simulated communication (Zhao et al. 2026). In these LLM-based planners, inter-agent coordination dependencies are typically expressed implicitly in natural language (e.g., "attack after your teammate arrives"), making them difficult to interpret, verify, and reliably execute during runtime. Consequently, agents normally become unsynchronized, leading to premature actions or coordination failures. Inspired by process synchronization in operating systems, where coordination is achieved through atomic wait operations, we introduce synchronization primitives that represent coordination as executable runtime constraints. To be specific, we design two synchronization primitives to capture both inter-agent dependencies and agent–environment interactions: • Wait_agents: agent waits until another agent reaches a specified milestone. • Wait_entity: agent waits until an environment entity satisfies a specified condition. These wait steps make cross-agent dependencies explicit and machine-checkable. Figure 3: Runtime execution. The module advances per-agent action chains and enforces synchronization through agent- and entity-dependent wait conditions. 4.3 Runtime Execution Considering the generated high-level plan cannot be directly executed by the low-level agents, especially the synchronization primitives, we introduce the execution module to maintain and synchronize the action chain. This module enables explicit synchronization, as illustrated in Fig. 3. A wait step blocks only the corresponding agent, while other agents continue executing their action chains. Formally, each agent i maintains a pointer hih_i to the current head step of πti _t^i. At each frame, the module evaluates the head step ui,hiu_i,h_i according to its type: • Executable actions (e.g., move, attack, interface) are dispatched directly. Once the current action completes, the execution pointer advances to the next action. • Synchronization primitives are interpreted as executable wait predicates. The agent emits a no-op until the corresponding predicate is satisfied. Once the head action is completed, hih_i advance to the next action. This mechanism allows the coordinator to express executable coordination dependencies, such as waiting for a teammate to arrive, waiting for an enemy to become visible, or waiting for an objective to reach a desired state. Deadlock Detection. Considering wait primitives will arise deadlocks, we therefore perform deadlock detection at every frame and trigger the coordinator to replan whenever a deadlock is detected. Wait-agent dependencies define a directed wait graph t=(,ℰt)G_t=(V,E_t), where each node is an agent and an edge i→ji→ j means that agent i is currently waiting for agent j. Since a circular wait dependency implies that no agent in the cycle can proceed, deadlocks are detected by searching for directed cycles in the wait graph at every frame. The detailed detection algorithm is provided in Appendix A.4. 4.4 Adaptive Correction The LLM coordinator assumes that the generated action chains remain valid. However, in dynamic multi-agent environments, this assumption is frequently violated as evolving game states continuously. When environmental changes, blindly following the original plan degrades coordination, whereas replanning at every timestep incurs prohibitive computational overhead. Therefore, SyncPlan introduces a lightweight Plan Staleness Detector (PSD) that explicitly determines whether the current collaborative plan remains valid under the latest environment state, triggering replanning only when necessary. At frame t, the PSD takes three inputs: (1) the binary chain-entity incidence matrix, which is used to label the participant entity in the action chains, (2) the normalized entity states and (3) the states difference between environments evolving. To be specific, the inputs are: 1. The chain-entity incidence matrix t∈0,1N×M×LC_t∈\0,1\^N× M× L, where M means the number of entity and L means the max length of one action chain. 2. The current entity-state matrix t∈[0,1]M×FX_t∈[0,1]^M× F, where F means the property number of an entity. 3. The state-difference matrix t∈[−1,1]M×F _t∈[-1,1]^M× F. The PSD uses two bilinear pathways. The chain pathway embeds which entities are referenced by action chains: C=N1×N×Attn(t)×CL×d∈ℝM×dH_C=W_N^\1× N\× Attn(C_t)×W_C^\L× d\ ^M× d (4) Attn() means the attention module. The state pathway embeds state-conditioned changes: X=(Attn(t)⊙Attn(t)⊙Q)X∈ℝM×dH_X= (Attn(X_t) Attn( _t) _Q )W_X ^M× d (5) where N,C,Q,WW_N,C,Q,W are learnable weight. The two pathways are combined and transformed through MLP module: Preplan(t)=σ(MLP(C⊤X))P_replan(t)=σ (MLP (H_C H_X ) ) (6) A replan is triggered when PreplanP_replan exceeds a threshold. For a clear explanation, the architecture is illustrated in Figure 4. Figure 4: Architecture of PSD. The chain and state pathways encode remaining-plan structure and entity-state changes, whose interaction produces the replanning probability. Table 1: Main comparison on Overcooked across standard and dynamic settings. Best and second-best are highlighted. Type Methods Standard (Coordination) Dynamic(Coordination) Dynamic(Ring) Dynamic(symmetric) TAR ↑ AED ↓ AAS ↓ RT ↓ TAR ↑ AED ↓ AAS ↓ RT ↓ TAR ↑ AED ↓ AAS ↓ RT ↓ TAR ↑ AED ↓ AAS ↓ RT ↓ RL Greedy 40.6% 70.52 73.40 0.34s 58.5% 76.32 86.57 0.40s 22.6% 74.08 94.91 0.30s 96.2% 51.20 53.08 0.26s PBT 92.0% 50.91 50.91 0.23s 88.7% 53.09 58.51 0.27s [rgb] .91, .792, .77696.2% [rgb] .808, .831, .87852.78 [rgb] .808, .831, .87864.60 0.26s [rgb] .808, .831, .87898.1% 44.92 45.98 0.22s FCP 91.0% 72.77 75.43 1.15s 74.0% 75.59 82.30 1.27s [rgb] .808, .831, .87891.0% 62.94 66.53 1.27s 94.3% 47.58 50.60 0.24s LLM-Based A-ToM(1st) 74.0% 43.74 46.96 3.15h 60.6% 72.05 83.45 4.85h 67.0% 67.50 78.67 5.36h 94.1% 73.25 74.88 5.82h A-ToM(2nd) 86.0% 44.67 44.46 3.52h 62.3% 65.39 78.83 6.09h 76.0% 63.74 74.35 6.46h 94.3% 62.12 64.32 7.05h Collab 79.5% 55.28 64.12 5.52h 63.0% [rgb] .808, .831, .87853.52 70.45 6.37h 50.7% 72.46 86.53 5.25h 95.9% 45.00 47.30 6.05h ProAgent 88.0% 75.93 78.88 12.72m 65.0% [rgb] .808, .831, .87877.91 86.06 23.33m 59.0% 65.50 80.12 23.40m 94.0% 45.56 48.82 13.91m DPT-Agent 91.3% 67.45 74.14 38.15m 71.5% 63.14 74.01 53.33m 69.3% 54.73 68.46 42.43m 96.3% 57.20 64.21 1.15h Ours (w/o SFT) 92.2% 49.88 [rgb] .808, .831, .87843.82 11.21s 88.4% 53.86 48.12 11.04s 76.5% 58.80 68.91 25.26s [rgb] .91, .792, .776100% 49.24 36.71 17.54s Ours (w/o RL) [rgb] .808, .831, .87894.8% [rgb] .808, .831, .87843.27 43.85 6.46s [rgb] .808, .831, .87888.8% 54.13 52.58 9.55s 76.9% 68.80 76.23 6.86s 92.2% [rgb] .808, .831, .87840.68 [rgb] .808, .831, .87832.79 5.38s Ours (Full) [rgb] .91, .792, .77696.1%** [rgb] .91, .792, .77643.10 [rgb] .91, .792, .77641.88 4.91s [rgb] .91, .792, .77693.0%** [rgb] .91, .792, .77653.57 [rgb] .91, .792, .77652.09 8.24s 88.3%** [rgb] .91, .792, .77652.23 [rgb] .91, .792, .77663.71 8.80s [rgb] .91, .792, .776100%** [rgb] .91, .792, .77640.18 [rgb] .91, .792, .77627.94 4.32s * p < 0.05, ** p < 0.01, compared with the baseline LLM-based methods under the same setting using a two-sided paired permutation test. 4.5 SFT and Reinforcement Learning While we can employ a general-purpose LLM as the coordinator, prompting-based SyncPlan still faces two bottlenecks: deployment latency, and a decision quality ceiling bounded by pre-trained knowledge. Therefore, we adopt an SFT and RL training pipeline to achieve both real-time responsiveness and superior performance on smaller models. SFT Warm-Start SFT initializes the coordinator to generate structured, executable multi-agent action chains. We construct instruction-response pairs from expert gameplay trajectories and distilled coordination data, with each target containing complete action chains and synchronization primitives. This establishes a strong prior over the SyncPlan schema and provides in-distribution initialization for subsequent RL. Training details are provided in Appendix B.5. Planning-oriented Reinforcement Learning After data fine-tuning, the LLM coordinator has developed the ability to coordinate multiple agents. However, it does not explicitly optimize long-horizon execution outcomes, as learning remains driven by token-level imitation rather than trajectory-level execution feedback. Therefore, we formulate executable collaborative planning as a reinforcement learning problem, improving the model’s planning quality and reasoning capability by rewarding correct and goal-directed executable action chains, thereby progressively aligning planning intent with executor behavior. We design a composite reward that jointly optimizes three complementary properties of executable collaborative planning: • Task Effectiveness, encouraging successful completion of long-horizon collaborative objectives; • Execution Correctness, discouraging syntax errors, semantic inconsistencies, and deadlocks; • Runtime Efficiency, encouraging efficient coordination with minimal unnecessary waiting and replanning. Let A denote an action chain produced by the coordinator. Executing A in the environment terminates in exactly one of five mutually exclusive outcomes: Success, SyntaxError, SemanticError, Deadlock, and Timeout. We denote the terminal outcome by Ω(A)∈ (A) , where =Succ,Syn,Sem,Dlk,TmoO=\ Succ, Syn, Sem, Dlk, Tmo\. The reward assigned to A combines a positive progress term with a set of outcome-dependent penalties: R(A)=Rprog(A)+α[Ω(A)=Succ]⏟intrinsic reward Rintr(A)−(Ptmo+Psyn+Psem+Pdlk)⏟penalty (A) aligned R(A)&= R_prog(A)+α\,1[ (A)= Succ]_intrinsic reward R_intr(A)\\ & - (P_tmo+P_syn+P_sem+P_dlk)_penalty P(A) aligned (7) where each penalty term is activated only when the corresponding outcome or event occurs during the execution of A: Intuitively, Rprog(A)R_prog(A) measures how much of the task the chain actually accomplishes before termination, and the bonus α is granted only when the chain fully completes the task. The four penalty coefficients λtmo,λsyn,λsem,λdlk _tmo, _syn, _sem, _dlk discourage the four failure modes with different severity: syntax and deadlock errors are penalized more heavily since they typically indicate that the chain is unusable, while semantic errors and timeouts receive milder penalties as they may still reflect partial progress. The detailed computation and the specific values of α,λ(⋅)α, _(·) are provided in Appendix A.8. Table 2: Performance comparison on Honor of Kings. Method Gemini-3.5-Flash DeepSeek-R1 (Thinking) TAR ↑ RTR ↓ TAR ↑ RTR ↓ Off-the-shelf coordinators (w/o SFT) ProAgent 56.3 ±3.5% 15.34 ±1.6x 62.5 ±2.6% 19.29 ±2.0x DPT-Agent 68.7 ±2.9% 21.76 ±2.1x 71.4 ±4.8% 23.10 ±2.8x SyncPlan (w/o SFT) 72.1 ±7.6% 7.32 ±2.0x 74.4 ±4.1% 9.41 ±2.5x Fine-tuned SyncPlan TAR ↑ RTR ↓ SyncPlan (SFT) 79.0 ±2.5% 0.96 ±0.03x SyncPlan (SFT + RL) 86.3 ±5.3% 0.83 ±0.07x 5 Experiments 5.1 Experimental Setup We evaluate SyncPlan on two complementary multi-agent platforms: Overcooked-AI is a public two-player cooperative benchmark in which two agents prepare and deliver an onion soup. We evaluate three map layouts with distinct spatial structures: Coordination, Ring, and Symmetric. Under the standard setting, episodes follow the original game dynamics without externally injected perturbations, enabling direct comparison with prior methods. To further evaluate robustness to unexpected environmental changes, we introduce three scripted perturbations: a held-item drop, partial scattering of pot contents, and agent displacement. Detailed layout configurations and event protocols are provided in Appendix B.4. Honor of Kings (HoK) is a 5v5 MOBA environment with ten agents across two opposing teams. In Commander mode, SyncPlan coordinates up to five allied heroes to eliminate a designated enemy hero, while uncontrolled heroes continue acting autonomously under built-in policies. HoK therefore provides a naturally dynamic testbed for long-horizon multi-agent coordination. Baselines and HoK disclosure. For Overcooked, we compare SyncPlan with task-specific RL methods, including FCP (Strouse et al. 2021), PBT (Jaderberg et al. 2017), and Greedy (Carroll et al. 2019; Li et al. 2023), as well as LLM-based coordinators, including Collab (Sun et al. 2025), Adaptive-ToM (Mu et al. 2026), ProAgent (Zhang et al. 2024), and DPT-Agent (Zhang et al. 2025b). For HoK, we focus on LLM-based coordinators sharing the same high-level planning interface, as a task-specific MARL would require a separate training pipeline with extensive environment interaction, bespoke reward design, and difficult joint exploration. LLM base model and Datasets. We evaluate our method on ten representative LLMs: Qwen(Hui et al. 2024), LLaMA (Grattafiori et al. 2024), GLM (GLM-5-Team 2026), Claude, GPT (Achiam et al. 2023), HY3, Gemini (Team et al. 2023), Kimi (Team et al. 2025), deepseek-r1 (Guo et al. 2025a) and MiniMax (Chen et al. 2026). For Overcooked, our SFT data is from the Gemini (Comanici et al. 2025) model distillation process. For HoK, our dataset was sampled from anonymized records of real game matches in the Commander Mode (HoK), where neither user identifiers nor any personally identifiable information was collected to safeguard player privacy. Metrics. We evaluate our approach using Task Achievement Rate (TAR) ↑ across both environments. In Overcooked, we additionally report Average Episode Duration (AED) ↓ , Average Action Steps (AAS) ↓ , Real-Time (RT) ↓ , and Deadlock Rate ↓ to measure execution efficiency and coordination failures. In HoK, we measure Real-Time Ratio (RTR) ↓ and Action Timeout Rate (ATR) ↓ to quantify computational efficiency and instruction execution reliability. Detailed definitions are provided in appendix B.3. Table 3: Ablation study on Overcooked across training regimes and architecture variants on the Coordination layout. Module Variant Dynamic Standard TAR ↑ AED ↓ AAS ↓ RT ↓ TAR ↑ AED ↓ AAS ↓ RT ↓ w/o SFT w/o PSD 82.3% ± 9.5% 50.93 ± 0.6 49.29 ± 2.0 15.08 ± 1.6 92.0% ± 2.1% 49.88 ± 0.4 43.82 ± 0.3 11.21 ± 0.3 RePlan 4FPS 64.7% ± 11.9% 59.27 ± 1.2 58.76 ± 2.5 91.26 ± 2.9 88.2% ± 3.7% 58.53 ± 1.0 56.18 ± 1.8 86.48 ± 1.9 RePlan 8FPS 76.5% ± 10.6% 58.77 ± 1.9 59.18 ± 2.9 63.60 ± 3.2 83.2% ± 3.1% 54.53 ± 0.5 51.47 ± 1.5 54.91 ± 2.1 SyncPlan 88.2% ± 8.1% 53.67 ± 2.3 49.29 ± 2.6 18.32 ± 2.8 92.0% ± 2.1% 49.88 ± 0.4 43.82 ± 0.3 11.21 ± 0.3 w/o RL w/o PSD 81.4% ± 4.0% [rgb] .808, .831, .878 50.71 ± 0.5 [rgb] .91, .792, .776 46.38 ± 0.9 10.09 ± 0.3 94.0% ± 1.3% 49.20 ± 0.1 43.87 ± 0.1 6.46 ± 0.1 RePlan 4FPS 17.5% ± 3.9% 61.94 ± 1.8 59.39 ± 1.0 49.34 ± 0.6 16.5% ± 3.8% 64.88 ± 1.8 55.19 ± 0.7 45.19 ± 0.3 RePlan 8FPS 29.9% ± 4.7% 71.31 ± 3.0 66.91 ± 1.5 29.03 ± 0.5 14.4% ± 3.6% 62.57 ± 4.9 56.39 ± 0.9 26.02 ± 0.3 SyncPlan [rgb] .808, .831, .878 88.7% ± 3.2% 54.53 ± 1.2 50.66 ± 1.3 [rgb] .808, .831, .878 8.85 ± 0.3 [rgb] .808, .831, .878 94.0% ± 1.3% [rgb] .91, .792, .776 49.20 ± 0.1 [rgb] .808, .831, .878 43.87 ± 0.1 [rgb] .808, .831, .878 6.46 ± 0.1 SyncPlan w/o PSD 82.3% ± 9.5% 50.79 ± 0.6 48.24 ± 2.2 11.15 ± 0.7 96.0% ± 2.0% 49.53 ± 0.2 41.88 ± 0.3 4.91 ± 0.1 RePlan 4FPS 23.5% ± 10.6% 62.00 ± 3.1 62.06 ± 1.9 41.50 ± 3.3 17.6% ± 9.5% 63.33 ± 5.4 53.71 ± 1.2 23.68 ± 0.4 RePlan 8FPS 23.5% ± 10.6% 56.50 ± 3.2 64.29 ± 3.7 17.41 ± 0.8 29.4% ±5.4% 71.80 ± 9.0 57.88 ± 2.0 16.34 ± 0.6 SyncPlan [rgb] .91, .792, .776 94.1% ± 5.9% [rgb] .91, .792, .776 50.25 ± 3.0 [rgb] .808, .831, .878 48.24 ± 2.6 [rgb] .91, .792, .776 6.58 ± 0.5 [rgb] .91, .792, .776 96.0% ± 2.0% [rgb] .808, .831, .878 49.53 ± 0.2 [rgb] .91, .792, .776 41.88 ± 0.3 [rgb] .91, .792, .776 4.91 ± 0.0 Figure 5: (A) The ROC curve of PSD model. (B) RL training curves. (C) Task performance during RL. (D) Deadlock ratios. 5.2 Main Comparison We benchmark SyncPlan against five external baselines with three architecture-stripped SyncPlan variants under a unified Overcooked protocol covering one Standard and three dynamic evaluation tasks (Table 1). The central finding is that SyncPlan substantially outperforms existing LLM-based coordinators on dynamic Overcooked tasks while maintaining much lower wall-clock latency. Compared with task-specific MARL baselines, SyncPlan achieves higher TAR on three settings. This advantage stems from SyncPlan’s event-driven correction design: instead of re-querying the LLM at a fixed frequency or per frame, it invokes the coordinator only when the PSD detects plan invalidation, reducing wall-clock overhead by two to three orders of magnitude compared with A-ToM and Collab. On the challenging Dynamic Ring layout, SyncPlan reaches 88.3% TAR, exceeding the LLM-based baselines A-ToM and Collab, while remaining below the best RL baseline. In HoK, we compare SyncPlan against two popular baseline methods, with results presented in Table 2. Our approach demonstrates lower latency by leveraging long-horizon planning. More importantly, SyncPlan and its variants exhibit significantly stronger coordination performance, achieving 86.3% TAR compared to the best baseline’s 68.75% in this complex multi-agent environment. Figure 6: Effect of coordinator model size on SyncPlan performance. The critical threshold lies between 1B and 1.5B. 5.3 Ablation Study Table 3 isolates each architectural choice by comparing Full SyncPlan against w/o PSD and two periodic replanning baselines across three training regimes. Key insights: Table 4: Ablation study on Honor of Kings. Module Variant TAR ↑ ATR ↓ RTR ↓ w/o SFT w/o PSD 59.0±11.1% 8.2±2.1% 5.92±1.3x RePlan 4FPS 67.9±4.7% [rgb] .808, .831, .8780.1±0.0% 81.17±7.7x RePlan 8FPS 69.7±6.4% 0.1±0.1% 57.52±9.4x SyncPlan 72.1±7.6% 5.8±1.3% 7.32±0.1x w/o RL w/o PSD 66.7±3.3% 7.9±4.0% [rgb] .808, .831, .8780.72±0.0x RePlan 4FPS 60.0±6.9% [rgb] .91, .792, .7760.0±0.0% 2.38±0.1x RePlan 8FPS 66.7±4.8% 0.1±0.1% 1.04±0.0x SyncPlan 79.0±2.5% 3.9±3.4% 0.96±0.0x SFT+RL w/o PSD 71.4±8.4% 6.6±1.5% 0.72±0.0x RePlan 4FPS 73.0±7.1% [rgb] .91, .792, .7760.0±0.0% 2.18±0.1x RePlan 8FPS [rgb] .808, .831, .87877.1±9.4% 0.1±0.1% 1.19±0.0x SyncPlan [rgb] .91, .792, .77686.3±5.3% 2.3±1.6% [rgb] .91, .792, .7760.83±0.0x PSD provides targeted, low-cost correction. On the standard layout, removing PSD has no effect because no dynamic perturbation ever invalidates the initial plan. Under dynamic events, the gap widens sharply: PSD recovers broken plans exactly when needed, whereas the w/o PSD variant cannot react and loses 8+ TAR points. Periodic RePlan baselines attempt to compensate by blind re-invocation, but they pay an order-of-magnitude RT penalty for marginal or even negative TAR gains, because frequent unnecessary replanning destabilizes partially executed chains. This confirms that when to correct matters more than how often. Figure 7: Performance on main backbone models. RL improves coordination quality and boosts TAR. Without RL (middle block), even Full SyncPlan achieves only 88.7% dynamic TAR because the SFT-only coordinator, despite generating syntactically correct plans, fails to account for the bot executor’s actual movement timing and collision dynamics, leading to poor coordination quality. RL enhances coordination by providing closed-loop feedback that helps the model learn execution-aligned strategies absent from offline demonstrations. The HoK ablation (Table 4) confirms these insights: SFT+RL Full SyncPlan reaches 86.3% TAR versus 79.0% without RL, while reducing ATR from 7.9% to 2.3%. These improvements demonstrate that RL refines the coordinator’s ability to generate plans that align with real execution constraints, thereby improving overall coordination quality and task success. 5.4 Training and Performance Analysis on base models Figure 5 reveals how the training stages shape coordinator behavior in complementary ways. Fig. 5(A) shows the ROC curves, demonstrating that PSD performs well under different MLP architectures. Fig. 5 (B,C) shows progressively improved TAR by exposing the coordinator to real execution feedback: the reward curve climbs steadily as the model learns to account for bot-level timing constraints that are invisible in the static SFT corpus. A byproduct is the deadlock ratio trajectory. Fig. 5D shows Full SyncPlan maintains the lowest deadlock density throughout training, while w/o SFT exhibits higher rates. This shows deadlock suppression stems from both training stages: SFT teaches structurally valid action chains that avoid resource conflicts, while RL further reduces deadlocks through execution-level collision feedback. We report the performance of backbone models in Fig. 7, from which we observe that Gemini-3.5-Flash and DeepSeek-R1 achieve the leading performance. Figure 8: PSD-triggered replanning in two scenarios. 5.5 Boundary Exploration To investigate the relationship between model capacity and planning performance, and to identify the minimum parameter threshold required for reliable action generation under structured constraints. We evaluate LLaMA-3.2-1B/3B, LLaMA-3.1-8B, and Qwen2.5-(0.5/1.5/3/7)B-Instruct. Performance (Fig. 6) scales log-linearly with parameter count, but the critical threshold lies between 1B and 1.5B: models below 1B fail to produce syntactically valid action chains at non-trivial rates, making downstream execution unreliable regardless of the framework. Above 3B, gains plateau under SyncPlan’s structured schema because the schema itself constrains the output space, meaning additional capacity yields diminishing returns once format compliance is achieved. 5.6 Case Studies Figure 8 illustrates how SyncPlan’s modules collaborate in two scenarios. When PSD detects that current plan is invalidated (P2 drops a plate, E1’s health is fast dropping). The PSD detects it and invokes LLM coordinator to update agent’s action chain to adjust the changes of environment’s state. This reactive correction completes in limited wall-clock time, whereas a fixed-interval replanner would either react too late or waste compute on unnecessary reinvocations. 6 Conclusion Aiming at coordinating multi-agents in real-time and dynamic environments, we presented SyncPlan to separate planning from execution and real-time correction detection. SyncPlan contains a synchronization-based LLM coordinator and an action correction detector to maintain the validity of plan. Experiments across different domains supported that the explicit synchronization enables effective coordination. This study also reveals that RL fine-tuning is critical for bridging LLM coordinator intent and reality across different domains. Future work will explore SyncPlan’s scalability, generalization to new environments, and larger team sizes. Additionally, we will enhance its recovery mechanisms against execution failures, persistent stalls, and rapid environmental dynamics. References J. Achiam, S. Adler, S. Agarwal, L. Ahmad, I. Akkaya, F. L. Aleman, D. Almeida, J. Altenschmidt, S. Altman, S. Anadkat, et al. (2023) Gpt-4 technical report. arXiv preprint arXiv:2303.08774. Cited by: §5.1. M. Ahn, A. Brohan, N. Brown, Y. Chebotar, O. Cortes, B. David, C. Finn, C. Fu, K. Gober, K. Gopalakrishnan, et al. (2022) Do as i can, not as i say: grounding language in robotic affordances. In Conference on Robot Learning, Cited by: §2. A. Bolton, A. Lerchner, A. Cordell, A. Moufarek, A. Bolt, A. Lampinen, A. Mitenkova, A. O. Hallingstad, B. Vujatovic, B. Li, et al. (2025) Sima 2: a generalist embodied agent for virtual worlds. arXiv preprint arXiv:2512.04797. Cited by: §1, §2. M. Carroll, R. Shah, M. K. Ho, T. Griffiths, S. Seshia, P. Abbeel, and A. Dragan (2019) On the utility of learning about humans for human-ai coordination. Advances in neural information processing systems 32. Cited by: §5.1. A. Chen, A. Li, B. Zhou, B. Gong, B. Jiang, B. Dan, C. Yu, C. Wang, C. Ma, C. Zhong, et al. (2026) The minimax-m2 series: mini activations unleashing max real-world intelligence. arXiv preprint arXiv:2605.26494. Cited by: §5.1. G. Comanici, E. Bieber, M. Schaekermann, I. Pasupat, N. Sachdeva, I. Dhillon, M. Blistein, O. Ram, D. Zhang, E. Rosen, et al. (2025) Gemini 2.5: pushing the frontier with advanced reasoning, multimodality, long context, and next generation agentic capabilities. arXiv preprint arXiv:2507.06261. Cited by: §5.1. Y. Feng, J. Wang, L. Zhou, Z. Lei, and Y. Li (2026) Doctoragent-rl: a multi-agent collaborative reinforcement learning system for multi-turn clinical dialogue. In ICASSP 2026-2026 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), p. 16952–16956. Cited by: §4.2. M. Geng, S. Pateria, et al. (2025) L2M2: a hierarchical framework integrating large language model and multi-agent reinforcement learning. In International Joint Conference on Artificial Intelligence, Cited by: §2. GLM-5-Team (2026) GLM-5: from vibe coding to agentic engineering. External Links: 2602.15763, Link Cited by: §5.1. R. Gong, Q. Huang, X. Ma, H. Vo, Z. Durante, Y. Noda, Z. Zheng, S. Zhu, D. Terzopoulos, L. Fei-Fei, and J. Gao (2024) MindAgent: emergent gaming interaction. In Proceedings of the AAAI Conference on Artificial Intelligence, Cited by: §2. A. Grattafiori, A. Dubey, A. Jauhri, A. Pandey, A. Kadian, A. Al-Dahle, A. Letman, A. Mathur, A. Schelten, A. Vaughan, et al. (2024) The llama 3 herd of models. arXiv preprint arXiv:2407.21783. Cited by: §5.1. D. Guo, D. Yang, H. Zhang, J. Song, R. Zhang, R. Xu, Q. Zhu, S. Ma, P. Wang, X. Bi, et al. (2025a) DeepSeek-R1: incentivizing reasoning capability in LLMs via reinforcement learning. arXiv preprint arXiv:2501.12948. Cited by: §5.1. J. Guo, Y. Li, Y. Wang, Z. Feng, and D. Zha (2025b) CaPo: cooperative plan optimization for efficient embodied multi-agent cooperation. In International Conference on Learning Representations, Cited by: §1, §2. W. Huang, F. Xia, T. Xiao, H. Chan, J. Liang, P. Florence, A. Zeng, J. Tompson, I. Mordatch, Y. Chebotar, et al. (2022) Inner monologue: embodied reasoning through planning with language models. In Conference on Robot Learning, Cited by: §2. B. Hui, J. Yang, Z. Cui, J. Yang, D. Liu, L. Zhang, T. Liu, J. Zhang, B. Yu, K. Lu, et al. (2024) Qwen2. 5-coder technical report. arXiv preprint arXiv:2409.12186. Cited by: §5.1. M. Jaderberg, V. Dalibard, S. Osindero, W. M. Czarnecki, A. Razavi, O. Vinyals, T. Green, I. Dunning, K. Simonyan, C. Fernando, and K. Kavukcuoglu (2017) Population based training of neural networks. arXiv preprint arXiv:1711.09846. Cited by: §5.1. J. G. Kuba, R. Chen, M. Wen, Y. Wen, F. Sun, J. Wang, and Y. Yang (2022) Trust region policy optimisation in multi-agent reinforcement learning. In International Conference on Learning Representations, Cited by: §1, §2. Y. Li, S. Zhang, J. Sun, Y. Du, Y. Wen, X. Wang, and W. Pan (2023) Cooperative open-ended learning framework for zero-shot coordination. In International Conference on Machine Learning, p. 20470–20484. Cited by: §5.1. Y. Liao, Y. Gu, Y. Sui, Z. Zhu, Y. Lu, G. Tang, Z. Sun, and W. Yang (2025) Think in games: learning to reason in games via reinforcement learning with large language models. arXiv preprint arXiv:2508.21365. Cited by: §1, §2. S. Liu, H. Wang, Y. Chen, J. Zhang, and Y. Yang (2026) MAGRPO: multi-agent group relative policy optimization. In AAAI Conference on Artificial Intelligence, Cited by: §2. C. Mu, Y. Zeng, Q. Zhang, K. Shao, C. Chu, H. Guo, D. Jia, Z. Wang, and S. Hu (2026) Adaptive theory of mind for llm-based multi-agent coordination. In Proceedings of the AAAI Conference on Artificial Intelligence, Vol. 40, p. 29608–29616. Cited by: §5.1. T. Rashid, M. Samvelyan, C. S. de Witt, G. Farquhar, J. Foerster, and S. Whiteson (2018) QMIX: monotonic value function factorisation for deep multi-agent reinforcement learning. In International Conference on Machine Learning, p. 4295–4304. Cited by: §1, §2. K. Shridhar, A. Stolfo, and M. Sachan (2023) Distilling reasoning capabilities into smaller language models. In Findings of the Association for Computational Linguistics: ACL 2023, p. 7059–7073. Cited by: §1. K. Son, D. Kim, W. J. Kang, D. E. Hostallero, and Y. Yi (2019) QTRAN: learning to factorize with transformation for cooperative multi-agent reinforcement learning. In International Conference on Machine Learning, p. 5887–5896. Cited by: §2. D. Strouse, K. McKee, M. Botvinick, E. Hughes, and R. Everett (2021) Collaborating with humans without human data. Advances in neural information processing systems 34, p. 14502–14515. Cited by: §5.1. H. Sun, S. Zhang, L. Niu, L. Ren, H. Xu, H. Fu, F. Zhao, C. Yuan, and X. Wang (2025) Collab-overcooked: benchmarking and evaluating large language models as collaborative agents. In Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing, Suzhou, China, p. 4922–4951. External Links: Link, Document, ISBN 979-8-89176-332-6 Cited by: §5.1. G. Team, R. Anil, S. Borgeaud, J. Alayrac, J. Yu, R. Soricut, J. Schalkwyk, A. M. Dai, A. Hauth, K. Millican, et al. (2023) Gemini: a family of highly capable multimodal models. arXiv preprint arXiv:2312.11805. Cited by: §5.1. K. Team, A. Du, B. Yin, B. Xing, B. Qu, B. Wang, C. Chen, C. Zhang, C. Du, C. Wei, et al. (2025) Kimi-vl technical report. arXiv preprint arXiv:2504.07491. Cited by: §5.1. G. Wang, Y. Xie, Y. Jiang, A. Mandlekar, C. Xiao, Y. Zhu, L. Fan, and A. Anandkumar (2023) Voyager: an open-ended embodied agent with large language models. Advances in Neural Information Processing Systems. Cited by: §2. Z. Xu, Y. Bai, B. Zhang, D. Li, and G. Fan (2023) HAVEN: hierarchical cooperative multi-agent reinforcement learning with dual coordination mechanism. In AAAI Conference on Artificial Intelligence, Cited by: §2. C. Yu, A. Velu, E. Vinitsky, J. Gao, Y. Wang, A. Baez, S. Bhatt, et al. (2022) The surprising effectiveness of ppo in cooperative multi-agent games. Advances in Neural Information Processing Systems. Cited by: §1, §2. Y. Yu, Z. Zhai, W. Li, and J. Ma (2024) Target-oriented multi-agent coordination with hierarchical reinforcement learning. Applied Sciences 14 (16), p. 7084. Cited by: §2. X. Zeng, Y. Sun, H. Li, S. Liu, and H. Wang (2026) Recapa: hierarchical predictive correction to mitigate cascading failures. arXiv preprint arXiv:2604.21232. Cited by: §2. C. Zhang, K. Yang, S. Hu, Z. Wang, G. Li, Y. Sun, C. Zhang, Z. Zhang, A. Liu, S. Zhu, X. Chang, J. Zhang, F. Yin, Y. Liang, and Y. Yang (2024) ProAgent: building proactive cooperative agents with large language models. In AAAI Conference on Artificial Intelligence, Cited by: §1, §2, §5.1. H. Zhang, Z. Du, T. Qi, D. Zhao, et al. (2025a) COMBO: compositional world models for embodied multi-agent cooperation. In International Conference on Learning Representations, Cited by: §2. S. Zhang, X. Wang, W. Zhang, C. Li, J. Song, T. Li, L. Qiu, X. Cao, X. Cai, W. Yao, et al. (2025b) Leveraging dual process theory in language agent framework for real-time simultaneous human-ai collaboration. In Proceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), p. 4081–4108. Cited by: §5.1. R. Zhao, D. Zhou, S. K. Jha, N. D. Bastian, and A. Shah (2026) HiComm: hierarchical communication for multi-agent reinforcement learning. arXiv preprint arXiv:2606.29126. Cited by: §4.2. Appendix A Method Details A.1 Algorithm Algorithm 1 separates the slow planning path from the per-frame execution path. The coordinator θD_θ first generates an initial multi-agent plan and initializes chain pointers and the wait graph for execution tracking (line 2). At each timestep, the system executes the current plan step and checks for deadlock situations (lines 4-5). If the task is completed, the algorithm terminates successfully (lines 6-8). Otherwise, the Plan Staleness Detector (PSD) evaluates whether replanning is necessary by analyzing the current context, execution status, and state changes (lines 9-10). Replanning is triggered either when a deadlock is detected or when the staleness probability exceeds the threshold η (line 11), in which case a new plan is generated and execution trackers are reset (lines 12-13). If the plan remains valid, only the chain pointers are updated to reflect execution progress (line 15). This design enables efficient plan reuse while maintaining adaptive coordination through selective replanning. A.2 Training Pipeline Overview Figure 9 illustrates the two-stage training pipeline used to optimize the SyncPlan Coordinator. Stage 1 (SFT) initializes the Coordinator with behavioral priors. Stage 2 (GRPO) further refines the policy through reinforcement learning with the composite reward signal defined in Table 7. Figure 9: Overview of the two-stage SFT++RL training pipeline for the SyncPlan Coordinator. Stage 1 performs supervised fine-tuning; Stage 2 applies GRPO reinforcement learning with environment-grounded rewards. We train the Coordinator using LoRA adapters in both stages. We first collect gameplay data and annotate it with labels. We use this labeled data to perform SFT, which produces the first-generation LoRA adapter. We then merge this adapter into the base model to obtain the SFT model. This model also serves as the starting point for the RL stage. At the beginning of the RL stage, we initialize the training loop with a LoRA adapter whose weights are all zero. This adapter does not change the behavior of the base model. It only provides a general interface for loading LoRA weights during the loop. During the RL loop, we use random seeds to generate different game matches, and we disable scripted dynamic events in the environment. As a result, RL does not directly train on injected perturbations; instead, the gains observed in dynamic evaluation arise from better alignment between the Coordinator and the real executor under the environment’s timing and collision constraints. We separate inference and training by using vLLM for inference and TRL for training. Algorithm 1 SyncPlan 0: task e, initial state s0s_0, correction threshold η 1: Π←θ(s0,e) _θ(s_0,e) 2: initialize chain pointers hi\h_i\ and wait graph G 3: for each frame t do 4: t,deadlock←ExecuteStep(Πt,hi,,st)a_t,deadlock← ExecuteStep( _t,\h_i\,G,s_t) 5: apply ta_t and observe st+1s_t+1 6: if (st+1,e)=1C(s_t+1,e)=1 then 7: return Success 8: end if 9: construct t+1,t+1,t+1C_t+1,X_t+1, _t+1 10: Preplan←PSD(t+1,t+1,t+1)P_replan (C_t+1,X_t+1, _t+1) 11: if deadlockdeadlock or Preplan>ηP_replan>η then 12: Π←θ(st+1,e) _θ(s_t+1,e) 13: reset hi\h_i\ and G 14: else 15: Update hi\h_i\ 16: end if 17: end for A.3 Complete Prompt Templates This subsection provides the full prompt templates used in the SyncPlan Plan Module. The Plan Module is invoked as a single structured LLM call that produces per-agent action chain assignments. We use two prompt variants depending on whether the underlying model has been fine-tuned on the target environment: a Non-SFT variant for off-the-shelf base/instruct models, and a SFTed variant for models that have already internalized the action vocabulary through supervised fine-tuning or RL on SyncPlan trajectories. Prompt schema overview. Both variants follow the same three-role chat layout. The System message encodes the static task framing: the environment Background, the coordination Target, and the number of controlled agents. The User message supplies the dynamic Current Environment State at the current decision step. The Assistant response emits per-agent action chains inside tagged blocks, one block per agent. The variants differ only in whether the action vocabulary (Description and Usage) is materialized in the System message. Variant 1: Non-SFT prompt. For base or instruct models with no environment-specific fine-tuning, the System message must spell out the full action vocabulary so the model can ground its outputs: [System] You are a planner for Background. Your target is Target while controlling Num of Agents agents. You assign each agent an action chain. The action list is Description; the usage is Usage. There are some cases: Case. [User] Here is the current state: State [Assistant] "agent_1":action1, action2, ..., "agent_2":action1, action2, ... ... Variant 2: SFTed prompt. For models that have been fine-tuned on SyncPlan trajectories from the target environment, the action vocabulary is already internalized in the weights, so the Description and Usage slots are dropped from the System message. [System] You are a planner for Background. Your target is Target while controlling Num of Agents agents. [User] Here is the current state: State [Assistant] "agent_1":action1, action2, ..., "agent_2":action1, action2, ... ... Slots in braces (Background, Target, Num of Agents, Description, Usage, State) are template variables filled at planning time; tokens inside the Assistant blocks are generated by the model. A.4 Deadlock Detection This detector addresses agent-dependency deadlocks: cycles induced by active Wait_agents predicates. It does not classify an unsatisfied Wait_entity predicate, a timeout, or another non-cyclic execution failure as a graph deadlock; those cases remain available to the PSD or the episode-level termination logic. We maintain a directed dependency graph =(,ℰ)G=(V,E), where =1,…,KV=\1,…,K\ and an edge i→j∈ℰi\!→\!j exists only while agent i is blocked by an active Wait_agents(j,m,s) Wait\_agents(j,m,s) predicate. A graph deadlock corresponds to a directed cycle in G. When agent i enters a new wait Wait_agents(j,m,s) Wait\_agents(j,m,s), we test whether j can already reach i in G before inserting the edge: ℛ(j,i)=trueif i=j,trueif ∃k.(j,k)∈ℰ∧ℛ(k,i),falseotherwise.R(j,i)\;=\; casestrue&if i=j,\\ true&if ∃ k.\ (j,k)\!∈\!E\, \,R(k,i),\\ false&otherwise. cases (8) If ℛ(j,i)=trueR(j,i)=true, inserting i→ji\!→\!j would close a cycle, which means a deadlock is found. Otherwise, the edge is appended to ℰE. When agent i’s wait is satisfied, the edge i→ji\!→\!j is removed in O(1)O(1); since the remaining graph stays acyclic by construction, no rebuild is required. Each reachability check is bounded by O(||+|ℰ|)=O(K2)O(|V|+|E|)=O(K^2) in the worst case, but in practice each agent has at most one outgoing wait edge (|ℰ|≤K|E|\!≤\!K), reducing the cost to O(K)O(K). A.5 The design details of action chains In this section, we introduce the details of action chains. Action-Chain Step Language Each step-level objective oi(ℓ)o_i^( ) takes one of two forms: an action or a wait condition. This design follows the basic distinction between execution and synchronization in concurrent programming. An action primitive specifies an operation that can be verified by the environment. A wait primitive specifies a condition on other agents or on the world state that must be satisfied before the next step can proceed. This design gives the LLM an explicit way to represent synchronization, rather than forcing it to hide such logic in natural-language step descriptions. ⟨step⟩ ::=⟨action⟩∣⟨wait⟩ := ⟨wait⟩ ::=⟨atom⟩∣⟨atom⟩(&∣|)⟨atom⟩ := \ ( \& |)\ ⟨atom⟩ \ ::=Wait_agents(a,start|done,s) := Wait\_agents(a,\start|done\,s) ∣Wait_entity(e,attr,op,v) \; Wait\_entity(e,attr,op,v) The action vocabulary depends on the environment. In contrast, the wait primitives capture two synchronization patterns that appear in both environments. In Wait_agents(a, m, s), a identifies the prerequisite agent, m∈start,donem∈\ start, done\ selects whether the prerequisite is the start or completion milestone, and s identifies the referenced step in that agent’s current chain. The predicate is removed as soon as the indicated milestone is observed. Wait_entity pauses progress until a condition on the world state becomes true, based on an exposed entity attribute such as hero health or pot status. We allow bounded & and | composition, so the language can express common coordination rules such as "both teammates have arrived" or "low HP or under attack" while keeping each predicate evaluation local to the current frame. This language is used directly by the Execute Module. A Wait_agents cycle triggers the graph-deadlock pathway in Appendix A.4; non-cyclic unsatisfied waits are not silently reclassified as deadlocks. The action list of Honor of Kings Table 5 defines the complete action-primitive vocabulary used by the Plan Module in the HoK environment. Type Target Description Kill Enemy or monster Kill the specific target Move Position Move to specific position Push Tower Destroy the specific tower Clear None Kill all the minions around Back None Back to home Table 5: HoK action-primitive vocabulary. In Honor of Kings, we support the five common action types described above. The LLM is required to coordinate participant agents using these five actions with the two wait primitives. The action list of Overcooked. Table 6 defines the action vocabulary for Overcooked. Type Target Description Interact Target Interact with the specified target Move_to Position Move to specific position Face Direction Face the specific direction Table 6: Overcooked action-primitive vocabulary. Target specifies the station or ingredient; Position is the grid coordinate. A.6 The design details of PSD The design principle Since the detector must operate at high frequency to capture situational changes in real time, efficiency is the primary design goal. We therefore use a simple and lightweight structure to track state changes in relevant entities. The input of PSD model Since the PSD module must monitor both the absolute state and the relative change of every entity in the environment, its input is built from two complementary entity-level tensors rather than raw observations. At each frame t, we compute the normalized entity-state matrix t∈[0,1]M×FX_t∈[0,1]^M× F, which encodes the current absolute state of all M tracked entities across F normalized attributes, and the state-change matrix t∈[−1,1]M×F _t∈[-1,1]^M× F, obtained by differencing tX_t against the state krefk_ref frames earlier. We use kref=3k_ref=3 (Table 7). Feeding both the absolute state tX_t and the differential signal t _t lets the detector distinguish a stable-but-unfavorable situation from one that is rapidly deteriorating. In addition to tX_t and t _t, we construct the chain-entity incidence tensor t∈0,1N×M×LC_t∈\0,1\^N× M× L for the remaining plan and N agents. Specifically, Ct,i,j,ℓ=1C_t,i,j, =1 if entity j is referenced by the unexecuted step ℓ≥hi ≥ h_i in agent i’s current chain; completed-prefix steps are masked out. This tensor supplies a relevance prior: rather than weighting every entity equally, it directs the PSD toward entities referenced by the portion of the plan that can still be invalidated. Tensor contraction and output shape. The concise notation in Equations (4)–(6) contracts the agent axis of tC_t. Concretely, C∈ℝL×dW_C ^L× d first maps the step axis to d dimensions, and NW_N then sums over controlled agents, yielding C∈ℝM×dH_C ^M× d. For the state pathway, Q∈ℝFW_Q ^F is broadcast across entities as a feature-wise gate and X∈ℝF×dW_X ^F× d maps the gated state-difference features to X∈ℝM×dH_X ^M× d. Thus C⊤X∈ℝd×dH_C H_X ^d× d; the MLP maps this interaction matrix to one logit, and the sigmoid produces the scalar Preplan(t)∈(0,1)P_replan(t)∈(0,1). This convention is used consistently in the implementation and in the main-paper equations. Figure 10: Constructing the remaining-plan chain-entity incidence tensor tC_t per domain. (a) Honor of Kings: spatial-proximity rule. (b) Overcooked: action-object binding. Action-Chain Incidence Matrix The definition of entity relevance in tC_t depends on the domain. For this reason, we do not learn tC_t from data. Instead, we construct it with a lightweight heuristic that reflects the structure of each environment. Figure 10 shows the resulting entity relevance matrices in the two domains. In Honor of Kings, most chain steps are spatial. Typical examples include Attack, Move, and Wait with respect to a target location or target entity. In this setting, whether an entity is relevant mainly depends on spatial proximity. For each step, we always include the self-agent. We also include entities within a fixed radius around the self-agent, as well as entities within a fixed radius around the target location or target entity. All included entities are marked as relevant by setting Ct,i,j,ℓ=1C_t,i,j, =1 for the corresponding agent i, entity j, and unexecuted step ℓ . Entities that are far away from both the self-agent and the target remain 0 (Figure 10a). In Overcooked, most chain steps are centered on specific objects or agents. Typical examples include Move_to and Interact Device. In this setting, relevance is determined by the object referenced in the step template rather than by spatial distance. We parse the operation template of the current step and identify the referenced entity category, such as a Device slot or a Player slot. The corresponding category is then marked as relevant in tC_t, while unrelated devices and players remain 0 (Figure 10b). This design keeps tC_t simple and fully rule-based. It does not introduce any additional learnable parameters. It is also easy to extend to a new environment. One only needs to define an appropriate relevance rule based on the structure of that domain. Training Data & Labels The PSD is trained as a binary classifier: given the input tensors (t,t,t)(C_t,X_t, _t) at frame t, it predicts whether the remaining chain should be corrected, supervised by a binary label yt∈0,1y_t∈\0,1\. Here yt=1y_t=1 denotes an operationally defined plan-staleness event: an observed or constructed change that invalidates an assumption used by at least one remaining chain step; yt=0y_t=0 denotes a clean frame with no such event. Training data for the two environments is constructed independently from the SFT corpus (Section A.7) and is not shared across environments. Overcooked: event-frame labeling. We reuse the dynamic-event injection protocol (Section B.4): the frame at which a dynamic event is injected is labelled yt=1y_t=1, since the event is designed to invalidate at least one field of the active chain. Frames drawn from clean (non-injected) rollouts are labelled yt=0y_t=0. Because positive frames are rare relative to the length of a rollout, we subsample negative frames at a positive-to-negative ratio of 1:51:5 to mitigate the class imbalance that would otherwise bias the classifier toward always predicting yt=0y_t=0. Honor of Kings: synthetic perturbation. HoK has no scripted event injection at evaluation time (Section B.4); however, to obtain a sufficiently dense supervision signal for training the PSD, we construct positive examples offline by synthetically perturbing recorded frames so that the active chain becomes invalid. Two perturbation types are used: (i) reducing the health of an allied agent referenced by the active chain, simulating an unexpected engagement risk; and (i) moving an enemy hero closer to the chain’s target location or agent, simulating an unanticipated rotation. Each perturbed frame is manually reviewed to confirm that the perturbation indeed renders the original chain unreasonable before being accepted as a positive example; frames without perturbation are labelled yt=0y_t=0. This synthetic construction is used exclusively to train the PSD offline and does not alter the injection-free evaluation protocol described in Section B.4, under which HoK dynamics arise entirely from uncontrolled bot behavior. Data collection and split. The HoK and Overcooked PSD training sets are each collected independently of the corresponding SFT rollout pool, and each is split into training and validation subsets with an 8:28:2 ratio. PSD Threshold Selection The PSD threshold θPSD _PSD trades off between recall (catching genuine chain invalidations) and precision (avoiding unnecessary replanning). We select θPSD=0.7 _PSD=0.7 via grid search over 0.3,0.5,0.7,0.9\0.3,0.5,0.7,0.9\ on a held-out validation set, balancing detection recall with replanning overhead. Figure 11: Event-driven SFT data augmentation. Each dashed vertical line marks an action-chain update event. Within one segment, different agents may execute different numbers of actions under the same chain. For example, the first segment has counts (4,3,3), while the next replanned segment has counts (2,2,1). A.7 SFT Data Augmentation Our SyncPlan-RL Coordinator is first warm-started with a short supervised fine-tuning (SFT) stage before online RL, and we also report an SFT-only baseline in the main paper. This section describes how the SFT corpus is constructed. A naive per-step imitation objective is inefficient, because many consecutive frames share the same action chain and therefore provide highly repetitive supervision. In contrast, the informative decision points are the moments when the Coordinator updates the chain. We therefore use an event-driven data augmentation scheme that converts each chain-update event into one QA training instance, while also recording the multi-agent action footprint within the corresponding segment. Construction protocol. We replay SyncPlan trajectories collected from the prompt-only Coordinator and treat each chain-update event as a supervision boundary. For each rollout, we apply the following procedure: 1. Detect chain-update events. A boundary tkt_k is recorded whenever the Plan Module emits a new action-chain set τitk\ _i\_t_k. 2. Aggregate per-agent action footprints. For each segment [tk,tk+1)[t_k,t_k+1), we record, for every controlled agent i, how many atomic actions were actually executed under the same chain. For example, the first segment in Figure 11 has action counts (4,3,3)(4,3,3). These counts are stored as auxiliary metadata for each segment. 3. Generate one QA instance per boundary. For each boundary tkt_k, we create one QA pair. The question consists of the Coordinator observation at tkt_k, including the current state otko_t_k, the previous chain set τitk−1\ _i\_t_k-1, and the correction history htkh_t_k. The answer is the new chain set τitk\ _i\_t_k emitted at that boundary, together with the per-agent action-footprint statistics collected from the subsequent segment [tk,tk+1)[t_k,t_k+1). A.8 Reward Design This section provides the full definition of the reward R(A)R(A) used in GRPO training. Executing a generated action chain terminates in exactly one of five mutually exclusive outcomes: Success, SyntaxError, SemanticError, Deadlock, or Timeout. For an action chain A, the reward is R(A)=Rprog(A)+α[Ω(A)=Success]−(Psyn(A)+Psem(A)+Pdlk(A)+Ptmo(A)). splitR(A)=R_prog(A)+α\,1[ (A)= Success]\\ - (P_syn(A)+P_sem(A)+P_dlk(A)+P_tmo(A) ). split Each penalty is zero unless its corresponding terminal outcome occurs. The reward is computed once per response and then clamped to the range [−1,1][-1,1]. Progress reward. The term Rprog(A)R_prog(A) combines three dense signals. The first is execution progress within the generated chain, rather than a second task-success indicator: Rprog(A)=wfracRfrac(A)+weffReff(A)+wlenRlen(A).R_prog(A)=w_fracR_frac(A)+w_effR_eff(A)+w_lenR_len(A). Each component is normalized to [0,1][0,1] before weighting. • Rfrac(A)R_frac(A) measures fractional progress toward the action chain: Rfrac(A)=ncompletedntotal,R_frac(A)= n_completedn_total, where ncompletedn_completed is the number of completed actions and ntotaln_total is the length of action chain. This term is defined for every response, regardless of the final outcome. • Reff(A)R_eff(A) rewards faster successful completion: Reff(A)=1−tfinishTR_eff(A)=1- t_finishT if the task is completed successfully, and Reff(A)=0R_eff(A)=0 otherwise. Here tfinisht_finish is the frame at which the task is completed, and T is the episode horizon. • Rlen(A)R_len(A) is a length regularization term. It favors responses whose length falls within the ideal token range [Lmin,Lmax]=[100,500][L_ ,L_ ]=[100,500], and decreases outside this range, with a maximum reduction of 0.50.5. Penalty terms. The penalty terms correspond to the four non-success outcomes. With the values in Table 7, deadlock receives the largest fixed penalty (1.01.0), semantic failure receives 0.30.3, syntax failure receives 0.10.1 scaled by the fraction of malformed instructions, and timeout has no additional fixed penalty; a timeout still forfeits both the success bonus and the efficiency reward. This explicit numerical ordering is the one used in training. • Syntax penalty. If the response cannot be parsed, we apply Psyn(A)=λsyn⋅sevsyn(A).P_syn(A)= _syn·sev_syn(A). The severity sevsyn(A)∈[0,1]sev_syn(A)∈[0,1] equals 11 for a fully unparsable response, such as invalid JSON. For a partially malformed response, it is defined as the fraction of invalid instructions among all instructions. • Semantic penalty. If the response is syntactically valid but fails semantic validation during execution, we apply a fixed penalty Psem(A)=λsemP_sem(A)= _sem Typical cases include references to non-existent targets or invalid entities. • Deadlock penalty. If execution enters deadlock, we apply Pdlk(A)=λdlkP_dlk(A)= _dlk • Timeout penalty. If the response times out without triggering syntax, semantic, or deadlock failure, we set Ptmo(A)=λtmoP_tmo(A)= _tmo In this case, the response receives no additional fixed penalty, but it also does not receive the success bonus α or the efficiency reward ReffR_eff. This makes timeout the mildest of the four failure modes. Parameter Value Success bonus α 0.45 Penalty coefficients λsyn _syn (syntax error) 0.1 λsem _sem (semantic error) 0.3 λdlk _dlk (deadlock) 1.0 λtmo _tmo (timeout) 0.0 RprogR_prog internal weights wfracw_frac (fractional progress) 0.15 weffw_eff (efficiency) 0.15 wlenw_len (length term) 0.25 Environment Horizon T 100 steps krefk_ref (replan reference) 3 Length regularization Ideal token range [Lmin,Lmax][L_ ,L_ ] [100,500][100,500] Maximum reduction 0.5 Table 7: Configuration of the GRPO reward function. Appendix B Experiment Details B.1 Computing infrastructure. All experiments were conducted on Linux servers running TencentOS Server 4.2. Each server is equipped with dual-socket AMD EPYC 9K84 96-Core processors and 8 NVIDIA H20 GPUs, each with 96 GB memory. The software environment uses Python 3.11.6, NVIDIA driver 535.161.08, and CUDA 12.8. Our training and inference stack is built on PyTorch 2.10.0, Transformers 4.57.6, TRL 0.24.0, vLLM 0.19.0, Accelerate 1.7.0, DeepSpeed 0.16.4, PEFT 0.18.1, and LLaMA-Factory 0.9.5.dev0. B.2 Environment Layouts We evaluate on three Overcooked layouts shown in Figure 12: Coordination, Ring, and Symmetric. The standard evaluation uses the original, unperturbed dynamics on the Coordination layout. Dynamic evaluation applies the seeded perturbation protocol in Section B.4 to each of the three layouts, yielding the Dynamic (Coordination), Dynamic (Ring), and Dynamic (Symmetric) settings reported in the main comparison. B.3 Evaluation metrics In this section, we define the reported metrics. For each evaluation setting, we run independent trials and report the mean and standard deviation across trials. The random seed for the i-th repeated trial is set to i, which ensures reproducible replay under the same evaluation protocol. In HoK, we additionally randomize the controlled heroes’ starting positions and orientations before each episode to increase evaluation diversity. HoK starting points are selected from player-match records using an internal filtering pipeline and then replayed under the same seed-controlled setup for all compared methods. Figure 12: Our experiments are conducted on three different layouts. We report four common metrics in both environments. Task Achievement Ratio (TAR) is the percentage of trials in which the target task is successfully achieved. Average Eposide Duration (AED), Average Action Steps(AAS), and Running Time (RT) denote the average episode duration, average movement steps, and wall-clock running time, respectively, computed over repeated trials. We also report domain-specific diagnostic metrics. For Overcooked, the deadlock rate is defined as the fraction of executed actions that result in deadlock. For HoK, we report Action Timeout Rate (ATR), defined as the fraction of coordinator action whose execution exceeds the allowed wall-clock budget. Paired statistical testing. For the marked main-table comparisons, the i-th run of each method is paired through the same evaluation seed and, in Overcooked, the same seeded event realization. We apply a two-sided paired permutation test to the trial-level outcomes under each setting. The significance markers in the main comparison denote comparisons of SyncPlan (SFT+RL) with the LLM-based baselines in the corresponding setting; the markers are not intended as a claim of significance against task-specific RL baselines. Figure 13: The HoK game map. B.4 Dynamic Event Taxonomy and Trigger Protocols The design rationale of dynamic events Real-world dynamic events form an open-ended combinatorial perturbation space: enemy support can arrive from any direction with any composition; held items can drop at any frame; an ally can disconnect or be teleported mid-chain. Enumerating this space exhaustively is impossible. Instead, for evaluation we define a small set of dynamic event types that provides broad coverage of the main failure modes. Each type is triggered by a seeded script in Overcooked so that the same perturbation can be replayed across methods and seeds. Figure 14: In-game performance variation over the course of RL training. Overcooked dynamic event injection Table 8 summarizes the three Overcooked dynamic event types and the action-chain field each one stresses. Overcooked events reuse the injection hooks exposed by the Collab-Overcooked platform. All three events are triggered from a seeded RNG so that runs across methods and seeds see the exact same sequence. ID Name Example O1 Held-Item Drop Held onion drops to floor O2 Pot-Content Scatter 1 of 3 onions scattered; timer resets O3 Agent Displacement Agent teleported to a far counter Table 8: Overcooked dynamic events. Hyperparameter Value Model Flash attention FA2 Precision bfloat16 LoRA Rank 32 Alpha 64 Dropout 0.05 Target modules All linear layers Data Template Qwen chat format Max sequence length 4,096 tokens Validation split 5% Optimization Per-device batch size 1 Gradient accumulation 8 Learning rate 2×10−52× 10^-5 LR schedule Cosine Warmup ratio 0.1 Epochs 4 Save interval 200 steps Eval interval 200 steps Table 9: SFT training hyperparameters (LLaMA-Factory + LoRA). HoK dynamic event injection In HoK we do not inject any scripted events. The environment is inherently non-stationary: uncontrolled allied and adversarial bots act on their own policies, so perturbations to an action chain (enemy reinforcements rotating in, an objective disengaging, a teammate dying) arise naturally during play. HoK therefore serves as a complexity stress-test in which dynamic events are endogenous, and only Overcooked uses the injected event protocol below. Hyperparameter Value Model Base model Qwen2.5-7B-Instruct Max sequence length 4,096 tokens Precision bfloat16 LoRA Rank 32 Alpha 64 Target modules q, k, v, o, gate, up, down proj GRPO Prompts per batch 10 Responses per prompt 10 Min group size 2 Clipping threshold ϵε 0.2 KL coefficient β 0.02 Entropy coefficient 0.001 Optimization Learning rate 5×10−55× 10^-5 Warmup ratio 0.03 Per-device batch size 2 Gradient accumulation 4 Max grad norm 1.0 Epochs 1 Seed 42 Table 10: RL (GRPO) training hyperparameters. Figure 15: Training curves (reward and loss) during RL optimization. B.5 SFT Training Hyperparameters Table 9 lists the hyperparameters for the supervised fine-tuning stage. We use LLaMA-Factory with LoRA adaptation on Qwen2.5-7B-Instruct. Figure 16: Overcooked case study on the Coordination layout. When the active chains create mutually dependent Wait_agents predicates, the incremental reachability test in Section A.4 detects the resulting wait cycle. The re-invoked Plan Module emits a revised chain with an explicit Wait_agents step that serializes tile access, allowing both agents to complete delivery without collision. B.6 RL Training Hyperparameters Table 10 lists all hyperparameters for the GRPO-based RL training. B.7 PSD Architecture Table 11: PSD Architecture Arch. Loss Param F1(opt) Acc(opt) Precision Recall Small BCE 68,737 0.8062 0.8363 0.6799 0.9902 Focal 68,737 0.8189 0.8491 0.697 0.9924 Medium BCE 261,377 0.8284 0.8588 0.7115 0.9913 Focal 261,377 0.8204 0.8509 0.7003 0.9902 Wide BCE 745,473 0.8169 0.8472 0.6947 0.9913 Focal 745,473 0.8382 0.8685 0.7266 0.9902 To determine the optimal architecture for the Plan Staleness Detector (PSD), we conducted an architecture search across different model scales and loss functions. As shown in Table 11, we evaluated three architectures—Small (68K parameters), Medium (261K parameters), and Wide (745K parameters)—with both Binary Cross-Entropy (BCE) and Focal loss. The results indicate that performance differences across architectures are relatively modest, with F1 scores ranging from 0.8062 to 0.8382 and accuracy from 0.8363 to 0.8685. Notably, all configurations achieve consistently high recall (above 0.99), which is critical for detecting plan staleness to avoid coordination failures. The Wide architecture with Focal loss achieves the best overall performance (F1: 0.8382, Acc: 0.8685), offering a favorable trade-off between precision (0.7266) and recall (0.9902). Based on these findings, we adopt the Wide+Focal configuration for subsequent experiments, as the marginal parameter increase is justified by its superior detection capability. Figure 17: Honor of Kings case study: the PSD detects an unexpected health drop on the support hero caused by an enemy rotation invalidating the original engagement-window assumption. Appendix C Additional Experimental Analysis C.1 Training Dynamics We visualize the RL training process from two complementary perspectives: in-game task performance (Figure 14) and optimisation-level statistics (Figure 15). In-game performance. Figure 14 tracks task completion and deadlock-rate trajectories over GRPO iterations. The curves show improving task completion together with a declining rate of cyclic wait failures. They are descriptive training diagnostics rather than an estimate of generalization to unseen event distributions. Optimization curves. Figure 15 reports the GRPO reward and policy-loss trajectories. The reward trend is interpreted jointly with the task-level evaluation tables: it is evidence of training progress, but it is not by itself evidence that any single reward component or module causes the final performance gain. C.2 Case Studies This section expands the two representative episodes summarized in the main paper’s Case Studies section with the full step-by-step trace of each correction event. Overcooked: Resolving a Spatial Conflict Figure 16 traces an episode on the Coordination layout in which the initial plan assigns both agents an overlapping tile as an intermediate waypoint. If execution turns this conflict into mutually dependent Wait_agents predicates, the incremental reachability check in Section A.4 detects that adding the new wait edge closes a cycle and raises a graph-deadlock signal. The Plan Module is then reinvoked and produces an explicit Wait_agents step that serializes access to the shared tile, after which the agents complete their pickup/delivery sequence. Honor of Kings: PSD-Triggered Reactive Correction Figure 17 traces a team-gank episode in which the original plan assumes a safe engagement window for a flanking maneuver on the enemy jungler. Partway through execution, an off-screen enemy hero rotates into the fight and the support hero’s health changes unexpectedly relative to the state on which the chain was conditioned. Because the affected hero is referenced by a remaining chain step, the PSD state pathway incorporates this entity-level change; once PreplanP_replan exceeds θPSD=0.7 _PSD=0.7, the Plan Module is reinvoked on the updated state. The resulting chain redirects the support hero to disengage and provide healing rather than continuing the original flanking route, while the remaining agents adjust their engagement timing. This case illustrates selective correction under endogenous HoK dynamics; aggregate latency results are reported in the main paper.