ELHPlan: Efficient LLM-Based Multi-Agent Planning

• ELHPlan is a framework for long-horizon task planning in dynamic, partially observable multi-agent environments using LLMs.
• It employs Action Chains—sequences of actions tied to sub-goal intentions—to enable local replanning and reduce token consumption.
• The framework achieves efficient performance by balancing adaptivity and resource costs, outperforming iterative methods in scalability and latency.

ELHPlan is a framework for efficient long-horizon task planning in LLM-based multi-agent collaboration, designed for partially observable, initially unknown, and dynamic embodied environments. It introduces Action Chains—sequences of actions explicitly bound to sub-goal intentions—as the fundamental planning primitive, and organizes planning as a cyclical process of construction, proactive validation, targeted refinement, and execution. The framework is presented as a response to a central trade-off in LLM planning: declarative methods are efficient but brittle under environmental dynamics, whereas iterative methods remain adaptive at the cost of frequent queries, high token consumption, and latency that scale poorly with horizon length and team size (Ling et al., 29 Sep 2025).

1. Problem setting and design objective

ELHPlan is evaluated on two embodied multi-agent benchmarks. The first is TDW-MAT (ThreeDWorld Multi-Agent Transport), which consists of long-horizon transport tasks in partially observable, initially unknown household-like indoor environments; episodes terminate either after 3,000 simulation steps or upon completion of 10 sub-goals, and evaluation is conducted on 24 test tasks. The second is C-WAH (Communicative Watch-And-Help), which emphasizes multi-agent assistance under constrained step budgets; episodes terminate at 150 steps with completion of assigned sub-goals, typically 3–5 per task, and evaluation is conducted on 10 test tasks (Ling et al., 29 Sep 2025).

The planning problem is defined by three coupled difficulties. First, partial observability and nonstationarity require plans to adapt when the environment deviates from prior assumptions. Second, iterative LLM planning incurs frequent model queries, large token budgets, and substantial wall-clock latency. Third, multi-agent coordination requires intention sharing to prevent duplication and resource conflicts, yet explicit dialogues are token-expensive and implicit inference may be unreliable. ELHPlan is therefore positioned between two existing paradigms: declarative planners such as LLM+PDDL and HTN, which are efficient but assume complete global knowledge, and iterative planners such as ReAct and correction-or-verification loops, which adapt online but incur high inference and coordination overhead (Ling et al., 29 Sep 2025).

The framework’s stated objective is to provide a planning horizon long enough to amortize LLM calls while remaining sufficiently adaptive for dynamic embodied execution. This objective motivates the choice of intention-bound Action Chains and the decision to avoid costly full re-planning whenever only local corrections are required.

2. Action Chains as the planning primitive

ELHPlan formalizes the environment as a POMDP with state space $S$, action space $A$, observation space $O$, and transition function $T$, with dynamics

$s_{t+1} = T(s_t, a_t).$

For agent $m$, an Action Chain is defined as

$$C^{(m)} = [(a_1^{(m)}, g_1^{(m)}), (a_2^{(m)}, g_2^{(m)}), \ldots, (a_{K_m}^{(m)}, g_{K_m}^{(m)})],$$

where each action $a_i^{(m)}$ is explicitly bound to a sub-goal intention $g_i^{(m)}$, summarized textually in the chain payload (Ling et al., 29 Sep 2025).

The paper treats these intention-bound chains as the minimal planning unit. They are generated per agent in single LLM calls, which distinguishes ELHPlan from step-wise planners that query the model at every action or every very short horizon. Feasibility is governed by action preconditions and effects: $$\mathrm{Pred}(a_i^{(m)}, s_t)=\mathrm{true}\Rightarrow a_i^{(m)} \text{ is applicable in } s_t,$$ and

$A$0

Several operational constraints are built into the Action Chain formalism. The paper specifies a resource or holding constraint of $A$1 objects in hand, a temporal ordering constraint in which actions execute in sequence and the next action is the latest unexecuted, and a dynamic action-space constraint under which only actions in $A$2 are valid. It also defines inter-agent conflicts in terms of overlap in targeted objects, containers, or rooms, including cases such as both agents attempting $A$3 for the same object $A$4 or repeatedly checking the same container (Ling et al., 29 Sep 2025).

A distinctive element is the explicit insertion of “replan” placeholders inside Action Chains. These tokens are placed at uncertainty frontiers, especially exploratory actions that enter unknown rooms. Rather than fully specifying uncertain downstream behavior in advance, ELHPlan defers local planning detail until new observations are available. This mechanism is central to the framework’s claim of combining long-horizon structure with low-cost adaptivity.

3. Cyclical planning architecture

