LARM: Large Auto-Regressive Model for Long-Horizon Embodied Intelligence

## Abstract

Abstract Due to the need to interact with the real world, embodied agents are required to possess comprehensive prior knowledge, long-horizon planning capability, and a swift response speed. Despite recent large language model (LLM) based agents achieving promising performance, they still exhibit several limitations. For instance, the output of LLMs is a descriptive sentence, which is ambiguous when determining specific actions. To address these limitations, we introduce the large auto-regressive model (LARM). LARM leverages both text and multi-view images as input and predicts subsequent actions in an auto-regressive manner. To train LARM, we develop a novel data format named auto-regressive node transmission structure and assemble a corresponding dataset. Adopting a two-phase training regimen, LARM successfully harvests enchanted equipment in Minecraft, which demands significantly more complex decision-making chains than the highest achievements of prior best methods. Besides, the speed of LARM is 6.8 × \times × faster.

## 1 Introduction

In recent years, remarkable progress has been achieved in various artificial intelligence (AI) fields [] like computer vision [] and natural language processing [], but most of them lack the capacity to physically interact with the real world. To address this disconnect, the concept of embodied AI is introduced []. Early embodied agents are predominantly developed on simulation platforms for specific tasks such as object grasping and indoor navigation []. While notable advancements are achieved, these agents tend to be specialist models confined to isolated tasks []. To overcome this limitation, recent studies, including this work, employ Minecraft [; ; ] as a benchmark to explore embodied agents with open-ended objectives and long-horizon reasoning chains.

The initial methods for developing such agents primarily rely on reinforcement learning, the exploration of which is inefficient and results in limited performance []. Recent works begin to investigate the use of large language models (LLMs) to build agents []. Owing to the extensive general knowledge and formidable reasoning capabilities of LLMs, these methods demonstrate promising results with significantly reduced domain-specific engineering efforts []. Nevertheless, LLMs continue to exhibit a number of limitations, rendering them ill-suited for embodied AI tasks. The limitations of LLM can be divided into two categories, inadequate model structure and ineffective data utilization. Concerning the model structure, on the one hand, the output of LLM is text-based. As illustrated in Fig. 1, although LLM could describe the future plan well, the specific actions still remain ambiguous. On the other hand, the output of LLM is generated through iterative token prediction, necessitating $N$ inference operations for $N$ tokens, which results in a sluggish speed. Regarding data utilization, the training data for LLMs is predominantly sourced from the internet and lacks intricate dependency knowledge among embodied actions, agent status, and environmental information.

Figure: Figure 1: LARM is the first method that achieves enchanted diamond equipment in Minecraft, surpassing previous SOTAs limited to crafting standard diamond tools. Compared with LLMs that generate ambiguous descriptive sentences for determining skills to execute, LARM directly predicts subsequent skills in an auto-regressive way.
Refer to caption: x1.png

To address the limitations of LLM, we propose Large Auto-Regressive Model (LARM). LARM engages in real-time interaction with the environment and predicts subsequent actions in an auto-regressive manner. Besides text information (target task description, historical action, agent position, inventory list, and environment feedback message), LARM incorporates multi-view images as input. Instead of generating a sentence composed of multiple tokens, LARM directly produces a single token to predict the next action. This design eradicates the ambiguity inherent in sentence description outputs and enhances the inference speed of LARM.

To train LARM, we introduce a unique data organization structure termed as Auto-Regressive Node Transmission Structure (ARNTS). Within ARNTS, each data sample is conceptualized as a node, encompassing text information, multi-view images, and the expected subsequent action. A chronological dependency exists among these nodes. The process of accomplishing a complex target can be interpreted as transmissions between different nodes. Adhering to this data structure, we manually collect an ARNTS dataset comprising 2,589 data samples, which cover diversified targets, weathers, and biomes. Leveraging this dataset to train the LARM agent, the agent can effectively learn the dependency knowledge among various information types. Additionally, we have devised three data augmentation strategies, each tailored to the unique characteristics of ARNTS. However, the ARNTS dataset alone is inadequate to train LARM due to its numerous parameters (e.g., 7 billion parameters). To mitigate this challenge, we employ a 34G multi-modal dataset [], sourced from Wiki Minecraft webpages, to pre-train the model before proceeding with ARNTS training.

Through integrating the aforementioned efforts, we develop an agent capable of crafting enchanted diamond tools. As shown in Fig. 1, crafting enchanted diamond tools requires a far more intricate action chain and long-horizon scheduling ability compared to existing state-of-the-art (SOTA) methods [; ], which are only capable of crafting standard diamond tools. Besides, the inference speed of LARM is 6.8$\times$ faster on average compared to an LLM with comparable parameter volume.

## 2 Related Work

Embodied benchmarks. Embodied AI recently garners significant attention due to its potential to bridge the gap between virtual algorithms and physical interactions []. The recent works in embodied AI primarily focus on enhancing agents’ interaction with the environment, and many benchmarks are established []. For instance, Anderson et al. propose a vision-and-language navigation task in photo-realistic environments []. Similarly, Chen et al. introduce Touchdown [], a game-like task that combines navigation and question-answering in urban environments. Moreover, the emergence of interactive environments like AI2-THOR [] and Habitat [] significantly contributes to embodied agent development. However, these benchmarks are mostly restricted to isolated tasks.

Minecraft. Minecraft provides a platform for exploring models with long-horizon planning capability []. Initial methods typically develop Minecraft agents via reinforcement learning []. To mitigate the optimization challenges, these methods manually decompose a high-level task into simpler atomic tasks, subsequently training agents to execute these atomic tasks sequentially []. However, the performance of these methods remains suboptimal due to the limited exploration efficiency []. To rectify this issue, recent works construct agents based on LLMs. For example, Voyager [] successfully crafts diamond tools using a training-free system based on GPT-4 []. Similarly, DEPS [] develops a more comprehensive LLM system, yielding satisfactory results. However, LLMs solely support text input, which is inadequate for encapsulating environmental information. To surmount this hurdle, certain studies train large vision-language models through fine-tuning LLMs [; ]. Despite these advancements, the output of these models remains ambiguous text.

