---
title: 'ELHPlan: Efficient LLM-Based Multi-Agent Planning'
url: https://www.emergentmind.com/topics/elhplan
type: topic
---

# ELHPlan: Efficient LLM-Based Multi-Agent Planning

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 [2509.24230].

## 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** [2509.24230].

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 [2509.24230].

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 [2509.24230].

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
\[
s_{t+1}=T(s_t,a_i^{(m)}) \text{ satisfies } \mathrm{Eff}(a_i^{(m)}).
\]

Several operational constraints are built into the Action Chain formalism. The paper specifies a **resource or holding constraint** of \(\mathrm{capacity}_m \le 2\) 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_{\mathrm{dyn}}(s_t)\) 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 \(\mathrm{grasp}(o)\) for the same object \(o\) or repeatedly checking the same container [2509.24230].

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 [2509.24230].

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_t^{(m)}\). If that action is `replan`, the system triggers **Chain Insertion**. Otherwise it checks both applicability, through \(\mathrm{Pred}(a_t^{(m)}, s_t)\), and action-space membership, through \(a_t^{(m)} \in A_{\mathrm{dyn}}(s_t)\). 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 [2509.24230]. 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 \(T(s_t,a_t^{(m)})\) realizes the intended effect, such as the object being held or relocated [2509.24230].

The inter-agent conflict predicate is stated as
\[
\mathrm{Conflicts}(i,j,s_t) =
[\mathrm{Target}(i,s_t)\cap \mathrm{Target}(j,s_t)\neq \emptyset]
\vee [\mathrm{OverlappingContainers}(i,j)]
\vee [\mathrm{OverlappingRooms}(i,j)].
\]
Here, \(\mathrm{Target}(m,s_t)\) extracts the objects, containers, or rooms targeted by agent \(m\)’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 [2509.24230].

## 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
\[
T_{\text{total}} = \sum_{c=1}^{C} T^{(c)},
\]
where \(T^{(c)}\) counts all input and output tokens used in cycle \(c\) across planning, validation or refinement, and execution prompts. **Inference Time (IT)** is defined by
\[
IT_{\text{total}} = \sum_{c=1}^{C} IT^{(c)},
\]
where \(IT^{(c)}\) 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 [2509.24230].

The paper also provides an explicit scalability perspective. If there are \(M\) agents, per-agent chain lengths \(K_m\), average chain length \(L\), and total primitive actions \(K=\sum_m K_m\), then step-wise or short-horizon baselines typically require \(O(K)\) LLM invocations, multiplied by \(M\) in multi-agent settings. ELHPlan amortizes planning by constructing length-\(L\) chains in single calls, so the number of planning calls per agent is approximately \(K_m/L\), plus occasional refinement, insertion, and conflict-resolution calls. The paper’s approximate token model is
\[
T_{\text{total}} \approx M \cdot (K/L)\cdot \bar{T}_{\text{plan}} + N_{\text{ref}}\cdot \bar{T}_{\text{ref}} + N_{\text{conf}}\cdot \bar{T}_{\text{conf}} + N_{\text{ins}}\cdot \bar{T}_{\text{ins}}.
\]

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 [2509.24230].

On **TDW-MAT**, the reported results are:
- **CoELA Llama3.1**: TR \(0.53\), MD \(309.02\), TC \(92.85\)K, IT \(1156.24\)s  
- **CoELA 4o-mini**: TR \(0.53\), MD \(275.16\), TC \(74.88\)K, IT \(545.43\)s  
- **CoELA GPT-4**: TR \(0.71\), MD \(266.25\), TC \(83.92\)K, IT \(464.68\)s  
- **REVECA 4o-mini**: TR \(0.87\); other metrics not reported  
- **ELHPlan Llama3.1**: TR \(0.775\), MD \(318.5\), TC \(63.28\)K, IT \(785.91\)s  
- **ELHPlan GPT-4o**: TR \(0.816\), MD \(292.1\), TC \(26.68\)K, IT \(119.70\)s  
- **ELHPlan 4o-mini**: TR \(0.804\), MD \(296.6\), TC \(36.94\)K, IT \(152.00\)s  

On **C-WAH**, the reported results are:
- **CoELA GPT-3.5**: SS \(71.90\), MD \(61.29\), TC \(83.05\)K, IT \(185.98\)s  
- **CoELA GPT-4o**: SS \(57.00\), MD \(90.80\), TC \(177.28\)K, IT \(152.57\)s  
- **CoELA 4o-mini**: SS \(65.50\), MD \(52.00\), TC \(253.65\)K, IT \(262.94\)s  
- **REVECA Llama 3.1**: SS \(56.00\), MD \(47.13\), TC \(248.30\)K, IT \(3235.24\)s  
- **REVECA GPT-4o**: SS \(49.13\), MD \(42.14\), TC \(72.51\)K, IT \(822.50\)s  
- **REVECA 4o-mini**: SS \(52.22\), MD \(46.21\), TC \(79.27\)K, IT \(374.53\)s  
- **ELHPlan Llama 3.1**: SS \(74.69\), MD \(142.11\), TC \(54.11\)K, IT \(670.83\)s  
- **ELHPlan GPT-4o**: SS \(60.50\), MD \(107.54\), TC \(17.83\)K, IT \(76.54\)s  
- **ELHPlan 4o-mini**: SS \(59.25\), MD \(106.10\), TC \(18.88\)K, IT \(83.31\)s  

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 [2509.24230].

## 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%** [2509.24230]. 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** [2509.24230].

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.

Source: https://www.emergentmind.com/topics/elhplan