ELHPlan operates through a four-stage cycle. The planning stage itself comprises Construction, Validation, and Refinement, followed by execution (Ling et al., 29 Sep 2025).

In the construction stage, a single LLM call per agent produces an agent-specific Action Chain containing an action_chain, an explicit intention, and replan markers adjacent to exploratory actions entering unknown rooms. The Memory module provides structured context, including the goal, shared observations, few-shot examples, and the current action space.

In the validation stage, the framework inspects the latest unexecuted action $A$5. If that action is replan, the system triggers Chain Insertion. Otherwise it checks both applicability, through $A$6, and action-space membership, through $A$7. It then performs inter-agent conflict detection by comparing the latest actions across agents for overlap in objects, rooms, or containers.

In the refinement stage, ELHPlan performs targeted modifications rather than global re-planning. Chain Refinement locally removes or replaces infeasible or inefficient actions while preserving the original intention. Chain Insertion instantiates detailed actions for a previously inserted replan token, using the newest room-level observations. Conflict Resolution reconstructs the Action Chains of conflicting agents to avoid overlap, including sub-goal reallocation and agent reassignment.

In the execution stage, the validated scheduled action is dispatched, shared memory is updated with new observations, and the cycle repeats until sub-goals are complete or the environment-imposed step limit is reached.

The paper summarizes this process in pseudocode: for each cycle and each agent, an empty or exhausted chain triggers ConstructChain; the latest action may trigger ChainInsertion if it is replan; infeasible or invalid actions trigger ChainRefinement; any detected pairwise conflicts invoke ConflictResolution; finally, Execute(ValidatedLatest(C^{(m)})) is called and memory is updated (Ling et al., 29 Sep 2025). Architecturally, the framework combines new Memory, Planning, and Validation–Refinement modules with Observation and Execution modules adopted from CoELA.

4. Conflict checking, feasibility control, and targeted repair

The validation layer is formalized around action feasibility, resource limits, ordering constraints, and explicit multi-agent conflict predicates. Applicability examples given in the paper include grasp(apple) requiring the apple’s coordinates to be known and place(obj, container) requiring the container to be open or otherwise accessible. The system also checks whether the transition $A$8 realizes the intended effect, such as the object being held or relocated (Ling et al., 29 Sep 2025).

The inter-agent conflict predicate is stated as

$A$9

Here, $O$0 extracts the objects, containers, or rooms targeted by agent $O$1’s latest or near-future actions. Example conflicts include simultaneous attempts to grasp the same object, redundant exploration of the same room, and repeated checking of the same container.

The three refinement mechanisms operate at different scopes. Chain Refinement performs local edits while preserving the chain’s intention field and respecting the current dynamic action space. Conflict Resolution jointly reconstructs the Action Chains of two conflicting agents and uses cost-minded reasoning together with capacity constraints. Chain Insertion expands replan tokens into room-specific sub-sequences and explicitly enforces prompt-level rules such as using explicit names+IDs and holding at most two objects.

The worked example described in the paper illustrates all three mechanisms. Agent 2 reaches a replan placeholder upon entering an unexplored room, after which Chain Insertion synthesizes a new sub-sequence focused on task-related objects in that room. Agent 1 encounters an infeasible action because a precondition fails, such as an unknown object position, and Chain Refinement adjusts that portion of the chain while preserving intention. A subsequent conflict is detected when both agents attempt to grasp apple (23), and Conflict Resolution reconstructs the chains so that one agent is reassigned to a different object or room. This example clarifies that ELHPlan’s adaptivity is local and intention-preserving rather than based on repeated end-to-end re-planning (Ling et al., 29 Sep 2025).

5. Efficiency model, scalability, and empirical performance

A central contribution of ELHPlan is the introduction of efficiency metrics tailored to LLM-driven multi-agent planning. Token Consumption (TC) is defined by

$O$2

where $O$3 counts all input and output tokens used in cycle $O$4 across planning, validation or refinement, and execution prompts. Inference Time (IT) is defined by

$O$5

where $O$6 measures wall-clock time spent by LLM calls in that cycle. Environment-specific task metrics are Transport Rate (TR) and Move Distance (MD) for TDW-MAT, and Simulation Steps (SS) for C-WAH (Ling et al., 29 Sep 2025).

The paper also provides an explicit scalability perspective. If there are $O$7 agents, per-agent chain lengths $O$8, average chain length $O$9, and total primitive actions $T$0, then step-wise or short-horizon baselines typically require $T$1 LLM invocations, multiplied by $T$2 in multi-agent settings. ELHPlan amortizes planning by constructing length-$T$3 chains in single calls, so the number of planning calls per agent is approximately $T$4, plus occasional refinement, insertion, and conflict-resolution calls. The paper’s approximate token model is