Large language models. GPT-3 emerges as a significant milestone in the evolution of LLMs, showcasing remarkable open-world generalization capabilities across diverse tasks []. Subsequently, the fine-tuning of GPT-3 using reinforcement learning with human feedback leads to the creation of ChatGPT, a model that displays an impressive breadth of general knowledge []. Further advancements result in the creation of GPT-4, reinforcing the advantages of increasing model size and training data []. In addition, there are notable open-source works that train models with fewer parameters while still achieving promising results, such as LLaMA []. However, a significant limitation of LLMs is their inability to interpret information in images, which are vital information sources. To overcome this, large vision-language models like LLaVA [] and Flamingo [] are developed. While these models can describe the content in provided images, they lack the capability to interact with the real world.

## 3 Algorithm

Figure: Figure 2: The overall framework of LARM. In this framework, the network takes the target task description, multi-view images, agent information, and environment feedback as input to predict a skill token. The skill token is matched with the skill embeddings, which are generated based on a pre-prepared skill library, to select the optimum skill. Then, the agent performs this skill, which helps the agent one step closer to completing the target and changes the environment.
Refer to caption: x2.png

### 3.1 Large Auto-Regressive Model

LARM is a large embodied AI model containing billions of parameters and predicting subsequent skills in an auto-regressive manner. Its framework is illustrated in Fig. 2. To save training cost, we generate skill embeddings before training LARM. Following Voyager [], we design prompts that describe the intended use of skills. Then, GPT-4 is employed to generate skill code based on these prompts and Mineflayer []. Combining the generated skills, a skill library is derived. We utilize MineCLIP [] to extract the embeddings of these skills. Every skill is mapped to an embedding vector with the length of $L$. All the embeddings are saved and directly used during training LARM.

The input to LARM consists of both text and image information. The text information includes the target task description, the agent information, and the environment feedback. Specifically, the agent information contains the last skill performed by the agent, the current 3D position coordinate of the agent in the Minecraft world, the agent’s inventory list (a list of the resources that the agent owns). This information well describes the current status of the agent. For the environment feedback, two kinds of information are included, i.e., whether the last skill performed by the agent is executed successfully and the game response message to that skill. All the text information is tokenized into text tokens by a frozen tokenizer, the weight of which is initialized from BERT [].

Different from previous Minecraft agents that take a monocular image as input [], LARM adopts $N$ views of images in different directions, providing a more comprehensive description of the surrounding environment. The $N$ multi-view images are tokenized as $N\times N^{I}$ image tokens by a frozen CLIP encoder. However, since there are $N$ images, the number of obtained tokens is increased by $N$ times and would result in a significant computational burden if using all these tokens as input to the subsequent decoders. To resolve this problem, we utilize a trainable Q-Former [] module to reduce the number of image tokens from $N\times N^{I}$ to $N^{I}$, as shown in Fig. 2. Besides reducing image tokens, this Q-Former module is also helpful for fusing the feature existing in multi-view images. After the Q-Former, the image tokens are further transformed by a trainable projector linking the vision branch with decoders. The decoders take both text and image tokens as input to conduct feature interaction. Given that the decoders contain numerous parameters and are challenging to train, we initialize the parameters from the LLaVA weight [] and freeze them during training. Additionally, a trainable LoRA [] is applied to assist the model in understanding Minecraft knowledge.

Figure: Figure 3: An example of various recipes for crafting a stick.
Refer to caption: x3.png

The output of the decoders is multiple tokens and we compress them into a single token with a trainable projector. We name the token produced by this projector as skill token, which contains the information about which skill should be executed as predicted by the LARM model. By conducting cosine distance [] based matching between the skill token and the many pre-generated skill embeddings, the most similar skill is selected for the agent to perform. The chosen skill alters both the status of the agent and the environment. LARM repeats the above process in an auto-regressive way until an <End> token is matched, marking the end of this skill execution chain.

### 3.2 Multi-view Vision Perception

In Minecraft, there are often multiple recipes for crafting the same item. For example, as shown in Fig. 4, different types of logs can be collected by chopping trees to craft sticks. When the agent is located in various biomes, the nearest tree category varies, and the optimal recipe is the one based on this nearest category of tree. Hence, it is important to perceive nearby environment information through images to determine the optimal recipe. To fully observe surrounding objects, we propose to use multi-view images as input. In LARM, by setting the agent observation pitch angle to $0^{\circ}$ and the yaw angle to $0^{\circ}$, $90^{\circ}$, $180^{\circ}$, and $270^{\circ}$, the 4 multi-view images illustrated in Fig. 4 are obtained, respectively. To enable the LARM model to associate each pixel in these 4 images with voxels in the 3D environment, two kinds of learnable position embeddings are added, the image position embedding (IPE) and view position embedding (VPE) in Fig. 4. Denote the size of the multi-view image batch as $N\times H\times W\times 3$, where $H$ and $W$ represent image height and width. IPE is to distinguish pixels in the same image and its size is $1\times H\times W\times 1$. Conversely, VPE is for classifying various views and thus its size is $N\times 1\times 1\times 1$.

### 3.3 Skill Library Preparation

Figure: Figure 5: The skill library generation pipeline using two GPT-4 agents, the programmer and checker. The programmer is for writing code and the checker is to check the correctness of generated code.
Refer to caption: x5.png

In this work, we manually design prompts for GPT-4 to generate the code of 106 skills in the skill library. As shown in Fig. 5, to ensure the correctness of code generation, two GPT-4 based agents are built, one serves as the programmer and the other one as the checker. The programmer takes a prompt that describes the skill information, a code format requirement, and a description about the atom functions based on Mineflayer as input to produce the corresponding skill code. The skill is then executed in the Minecraft environment. Afterwards, the execution result, along with the original code, is sent to the checker. If the checker judges that the skill code or execution result do not satisfy the requirement, it informs the programmer about the reason and asks the programmer to rewrite it. Otherwise, the skill code is added to the skill library. Notably, in Fig. 5, the skill is generated based on pre-defined prompts. However, the skill library can also be dynamically expanded following the procedures developed in Voyager [].

