Choices are More Important than Efforts: LLM Enables Efficient Multi-Agent Exploration

## Abstract

Abstract With expansive state-action spaces, efficient multi-agent exploration remains a longstanding challenge in reinforcement learning.
Although pursuing novelty, diversity, or uncertainty attracts increasing attention, redundant efforts brought by exploration without proper guidance choices poses a practical issue for the community.
This paper introduces a systematic approach, termed LEMAE, choosing to channel informative task-relevant guidance from a knowledgeable L arge Language Model (LLM) for E fficient M ulti- A gent E xploration.
Specifically, we ground linguistic knowledge from LLM into symbolic key states, that are critical for task fulfillment, in a discriminative manner at low LLM inference costs.
To unleash the power of key states,
we design Subspace-based Hindsight Intrinsic Reward (SHIR) to guide agents toward key states by increasing reward density.
Additionally, we build the Key State Memory Tree (KSMT) to track transitions between key states in a specific task for organized exploration.
Benefiting from diminishing redundant explorations, LEMAE outperforms existing SOTA approaches on the challenging benchmarks (e.g., SMAC and MPE) by a large margin, achieving a 10x acceleration in certain scenarios.

## 1 Introduction

Exploration stands as a fundamental issue in reinforcement learning (RL) (Du et al., ; Liu et al., ).
Researchers have developed several exploration strategies directed by novelty, diversity, or uncertainty (Linke et al., ; Burda et al., ; Pathak et al., ), mainly in single-agent reinforcement learning.
However, these methods may induce task-irrelevant redundant exploration, especially in complex environments (Du et al., ).
In the realm of Multi-Agent Reinforcement Learning (MARL), the need to mitigate exploration redundancy becomes even more urgent due to the challenges like exponential expansion of the state-action spaces.
Widespread real-world applications, including MOBA games (Qu et al., ), social science (Jaques et al., ), and multi-vehicle control (Xu et al., ), further underscore the growing need for efficient multi-agent exploration.

This work identifies task-relevant guidance as an important consideration in enhancing exploration efficiency.
Incorporating priors in exploration mechanism design, such as complex reward structures, typically requires expert knowledge and substantial human efforts (Liu et al., ; Abbeel & Ng, ).
Hopefully, recent advances have witnessed the remarkable reasoning and planning capabilities of Large Language Models (Touvron et al., ; Achiam et al., ), providing a plausible choice to facilitate efficient exploration through LLM’s effortless prior provision.
However, it is non-trivial to effectively comprise linguistic LLM priors into symbolically represented RL tasks (Peng et al., ; Carta et al., ), and the investigation of practical ways to avoid nuisances caused by such an expression discrepancy is of critical importance.

Figure: Figure 1: (a) The map of the task Pass. Two agents are initially positioned in the left room, requiring cooperation to explore the rooms, uncover the hidden switches, and move to the right room. (b) The key states ($\kappa_{1}$ and $\kappa_{2}$) generated by LLM for the task Pass, where the superscripts $A,B$ of $\kappa_{i}$ denote two agents Alice and Bob. (c) Visitation Map (log scale) of SOTA baseline method CMAE. (d) Visitation Map (log scale) of our method LEMAE. Our method exhibits a significant reduction in redundant exploration. Furthermore, an organic division of labor among agents emerges.
Refer to caption: extracted/5898825/img/heatmap.png

In response to the above issue, we propose LEMAE, a novel framework to enable efficient multi-agent exploration with LLM.
The framework primarily consists of two components: (i) key states localization with LLM and (ii) key state-guided exploration.
The first component grounds linguistic knowledge from LLM into symbolic key states by automatically localizing key states that are essential for task fulfillment.
Specifically, the discriminator function induced by LLM works to discriminate key states from rollout trajectories, avoiding the overburden of LLM inference costs.
The second component harnesses the localized key states as meaningful guidance to achieve efficient exploration.
In implementation, we encourage agents toward targeted key states by devising Subspace-based Hindsight Intrinsic Reward (SHIR) to increase reward density.
For the purpose of organized exploration, Key States Memory Tree (KSMT) is further constructed to track key state transitions, mitigating exploration complexity and enhancing guidance in SHIR.
As illustrated in Fig. 1, our design empowers LEMAE with
a significant performance advantage through notably reducing redundant exploration.

Our main contributions are summarized as follows:

- 1.
We build a bridge between LLM and RL to facilitate efficient multi-agent exploration by developing a systematic approach dubbed LEMAE.
- 2.
We devise a computationally efficient inference strategy channeling task-specific information from LLM to distinguish key states critical for task fulfillment as subgoals for targeted exploration.
- 3.
We introduce a Key State Memory Tree to organize exploration according to historic key state transitions and devise the Subspace-based Hindsight Intrinsic Reward, encouraging agents’ guidance.

We conduct extensive experiments on typical multi-agent exploration benchmarks.
LEMAE (i) consistently outperforms the state-of-the-art (SOTA) baselines with 10x acceleration in certain scenarios, (ii) achieves performance comparable to the baseline trained with human-designed dense rewards in sparse reward scenarios, and
(iii) exhibits potential to generalize to brand-new, non-symbolic tasks.
These observations validate the effectiveness of our design in reducing redundant exploration and improving exploration efficiency, showing promise for real-world deployment in scenarios requiring efficient exploration.

## 2 Preliminary

The environments considered in this work are characterized as a decentralized partially observable Markov decision process (Dec-POMDP) (Oliehoek et al., ) with $n$ agents, which can be defined as a tuple $G=\langle S,A,I,P,r,Z,O,n,\gamma\rangle$, where $s\in S$ is the global state, $A$ is the action space for each agent, and $\gamma\in[0,1)$ is the discount factor.
At time step $t$, each agent $i\in I\equiv\{1,...,n\}$ has its local observations $o^{i}\in O$ drawn from the observation function $Z(s,i):S\times I\rightarrow O$ and chooses an action $a^{i}\in A$ by its policy $\pi^{i}(a^{i}|o^{i}):O\rightarrow\Delta([0,1]^{|A|})$, forming a joint action $\mathbf{a}\in\mathbf{A}\equiv A^{n}$.
$T(s^{\prime}|s,\mathbf{a}):S\times\mathbf{A}\times S\rightarrow[0,1]$ is the environment’s state transition distribution.
All agents share a common reward function $r(s,\mathbf{a}):S\times\mathbf{A}\rightarrow\mathbb{R}$.
The agents’ joint policy $\bm{\pi}:=\prod_{i=1}^{n}\pi^{i}$ induces a joint *action-value function*: $Q^{\bm{\pi}}(s,\mathbf{a})=\mathbb{E}[R|s,\mathbf{a}]$, where $R=\sum^{\infty}_{t=0}\gamma^{t}r_{t}$ is the expected discounted return. The goal of MARL is to find the optimal joint policy $\bm{\pi}^{*}$ such that $Q^{\bm{\pi}^{*}}(s,\mathbf{a})\geq Q^{\bm{\pi}}(s,\mathbf{a})$, $\forall\bm{\pi}\ \text{and}\ (s,\mathbf{a})\in S\times\mathbf{A}$. Notably, we specifically focus on sparse reward tasks, i.e., $r_{t}=1$ only when $s_{t+1}=s_{success}$, otherwise $r_{t}=0$.
We denote the symbol for the $i$-th key state by $\kappa_{i}$ together with its discriminator function $\mathcal{F}_{i}$.

## 3 Related Works

##### LLM in Decision Making.

Large Language Models have showcased impressive capabilities across various downstream tasks (Touvron et al., ; Radford et al., ; Brown et al., ).
Recent advances indicate a growing trend of using LLM in decision-making problems (Wang et al., ).
A primary challenge within this domain is grounding LLM’s linguistic knowledge into specific low-level control tasks typically represented in symbolic form (Peng et al., ; Carta et al., ), especially in RL.
Creating linguistic twin tasks (Carta et al., ) are intuitive but require substantial manual workloads.
Some works employ LLMs as high-level planners, e.g., coding with APIs (Liang et al., ), using human-annotated or LLM-summarized action template (Yao et al., ; Shinn et al., ; Lin et al., ; Zhu et al., ; Wang et al., ).
Despite significant progress, they rely on difficult-to-obtain low-level policies or APIs, limiting their real-world applicability.
Recently, LLMs have been integrated with RL to directly enhance low-level decision making (Cao et al., ).
LLMs can act as environmental information processors, reducing learning complexity (Paischer et al., ; ; Kim et al., ; Wang et al., ), but cannot directly facilitate efficient exploration.
Some works utilize LLMs as goal selectors in goal-conditioned RL (Su & Zhang, ; Shukla2023lgts) or teacher policy (Zhou et al., ) but require predefined skills or subgoals.
Alternative methods like LLM-based reward or policy design (Ma et al., ; Kwon et al., ; Song et al., ; Liu et al., ; Chen et al., ) and fine-tuning (Carta et al., ; Shi et al., ) are either limited to simple tasks with sufficient information or demand enormous data and resources.
ELLM (Du et al., ) aims to enhance exploration using LLM but depends on predefined symbolic observation captioner and frequent LLM inferences.
Its semantic similarity-based rewards may also struggle to generalize across diverse scenarios.
In contrast, LEMAE integrates linguistic LLM priors into symbolic states with minimal task-specific information and LLM inference costs, achieved by localizing key states in rollout trajectories using LLM-generated discriminator functions.

##### Efficient Multi-Agent Exploration.

Exploration efficiency has long been a focal point in RL (Thrun, ; Cai et al., ; Seo et al., ; Mahajan et al., ; Jeon et al., ; Liu et al., ).
Typical exploration methods focus on random exploration (Mnih et al., ; Rashid et al., )
or heuristic indicators, such as diversity or novelty, to facilitate exhaustive exploration, particularly in single agent exploration (Linke et al., ; Burda et al., ; Pathak et al., ; Burda et al., ; Bellemare et al., ).
Despite their success, they may induce notable redundant exploration due to a lack of task-relevant guidance (Du et al., ).
The exponential expansion of the state-action spaces renders exhaustive exploration impractical in multi-agent settings.
Consequently, efficient multi-agent exploration (MAE) becomes increasingly imperative and necessary (Jeon et al., ; Liu et al., ).
MAE is also challenging due to the complex configurations, e.g., the entangled effect of multi-agent actions and intricate reward design (Liu et al., ; Qu et al., ; Xu et al., ).
Given our emphasis on efficient exploration, we prioritize evaluation in multi-agent settings.
Some MAE methods encourage influential behaviors during agent interactions (Liu et al., ; Jaques et al., ; Wang et al., ).
Nevertheless, they may lead to unintended coalitions or require additional priors (Liu et al., ).
Certain studies leverage subgoals to guide exploration (Jeon et al., ).
However, due to challenges in integrating task-related information into subgoals, they either necessitate human expertise for subgoals design (Tang et al., ; Kulkarni et al., ) or struggle to identify useful subgoals (Jeon et al., ; Liu et al., ).
Distinguished from the above, this work underscores the significance of task-relevant guidance in exploration and utilizes the key state priors extracted from LLM to enable efficient multi-agent exploration.