$T$5

Experimentally, ELHPlan is evaluated with Llama 3.1, GPT-4o, 4o-mini, and GPT-3.5, depending on the baseline. In the paper’s tables, ELHPlan is labeled “LEAPlan”, and this label corresponds to the same framework (Ling et al., 29 Sep 2025).

On TDW-MAT, the reported results are:

• CoELA Llama3.1: TR $T$6, MD $T$7, TC $T$8K, IT $T$9s
• CoELA 4o-mini: TR $s_{t+1} = T(s_t, a_t).$0, MD $s_{t+1} = T(s_t, a_t).$1, TC $s_{t+1} = T(s_t, a_t).$2K, IT $s_{t+1} = T(s_t, a_t).$3s
• CoELA GPT-4: TR $s_{t+1} = T(s_t, a_t).$4, MD $s_{t+1} = T(s_t, a_t).$5, TC $s_{t+1} = T(s_t, a_t).$6K, IT $s_{t+1} = T(s_t, a_t).$7s
• REVECA 4o-mini: TR $s_{t+1} = T(s_t, a_t).$8; other metrics not reported
• ELHPlan Llama3.1: TR $s_{t+1} = T(s_t, a_t).$9, MD $m$0, TC $m$1K, IT $m$2s
• ELHPlan GPT-4o: TR $m$3, MD $m$4, TC $m$5K, IT $m$6s
• ELHPlan 4o-mini: TR $m$7, MD $m$8, TC $m$9K, IT $$C^{(m)} = [(a_1^{(m)}, g_1^{(m)}), (a_2^{(m)}, g_2^{(m)}), \ldots, (a_{K_m}^{(m)}, g_{K_m}^{(m)})],$$0s

On C-WAH, the reported results are:

• CoELA GPT-3.5: SS $$C^{(m)} = [(a_1^{(m)}, g_1^{(m)}), (a_2^{(m)}, g_2^{(m)}), \ldots, (a_{K_m}^{(m)}, g_{K_m}^{(m)})],$$1, MD $$C^{(m)} = [(a_1^{(m)}, g_1^{(m)}), (a_2^{(m)}, g_2^{(m)}), \ldots, (a_{K_m}^{(m)}, g_{K_m}^{(m)})],$$2, TC $$C^{(m)} = [(a_1^{(m)}, g_1^{(m)}), (a_2^{(m)}, g_2^{(m)}), \ldots, (a_{K_m}^{(m)}, g_{K_m}^{(m)})],$$3K, IT $$C^{(m)} = [(a_1^{(m)}, g_1^{(m)}), (a_2^{(m)}, g_2^{(m)}), \ldots, (a_{K_m}^{(m)}, g_{K_m}^{(m)})],$$4s
• CoELA GPT-4o: SS $$C^{(m)} = [(a_1^{(m)}, g_1^{(m)}), (a_2^{(m)}, g_2^{(m)}), \ldots, (a_{K_m}^{(m)}, g_{K_m}^{(m)})],$$5, MD $$C^{(m)} = [(a_1^{(m)}, g_1^{(m)}), (a_2^{(m)}, g_2^{(m)}), \ldots, (a_{K_m}^{(m)}, g_{K_m}^{(m)})],$$6, TC $$C^{(m)} = [(a_1^{(m)}, g_1^{(m)}), (a_2^{(m)}, g_2^{(m)}), \ldots, (a_{K_m}^{(m)}, g_{K_m}^{(m)})],$$7K, IT $$C^{(m)} = [(a_1^{(m)}, g_1^{(m)}), (a_2^{(m)}, g_2^{(m)}), \ldots, (a_{K_m}^{(m)}, g_{K_m}^{(m)})],$$8s
• CoELA 4o-mini: SS $$C^{(m)} = [(a_1^{(m)}, g_1^{(m)}), (a_2^{(m)}, g_2^{(m)}), \ldots, (a_{K_m}^{(m)}, g_{K_m}^{(m)})],$$9, MD $a_i^{(m)}$0, TC $a_i^{(m)}$1K, IT $a_i^{(m)}$2s
• REVECA Llama 3.1: SS $a_i^{(m)}$3, MD $a_i^{(m)}$4, TC $a_i^{(m)}$5K, IT $a_i^{(m)}$6s
• REVECA GPT-4o: SS $a_i^{(m)}$7, MD $a_i^{(m)}$8, TC $a_i^{(m)}$9K, IT $g_i^{(m)}$0s
• REVECA 4o-mini: SS $g_i^{(m)}$1, MD $g_i^{(m)}$2, TC $g_i^{(m)}$3K, IT $g_i^{(m)}$4s
• ELHPlan Llama 3.1: SS $g_i^{(m)}$5, MD $g_i^{(m)}$6, TC $g_i^{(m)}$7K, IT $g_i^{(m)}$8s
• ELHPlan GPT-4o: SS $g_i^{(m)}$9, MD $$\mathrm{Pred}(a_i^{(m)}, s_t)=\mathrm{true}\Rightarrow a_i^{(m)} \text{ is applicable in } s_t,$$0, TC $$\mathrm{Pred}(a_i^{(m)}, s_t)=\mathrm{true}\Rightarrow a_i^{(m)} \text{ is applicable in } s_t,$$1K, IT $$\mathrm{Pred}(a_i^{(m)}, s_t)=\mathrm{true}\Rightarrow a_i^{(m)} \text{ is applicable in } s_t,$$2s
• ELHPlan 4o-mini: SS $$\mathrm{Pred}(a_i^{(m)}, s_t)=\mathrm{true}\Rightarrow a_i^{(m)} \text{ is applicable in } s_t,$$3, MD $$\mathrm{Pred}(a_i^{(m)}, s_t)=\mathrm{true}\Rightarrow a_i^{(m)} \text{ is applicable in } s_t,$$4, TC $$\mathrm{Pred}(a_i^{(m)}, s_t)=\mathrm{true}\Rightarrow a_i^{(m)} \text{ is applicable in } s_t,$$5K, IT $$\mathrm{Pred}(a_i^{(m)}, s_t)=\mathrm{true}\Rightarrow a_i^{(m)} \text{ is applicable in } s_t,$$6s