Figure: Figure 6: For ARTNS, the procedures of performing a multi-step task is interpreted as a graph. In different nodes, the agent perceives the environment information and selects a skill to execute. During an edge linking two nodes, the agent performs the selected skill, and its status transfers from the start node to the end node. Besides, there exist dependencies among various nodes. For example, as marked by the blue dotted lines, Node D depends on the first three nodes, because crafting 1 wooden axe requires the planks, sticks, and crafting table in Minecraft.
Refer to caption: x6.png

## 4 Data and Training

### 4.1 ARTNS Dataset

In ARTNS, we represent the performing a multi-step task process as a sequential chain, which includes nodes and edges that link these nodes. As illustrated in Fig. 6, the nodes denote the moments when the agent perceives environmental information and selects the next skill. When the selected skill is performed, the status of the agent transitions from a node to the next node, represented by the edge linking these two nodes. Notably, there exists dependence relations among nodes, and the next node does not necessarily depend on the previous node. For example, as shown in Fig. 6, making a crafting table requires planks but not sticks, which means Node C depends on the completion of the target in Node A but not Node B. In addition, a node could depend on multiple previous nodes, like Node D depends on Node A, Node B, and Node C simultaneously.

In accordance with the ARTNS format, we manually operate an agent to complete various tasks in Minecraft and record the data. Through collecting data in diverse biomes and weather, we obtain a dataset consisting of 2,589 data pairs. Each pair contains the exploration trajectory ID, data pair ID, time, weather, biome name, target, agent position, agent inventory list, the name of the last performed skill and its corresponding execution result, the next skill, and multi-view images. Some multi-view image examples are visualized in Fig. 7. Then, we annotate the dependency relations among nodes, which are represented as a graph like the blue dotted lines illustrated in Fig. 6. This graph describes the skills in some nodes are prerequisites for other nodes, and the agent should learn this knowledge to understand how to schedule future skills. Refer to Section F in Appendix for data collection details.

Figure: Figure 7: Some examples of the collected multi-view images, which covers diverse tasks, biomes, weather, etc. The bottom right group of images is a rainy night case so its original images are dim. We adjust its color contrast for clearer visualization, and the input to LARM is still the original form.
Refer to caption: x7.png

### 4.2 ARTNS-based Augmentation

Based on the characteristics of ARTNS, we develop three augmentation strategies: (1) target transmission, (2) target rephrasing, and (3) skill roll-back. They are beneficial to improving the robustness of the agent. The target transmission strategy is devised based on the dependency relations among nodes. As shown in Fig. 6, making a wooden pickaxe in Node D requires the planks crafted in Node A. Thus, when an agent is in node A, even if the original target is replaced with the target “Craft 1 wooden pickaxe” from Node D, the next correct skill is still “Craft 16 planks”. Based on this concept, we transmit the targets of future nodes to the current node and train LARM to infer the next skill. This training is beneficial to improving the long-horizon scheduling ability of LARM. In the target rephrasing strategy, we utilize LLMs to rewrite the targets in various nodes. For example, the “Craft 4 sticks” can be augmented as “Make 4 sticks” or “Go to craft 4 sticks”. This strategy enhances the robustness in dealing with different target expressions. The skill roll-back strategy is to enable LARM to situations where a skill is executed unsuccessfully. For instance, when an agent is collecting oak logs, by setting the oak log number below expectation and the execution result of the last skill as “fail”, we train LARM to know to re-implement the last skill. In this way, LARM becomes more robust to unexpected situations and can recover from failure automatically.

### 4.3 Two-phase Training

Since the initial knowledge of LARM about Minecraft is limited and the ARTNS dataset volume is insufficient, we use 34G webpage data [] crawled from Wiki to pre-train LARM before the ARTNS data training. Specifically, we remove the text comprising fewer than 30 letters in the webpage data. In this way, 63,666 sentences are obtained. The sentences are matched with the closest images on webpages and provided to the model. In Wiki pre-training, we mask a part of these sentences and train the model to predict the masked words. This helps the pre-trained model gain a better understanding of Minecraft. Refer to Section D in Appendix for more details. The model in Wiki pre-training shares the same network structure and training process as LLaVA. Subsequently, in the ARTNS training stage described in Section 3.1, we employ the decoder weight of the pre-trained model to initialize the LARM decoders shown in Fig. 2. The experimental results suggest that the devised Wiki pre-training effectively improves the convergence speed of LARM.

## 5 Experiments

### 5.1 Experimental Setup

Implementation details. In our implementation, the parameters $N$, $H$, $W$, $L$, and $N^{I}$ are set to 4, 480, 640, 512, and 1,024, respectively. LARM is built with 32 decoders, which contain about 7B parameters. The epoch number and learning rate are set to 1 and 2e-4 for Wiki pre-training, and 6 and 2e-5 for the ARTNS training stage. The training batch size is 16 for both Wiki pre-training and ARNTS training. Other training details, like the choice of optimizer and learning scheduler, follow the LLaVA model. All training experiments are conducted on four RTX3090 GPUs.

Experimental settings. Unless specifically stated otherwise, the agent is randomly initialized in a Minecraft environment with an empty inventory. A description of the target task is given to the agent, and the agent is expected to complete this task independently without human intervention. For each task, the agent is tested multiple times in various environments using different target descriptions. This is to verify whether it can complete the given task under a variety of challenging circumstances. The diverse tasks reflect both the long-term scheduling ability and robustness of validated models.

### 5.2 Comparison with Previous Methods

Tech tree mastery comparison. In this experiment, we compare the tech tree mastery of LARM with previous counterparts, including MineAgent [], Plan4MC [], LLAMA-Rider [], ReAct [], Reflection [], AutoGPT [], Voyager [], and STEVE []. Among the compared methods, MineAgent and Plan4MC are based on reinforcement learning. Due to their inefficiency in exploring the environment, their performances are limited, and they can only conduct some simple tasks, like collecting logs and crafting wooden tools. Similarly, although LLAMA-Rider is an LLM-based method, it is established upon the skills learned from Plan4MC. Hence, its tech mastery achievement is also limited. ReAct, Reflection, and AutoGPT are LLMs specially designed for conducting task-specific skill scheduling, and previous works utilize them to build embodied agents in Minecraft []. Voyager is a competitive counterpart built based on GPT4 and obtains the diamond tool achievement using LLM for the first time, which confirms the superiority of LLM. Nevertheless, Voyager only supports text input, and thus its environment perception capability is restricted. To bridge this gap, STEVE leverages the power of large vision-language models to perform long-term skill scheduling and derives promising achievement.