## 4 Method

Figure: Figure 2: Overview of the training process. (a) Key States Localization with LLM: We devise a set of prompts to guide LLM in localizing key states based on task-specific information. Refinements of the response are achieved through iterative self-checks by LLM. Subsequently, discriminator functions are derived from the final response to discriminate key states within trajectories. (b) Key States-Guided Exploration: Using the achieved key states chain within the processed trajectory, we look up KSMT to get the most probable next key states. By sampling from them as the subgoal for the concluding sub-trajectory, we integrate intrinsic rewards into the overall trajectory using SHIR.
Refer to caption: x1.png

This section elaborates on the developed LEMAE.
The concept of the key states is first induced as the task-relevant guidance in Sec. 4.1.
Centering around the key states, we construct two components: (i) key states localization with LLM (Sec. 4.2) and (ii) key state-guided exploration (Sec. 4.3).
The former directs LLM to generate discriminator functions for localizing key states in rollout trajectories, while the latter guides and organizes exploration with the introduced Subspace-based Hindsight Intrinsic Reward and Key States Memory Tree.
Please refer to Fig. 2 and Algorithm 1 for details.
Also, we provide a [demonstration](https://sites.google.com/view/lemae)(^1^11[https://sites.google.com/view/lemae](https://sites.google.com/view/lemae)) to clarity the LEMAE’s execution pipeline.

### 4.1 Devil is in the Key States

Previous methods suffer from redundant exploration efforts in
pursuing task-agnostic novelty (Du et al., ), potentially reducing training efficiency.
This motivates us to integrate task-relevant information as a better guidance choice for efficient exploration.
Nevertheless, practical proposals are limited in the field.
This work identifies the Key States as the novel task-relevant prior, which corresponds to intermediate states with explicit semantics and expressions pertaining to the task.
Meanwhile, Proposition 4.1 explicitly reflects the efficacy of incorporating them.

###### Proposition 4.1 .

Consider the one-dimensional asymmetric random walk problem, where an agent starts at $x=0$ and aims to reach $x=N\in\mathbb{N^{+}},N>1$.
The initial policy is asymmetric and random with probabilities $p\in(0.5,1)$ and $1-p$ for right and left movements, respectively.
Without prior knowledge, the expected first hitting time is $\mathbb{E}(T_{0\rightarrow N})=\frac{N}{2p-1}$.
After introducing the task-relevant information that the agent must first reach key states $\kappa=1,...,N-1$ before reaching $x=N$, we can decrease the expected first hitting time by $\mathbb{E}(T_{0\rightarrow N})-\mathbb{E}(T^{prior}_{0\rightarrow N})=(N-1)*(
\frac{1}{2p-1}-\frac{2}{p}+1)>0$.

The proof is deferred to Appendix C.
The exploration policy substantially benefits from the involvement of key states, e.g., $\mathbb{E}(T_{0\rightarrow N})-\mathbb{E}(T^{prior}_{0\rightarrow N})\to\infty$ with $p\to 0.5$.
Such a concept is also commonly seen in practical scenarios, such as in-game checkpoints (Demaine et al., )
and landmarks in navigation (Becker et al., ).

###### Proposition 4.1 .

### 4.2 Key States Localization with LLM

To reduce manual workload, we employ LLM to localize key states.
Although generating the aforementioned symbolic key states can be straightforward, LLM’s weakness in comprehending symbolic states or environment details necessitates additional information in certain tasks and can lead to errors and hallucinations that are difficult to detect.
Here, we stress the importance of LLM’s discriminative ability to localize key states in rollout trajectories to better leverage LLM’s general knowledge.
The rationale is that discrimination demands only a high-level task understanding and is more reliable and universal than naive generation, as discussed in detail in Appendix B.1.

To discriminate key states, we prompt LLM to generate $m$ discriminator functions $\{\mathcal{F}_{i}\}_{i=1}^{m}$, as depicted in Fig. 2.
Each discriminator function $\mathcal{F}_{i}$ takes in the state $s_{t}$ at timestep $t$ and outputs a boolean value to tell whether the input state is the key state $\kappa_{i}$.
Such an approach systematically annotates each state in trajectories as a key state instance or not.
Notably, LEMAE injects task-relevant information into the symbolic states without predefined components such as observation captioners (Du et al., ) or environment codes (Xie et al., ), which require manual fine-tuning, may be unavailable in many scenarios, or could introduce extra information.
In addition, the discriminator functions’ reusability avoids frequent calls, and our method empirically requires fewer than three LLM inferences for a specific task.
These advantages highlight the potential of LEMAE to expand the scope of application scenarios with fewer constraints and reduced costs.

We design prompts to alleviate the burden of labor-intensive prompt engineering across tasks.
As illustrated in Fig. 2, each task’s prompt is structured by a standardized prompt template and task information.
The prompt template, consistent across tasks, primarily contains several role instructions to guide LLM in role understandings (including promoting labor division among agents in MARL) and output constraints.
For a new task with symbolic state space, the prompt template requires only essential details, i.e., the task description and the state form, which can be easily extracted from the task document without additional processing, making it less demanding than previous methods (Ma et al., ; Du et al., ).
An extension to vision-based tasks is described in Appendix F.2.

Considering that LLM sometimes generates inaccurate responses and non-executable codes, we develop a Self-Check mechanism to enable LLM’s autonomous evaluation and response improvement, which is inspired by recent approaches (Shinn et al., ; Dhuliawala et al., ).
The mechanism comprises two checking operations: LLM rethinking and code verification.
The former prompts LLM with a set of queries for self-assessment, ensuring compliance with specified criteria.
The latter verifies the executability of discriminator functions with actual state inputs, providing feedback until all functions are executable.

We use GPT-4-turbo from OpenAI API and prompt details are attached in Appendix D.

### 4.3 Key State-Guided Exploration

#### 4.3.1 Subspace-based Hindsight Intrinsic Reward

With the annotated key states, trajectories can naturally be segmented into sub-trajectories.
Drawing inspiration from Andrychowicz et al. (), we integrate hindsight intrinsic rewards by conceptualizing the annotated key states as sub-trajectories’ subgoals, which is further discussed in Appendix E.3.
Such integration guides the policy toward achieving these key states by increasing reward density, thus reducing manual reward design burdens.
Moreover, the state vector index from the discriminator function constitutes the reward-related subspace of the state (Liu et al., ).
Here, we write the Subspace-based Hindsight Intrinsic Reward (SHIR) function as:

$$ $r_{I}^{\kappa_{m}}(t)=\|\Phi_{m}(s_{t})-\Phi_{m}(\kappa_{m})\|-\|\Phi_{m}(s_{t +1})-\Phi_{m}(\kappa_{m})\|,$ (1) $$

where $\|\cdot\|$ denotes a distance metric, e.g., Manhattan Distance; $\Phi_{m}(s)=(s_{e})_{e\in\upsilon_{m}}$ restricts the state space to elements $e\in\upsilon_{m}$, $s_{e}$ is the $e$-th element of the full-state $s$, and $\upsilon_{m}\subset\mathbb{N}^{+}$ refers to the subset of entire state space from the discriminator function $\mathcal{F}_{m}$.

Given that rewards generally rely on a limited subset of the entire state space (Liu et al., ; Todorov et al., ), adopting subspace-based rewards helps avoid the potential redundancy and bias associated with the design of intrinsic rewards in the entire state space.
LEMAE is also applicable to scenarios where rewards depend on the global state space, as it imposes no strict constraints.
Hence, the final reward function is further derived as:

$$ $r(t)=\alpha\cdot r_{E}(t)+\beta\cdot r_{I}^{\kappa_{m}}(t),$ (2) $$

where $r_{E}$ denotes the extrinsic reward with $\alpha,\beta\in\mathbb{R^{+}}$ non-negative scaling factors.

#### 4.3.2 Key States Memory Tree

To organize exploration with memory, we introduce the concept of Key States Memory Tree (KSMT).
It tracks transitions between key states and further serves exploration and planning.
Compared with the naive $\epsilon$-greedy method, gradually revealing the KSMT helps avoid redundant exploration throughout the state space, particularly beneficial in more complicated real-world scenarios.
Notably, LEMAE is compatible with other memory structures, such as Directed Acyclic Graphs.

Construct KSMT:
Initialized at the root node, KSMT dynamically expands by iteratively incorporating key state chains obtained from annotated trajectories, as outlined in Algorithm 2.
These steps repeat until either reaching the success state or fully depicting the transitions between key states.

Explore with KSMT:
To discover new KSMT branches, we adopt an exploration strategy that balances high-randomness policy $\bm{\pi}_{\theta}^{\epsilon_{h}}$ for exploring under-explored nodes with low-randomness policy $\bm{\pi}_{\theta}^{\epsilon_{l}}$ to minimize interference with policy learning, as shown in Algorithm 2.
Upon reaching a leaf node, agents execute $\bm{\pi}_{\theta}^{\epsilon_{h}}$ to deepen KSMT.
While reaching a non-leaf node $\xi_{i}$, the agents take $\bm{\pi}_{\theta}^{\epsilon_{h}}$ with probability $p_{i}$ to expand the breadth or $\bm{\pi}_{\theta}^{\epsilon_{l}}$ with probability $1-p_{i}$ for progression towards the next key state.
The probability $p_{i}$ is calculated as $p_{i}=\frac{1}{d_{i}+1}$, with $d_{i}$ the degree of the node $\xi_{i}$ as an indicator of the degree of under-exploration.
The exploration phase completes upon the discovery of the success state.
We also prune branches that do not lead to success to circumvent task-irrelevant key states.
In this way, KSMT enables exploration in a more meaningful state subspace.

Plan with KSMT:
Since KSMT acts as a dynamic model within the key state space, we plan the subgoal for the final sub-trajectory based on it.
As shown in Fig. 2b, given the achieved key states chain, we identify the corresponding branch ($\kappa_{2}\rightarrow\kappa_{1}\rightarrow\text{children}$) in KSMT through a lookup operation.
Since they have been validated by memory, the children represent the most likely next key states, from which we randomly sample the final subgoal.
This process mainly handles cases where trajectories fail to reach a key state as the final subgoal.
It enhances SHIR and improves the efficacy of exploring KSMT by encouraging agents to access existing key states.

## 5 Experiments

Figure: Figure 3: Evaluating LEMAE against baseline methods on four MPE maps with sparse rewards, using test win rate as the evaluation metric. The acceleration rate refers to how much faster LEMAE finds the success state compared to CMAE.
Refer to caption: x2.png

We conduct experiments on commonly used multi-agent exploration benchmarks: (1) the Multiple-Particle Environment (Lowe et al., ; Wang et al., ) and (2) the StarCraft Multi-Agent Challenge (Samvelyan et al., ).
Following previous studies (Ma et al., ; Liu et al., ; Xu et al., ),
we focus primarily on tasks with symbolic state spaces and use the sparse reward version for all tasks without specific instructions.

Baselines.
We compare LEMAE with representative baselines:
IPPO is a MARL algorithm which extends PPO (Schulman et al., );
QMIX (Rashid et al., ) is a widely adopted MARL baseline;
EITI and EDTI (Wang et al., ) employ the impact of interaction in coordinated agents’ behaviors;
MAVEN (Mahajan et al., ) combine value-based and policy-based approaches through hierarchical control;
CMAE (Liu et al., ) learns cooperative exploration by selecting shared goals from multiple projected state space;
RODE (Wang et al., ) decomposes joint action spaces into role-based ones to enhance exploration;
MASER (Jeon et al., ) generates subgoals automatically for multiple agents from the experience replay buffer;
LAIES (Liu et al., ) addresses the lazy agents problem by mathematical definition and causal analysis.
ELLM (Du et al., ) employs LLM priors to guide vision-based exploration, using state captioners and semantic similarity-based rewards.
LEMAE is implemented on IPPO in MPE and QMIX in SMAC, consistent with previous works (Wang et al., ; Liu et al., ; Jeon et al., ) to ensure fair comparisons.

We run each algorithm on five random seeds and report the mean performance with standard deviation.
Further details can be referenced in Appendix E.

### 5.1 Multiple-Particle Environment (MPE)

In MPE, we evaluate LEMAE on Pass, Secret-Room, Push-Box, and Large-Pass, which are commonly used multi-agent exploration tasks in previous works (Wang et al., ; Liu et al., ).

LLM can effectively discriminate key states.
To start with, we examine the efficacy of LLM in discriminating key states.
On the Pass task,
as shown in Fig. 1a, a room is divided by a wall, each half containing an invisible switch. Passage through the door is allowed only when an agent occupies a switch. Initially, in the left half-room, agents must cooperate to move to the right half-room. In Fig. 4(a), LLM exhibits a precise understanding of the task and generates meaningful discriminator functions, demonstrating the feasibility of our approach based on the current LLM.

Figure: (a)
Refer to caption: extracted/5898825/img/passresponse.png

LEMAE achieves superior performance.
We investigate how LEMAE enhances exploration by comparing it with baselines, confirming the value of incorporating LLM priors.
The training curves are depicted in Fig. 3.
The failure of commonly used baselines highlights the necessity and urgency for efficient exploration, while the superior performance of LEMAE underscores the effectiveness of augmenting RL with task-specific guidance from LLM.
Specifically, the failure of EITI, EDTI, and LAIES may be attributed to the complexity of learning dynamics or the scarcity of external state changes in the tasks.
While CMAE learns effective strategies for simple tasks, its redundant exploration hampers efficiency, rendering it inadequate for tasks with expansive exploration spaces, such as Large-Pass.
Although it benefits from LLM priors, ELLM performs worse than LEMAE due to the weak guidance provided by semantic similarity-based rewards, not to mention its reliance on frequent LLM inference and a predefined state captioner.
Furthermore, we compare LEMAE with traditional SOTA baseline CMAE using the metric of the number of exploration steps taken to find the success state.
The results indicate a significant exploration acceleration rate, up to 10x, underscoring LEMAE’s efficiency.
The superior performance of our method can be attributed to the mitigating of redundant exploration by incorporating task-relevant information.

LEMAE benefits from LLM priors through discrimination.
We evaluate HER (Andrychowicz et al., ), which also employs hindsight intrinsic rewards but selects goals randomly from memory.
HER’s poor performance emphasizes the critical role of incorporating LLM priors for localizing key states in achieving efficient exploration.
To further support our claim about the superiority of LLM discrimination over generation, we evaluate Eureka-si, a single-iteration variant of Eureka (Ma et al., ), which uses LLM to generate reward functions directly.
While Eureka-si performs comparably to LEMAE in simple tasks, it struggles in most complex tasks with partial observability, indicating that LLM-based discrimination may offer a more general and effective integration of LLM.
Notably, these two methods are not specifically designed for efficient exploration.
Please refer to Appendix E.2, E.3 for more details.

LEMAE reduces redundant exploration.
We further compare the exploration behavior of LEMAE with that of CMAE on the Pass task.
The visitation maps, displayed in log scale, are depicted in Fig. 1.
The illustration reveals that LEMAE markedly avoids redundant exploration: agents trained with CMAE tend to excessively explore the left room, while the agents’ visitation area in LEMAE is notably concentrated around the success path.
Furthermore, an organic division of labor among agents emerges, affirming the efficacy of encouraging labor division in prompt design.

LEMAE circumvents task-irrelevant key states.
Due to the incomplete information, LLM may discriminate task-irrelevant key states.
For instance, in the Secret-Room task, three rooms are present on the right, but LLM is not informed about the real target room for fairness.
In Fig. 4(b), LLM discriminates two task-irrelevant key states, denoted as $\kappa_{2}$ and $\kappa_{4}$, which represent an exploration of the two irrelevant rooms, respectively.
Fig. 4(c) shows that the pruning mechanism after finding the success state in LEMAE makes it effective in circumventing task-irrelevant key states.
A more detailed robustness analysis is provided in Sec. 5.5.

Figure: Figure 5: Evaluating LEMAE on six SMAC maps with sparse rewards, using test win rate as the evaluation metric. Notably, QMIX-DR is QMIX with dense rewards in the original SMAC.
Refer to caption: x3.png

### 5.2 StarCraft Multi-Agent Challenge (SMAC)

SMAC is a widely-used challenging benchmark in MARL.
In contrast to dense or semi-sparse reward versions used before, we employ fully sparse-reward tasks to emphasize exploration, rewarding agents only upon complete enemy elimination.
In addition, to validate LEMAE across diverse scenarios, we conduct experiments on six maps with varied difficulty and agent numbers.

In Fig. 5, LEMAE demonstrates superior performance over all baselines.
Although baselines QMIX, MAVEN, CDS, and MASER excel in dense or semi-sparse reward settings, they struggle in fully sparse reward scenarios.
CMAE shows partial efficacy in simpler tasks but fails in harder scenarios due to the lack of task-related information in curiosity-driven goal selection.
LAIES is the only non-LLM baseline comparable to LEMAE. However, it requires handcrafted external state priors and still underperforms compared to LEMAE, especially on more challenging tasks.
ELLM, benefiting from LLM priors, performs well on simpler tasks, but its effectiveness diminishes on harder ones, likely due to the instability and less reliable guidance of semantic similarity-based rewards.
Notably, we add QMIX-DR, which augments QMIX with dense rewards in the original SMAC.
Surprisingly, LEMAE demonstrates the potential to match or even surpass QMIX-DR, particularly in hard maps, shedding light on minimizing the manual workload in complex reward design in real-world scenarios.
Given the complexity of the SMAC benchmark, the consistent superiority of LEMAE confirms its potential applicability in more complex real-world scenarios.
We further evaluate LEMAE on SMACv2 (Ellis et al., ), an enhanced version with more stochasticity, as detailed in Appendix F.1.

Figure: (a)
Refer to caption: x4.png

### 5.3 Compatiblility with Various Algorithms

LEMAE incorporates task-relevant guidance in the form of intrinsic rewards and is agnostic to RL algorithms.
Sec. 5.1 and 5.2 have verified the compatibility through implementing on two distinct MARL algorithms: IPPO in MPE and QMIX in SMAC.
To further substantiate this claim, we build our method on two widely-used MARL algorithms, namely QPLEX (Wang et al., ) and VMIX (Su et al., ), adopting a value-based and actor-critic methodology respectively.
As illustrated in Fig. 6(a), algorithms combined with LEMAE consistently improve performance, underscoring the potential of LEMAE to integrate with alternative algorithms across diverse fields in the future.
Additionally, LEMAE is a versatile approach for efficient exploration, not limited to MARL.
To validate this assertion, we conduct further evaluations of LEMAE in a single-agent variant of MPE, as demonstrated in Appendix F.4.

### 5.4 Ablation Studies

Role of SHIR and KSMT.
We conduct an ablation study to assess the significance of KSMT and SHIR within LEMAE.
We select two exemplary tasks from MPE and SMAC and report results in Fig. 6(b).
In SMAC, Base refers to QMIX, while in MPE, it denotes IPPO.
Besides, SHIR represents subspace-based hindsight intrinsic reward, KSMTE signifies exploration with KSMT, KSMTP denotes planning with KSMT, and LEMAE encompasses Base+SHIR+KSMTE+KSMTP.
As illustrated, the absence of SHIR or KSMT significantly deteriorates performance, revealing both components’ pivotal roles in achieving effective key state-guided exploration.

Role of Self-Check mechanism and LLMs.
We conduct a comparative analysis between GPT-4-turbo and GPT-3.5-turbo regarding generating discriminator functions.
Meanwhile, we investigate the performance of GPT-4-turbo without the Self-Check mechanism (GPT-4-turbo w/o).
The Acceptance Rate ($r_{acc}$) denotes the proportion of seeds achieving over $80\%$ of the best performance after RL training, while the Execution Rate ($r_{exe}$) indicates the proportion of seeds for which all discriminator functions are executable.
As depicted in Table 7, the results demonstrate that a powerful LLM with our Self-Check mechanism effectively ensures the high quality of key states, as evidenced by the code’s executability and the final performance.
The scalability of LEMAE to LLM and our Self-Check mechanism promise that LEMAE can leverage more powerful LLMs in the future and be applied to more challenging real-world tasks safely and efficiently.

Figure: Table 1: Ablation studies on Self-Check mechanism and LLMs. We compare the performance of two LLMs (GPT-4-turbo and GPT-3.5-turbo), recording the Acceptance Rate ($r_{acc}$) and Execution Rate ($r_{exe}$) in ten runs of the generated discriminator functions. w/o denotes the absence of our Self-Check mechanism.
Refer to caption: x6.png

### 5.5 Sensitivity & Robustness Analysis

Sensitivity to Hyperparameters.
We conduct experiments on the pivotal hyperparameters in LEMAE, i.e., reward scaling rates $\alpha$ and $\beta$.
The x-axis represents the relative values with respect to the default ($\alpha=10$, $\beta=1$), encompassing evaluations for $\alpha\in\{1,5,10,50,100\}$ and $\beta\in\{0.1,0.5,1,5,10\}$. Fig. 7 illustrates that LEMAE is robust to these hyperparameters across a considerable range.
Notably, excessive extrinsic reward scaling rate $\alpha$ or insufficient intrinsic reward scaling rate $\beta$ can cause performance degradation due to the abrupt alteration of the reward or the inadequate motivational impact.
Additionally, we conduct an ablation study on mixed-randomness exploration in Appendix F.3.

Robustness to Perturbations in Key States.
We conduct experiments to evaluate the robustness of LEMAE to perturbations in key states.
Specifically, Reduction simulates the absence of key states by randomly clearing a certain percentage of key states.
Distraction simulates the misidentification of common states as key states by randomly adding a certain portion of

**Table 2: Robustness analysis of LEMAE to perturbations in key states, whether randomly deleting key states (Reduction) or adding distracting states (Distraction).**
|  |  | Reduction | Distraction |  |  |
| --- | --- | --- | --- | --- | --- |
| Tasks | Default | 25% | 50% | 50% | 100% |
| 1c3s5z | 0.98$\pm$0.02 | 0.97$\pm$0.01 | 0.97$\pm$0.02 | 0.92$\pm$0.04 | 0.89$\pm$0.05 |
| 3s_vs_5z | 0.83$\pm$0.07 | 0.80$\pm$0.18 | 0.57$\pm$0.28 | 0.80$\pm$0.11 | 0.66$\pm$0.08 |
| MMM2 | 0.89$\pm$0.08 | 0.89$\pm$0.03 | 0.79$\pm$0.09 | 0.86$\pm$0.04 | 0.79$\pm$0.08 |

distracting states (encouraging a random state dimension to 0).
The observed performance decrease with increasing perturbations in Table 2 underscores the significance of key states’ quality.
LEMAE exhibits notable robustness to perturbations, ensuring its reliability across diverse application scenarios, particularly in light of the limited capabilities of current LLMs.

### 5.6 Scalability & Generalization Analysis

Figure: Figure 8: (a) A brand new task, River, which LLM has never encountered before. (b) The training curves of LEMAE and baselines using the evaluation metric of test win rate.
Refer to caption: x7.png

To rule out the possibility that LEMAE’s success relies on LLM’s familiarity with the chosen tasks, we’ve handcrafted a brand new task, termed River, which LLM has never encountered before.
The task is illustrated in Fig. 8a, where the objective is for Bob to help Alice, who is afraid of water, cross two rivers to reach the bottom-right corner.
As shown in Fig. 8b, LEMAE outperforms the baselines, and this confirms LLM’s generalization capabilities to empower LEMAE’s effectiveness in promoting efficient exploration in diverse new tasks.
Please refer to Appendix E.4.3 for details on the task.

Additionally, we extend LEMAE to a vision-based task, as described in Appendix F.2, demonstrating the scalability potential of LEMAE.

## 6 Conclusion

Summary of This Work:
We present LEMAE, a novel framework that benefits multi-agent exploration with task-specific guidance from LLM.
LEMAE executes the key states localization with LLM and enables the key state-guided exploration to improve sample efficiency.
In this way, we can (i) build up connections between LLM and RL to ground linguistic knowledge into decision-making, (ii) reduce the manual workload in accessing knowledge and intensive inference calls from LLM, and (iii) significantly boost exploration efficiency through guided and organized exploration.
Extensive experiments further examine the effectiveness of LEMAE in typical benchmarks.

Limitations & Future Investigations:
In developing LEMAE, we made efforts to compensate for the pitfalls of concurrent LLMs, e.g., careful preparation for prompt engineering and task-related prior provision to avoid the nuisances in LLM usages.
All of these can be circumvented with the progress of LLM’s capability enhancement.
This work paves the way for LLM-empowered RL to achieve the potential in complicated decision-making scenarios.

## Appendix A Algorithm

This section includes the pseudo algorithms. Algorithm 1 presents LEMAE’s main algorithm.
LEMAE consists of four phases: generating discriminator functions with LLM, exploring with KSMT, calculating SHIR, and performing RL training.
For on-policy RL, the buffer $D$ corresponds to a rollout buffer, while for off-policy RL, it is initialized as a replay
buffer (Paischer et al., ).
Algorithm 2 illustrates the process of exploring with KSMT.
As our approach is agnostic to reinforcement learning algorithms, we leave out the details of standard RL training in the main paper.

Figure: Algorithm 1 LEMAE

Figure: Algorithm 2 Explore with Key States Memory Tree (KSMT-Exp)

## Appendix B Further Discussions

### B.1 The Insights Behind Key States Discrimination

In our considered scenarios, we claim that discrimination is generally easier and more universal than key state generation by LLM, particularly in the context of high-dimensional states and partial observability. The reasons are as follows:

- 1.
Discrimination focuses on high-level task understanding and identifying key state characteristics, while generation requires detailed, low-level comprehension, assigning values to each element. This makes generation more challenging and error-prone, particularly in high-dimensional settings. Discrimination equivalently simplifies the output space to key state labels, thus alleviating issues like hallucinations.
- 2.
In implementations, errors in discriminator functions are easier to examine and correct through testing with real states. In contrast, errors in generated key states are harder to detect and are typically inferred from training performance.
- 3.
In cases of partial observability, generating key states directly is unreliable. For example, in the Pass task, the positions of hidden switches are unknown and must be inferred from the door’s status. LLM cannot generate key states accurately without knowledge of the specific agents’ positions required to activate a switch.

### B.2 Limitations

We build a bridge between LLM and RL to facilitate efficient exploration by leveraging task-related guidance provided by LLM.
However, persistent constraints inherent to LLMs, such as their limited capacity to comprehend task-specific information and the inevitable hallucination, become bottlenecks in our approach, which induces the following limitations:

- 1.
We mitigate heavy prompt engineering through the use of a standardized prompt template but the necessity persists for manually providing task information for LLM.
Thus, we assume the availability of semantic meanings for symbolic states.
This assumption is feasible, as these manually designed states have inherent meanings documented in task specifications (Liu et al., ; Samvelyan et al., ), and is no stronger than prior works requiring a state captioner (Du et al., ) or environment code (Ma et al., ), which also involve manual fine-tuning or access to additional state information.
- 2.
Constrained by the limitations of LLM’s capabilities and the inherent issue of hallucination, it may face challenges in directly providing effective key state priors for more complex tasks.
Besides, due to our use of LLMs, this work primarily focuses on tasks with symbolic states. Future research could extend its application to more complicated tasks, e.g., image-based tasks, by employing advanced multi-modal LLMs. We provide an initial attempt to extend LEMAE beyond symbolic tasks in Appendix F.2.

Since the efficiency of the proposed LEMAE is essentially derived from versatile LLMs, we believe that the surge of foundation model exploration will flourish LLM-empowered RL.

### B.3 Future Works

The success of the proposed LEMAE highlights the necessity and efficacy of empowering RL with LLM. To enhance performance and extend applicability, we will explore two avenues for future research aimed at addressing the identified limitations. These avenues are outlined as follows:

- 1.
Streamlining the task information provision through multi-modal self-collection:
Multi-modal LLMs are garnering increasing attention for their ability to comprehend situations through various modalities. Incorporating them with self-exploration and memory mechanisms shows promise in automating the collection and understanding of task information, thereby streamlining the implementation and enhancing the adaptability of LEMAE.
We provide an initial attempt to extend LEMAE beyond symbolic tasks in Appendix F.2.
- 2.
Unleashing the power of better LLM with an iterative feedback mechanism:
Undoubtedly, given the rapid pace of LLM development, the emergence of more powerful LLMs is imminent. On one hand, we intend to harness the capabilities of these advanced LLMs. On the other hand, to fully unleash the potential of LLMs, we plan to devise an iterative feedback mechanism to feedback LLM in LEMAE during RL training to mitigate issues like hallucinations and errors in task understanding.

### B.4 Broader Impacts

Large Language Models have demonstrated considerable potential in showcasing impressive capabilities across various downstream tasks. However, research on empowering RL with LLMs is still nascent. As a pioneering endeavor to empower RL with LLM, we propose a general approach facilitating efficient exploration in RL with task-specific guidance from LLM.

- 1.
For the research community, the publication of this work will inspire further exploration into encouraging the integration of LLMs with RL to address the inherent challenges in RL, such as efficient exploration, limited sample efficiency, and unsatisfactory generalization. Additionally, our design promotes the application of discrimination and coding to ground linguistic knowledge from LLMs into symbolic tasks.
- 2.
LEMAE shows promise for real-world deployment in scenarios requiring efficient exploration, such as autonomous vehicle control and robot manipulation. Moreover, as LLM is growing by leaps and bounds, it is foreseeable that LEMAE can be applied to more challenging real-world tasks by taking advantage of more powerful LLM. Notably, to mitigate potential risks, it is imperative to conduct LLM generation and RL training under human supervision, thereby ensuring undesirable outcomes are averted.

## Appendix C Proof of Proposition 4.1

###### Proof.

Random walk is a fundamental stochastic process, formed by successive summation of independent, identically distributed random variables (Lawler & Limic, ).
This work considers the one-dimensional asymmetric random walk problem, where an agent starts at $x=0$ and aims to reach $x=N\in\mathbb{N^{+}},N>1$.
The expected first hitting time considered as the metric of performance, implying the average computational time complexity (Yu & Zhou, ).
Below is the proof of Proposition 4.1.

Firstly, we can prove the expected first hitting time within the default setting through the application of martingale theory.
According to the problem setting, we can define the movement at each time step as: $M_{0}=0$, $M_{1},M_{2}...$ are i.i.d. random variables with distribution $P(M_{i}=1)=p,P(M_{i}=-1)=1-p,p\in(0.5,1)$. Then the position of agent after n steps can be represented as:

$$ $S_{n}=\sum_{i=1}^{n}M_{i},S_{0}=0$ (3) $$

However, because of the asymmetry of random variables $M_{i}$, $\{S_{n},n\geq 0\}$ does not pertain to the martingale $w.r.t.$ $\{M_{n},n\geq 1\}$. It’s observed that $\mathbb{E}(M_{i})=2p-1,i\geq 1$. Then, we can define:

$$ $Y_{n}=\sum_{i=1}^{n}\left(M_{i}-(2p-1)\right),Y_{0}=0$ (4) $$

It’s easy to prove that

$$ $\mathbb{E}|Y_{n}|=\sum_{i=1}^{n}E|M_{i}|-n(2p-1)=2n-2np<\infty$ (5) $$

$$ $\mathbb{E}(Y_{n+1}|M_{0},M_{1},...M_{n})=Y_{n}+\mathbb{E}(M_{n+1})-(2p-1)=Y_{n}$ (6) $$

So, according to the definition, $\{Y_{n},n\geq 0\}$ is a martingale $w.r.t.$ $\{M_{n},n\geq 1\}$

Let $T_{0\rightarrow N}=min\{n:S_{0}=0,S_{n}=N\}=min\{n:Y_{0}=0,Y_{n}=N-n*(2p-1)\}$. It’s clear that $T_{0\rightarrow N}$ is a stopping time $w.r.t.$ $\{M_{n},n\geq 1\}$.

It’s easy to prove that

$$ $\mathbb{E}\left(|Y_{n+1}-Y_{n}||M_{0},M_{1},...M_{n}\right)=\mathbb{E}\left(|M _{n+1}|\right)-(2p-1)=2-2p<2$ (7) $$

We can assume that $\mathbb{E}(T_{0\rightarrow N})<\infty$. Then, according to the Optional Stopping Theorem (Durrett, ), we can get

$$ $\mathbb{E}(Y_{T_{0\rightarrow N}})=N-\mathbb{E}(T_{0\rightarrow N})*(2p-1)= \mathbb{E}(Y_{0})=0$ (8) $$

Then

$$ $\mathbb{E}(T_{0\rightarrow N})=\frac{N}{2p-1}$ (9) $$

The assumption $\mathbb{E}(T_{0\rightarrow N})<\infty$ is thereby validated. Consequently, the expected first hitting time within the default setting is $\mathbb{E}(T_{0\rightarrow N})=\frac{N}{2p-1}$, a conclusion also articulated in Theorem 4.8.9 of Durrett ().

We can introduce the task-relevant information that the agent must first reach key states: $\kappa=1,...,N-1$ before progressing to $x=N$.
It is presupposed that every time the agent achieves at $x=\kappa$, the policy where $x<\kappa$ is updated to a deterministic rightward movement, i.e., $P(M_{x}=1)=1,x<\kappa$, thereby emulating the update process in Reinforcement Learning.

The expected first hitting time from $x=0$ to $x=1$ is $\mathbb{E}(T_{0\rightarrow 1})=\frac{1}{2p-1}$. After reaching $x=1$, the expected first hitting time from $x=1$ to $x=2$ can be calculated as:

$$ $\mathbb{E}(T^{prior}_{1\rightarrow 2})=p*\sum^{\infty}_{n=0}(2n+1)(1-p)=\frac{ 2}{p}-1$ (10) $$

Similarly, we can easily prove that

$$ $\mathbb{E}(T^{prior}_{1\rightarrow N})=(N-1)*\left(\frac{2}{p}-1\right)$ (11) $$

Consequently, the expected first hitting time after the integration of priors becomes $\mathbb{E}(T^{prior}_{0\rightarrow N})=\mathbb{E}(T_{0\rightarrow 1})+\mathbb{
E}(T^{prior}_{1\rightarrow N})=\frac{1}{2p-1}+(N-1)*\left(\frac{2}{p}-1\right)$.

The total advantage resulting from the integration of appropriate priors is expressed as $\mathbb{E}(T_{0\rightarrow N})-\mathbb{E}(T^{prior}_{0\rightarrow N})=(N-1)*(
\frac{1}{2p-1}-\frac{2}{p}+1)>0,p\in(0.5,1),N\in\mathbb{N}^{+},N>1$

∎

###### Proof.

## Appendix D LLM Prompts and Responses

Here are the example prompt and response in our work. Please reference the code for further details. Notably, we adopt the chain-of-thought technique from Wei et al. ().

Figure: Figure 9: The number of LLM-generated key state discriminator functions.
Refer to caption: x8.png

Notably, the number of key states is primarily determined by LLM. For each task, we only prompt LLM to prevent it from generating too few functions according to the complexity of the environment. Specifically, as detailed in Appendix D, we instruct LLM to generate several critical key states for MPE and more than 2*n_enemies critical key states for SMAC.

As shown in Fig. 9, we summarize the number of LLM-generated key state discriminator functions. It is notable that the number of discriminator functions increases with the difficulty of the task or the number of interactive objects in the environment, which aligns with intuition.

Additionally, we have omitted the intermediate LLM outputs to maintain conciseness in this section, retaining only the initial generation, as the differences between the initial and rechecked generations are minimal in the absence of errors.

## Appendix E Implementation Details

### E.1 LEMAE and Baselines

LEMAE: Our code is based on the widely-used code framework pymarl2 at [https://github.com/hijkzzz/pymarl2](https://github.com/hijkzzz/pymarl2). In this study, we have integrated our method with several base algorithms IPPO, QMIX, QPLEX, and VMIX. Throughout the integration process, we have refrained from modifying the algorithmic implementation and have maintained consistency in parameters, including batch size, learning rate, and loss coefficients, in alignment with the configurations of the base algorithms.

EITI and EDTI (Wang et al., ): We compare our method with EITI and EDTI on MPE tasks proposed in Liu et al. (). We use the experiment results reported in Liu et al. (), which found that these algorithms perform poor because a long
rollout (512 steps × 32 processes) between model updates
is used.

CMAE (Liu et al., ): We compare our method with CMAE on MPE and SMAC tasks. On MPE tasks, the results of CMAE are reproduced using the publicly available code released by the authors at [https://github.com/IouJenLiu/CMAE](https://github.com/IouJenLiu/CMAE). As CMAE lacks an implementation for SMAC, we use the results reported in the original paper.

MAVEN (Mahajan et al., ): We use the code at [https://github.com/starry-sky6688/MARL-Algorithms](https://github.com/starry-sky6688/MARL-Algorithms), which contains pytorch implementations of various MARL algorithms on SMAC, like the choice in LAIES (Liu et al., ).

RODE (Wang et al., ) and MASER (Jeon et al., ):
We utilized the publicly available code provided by the authors, accessible at [https://github.com/Jiwonjeon9603/MASER](https://github.com/Jiwonjeon9603/MASER) and [https://github.com/TonghanWang/RODE](https://github.com/TonghanWang/RODE), respectively. Default configurations were employed, and their suboptimal performance is also documented in LAIES (Liu et al., ).

LAIES (Liu et al., ):
We employed the publicly accessible code provided by the authors, which can be accessed at [https://github.com/liuboyin/LAIES](https://github.com/liuboyin/LAIES). When conducting experiments on SMAC, we adhered to the default configurations and external states. Notably, the original LAIES paper evaluation did not include assessments on the MPE. Consequently, we integrated the MPE environment into the LAIES codebase, designating the external states to represent the door status or the position of the box.

ELLM (Du et al., ):
Since the tasks in this work have clearly defined goals, we minimize LLM inference costs by following the ELLM methodology but adapting its goal generation to occur only once at the start of the training. Consistent with the hyperparameters in the official codebase [https://github.com/yuqingd/ellm](https://github.com/yuqingd/ellm), we set the similarity threshold to 0.99, rewarding only when the goal is achieved.
We rely on LLM-generated functions to verify goal achievement, which we found to be more effective than directly using semantic similarity-based rewards.

For all algorithms, we ensure the same environmental settings, including observation space, environment reward function, and so on.

### E.2 Comparison with LLM Reward Design

We conduct additional experiments comparing LEMAE with a baseline called Eureka-si, which can be seen as a single-iteration variant of Eureka (Ma et al., ), where LLM designs rewards directly. For fairness, we does not adopt evolutionary optimization in Eureka and use LLM to generate reward functions with the same role instructions as in Eureka, while maintaining designs like Self-Check as in LEMAE.
As shown in Fig. 3, Eureka-si is comparable to LEMAE in simple tasks like Push-Box but fails in challenging tasks with characteristics like partial observability, such as Pass, where hidden switches make it difficult to design effective reward functions. In contrast, LEMAE consistently demonstrates impressive performance. Notably, comparing LEMAE with Eureka directly would be unfair since Eureka’s evolutionary search requires multiple training iterations and candidates, leading to significantly more sampling and training than LEMAE.
Overall, LEMAE’s advantage over RL algorithms lies in incorporating prior knowledge from the LLM, and its advantage over other LLM-based methods is due to our designs for better LLM incorporation, such as utilizing discrimination, SHIR, and KSMT.

### E.3 Connection and Comparison with HER

The proposed Key State-Guided Exploration is similar to Hindsight Experience Replay (HER) (Andrychowicz et al., ) in form, where key states and subgoals are certain states from sampled trajectories.
However, unlike HER, which samples goals from memory using random or heuristic strategies and often struggles with shaped rewards, our method incorporates LLM priors for more targeted goal selection (key states localization). Additionally, the proposed KSMT and SHIR facilitate organized exploration and enhanced reward guidance.

We conduct additional experiments to further confirm the advantages of our method.
We evaluate HER with IPPO as the backbone in MPE. We use the future strategy for goal selection, as proposed in the HER paper, and employ a reward function based on the Manhattan Distance, which we find to be the best match. However, as depicted in Fig. 3, HER does not perform well on both MPE tasks. This outcome suggests that the random sampling strategy for goals may not be sufficient, underscoring the importance of incorporating LLM priors for efficient exploration as we proposed.

### E.4 Tasks

#### E.4.1 Multiple-Particle Environment (MPE)

The Multiple-Particle Environment serves as a widely-adopted benchmark for multi-agent scenarios. In this work, we employ tasks specifically crafted for evaluating multi-agent exploration, proposed by Wang et al. (). The implementation utilized in this study is based on the work by Liu et al. (). In this section, we provide details of the four sparse-reward tasks we adopted.

$\bullet$ Pass:
In the Pass task, depicted in Fig. 10a, two agents are positioned in a room of 30 x 30 grid. The room is divided into two halves by a wall featuring a door. Each half-room contains an invisible switch, the details of which are not contained in the state or prompt for LLM. The door permits passage only when one of the switches is occupied by an agent. Initially situated within the left half-room, both agents must cooperate to transfer to the right half-room. The external reward function is denoted as $r_{E}=I(two\ agents\ are\ in\ the\ right\ room)$, where $I$ represents the indicator function.

$\bullet$ Secret-Room:
Secret-Room is an extension task of Pass. As illustrated in Fig. 10b, the configuration comprises one sizable room on the left and three smaller rooms on the right, interconnected by three doors. Within each room, there is an invisible switch; notably, the switch in the left room has the capability to control all three doors, whereas each right room’s switch exclusively controls its respective door. The grid size is 25 x 25. Two agents are initialized within the left room and are required to collaborate in order to transition to the real target room, which is the right room 2. The external reward function is denoted as $r_{E}=I(two\ agents\ are\ in\ the\ right\ room\ 2)$, where $I$ represents the indicator function.

$\bullet$ Push-Box:
As depicted in Fig. 10(c), two agents and a box are initially positioned within a 15 x 15 grid. To successfully move the box, both agents must simultaneously exert force in the same direction. The task is deemed accomplished when the box is successfully pushed to the wall. The external reward function is denoted as $r_{E}=I(the\ box\ is\ pushed\ to\ the\ wall)$, where $I$ represents the indicator function.

$\bullet$ Large-Pass:
Large-Pass is a direct extension task of Pass by enlarging the grid dimensions to 50 x 50, which makes it more challenging. The external reward function aligns with that of the Pass task.

The details of these tasks, including observation space and action space, are listed in Table 3.

**Table 3: Details of MPE tasks**
| MPE tasks | n_agents | observation space | state space | action space |
| --- | --- | --- | --- | --- |
| Pass | 2 | 5 | 5 | 4 |
| Secret-Room | 2 | 5 | 5 | 4 |
| Push-Box | 2 | 6 | 6 | 4 |
| Large-Pass | 2 | 5 | 5 | 4 |

Figure: Figure 10: MPE Tasks.
Refer to caption: extracted/5898825/img/MPE.png

#### E.4.2 StarCraftII Multi-Agent Challenge (SMAC)

StarCraftII Multi-Agent Challenge (SMAC) (Samvelyan et al., ) is a widely-used benchmark in the realm of cooperative multi-agent reinforcement learning research (Rashid et al., ; Shao et al., ; Liu et al., ; Shao et al., ).
Derived from the renowned real-time strategy game StarCraft II, SMAC concentrates specifically on decentralized micromanagement scenarios rather than the full game.
Typically, the tasks within SMAC adopt a dense-reward framework, wherein agents receive dense rewards for damage received, attacking and eliminating enemies.
To promote the need for exploration, we adopt fully sparse-reward versions of tasks in SMAC where agents are solely rewarded upon the successful elimination of all enemies.
The external reward function is denoted as $r_{E}=I(all\ enemies\ are\ eliminated)$, where $I$ represents the indicator function.
Notably, this sparse-reward setting differs from the sparse SMAC, which can be called semi-sparse SMAC, used in some previous studies (Jeon et al., ; Jo et al., ), where agents are rewarded when one or all enemies die or when one ally dies.
In addition, to validate the versatility of LEMAE across diverse scenarios, we conducted experiments on six maps with different difficulty and diverse agent numbers, as illustrated in Table 4 and Table 5.
We use the version of SC2.4.10.
Please refer to the official document(^2^22[https://github.com/oxwhirl/smac/blob/master/docs/smac.md](https://github.com/oxwhirl/smac/blob/master/docs/smac.md)) for more details.

**Table 4: SMAC tasks.**
| Task | Ally Units | Enemy Units | Type | Difficulty |
| --- | --- | --- | --- | --- |
| 1c3s5z | 1 Colossi,<br>3 Stalkers,<br>5 Zealots | 1 Colossi,<br>3 Stalkers,<br>5 Zealots | heterogeneous & symmetric | Easy |
| 2m_vs_1z | 2 Marines | 1 Zealot | micro-trick: alternating fire | Easy |
| 3s_vs_5z | 3 Stalkers | 5 Zealots | micro-trick: kiting | Hard |
| 5m_vs_6m | 5 Marines | 6 Marines | homogeneous & asymmetric | Hard |
| 3s5z_vs_3s6z | 3 Stalkers,<br>5 Zealots | 3 Stalkers,<br>6 Zealots | heterogeneous & asymmetric | Super-Hard |
| MMM2 | 1 Medivac,<br>2 Marauders,<br>7 Marines | 1 Medivac,<br>3 Marauders,<br>8 Marines | heterogeneous & asymmetric | Super-Hard |

**Table 5: Details of SMAC tasks**
| SMAC tasks | n_agents | n_enemies | observation space | state space | action space |
| --- | --- | --- | --- | --- | --- |
| 2m_vs_1z | 2 | 1 | 16 | 26 | 7 |
| 1c3s5z | 9 | 9 | 162 | 270 | 15 |
| 3s_vs_5z | 3 | 5 | 48 | 68 | 11 |
| 5m_vs_6m | 5 | 6 | 55 | 98 | 12 |
| 3s5z_vs_3s6z | 8 | 9 | 136 | 230 | 15 |
| MMM2 | 10 | 12 | 176 | 322 | 18 |

#### E.4.3 A Brand New Task: River

To exclude the probability that LEMAE’s success relies on LLM’s familiarity with the chosen tasks, we’ve designed a brand new task, termed River, which LLM has never encountered before. The task is detailed as follows:

The River task is adapted from the Multiple-Particle Environment and its map is illustrated in Fig. 8a.
Two agents, Alice and Bob, are placed in a 30 x 30 grid field intersected by two rivers running vertically and horizontally. A mountain in the bottom-left corner obstructs the passage. Alice and Bob start randomly in the top-left part of the field and need to move to the bottom-right part. However, Alice is afraid of water and cannot cross the river unless Bob stays in the river to act as a bridge for her.

The observation space is discrete with four dimensions, representing the positions of two agents, i.e., $o=[x_{1},y_{1},x_{2},y_{2}]$. The action space is also discrete, allowing movement in four directions. Agents receive a positive reward only when both agents reach the bottom-right corner of the field.

### E.5 Hyperparameters

In LEMAE, we introduce three important hyperparameters: extrinsic reward scaling rate $\alpha$, intrinsic reward scaling rate $\beta$, and high randomness epsilon $\epsilon_{h}$. Notably, the low randomness epsilon $\epsilon_{l}$ is the hyperparameter in the base algorithms, such as 0.05 for QMIX and 0.0 for IPPO.

For MPE, we adopt $\{\alpha=10,\beta=0.1,\epsilon_{h}=1\}$ on Pass, Secret-Room, and Large-Pass and use $\{\alpha=10,\beta=0.05,\epsilon_{h}=0.2\}$ on Push-Box.

For SMAC, we adopt $\{\alpha=50,\beta=1,\epsilon_{h}=0.5\}$ on MMM2 and 1c3s5z, $\{\alpha=10,\beta=1,\epsilon_{h}=0.5\}$ on 3s_vs_5z and 2m_vs_1z, $\{\alpha=1,\beta=1,\epsilon_{h}=0.5\}$ on 5m_vs_6m and 3s5z_vs_3s6z.

### E.6 Resources

We use a server with 8*NVIDIA RTX 3090 GPUs, and 2*AMD 7H12 CPUs to run all the experiments.
Without specifying, each setting is repeated for 5 seeds.
For one seed in SC2, the running time ranges from approximately 50 minutes to 12 hours.
For MPE, the running time varies from around 3 to 7 hours.
The input for each LLM (GPT-4-1106-preview) inference comprises approximately 600-4000 tokens (0.006-0.04 dollars), yielding an output of about 300-1600 tokens (0.009-0.048 dollars).

## Appendix F Additional Experimental Results

### F.1 More Complicated Benchmark: SMACv2

We have evaluated LEMAE on three typical tasks, protoss_5_vs_5, terran_5_vs_5, and zerg_5_vs_5, in SMACv2 (Ellis et al., ) to demonstrate its effectiveness under stochastic dynamics settings.
We utilized the typical hyperparameters for both LEMAE and LAIES as used in SMAC.
As shown in Fig. 11, LEMAE achieves outstanding performance, confirming its applicability to such settings.
This result further demonstrates LEMAE’s potential for real-world scenarios with complexity and stochasticity.

Figure: Figure 11: Evaluating LEMAE against baseline methods across three maps in SMACv2, which features greater randomness, using the evaluation metric of test win rate. QMIX-DR is QMIX with dense rewards in the original SMACv2. This result further demonstrates LEMAE’s potential for real-world scenarios with complexity and stochasticity.
Refer to caption: x9.png

### F.2 Extending LEMAE Beyond Symbolic Tasks

This work primarily focuses on tasks with symbolic state spaces, where states are represented as symbolic arrays describing the agent and environment.
As discussed in Appendix B.3, to extend LEMAE from symbolic tasks to vision-based tasks, we can exchange the LLM for a multi-modal LM in LEMAE for key state localization.
To confirm the applicability of LEMAE to vision-based tasks, we conduct a demonstrative experiment: We extend the task Pass to a vision-based task Visual-Pass, as illustrated in Fig. 12a.
We prompt a LLM to define key states with the same task description and role instruction as proposed in Sec. 4.2 and use the LLM-generated definition as the prompt for a Vision Language Model (GPT-4o).
Then, it is prompted to discriminate key states in the randomly sampled states.
GPT-4o achieves a 98% accuracy rate in discriminating key states among the 50 sampled image states.
This confirms that with a proper extension of the LLM, LEMAE can eliminate dependence on state semantics and be applied to other tasks such as visual-input.

Figure: Figure 12: (a) An illustration of the vision-based task Visual-Pass. (b) The prompt for the Vision Language Model (VLM), which includes the task description, role instruction, image state and key states definition provided by another LLM. The VLM is tasked with determining whether the given image state corresponds to a key state.
Refer to caption: extracted/5898825/img/room_img.png

### F.3 Ablation Studies on Mixed-Randomness Exploration

As demonstrated in Fig 13, we conduct an ablation study on mixed-randomness exploration within the 3s_vs_5z map. Results indicate that LEMAE exhibits insensitivity to the parameter $\epsilon_{h}$, provided that the level of randomness remains moderate, as opposed to being excessively extreme (0.1 or 0.9). Besides, the effectiveness of our design is highlighted through a comparison between LEMAE and its variants, namely, only leaf node and LEMAE w/o KSMTE.

Figure: Figure 13: Ablation study on mixed-randomness exploration. The default hyperparameter used in LEMAE is $\epsilon_{h}=0.5$. Robustness evaluation included variations in $\epsilon_{h}=[0.1,0.3,0.7,0.9]$. The only leaf node denotes simply using $\epsilon_{l}$ for the non-leaf node and $\epsilon_{h}$ for the leaf node. The LEMAE w/o KSMTE denotes LEMAE without mixed-randomness exploration.
Refer to caption: x10.png

### F.4 Experiments for Single-Agent setups

Indeed, we propose LEMAE as a general approach for LLM-empowered efficient exploration in reinforcement learning, applicable to both single-agent and multi-agent settings. We underscore the evaluation of its performance in multi-agent settings due to its inherent complexity.

As the proposed method can seamlessly extend to single-agent scenarios, we introduce a single-agent variant of MPE and assess PPO (Schulman et al., ) and PPO-based LEMAE across four tasks. We run each algorithm using three random seeds with 300k environment steps, using the evaluation metric of the test win rate. The following table shows that LEMAE can facilitate efficient exploration in single-agent scenarios.

**Table 6: Final test win rate of LEMAE and PPO on single-agent variant of MPE tasks.**
| Single MPE | PPO | LEMAE |
| --- | --- | --- |
| Single Pass | 0.00$\pm$0.00 | 1.00$\pm$0.00 |
| Single Secret-Room | 0.00$\pm$0.00 | 0.98$\pm$0.01 |
| Single Large-Pass | 0.00$\pm$0.00 | 0.99$\pm$0.01 |
| Single Push-Box | 0.00$\pm$0.00 | 0.96$\pm$0.08 |

### F.5 Discussion on the KSMT

Using KSMT could pose a limitation due to potential memory costs in certain scenarios.
However, this has not been a significant issue in our experiments, as the key states are relatively few, primarily focusing on the most critical ones, with a natural sequential relationship typically existing between them.
Notably, LEMAE is also compatible with other memory structures, such as Directed Acyclic Graphs (DAGs), which could be an interesting direction for future exploration.

To demonstrate the effectiveness of LEMAE with other memory structures, in scenarios where task completion follows a linear pattern (e.g., $Init\rightarrow A\rightarrow B\rightarrow Success$), we employ a more efficient strategy by using a KSMT variant with a single branch representing the sequential order of key states.
Specifically, we systematically assign a priority value to each key state, continuously updating it based on its occurrence order within the sequence of attained key states. The determination of the ranking of key states within the one-branch KSMT relies on this established priority.

As illustrated in Fig. 14, an ablation study is conducted to compare the performance between raw KSMT and the one-branch KSMT variant across six maps in SMAC. The results demonstrate the increased necessity of employing the one-branch KSMT variant for tasks involving a larger number of agents and greater complexity, such as 5m_vs_6m, 3s5z_vs_3s6z, and MMM2. Consequently, we have adopted the one-branch KSMT approach for these specific SMAC tasks: 5m_vs_6m, 3s5z_vs_3s6z, and MMM2.

Figure: Figure 14: Ablation study conducted to compare the performance between raw KSMT and the one-branch KSMT variant across six maps in SMAC.
Refer to caption: x11.png

#### F.5.1 Working with dense reward settings

We also evaluate LEMAE in tasks with dense rewards in SMAC, denoted as LEMAE-DR. As shown in Fig. 15,
the results confirm that LEMAE-DR facilitates efficient exploration in both dense and sparse reward settings, highlighting the main contribution of our method. Additionally, LEMAE-DR achieves better convergence than LEMAE due to the guidance provided by dense rewards.

Figure: Figure 15: Evaluating LEMAE with dense rewards across three maps in SMAC using the evaluation metric of test win rate. LEMAE-DR is LEMAE with dense rewards in the original SMAC, which effectively ensures efficient exploration and achieves better convergence.
Refer to caption: x12.png

### F.6 Additional Results

**Table 7: Final test win rate of LEMAE and comparable baseline (CMAE) on MPE tasks.**
| MPE | LEMAE (Ours) | CMAE |
| --- | --- | --- |
| Pass | 1.00$\pm$0.00 | 0.75$\pm$0.43 |
| Secret-Room | 1.00$\pm$0.00 | 0.80$\pm$0.40 |
| Push-Box | 1.00$\pm$0.00 | 0.80$\pm$0.40 |
| Large-Pass | 1.00$\pm$0.00 | 0.00$\pm$0.00 |

**Table 8: Final test win rate of LEMAE and comparable baseline (LAIES) on SMAC tasks. QMIX-DR denotes training QMIX with dense reward.**
| SMAC | LEMAE (Ours) | LAIES | QMIX-DR |
| --- | --- | --- | --- |
| 1c3s5z | 0.98$\pm$0.02 | 0.89$\pm$0.09 | 0.99$\pm$0.01 |
| 2m_vs_1z | 1.00$\pm$0.01 | 0.73$\pm$0.24 | 1.00$\pm$0.01 |
| 3s_vs_5z | 0.83$\pm$0.07 | 0.10$\pm$0.12 | 0.66$\pm$0.16 |
| 5m_vs_6m | 0.74$\pm$0.08 | 0.68$\pm$0.10 | 0.78$\pm$0.08 |
| 3s5z_vs_3s6z | 0.73$\pm$0.14 | 0.45$\pm$0.35 | 0.73$\pm$0.07 |
| MMM2 | 0.89$\pm$0.08 | 0.62$\pm$0.25 | 0.90$\pm$0.05 |

**Table 9: Comparing LEMAE with SOTA baseline CMAE across four maps in MPE using the metric of the number of exploration steps (in thousand) taken to find the success state**
| MPE | LEMAE (Ours) | CMAE | Acceleration rate |
| --- | --- | --- | --- |
| Pass | 153.1$\pm$20.7 | 2114.8$\pm$157.4 | 13.8 |
| Secret-Room | 316.6$\pm$134.6 | 1448.5$\pm$467.2 | 4.6 |
| Push-Box | 159.0$\pm$42.5 | 972.3$\pm$887.3 | 6.1 |
| Large-Pass | 446.9$\pm$256 | >3000 | >6.7 |

Figure: Figure 16: The training curve while evaluating the efficacy of combining our method with various algorithms.
Refer to caption: x13.png

In this section, we provide some additional experimental results.

As demonstrated in Table 7 and Table 8, we augment the final test win rate of our proposed method, LEMAE, with comparable baseline algorithms in MPE and SMAC tasks. This augmentation serves to elucidate the superior performance of our method. It is pertinent to note that baseline algorithms, the performance of which has been demonstrated to be poor in the training curves, are omitted from the tables for conciseness.

As demonstrated in Table 9, we compare LEMAE with SOTA baseline CMAE using the metric of the number of exploration steps taken to find the success state.
The results indicate a significant exploration acceleration rate, up to 10x, underscoring LEMAE’s superior efficiency.

Moreover, as illustrated in Fig. 16, we supplement the training curve while evaluating the efficacy of combining our method with various algorithms, i.e., QPLEX and VMIX.

## Peer Reviews

confidence: 3
contribution: 2
initial_rating: 6
presentation: 3
questions: Refer to weakness.
soundness: 3
strengths: Developing an effective way to leverage the linguistic knowledge in LLMs for RL is a promising approach. This paper makes a step forward by proposing the idea of 'discriminating key state' and tree search. I believe this could be a valuable supplement to RL community with the integration of large foundation models. 

In addition, I list some other pros as follow:

1. Overall the paper is well-organized and well-established. It is easy to follow the motivation and method design. 
2. The proposed method seems a general method that can be utilized for wide RL problems, e.g., single agent setting. It would be interesting to see the results on single agent RL tasks.
3. The experiment is comprehensive, including wide ranges of baselines and evaluation tasks.
summary: This paper study utilizing LLMs to improve exploration for multi-agent RL setting. The key motivation is that LLMs, pre-trained on general knowledge, can extract task-relevant guidance for improving exploration. The proposed method,  LEMAE, identifies key states by prompting LLMs, and encourages the agents to move forward key states using a memory tree. Experiment results on SMAC and MPE show that LEMAE outperforms various RL methods in terms of improvement speed and final performance.
weaknesses: It seems that LEMAE is quite limited to specific tasks, whose state is simple to describe. A key point of LEMAE is to address the symbolic state representation issue for LLMs. However, for tasks with complex state representation, such as robotics control, it is hard to explain a specific state value. LEMAE is hard to be applied in such domain, which is an important sub-filed of RL tasks. 

Besides, LEMAE is proposed for multi-agent RL problem, but it lacks a consideration for solve MARL training, e.g., cooperation between partners. Taking this into consideration would make the method more reliable and efficient.

There are also some more suggestions on the writing:
1. I feel that the introduction of the method in Section 1 is a simple re-writing of the abstract. 
2. I do not find the importance of putting "CHOICES ARE MORE IMPORTANT THAN EFFORTS" in the title. I think it is not the main highlight of this paper. Maybe it is better to consider from the perspective of LLMs.

---

confidence: 4
contribution: 2
initial_rating: 5
presentation: 3
questions: - How does the proposed method compare with other LLM-based reward shaping algorithms?
- Could the authors clarify whether the same prompts were used across all LLM-based methods?
- How well can the proposed algorithm scale to environments with complex state space/action space/transition dynamics?
- It seems that the proposed method can be applied to both single-agent and multi-agent environments. Is there a particular reason to use it primarily in multi-agent environments?
- How does the key states memory tree compare to the memory structure used in Go-Explore?
soundness: 3
strengths: Hindsight experience replay is a very effective auxiliary reward generation methods that have shown successes in many RL environments. However, its main limitation is the difficulty to correctly “identify” goal states. This paper proposes to use LLM to generate such “key states”.
summary: This paper proposes to improve exploration in multi-agent environments by generating key states with the aid of LLMs and then use hindsight experience replay to generate auxiliary rewards. Specifically, task descriptions as well as task-relevant knowledge is converted to text and then fed to an LLM that is tasked to generate a function (e.g., written in Python) that takes in a state and returns whether this is a goal state. During a typical online reinforcement learning procedure, each experienced state is examined by the key state checking function, and if it is masked as a key state, hindsight experience replay will be used to add auxiliary rewards to prior states in the same trajectory/episode. The proposed algorithm was tested on the Multiple-Particle Environment and the StarCraft Multi-Agent Challenge.
weaknesses: - Connection with other LLM-based reward shaping algorithms. While the paper discusses many LLM-based reward generation algorithms in their related works, better and more comprehensive comparison with these methods are needed in the experiment sections to better demonstrate the effectiveness of the proposed algorithm (e.g., Xu et al., 2023 and Liu et al., 2023 cited in the paper). Specifically, as mentioned in the paper, specific prompts for description the task/state space/action space are used for each environment independently. Whether the same set of prompts are used in relevant baselines? If the prompt is good enough for the LLM to generate key state description functions, it seems natural that with similar prompts the LLM can also directly generate good auxiliary rewards and/or reward functions, which are done by many existing LLM-based reward generation algorithms. It would be very helpful to clearly describe the settings and make sure that the relevant baselines are also exposed to the same prompts. 

- There is only one LLM-based reward generation baseline adopted. Are there particular reasons for only including this LLM-based baseline algorithm? Since the proposed method leverages knowledge from LLMs, it would be more natural to include more LLM-based baselines.

- Generalizability of the LLM-based key-state detector to other environments. The adopted environments have discrete and small state/action spaces, which makes it easier to create key-state detectors. Also, the environments are relatively simple to describe with natural language. I wonder how this method performs in environments with more complex state space/action space/transition dynamics, for example in robotics tasks?

- Minor: relation with Go-Explore [1]. This key states memory tree seems to be related to go-explore. Could the authors discuss their similarities and differences?


[1] Ecoffet, Adrien, Joost Huizinga, Joel Lehman, Kenneth O. Stanley, and Jeff Clune. "Go-explore: a new approach for hard-exploration problems." arXiv preprint arXiv:1901.10995 (2019).

---

confidence: 4
contribution: 3
initial_rating: 6
presentation: 2
questions: see weakness.
soundness: 3
strengths: 1. important topic and novel methods: Efficient multi-agent exploration is important for MAS, the proposed methods leverage LLM for this goal, which is novel as the reviewer knows.  

2. memory tree to orginaze the key states for guided exploration (instead of greedy redundant exploration) is interesting and novel.  

3. The paper is clear and easy to understand.

4. The results show that the proposed methods achieve better results than most baseline methods.
summary: This paper proposes to channel informative task-relevant guidance from a knowledgeable LLM for efficient Multi-Agent Exploration. It uses LLM to localize key states and use hindsight reward for exploration (also use memory tree to orginaze the key states). The results show that the proposed methods achieve better results than most "traditional" deep MARL methods.
weaknesses: 1. Proposition 4.1 is one of hte most important motivation for task-relevant information based exploration. But the setting is the one-dimensional asymmetric random walk problem. What is means for a more realistic scenarios (e.g., MPE, SMAC)?  Could the authors discuss how the insights from Proposition 4.1 might generalize or relate to more complex environments (higher-dimensional state spaces with multiple agents) like MPE and SMAC?

2. The key states localization is the most important for the proposed methods. But current description (i..e, Section 4.2)  is not clear about the method detaills. (besides discrimination by LLM rather than generation; m discriminator functions). Could the authors discuss the process of generating the m discriminator functions (or the detailed prompts), how the number m is determined, or how the discriminator functions are applied to states in practice. And how to make sure the LLM-based discriminators can work well as the designed intention?

3. The baselines compared seems to be general MARL methods. It is better to compare MA-exploration methods and methods that also combine LLM with MARL (e.g., [1,2,3]).  Could the authors explain why these specific baselines were not included, and could you either add comparisons to these methods or discuss how their approach differs conceptually from these related works. This would help contextualize your contribution within the most relevant recent literature.

[1] Learning When to Explore in Multi-Agent Reinforcement Learning. TCYB 2023.  (which learns to when to explore)
[2] Controlling Large Language Model-based Agents for Large-Scale Decision-Making: An Actor-Critic Approach. (which uses two LLMs for exploration-exploitation tradeoff)

---

confidence: 5
contribution: 1
initial_rating: 1
presentation: 1
questions: - L190: What do you mean by “the initial policy is asymmetric”?
- L247: What’s the rationale for using Manhattan Distance instead of, for example, cosine similarity?

What the authors would have to demonstrate to see an improved rating from me:
- Redo experiments on SMACv2 (A)
- Add baselines Motif and OMNI, requiring them to be evaluated on MARL (B)
- Add E3B baseline, again integrating that into the MARL setup, or, alternatively (since the proposed method is not MARL-specific) run the proposed method on single-agent procedurally generated environments. (C) 
- Demonstrate that the proposed method also works for non-symbolic observations (D)
soundness: 1
strengths: - I believe the paper provides sufficient detail in the appendix to reproduce it.
- The direction of the paper, addressing hard exploration in multi-agent systems, is an important one.
summary: This paper presents an approach for using LLMs to identify key states for multi-agent reinforcement learning agents to more efficiently explore in procedurally generated environments. Given a trajectory, the LLM generates key states, which are then organized in a key states memory tree, and used in a hindsight experience replay-like approach.
weaknesses: ## Major
A) The main results of the paper center around The StarCraft Multi-Agent Challenge (SMACv1) by Samvelyan et al. (2019). However, it is well established by now that SMACv1 is saturated and too simple. The authors should use the 2022 released SMACv2 [1] for their experiments. From the SMACv2 paper: “after years of sustained improvement on SMAC, algorithms now achieve near-perfect performance. In this work, we conduct new analysis demonstrating that SMAC lacks the stochasticity and partial observability to require complex *closed-loop* policies. In particular, we show that an *open-loop* policy conditioned only on the timestep can achieve non-trivial win rates for many SMAC scenarios.”

B) Using language observations or LLMs to guide exploration of RL agents for hard exploration problems has been extensively studied in the single-agent setup. The authors have not covered important very related methods (e.g. [2-4]) in this space. In particular I would expect Motif [3] and OMNI [4] to be tried out as a baseline in the multi-agent RL (MARL) setting. In fact, I would go as far and say that the proposed method is not MARL-specific at all, so the authors really need to show that it provides benefits over existing exploration methods in the single agent setting.

C) Related to B, it is even unclear to me whether explicit key states are necessary for exploration in the MARL environments used here. I would like to see a comparison to MARL with general intrinsic reward mechanisms such as E3B [5] to answer the question whether key states significantly improve exploration over generic intrinsic reward methods.

D) The authors claim that “KSMT helps avoid redundant exploration throughout the state space, particularly beneficial in more complicated real-world scenarios” despite that no experiments on such real-world problems are provided. Either tone it down or provide additional empirical evidence in more-real world environments. I would be very interested in the latter, in particular seeing experiments on environments that do not have a symbolic observation space.

[1] Ellis, B., Moalla, S., Samvelyan, M., Sun, M., Mahajan, A., Foerster, J. N., & Whiteson, S. (2022). SMACv2: An Improved Benchmark for Cooperative Multi-Agent Reinforcement Learning. arXiv. https://doi.org/10.48550/arXiv.2212.07489

[2] Mu, J., Zhong, V., Raileanu, R., Jiang, M., Goodman, N., Rocktäschel, T., & Grefenstette, E. (2022). Improving Intrinsic Exploration with Language Abstractions. arXiv. https://doi.org/10.48550/arXiv.2202.08938

[3] Klissarov, M., D’Oro, P., Sodhani, S., Raileanu, R., Bacon, P.-L., Vincent, P., … Henaff, M. (2023). Motif: Intrinsic Motivation from Artificial Intelligence Feedback. arXiv. https://doi.org/10.48550/arXiv.2310.00166

[4] Zhang, J., Lehman, J., Stanley, K., & Clune, J. (2023). OMNI: Open-endedness via Models of human Notions of Interestingness. ICLR 2024.

[5] Henaff, M., Raileanu, R., Jiang, M., & Rocktäschel, T. (2023). Exploration via Elliptical Episodic Bonuses. arXiv. https://doi.org/10.48550/arXiv.2210.05805


## Minor
- LLMs instead of LLM (e.g. in the title); also "Efforts" -> "Effort" in the title
- Be more precise with what you mean by “redundant exploration”
- Use more formal language (e.g. not “brand-new” in line 089)
- L160: “to clarity” -> “to clarify”
- Figure 2 is somewhat unclear to me, in particular the LLM-mapping from Prompt to Response. I particularly find it hard to map what’s formalized in 4.2 (e.g. L209 to L212) to what’s shown in Figure 2. Also, what feedback flows directly back from response to prompt?

Meta-review: This paper proposes to improve exploration in multi-agent environments by generating key states with the aid of LLMs and use hindsight experience replay to generate auxiliary rewards. 

The method is novel, the paper is well-organized, and it is easy to follow the motivation and method design.

However, the method is not sufficiently evaluated in more complex tasks and it also lacks consideration of specifics in multi-agent RL. The baselines are not sufficient for evaluating the proposed methods. Thus, current empirical results do not fully support the claim of the paper.

Decision: Reject