The paper’s headline claim is that “ELHPlan achieves comparable task success rates while consuming only 24% of the tokens required by state-of-the-art methods.” It gives the explicit example of C-WAH with GPT-4o, where ELHPlan uses 17.83K tokens versus 72.51K for REVECA, or approximately 24.6%. For the same setting, inference time is 76.54s for ELHPlan versus 822.50s for REVECA, corresponding to an approximately 90.7% reduction. The paper further reports that ELHPlan exhibits much lower metric variance across LLMs than CoELA, which is presented as evidence of cross-LLM stability (Ling et al., 29 Sep 2025).

6. Ablations, comparative interpretation, and limitations

Ablation studies are reported on C-WAH with gpt-4o-mini. Removing Action Chains increases token usage by 79.4% and planning time by 181.7%, from 18,882.1 to 33,884.8 tokens and from 83.31s to 234.54s. Removing Chain-level Refinement increases simulation steps by 15.6% and tokens by 9.0%. Removing Intention Binding yields −15.6% task efficiency and +117.7% planning time. Removing Proactive Replan increases simulation steps by 25.4% (Ling et al., 29 Sep 2025). These results support the paper’s interpretation that chain-level structure, explicit intention binding, and proactive replanning are all critical to the framework’s efficiency-effectiveness balance.

In comparative terms, ELHPlan is presented as distinct from both declarative and iterative LLM planners. Relative to LLM+PDDL, DELTA, and HTN, it does not assume complete scene knowledge. Relative to ReAct, correction-and-verify loops, Adapt, LLM-BT, and semantic skill hierarchies, it reduces repeated LLM interaction by making longer-horizon commitments while preserving the option of local repair. A plausible implication is that ELHPlan’s main contribution is not a stronger global planner in the classical sense, but a different granularity of planning and repair: intentions are made explicit at chain level, then revised only where validation reveals necessity.

The paper also identifies clear limitations. ELHPlan produces longer path length or MD than the best-performing baselines in both environments, indicating suboptimal fine-grained spatial reasoning and an exploratory bias. Although faster than typical iterative LLM planning, long-horizon chain synthesis is still slower than human planning. The system can produce occasional constraint violations or hallucination-like actions, and the paper explicitly points to RLHF or preference feedback as a future direction for improving adherence and reliability. Proposed extensions include lightweight or fine-tuned models optimized for Action Chain generation, improved spatial reasoning modules or hybrid planners to reduce MD, and scaling to larger teams through hierarchical or coordinated chain generation and learned conflict predictors (Ling et al., 29 Sep 2025).

Within the paper’s own framing, ELHPlan defines an efficiency–effectiveness frontier for LLM-based multi-agent planning: rather than maximizing absolute success at any resource cost, it seeks a Pareto compromise in which planning remains adaptive but token and latency budgets are sharply reduced. This suggests that its main significance lies in deployment-oriented multi-agent embodied systems, where inference cost and responsiveness are themselves first-order constraints.