The task completion success rates of LARM and reinforcement learning skill based methods, which include MineAgent, Plan4MC, and LLaMA-Rider, are reported in Table 1. A variety of tasks are tested and the best method is marked in light gray. It can be observed that the reinforcement learning skill based methods display significantly poorer performance compared with LARM, which can complete almost all these tasks with a success rate of 100%. Besides, except LARM, all these methods fail to craft a diamond sword and enchanted sword.

**Table 1: Performance comparison with reinforcement learning skill based methods. Following previous works [; ], except for the tasks “harvest diamond sword” and “harvest enchanted sword” where the methods are tested 3 times, all the methods are run 30 times in other tasks. The shown numbers are the success rates of the methods in completing these tasks successfully. The best method is highlighted in light gray. Refer to Section E in Appendix for more experimental details.**
| Task | MineAgent | Plan4MC | LLaMA-Rider Base | LLaMA-Rider | LARM |
| --- | --- | --- | --- | --- | --- |
| Harvest stick | 0.00 | 0.30 | 0.23 | 0.43 | 1.00 |
| Harvest crafting table | 0.03 | 0.30 | 0.37 | 0.67 | 1.00 |
| Harvest bowl | 0.00 | 0.47 | 0.73 | 0.97 | 1.00 |
| Harvest chest | 0.00 | 0.23 | 0.67 | 0.77 | 1.00 |
| Harvest wooden sword | 0.00 | 0.47 | 0.63 | 0.10 | 1.00 |
| Harvest furnace | 0.00 | 0.37 | 0.00 | 0.17 | 1.00 |
| Harvest stone stairs | 0.00 | 0.47 | 0.00 | 0.57 | 1.00 |
| Harvest stone sword | 0.00 | 0.10 | 0.00 | 0.00 | 1.00 |
| Harvest iron ingot | 0.00 | 0.47 | 0.03 | 0.13 | 1.00 |
| Harvest bucket | 0.00 | 0.20 | 0.00 | 0.00 | 1.00 |
| Harvest iron sword | 0.00 | 0.20 | 0.00 | 0.00 | 1.00 |
| Harvest beef | 0.33 | 0.43 | 0.03 | 0.03 | 1.00 |
| Harvest mutton | 0.35 | 0.33 | 0.00 | 0.03 | 1.00 |
| Harvest diamond sword | 0.00 | 0.00 | 0.00 | 0.00 | 1.00 |
| Harvest enchanted sword | 0.00 | 0.00 | 0.00 | 0.00 | 0.67 |

**Table 2: Performance comparison with LLM based methods on the tech tree mastery. Following previous works [], all the methods are run 3 times. The fractions in this table show the successful trials of every method within 3 runs. Notably, all the compared methods demand tens of prompting iterations, while LARM obtains the enchanted tool achievement with only 1 prompt. The best method is highlighted in light gray. Refer to Section E in Appendix for more experimental details.**
| Achievement | ReAct | Reflexion | AutoGPT | Voyager | STEVE | LARM |
| --- | --- | --- | --- | --- | --- | --- |
| Wooden Tool | 0/3 | 0/3 | 3/3 | 3/3 | 3/3 | 3/3 |
| Stone Tool | 0/3 | 0/3 | 3/3 | 3/3 | 3/3 | 3/3 |
| Iron Tool | 0/3 | 0/3 | 3/3 | 3/3 | 3/3 | 3/3 |
| Diamond Tool | 0/3 | 0/3 | 0/3 | 1/3 | 3/3 | 3/3 |
| Enchanted Tool | 0/3 | 0/3 | 0/3 | 0/3 | 0/3 | 2/3 |

We further compare LARM with LLM based methods in Table 2. It can be found that the results of the methods in Table 2 are significantly better than those in Table 1. This observation indicates that LLM-based agents generally outperform reinforcement learning skill based ones. Moreover, LARM is the only method capable of crafting enchanted tools, which requires a complex skill execution chain. Therefore, the superiority of LARM is confirmed.

Figure: Figure 8: Analysis on the effect of the Wiki pre-training. (a) The most advanced items achieved by the models with and without Wiki pre-training after various iterations of ARTNS training. It can be observed that the model converges more quickly and presents better performance with the ARTNS training phase. (b) The model initialized from LLaVA lacks knowledge about Minecraft and gives a false answer to the question. By contrast, the model after Wiki pre-training answers correctly. The key points of the false and correct responses are highlighted in bronze and green, respectively.
Refer to caption: x8.png

Inference efficiency. Besides the tech tree mastery achievement, inference efficiency is also important. However, many aforementioned methods are implemented based on LLM APIs. The inference speed of these methods is significantly affected by network latency, while LARM is a model deployed in local machines. Additionally, the GPUs used by these methods may vary and are uncontrollable. Therefore, directly comparing their inference speeds is meaningless. Thankfully, the methods built upon LLM share similar network architectures, i.e., the Transformer structure. Thus, it is reasonable to compare LARM with a LLM of the same parameter volume to validate inference efficiency. Following this thought, we compare the inference time costs of LARM and LLaVA-1.6 with both 7B parameters. They are tested in 100 cases to compute the average inference time, with each case corresponding to a node in Fig. 6. The output of LLaVA is prompted to be as concise as possible. This experiment is performed using one RTX3090 GPU. Through this experiment, we find that the average inference time of LLaVA on the 100 cases is 5.78 seconds while LARM is 0.85 seconds, which indicates that LARM is 6.8$\times$ more efficient. The efficiency of LARM stems from its characteristic that it generates a single token rather than a sequence of tokens at each step.

**Table 3: Ablation study on the ARTNS-based augmentation strategies including target transmission (TT), target rephrasing (TR), and skill roll-back (SR). The setting of this experiment follows Table 2.**
| TT | TR | SR | Wooden Tool | Stone Tool | Iron Tool | Diamond Tool | Enchanted Tool |
| --- | --- | --- | --- | --- | --- | --- | --- |
|  |  |  | 3/3 | 3/3 | 0/3 | 0/3 | 0/3 |
|  | ✓ | ✓ | 3/3 | 3/3 | 1/3 | 0/3 | 0/3 |
| ✓ |  | ✓ | 3/3 | 3/3 | 3/3 | 3/3 | 1/3 |
| ✓ | ✓ |  | 3/3 | 3/3 | 3/3 | 2/3 | 1/3 |
| ✓ | ✓ | ✓ | 3/3 | 3/3 | 3/3 | 3/3 | 2/3 |

### 5.3 Ablation Study

Figure: Figure 9: Qualitative study on the multi-view vision input. (a) LARM utilizes vision information to collect water and lava and then obtains obsidian. Due to the space limit, we only visualize the image view facing toward the target. (b) LARM can dynamically select the optimal recipe (acacia log, highlighted in yellow) for crafting sticks based on multi-view vision input. By contrast, previous methods often directly adopt the default recipe (oak log, highlighted in orange), which causes them to explore a longer distance for gathering materials and this process could take quite a longer time.
Refer to caption: x9.png

Effectiveness of Wiki pre-training. LARM is initialized using the weight of LLaVA, which lacks knowledge about Minecraft. To bridge this gap, we introduce the Wiki pre-training phase to enrich the knowledge. In this part, we examine the impact of Wiki pre-training on the performance of the trained model and visualize the results in Fig. 8.

In Fig. 8 (a), we compare the most advanced items obtained by the models after different iterations of ARTNS training. Achieving an upper item indicates more superior performance, and the two curves correspond to models with and without Wiki pre-training. From Fig. 8 (a), it can be inferred Wiki pre-training accelerates the convergence of LARM and contributes to better performance.

Fig. 8 (b) presents the responses of the models with and without Wiki pre-training to a question about Minecraft. The model without Wiki pre-training is exactly the original LLaVA-1.6-7B model. The key points of these two answers are marked in different colors. We can find that although the question is about how to combat a horse when a diamond sword is in the inventory, the model without Wiki pre-training provides an answer about riding a horse instead. Besides, the provided recipe for crafting a saddle is incorrect. By contrast, the model after Wiki pre-training accurately and in detail describes the steps for combating a horse. This demonstrates that Wiki pre-training effectively enriches the knowledge of LARM about Minecraft.

Effectiveness of ARTNS-based augmentation. In this part, we ablate the effectiveness of the three augmentation strategies, including target transmission (TT), target rephrasing (TR), and skill roll-back (SR). The results are reported in Table 3. Given the limited data volume of the collected ARTNS dataset, we can find that these augmentation strategies are crucial for the performance of LARM. Specifically, TR and SR boost the results significantly by improving the robustness of LARM. TT contributes the most to tech tree mastery. Without TT, LARM often chooses an incorrect skill to perform during the exploration process. This is because completing a complex task in Minecraft demands multiple steps of decision-making, and any wrong decision at any step could lead to final failure. TT effectively reduces the frequency of incorrect decision-making.

Effectiveness of multi-view vision input. In this study, we qualitatively analyze the effectiveness of multi-view vision input. As shown in Fig. 9 (a), the agent aims to harvest obsidian, which requires the fusion of water and lava. The agent utilizes vision information to search for water and lava, and eventually successfully produces obsidian. If the input is limited to a single-view image instead of multi-view images, the agent may fail to detect the necessary targets.

In Fig. 9 (b), we compare the behaviors of LARM and previous methods [; ] in selecting a recipe for crafting sticks. Thanks to the multi-view vision input, LARM can identify that the nearest source of logs is an acacia tree. By contrast, previous methods often default to the standard recipe, which involves using oak logs to craft sticks. However, finding oak trees may take a considerably longer time. The results confirm the effectiveness of multi-view image input and the superiority of LARM in dynamically choosing the optimal recipe.

## 6 Conclusion and Limitation

In this work, we have introduced LARM, an embodied intelligence predicting subsequent skills in an auto-regressive manner. To train LARM, a new data organization structure has been proposed and a corresponding dataset has been collected. Compared with previous methods, LARM presents stronger long-horizon scheduling ability and faster inference speed. LARM is the first method capable of crafting enchanted diamond tools in Minecraft. We hope this work significantly contributes to the development of embodied intelligence. At the current stage, LARM is mainly tested in Minecraft without deploying in real-world scenarios, which is the primary limitation of this work.

## Appendix A Appendix Overview

Due to the page-limit of the main paper, we provide more sufficient analysis of LARM in this Appendix. The content in this Appendix is structured as follows:

$\bullet$   Section B: In the main paper, we mainly show the result of LARM on crafting an enchanted diamond sword. In this section, we show more behavior examples of LARM in performing other tasks, i.e., searching a village, building a nether portal and entering the nether, and multi-agent collaboration to combat zombies.

$\bullet$   Section C: As the training data volumn is often important for deep learning based methods, we study how the data amount affects the performance of LARM in this section.

$\bullet$   Section D: In this part, we further describe the procedures of the Wiki pre-training stage.

$\bullet$   Section E: In Minecraft, various methods often adopt different training and testing protocols due to the lack of a widely accepted benchmark. Therefore, the compared methods reported in Table 1 and Table 2 may adopt different training and validation procedures from others. In this section, we elaborate on the details of these compared methods.

$\bullet$   Section F: This section describe how the ARTNS Dataset is collected.

$\bullet$   Section G: We begin with an in-depth analysis on the output of large language models (LLMs). In this analysis, we compare the Minecraft knowledge of various popular large language models (LLMs), which include LLaVA [], ChatGPT [], and GPT-4 []. The experimental results reveal that the output description is not only ambiguous but also often incorrect.

$\bullet$   Section H: As explained in the main paper, the input to LAM consists of two parts, the text information and image information. The text information describes information about the agent status, surrounding environment information, and system feedback. In this part, we show how the different information is organized as the text input, and several examples are presented.

$\bullet$   Section I: As mentioned in the main paper, a skill library generation pipeline is devised to produce the skills in the skill library. These skills serve as basic actions for LARM. In this part, we explain these skills. Specifically, the code of a skill is presented as an example. In addition, the names and abstract descriptions of more skills are presented.

$\bullet$   Section J: This section presents a discussion on whether low-level control signals or high-level skill predictions are more suitable to serve as the output of an embodied model.

## Appendix B Case Study

In Fig. 10, we present three additional examples of LARM behavior. In the first case, the agent travels through various biomes to find a village, which demonstrates the strong exploration capability of LARM. For the second one, the agent builds a nether portal and enters the Nether through it. This case suggests the promising construction capability of LARM. In the last example, two agents collaborate with each other to combat a large group of zombies, confirming that multiple LARM models can efficiently cooperate together. These three cases reveal the promising performance of LARM from different perspectives and implies that it can achieve more complex targets with stronger skill library and more training data.

## Appendix C Study on training data volume

In this experiment, we delve into how different ARTNS training data volumes influence the obtained highest achievement. Specifically, we separately train LARM using 10%, 50%, and 100% of the total training data, and the results are presented in Table 4. It can be observed that having sufficient training data is critical for the performance. When only 10% of data is employed, the model can only craft stone tools with a low success rate. In contrast, when 100% of the data is utilized, the model successfully successfully harvests enchanted tools.

Figure: Figure 10: More behavior example illustrations of LARM, which include searching a village, building a nether portal and entering the nether, and multi-agent collaboration to combat zombies.
Refer to caption: x10.png

**Table 4: Ablation study on the influence of ARTNS training data volume. The setting of this experiment follows the one in Table 2.**
| Data Ratio | Wooden Tool | Stone Tool | Iron Tool | Diamond Tool | Enchanted Tool |
| --- | --- | --- | --- | --- | --- |
| 10% | 3/3 | 1/3 | 0/3 | 0/3 | 0/3 |
| 50% | 3/3 | 3/3 | 2/3 | 1/3 | 0/3 |
| 100% | 3/3 | 3/3 | 3/3 | 3/3 | 2/3 |

## Appendix D Wiki Pre-training Details

To explain our method clearly, we further explain the training details of the Wiki Pre-training stage in this section. The procedures are visualized in Fig. 11 for clarity. As shown, the data in Wiki webpages include both text and image information. The work Minddojo [] crawls 34G of Minecraft data from Internet and composes it as a multi-modal dataset. However, this dataset contains many short phrases that offer limited useful information. To resolve this problem, we exclude text with fewer than 30 characters. For the remaining data, we match every text with its closest image as a multi-modal data pair and uses it to train LARM. As depicted in Fig. 11, we mask a portion of the text information and construct a prompt from the remaining text and image. The model is trained to fill in the masked words. The model output format, training loss, and hyper-parameter details follow LLaVA []. Each data pair is utilized twice in the Wiki pre-training stage, equating to two epochs of training.

Figure: Figure 11: LARM is pre-trained based on Wiki data to enrich the knowledge about Minecraft. In this stage, the model is asked to predict the remaining words in a sentence based on the given context.
Refer to caption: x11.png

## Appendix E Details of Compared Methods

In Minecraft, as there is no widely accepted benchmark, different methods often employ varying training pipelines, testing protocals and training data. Therefore, the methods compared in Table 1 and Table 2 are not always trained in the same setting. However, this problem does not affect the significant contribution of LARM, because the main focus of embodied AI research is how intelligent the agent can achieve, and LARM obtains the achievement significantly better than all previous counterparts. Besides, we described below, the testing protocal of LARM is more challenging than all compared methods. To be more transparent about the difference among various methods, we elaborate on the details of all compared methods in this section one by one.

MineAgent []. MineAgent is the baseline method provided by Minddojo. This work first fine-tunes the CLIP model [] based on numerous Internet data and uses the data to guide the training of reinforcement learning based algorithms. The method is test with Minddojo. In each testing iteration, the agent is initialized with some tools and asked to complete a task described by given text.

Plan4MC []. Plan4MC is a reinformcement learning based method. It splits the tasks of an agent into basic skills and trains an agent to learn them one by one in a hierarchical way. The model is test based on Minddojo. In each testing iteration, the agent is initialized with some tools and asked to complete a task described by given text.

LLaMA-Rider []. LLaMA-Rider is a LLM obtained by fine-tuning LLaMA. For its developing model process, this work first makes the agent explore the environment by itself and collect some data during this process. Then, they complile the collected data into a dataset to fine-tune the LARM model in a supervised manner. The output of LLaMA-Rider is text and the text is used to call the skills generated by Plan4MC. The model is test using Minddojo. In each testing iteration, the agent is initialized with some tools and asked to complete a task described by given text.

Voyager []. Voyager is a method implemented based on GPT4 and has no training process. Its main contribution is designing a multi-step prompt generation pipeline. The skills required by it are implemented based on Mineflayer. When a target task is given, the method prompts GPT4 to know which skill should be executed and gradually realizes the target. This method is test in the standard Minecraft game environment. In the begining of testing, the agent is initialized with no any tool.

ReAct [], Reflexion [], and AutoGPT []. All the three methods are LLMs and can reason about what skill should be performed through multi-step question answering. Their performances in Minecraft are test in the work Voyager. Their called skills are also implemented based on Mineflayer and the testing protocols are the same as Voyager.

STEVE []. STEVE is large vision-language model. The authors of this work collects a training dataset including both viedos and test-image pairs and uses the data to fine-tune a LLaMA model. The obtained model is used to conduct multi-step reasoning and call skills implemented based on Mineflayer. Its testing protocol follows Voyager.

## Appendix F Data Collection Procedures

As described in the main paper, the data is organized in the ARTNS format and we collect the data manually. Specifically, for each given target task, we first decompose the task into multiple steps and each step corresponds to a basic skill. We operate the agent to execute these skills one by one. After each skill is performed, the moment of which corresponds to a node in Fig. 6, we record all the concerned information, such as multi-view images, agent position information, etc. After collecting the data, we label the dependence relations among all nodes.

## Appendix G Analysis on LLM Output

As discussed in the main paper, the output of LLMs is often ambiguous for agents to selecting specific actions. In addition, we find that the generated response of existing LLMs is often incorrect due to their limited knowledge about Minecraft. In the following, we compare three various popular LLMs, i.e., LLaVA-1.6-7B, ChatGPT, and GPT-4 in Minecraft related question-answer test.

According the above two dialogues, the output of LLaVA is significantly incorrect. First of all, the prompt is about combating a horse, while the response of LLaVA is about how to ride a horse. In addition, saddle cannot be crafted by the agent itself in Minecraft, the given recipe is also false. By contrast, ChatGPT gives a relatively better answer, locate a horse first and then combat it. Nevertheless, ChatGPT overlooks the fact that there is a diamond sword in the inventory list and combating a horse without any weapon is quite inefficient. In contrast to LLaVA and ChatGPT, the knowledge of GPT-4 about Minecraft is much more richer. When a diamond sword is in the inventory list, GPT-4 knows the agent should first equip the sword, and then find a horse and combat it. Conversely, if there is no weapon in the inventory list, GPT-4 understands a stone sword should be crafted first based on the available resources in the inventory list. GPT-4 does not selects to craft a iron sword because there is iron ingot. Additionally, crafting a wooden sword is not chosen because its damage is weaker than the stone sword.

Based on the aforementioned result and analysis, we can observe that GPT-4 behaves the best among these three LLMs. This observation suggests that the model size and training data volumn are also crucial for the LLMs applied to Minecraft. However, although GPT-4 presents promising performance, it shows slow inference speed and the demands numerous GPUs for inference. These characteristics make it unsuitable for embodied applications, which require real-time operations and have limited local computing resource. Compared with these LLMs, LARM is much more fast, computing economical, and presents superior performance. Therefore, LARM is more suitable for developing embodied intelligence than the many previous LLMs.

## Appendix H LARM Text Input

As mentioned in the main paper, the text input is important for LARM to perceive information. In the following, we introduce how different text information is organized as an input sentence, which is shown below.

## Appendix I Skill Library Description

As mentioned before, the skill library is important for LARM, as the skills included in this library serve as the basic actions for LARM. To clearly explain the details of these skills, the code of one skill is given as an example. In addition, we present the titles and description of 10 skills in this part.

Figure: Skill-Code example 1: "The code of combating one mob".

## Appendix J Discussion on LARM Output

As described in the main paper, LARM takes a skill (high-level action) as one atomic operation. Simultaneously, there is also some methods that directly output a low-level action, like the mouse click or keyboard press []. In this section, we present a discussion on whether we should employ high-level or low-level actions in embodied artificial intelligence (AI).

In practical embodied applications, differing agents usually have significantly different mechanical structures. Although there are works that try unifying them by training end-to-end models with a large amount of parameters and collecting numerous data, the obtained performance is still limited and cannot be deployed in real industrial environments [; ]. Conversely, existing deployed robots are mainly implemented based on many traditional control modules [], which are similar to the pre-generated skills in Minecraft. Therefore, making models output high-level actions is beneficial to alleviate the deployment difficulty.

Similarly, in Minecraft, although building VPT [] consumes numerous resource, its obtained highest achievement is much weaker than LARM, while LARM is trained using only 4 RTX3090 GPUs. Therefore, when the data and computing resource is not very abundant, exploring models with high-level output is a promising choice.

## Peer Reviews

confidence: 3
contribution: 2
initial_rating: 5
presentation: 3
questions: Please see weaknesses.
soundness: 3
strengths: - The work is well-organized and includes numerous details that help readers understand the LARM process.
- Besides LARM, the work defines a dataset for training the model, enabling LARM to learn sequential actions effectively.
- A demonstration of LARM is also provided.
summary: This work introduces the Large Auto-Regressive Model (LARM) for long-horizon tasks, focusing on the Minecraft environment. LARM is built upon various existing techniques, including GPT-4, LoRA, and Q-Former. Given a specific target task, LARM takes multi-view images along with the corresponding task text as input to predict the next action. The predicted skill token is then used to match an existing skill set generated by GPT-4, allowing for selecting the optimal skill. The authors claim this approach is efficient as it predicts the next action directly. Additionally, to train LARM, the work introduces a data format known as ARNTS to manage sequential chains. Experimental results indicate that LARM outperforms existing reinforcement learning-based methods.
weaknesses: - The method relies heavily on existing techniques, which undermines the novelty of the work.
- The tasks in the experiments are not particularly challenging, raising concerns about the generalizability of LARM.
- The formulation of LARM is relatively simple and closely resembles imitation learning. Aside from reinforcement learning methods, are there any imitation learning-based baselines to compare with LARM?
- Furthermore, have the baselines in Tables 1 and 2 been fine-tuned with the same data as LARM?

---

confidence: 3
contribution: 3
initial_rating: 5
presentation: 2
questions: Please see the weakness.
soundness: 2
strengths: - The proposed method can be fully embedded into the device without the need for a call from a proprietary LLM API.
- Inference speed seems to be faster than the LLava-1.6-7B. (But the comparison looks a little bit tricky.)
- Reasonable architectural design and pre-training/fine-tuning processes.
- Solid performance over the Minecraft simulation benchmark.
summary: Recently, embodied agents have been considered one of the promising and attractive research directions that are able to communicate with their surroundings and do complex open-world tasks. However, these agents may require comprehensive task knowledge, long-term planning, and rapid response capabilities to interact effectively with the world. Although LLMs excel in open-world tasks leveraging their rich knowledge, their outputs are slow and not directly executable, requiring translation into actions. To overcome these limitations, this paper introduces the large auto-regressive model (LARM), which directly predicts the next action based on environment observations in an auto-regressive manner. Unlike LLMs, LARM forecasts actionable skills immediately, reducing latency. The authors also introduce an auto-regressive node transmission data format to train LARM, emphasizing dependencies between actions and observations.
weaknesses: - The grounds for using Q-former architecture for visual token compression are not sufficiently validated. If this Q-former structure aims for token compression into a fixed length, there should be a number of competitive techniques, including token sparsification, merging, pooling, convolution layers, MLPs, Mixture-of-experts, etc. I expect analyses that provide reasonable observations and insights into why this employed design is more appropriate than those nonparametric and parametric potential counterparts for Long-Horizon Embodied Intelligence.

- Also, the effect of other components, such as training the LoRA or projector weights, is not clearly verified. At the same time, the discussion of the 'single skill token' is also not very clear. It is also possible to  1) produce multiple skill tokens, 2) perform the Hungarian algorithm to match 'multiple' skill tokens with relevant skill embeddings, and then 3) select the best-matched skill based on some importance/uncertainty metrics. More discussions and insights/evidence on the use of single-skill tokens would be helpful for the design choice of the proposed approach.

- Efficiency comparison sounds not that reliable to me. Even baselines with LLM API calls have a fluctuation in inference time depending on network latency; it would be meaningful to compare the wall-clock running time/cost among baselines and the proposed methods under stable network conditions. 

- detailed explanations of the usage of GPT-4 for the skill library and the examples/format of /environment feedback' and 'the last skill position coordinate inventory list' are not provided. I believe the design choice of this structure also affects the model performance; the authors should provide detailed information in the appendix.

---

confidence: 5
contribution: 2
initial_rating: 3
presentation: 3
questions: -How does the agent perform the skill in Minecraft? Is it hard-coded and executed deterministically?

-Does this method generalize beyond Minecraft in other decision-making environments (e.g. ALFRED)? 

-Having a finite skill space might limit the generalizability of the proposed framework. What is the authors response to the statement?
soundness: 2
strengths: -The authors proposed LARM to solve complicated decision-making tasks in Minecraft and achieved good results than previous models.

-The authors pinpointed the potential problem of lacking mutual dependency between actions and observation

-The inference speed of this method is faster than those LLM-based ones.
summary: To address the problem that LLM-based embodied agent policy requires post-processing, the authors proposed LARM: large auto-regressive model to predict the next skill for execution, taking in environment feedback and observations.  They also proposed auto-regressive node transmission structure to reflect the correlation between actions and observation. They conducted experiments on Minecraft and completed some complex decision-making tasks with faster inference speed.
weaknesses: -When considering decision-making agents, the authors missed important benchmarks in related work.

-There is no evidence showing that propose method can generalize to other domains.

-The proposed method requires engineering adaption to new domains.

-The proposed model consists of many components, yet the individual performance contribution and their necessity are not shown in any 
ablation studies at all.

-The proposed model is not novel enough, a combination of foundation models.

---

confidence: 3
contribution: 2
initial_rating: 5
presentation: 3
questions: Questions:
1.This paper introduces a new data structure called Auto-Regressive Node Transmission Structure (ARNTS). However, it also mentions a similar term, ARTNS, which appears to be a typographical error for ARNTS and can lead to confusion while reading. If ARTNS refers to a technique in another paper, please provide the appropriate citation.

While the authors provide a detailed comparative analysis with baseline methods, the paper still lacks point-by-point examinations of their proposed settings to demonstrate the overall pipeline. This raises some concerns, which I have outlined in the above questions.
I will reevaluate the paper's rating after carefully considering the perspectives of other reviewers and the authors' responses. I am also willing to increase my score if the authors address my concerns.
soundness: 3
strengths: 1. The writing in this paper is well-structured, and the experimental results demonstrate the effectiveness of the proposed method.
2. LARM shows impressive performance in both skill prediction and tech tree mastery, indicating promising improvements in long-term decision-making chains. 
3. LARM significantly enhances the efficiency of LLMs-based methods deployed on local machines, showcasing the advantages of its end-to-end subsequent skill prediction approach.
summary: This paper introduces a novel auto-regressive method for long-horizon planning called LARM, which is an extension of LLaVA with a trainable LoRA module. This auto-regressive approach directly predicts subsequent actions rather than generating long-context task descriptions, enabling end-to-end skill generation. To address the limitations of environmental dependency in web data, the paper also defines a graph-like data node structure (ARNTS). This structure allows the agent to learn how to schedule future skills by following a sequential chain in multi-step tasks. The paper demonstrates remarkable improvements compared to recent state-of-the-art methods in the Minecraft environment. LARM achieves 100% success on 14 out of 15 skills, significantly outperforming baselines such as MineAgent and LLaMA-Rider. Notably, LARM is the first method to successfully craft an enchanted tool, which requires a complex chain of steps to achieve.
weaknesses: 1. The authors assert that learning the dependency relationships among nodes is crucial for the agent's understanding of the long-horizon chain of skill prediction. Could the authors provide detailed information on the implementation of this node dependency learning process, particularly regarding the blue dotted lines in Figure 3? 

2. In this paper, LARM utilizes multi-view images as input for visual tokens, and I agree that this approach can enhance the visual perception of the surrounding environment, particularly for embodied agents. However, it would be beneficial to conduct an ablation analysis on the number of views and compare the results with those from monocular images to further refine the training design.

3. The skill library in LARM is largely based on the one built for Voyager. In Voyager's paper, they conducted a zero-shot generalization evaluation on unseen tasks, demonstrating the potential of a lifelong skill library to expand skills in an open-world environment. Since LARM's skill library is pre-prepared, I wonder if LARM can similarly adapt to new tasks in a zero-shot manner as the skill library expands? 
 
4. This paper discusses inference efficiency in the comparison section, but the comparison setup is unclear. From my understanding, LARM is built on LLaVA, with additional trainable modules like Q-Former, LoRA, and a projector. In this context, the differences in inference efficiency compared to vanilla LLaVA are primarily due to these added modules and the length of the text context. As a result, the comparison lacks clarity and is not convincing, making it difficult to draw firm conclusions about LARM's inference efficiency.

5. This paper has demonstrated that Wiki pre-trained LLaVA can learn general knowledge in the Minecraft world, which raises an interesting question about the performance of Wiki-pretrained LLaVA in predicting the next skills. While the authors assert that LLM outputs are typically limited to sentences or code, I do not agree that the output format limit the use of LLMs. For example, a prompt design strategy could be employed, using question prompt templates for LLaVA to predict fixed-length skill keywords. These keywords could then be projected into MineCLIP embeddings as query tokens for the skill library. Therefore, I recommend that the authors conduct additional analyses of the Wiki pre-trained LLaVA to thoroughly explore the capabilities of VLMs.