---

前言

前面阅读 Agent 记忆机制时，我们更多关注的是：

• 如何保存用户偏好和历史事实；
• 如何从长期对话中检索相关信息；
• 如何更新、删除已经过时的记忆；
• 如何控制记忆写入和召回的成本。

但 Agent 的“记忆”并不只有事实记忆。

对于需要长期与环境交互的 Agent 来说，还有一种非常重要的记忆：

我曾经怎样成功完成过某项任务？

例如，一个编程 Agent 第一次修复依赖冲突时，可能需要经过多轮搜索、修改和测试。但如果它只是保存“依赖冲突已解决”这一事实，下次遇到类似问题时，仍然需要重新探索。

更有价值的做法是把成功经验整理为一个可以直接复用的技能：

检测依赖版本
    ↓
定位冲突包
    ↓
修改配置
    ↓
重新安装
    ↓
运行测试

如果这个过程能够进一步保存为可执行程序，Agent 就不只是“记住了发生过什么”，而是获得了一个可以重复调用的能力。

Voyager 正是从这个角度设计记忆。

它让 GPT-4 在 Minecraft 中不断探索，根据当前状态为自己提出新的任务，通过环境反馈迭代生成可执行代码，并将成功完成任务的程序保存到技能库中。

之后面对更复杂的任务时，Agent 可以从技能库中检索相关技能，并在已有技能的基础上组合出新的能力。

因此，Voyager 的核心贡献不是简单地“让 GPT-4 玩 Minecraft”，而是构建了一个完整的开放式终身学习循环：

自主提出任务
    ↓
检索已有技能
    ↓
生成并执行程序
    ↓
根据环境反馈修正程序
    ↓
验证任务是否完成
    ↓
将成功程序写入技能库
    ↓
继续挑战更复杂的任务

从 Agent 记忆的角度看，Voyager 展示了一种重要思路：

记忆不一定是自然语言事实，也可以是经过环境验证、能够直接执行和组合的程序技能。

---

零、论文基本信息

• 论文名称：Voyager: An Open-Ended Embodied Agent with Large Language Models
• 发表平台：NeurIPS 2023 Open-Ended Learning Workshop
• 代码仓库：MineDojo/Voyager
• 作者信息：Guanzhi Wang、Yuqi Xie、Yunfan Jiang、Ajay Mandlekar、Chaowei Xiao、Yuke Zhu、Linxi “Jim” Fan、Anima Anandkumar

---

一、背景与问题

1. 开放世界没有明确的终点

传统 Agent 任务通常会提供一个明确目标，例如：

• 找到某个网页中的答案；
• 修复一个指定 Bug；
• 把物体移动到目标位置；
• 根据用户要求生成一份报告。

但 Minecraft 是一个开放世界。

环境不会直接告诉 Agent：

接下来应该先收集木头，然后制作工作台，再制作木镐。

Agent 需要自己决定：

• 当前应该探索什么；
• 哪个任务符合现有能力；
• 哪些资源需要优先收集；
• 什么时候应该挑战更困难的任务；
• 失败后应该重试还是暂时放弃。

因此，Voyager 面临的第一个问题不是“如何执行任务”，而是：

在没有预定义最终目标的情况下，Agent 如何持续为自己生成有价值的新目标？

2. 低层动作难以表示长时技能

如果 Agent 直接输出：

• 向前移动；
• 左转；
• 跳跃；
• 攻击；
• 放置方块；

那么完成“制作一把铁镐”可能需要非常长的动作序列。

这种低层控制存在几个问题：

• 任务跨度太长；
• 探索效率低；
• 成功行为难以复用；
• 动作本身缺少语义；
• 很难组合出更复杂的能力。

Voyager 没有让 GPT-4 直接控制每一个底层动作，而是让模型生成 JavaScript 程序，通过 Mineflayer 提供的高层接口控制 Minecraft Agent。

例如，一个技能可以表示为：

async function craftStonePickaxe(bot) {
    // 收集原料
    // 放置工作台
    // 制作木棍
    // 制作石镐
}

程序能够表示跨越较长时间的行为，也可以调用其他已有程序，因此更加适合作为技能记忆。

3. 一次生成很难得到正确程序

即使 GPT-4 具备代码生成能力，也很难一次生成能够在真实环境中正确执行的程序。

失败可能来自：

• 环境中缺少材料；
• 使用了不存在的物品；
• 调用了错误的 API；
• 程序存在语法错误；
• Agent 被障碍物挡住；
• 程序执行了，但任务实际上没有完成。

因此，系统不能只执行一次“LLM 生成代码”，还需要形成反馈闭环：

生成代码
    ↓
在环境中执行
    ↓
获得环境状态和错误信息
    ↓
判断任务是否成功
    ↓
修改代码并重新执行

4. 成功经验需要长期积累

如果 Agent 每次面对新任务都从头生成程序，随着任务复杂度增加，探索成本会越来越高。

例如，“制作铁镐”依赖多个基础能力：

• 收集木头；
• 制作木板；
• 制作工作台；
• 制作木棍；
• 制作木镐；
• 开采圆石；
• 制作石镐；
• 开采铁矿；
• 熔炼铁锭。

如果这些基础能力已经学会，Agent 应该能够直接复用，而不是重新探索。

因此，Voyager 还需要解决：

如何把已经验证成功的行为保存为长期技能，并在之后的任务中准确召回和组合？

---

二、相关工作

1. Minecraft 中的具身智能体

Minecraft 具有开放地图、资源收集、工具制作、战斗和建筑等机制，因此经常被用于研究开放世界智能体。

传统方法通常可以分为两类。

低层控制方法

这类方法直接从图像或状态输入预测键盘、鼠标等低层动作，常见路线包括：

• 强化学习；
• 模仿学习；
• 从玩家视频中学习；
• 世界模型。

它们能够研究视觉感知和运动控制，但通常需要大量训练数据与环境交互。

高层规划方法

这类方法使用语言模型生成计划或程序，再由已有控制器执行。

优点是能够利用大语言模型中的先验知识，但许多方法主要面向预先给定的任务，还不具备持续自主探索和技能积累能力。

Voyager 属于高层规划方法。它不直接从屏幕像素预测低层动作，而是读取结构化环境状态，并通过 Mineflayer JavaScript API 执行程序。

2. LLM Agent 规划

ReAct 通过交替生成推理和行动，让模型能够根据环境观察调整后续计划。

Reflexion 在此基础上引入反思，让 Agent 从失败轨迹中总结问题。

AutoGPT 则把高层目标分解为多个子目标，并通过循环逐步执行。

这些方法已经能够形成一定的任务闭环，但主要问题是：

• 通常需要外部提供目标；
• 每次任务仍然依赖重新推理；
• 成功行为没有稳定沉淀为可执行技能；
• 缺少不断提高任务难度的长期学习机制。

Voyager 将自主课程、反馈修正和技能积累连接成了一个持续运行的系统。

3. 程序化策略

与自然语言计划相比，程序有几个优势：

• 可以直接执行；
• 行为过程更加确定；
• 容易调试；
• 可以参数化；
• 可以调用其他函数；
• 可以组合成更复杂的能力。

因此，Voyager 没有把成功经验保存为一段普通反思，而是保存为可执行代码。

4. Agent 记忆

传统 Agent 记忆更关注事实、对话和事件，例如：

用户不喜欢乳制品。

Voyager 的技能记忆则是：

在什么情况下，调用什么程序，可以完成什么任务。

两类记忆解决的问题不同：

记忆类型	保存内容	主要用途
事实记忆	用户偏好、环境事实、历史信息	帮助 Agent 理解当前状态
情节记忆	某次任务的过程与结果	帮助 Agent参考历史经历
反思记忆	失败原因和改进建议	避免重复错误
技能记忆	经过验证的可执行程序	直接复用成功行为

Voyager 的重点是将成功经验从“发生过的事件”提升为“可以调用的能力”。

---

三、方法总览

为了理解 Voyager 的完整工作流程，可以先看论文 Figure 2。

图源：论文 Figure 2。
该图展示了 Voyager 的三个核心模块：自动课程负责提出新任务，技能库负责保存和检索已有程序，迭代提示机制根据环境反馈修正代码。成功技能进入技能库后，又会支持更复杂的后续任务。

Voyager 包含三个核心模块：

1. 自动课程（Automatic Curriculum）

   根据当前环境状态、已经完成的任务和失败记录，为 Agent 选择下一个难度合适的新目标。

2. 技能库（Skill Library）

   将成功完成任务的程序保存到向量数据库中，并在相似任务中检索相关技能。

3. 迭代提示机制（Iterative Prompting Mechanism）

   执行 GPT-4 生成的代码，收集环境反馈、程序错误和自验证结果，再让 GPT-4 修改程序。

完整流程可以概括为：

读取当前环境状态
    ↓
自动课程生成下一个任务
    ↓
根据任务和环境检索相关技能
    ↓
GPT-4 生成 JavaScript 程序
    ↓
在 Minecraft 中执行
    ↓
收集环境反馈和执行错误
    ↓
自验证模块判断任务是否完成
    ↓
失败：修改程序并重试
成功：写入技能库
    ↓
自动课程提出更复杂的新任务

这三个模块并不是彼此独立的。

自动课程决定 Agent 应该学习什么，迭代提示机制负责把新任务练会，技能库则负责让已经学会的能力不会随着时间消失。

---

四、自动课程：让 Agent 自己决定学什么

1. 设计动机

在开放世界中，如果只给 Agent 一个抽象目标：

尽可能探索 Minecraft。

模型很难直接将其转化为稳定、连续的行动。

如果目标太简单，Agent 会不断重复已经掌握的行为；如果目标太难，Agent 会长期卡在无法完成的任务上。

因此，Voyager 需要一个动态课程，为 Agent 选择：

略高于当前能力，但又有可能完成的下一个任务。

2. 输入信息

自动课程模块会接收以下信息：

当前环境状态

包括：

• 物品栏；
• 已装备物品；
• 附近方块；
• 附近生物；
• 所处生物群系；
• 当前时间；
• 生命值；
• 饥饿值；
• 当前位置。

探索进度

包括：

• 已经完成的任务；
• 以前失败的任务；
• 已经获得的物品；
• 当前能力边界。

全局探索目标

系统提示词会告诉 GPT-4：

最终目标是发现尽可能多的不同事物，
完成尽可能多的不同任务，
并成为优秀的 Minecraft 玩家。

同时要求下一个任务不能太难，需要与当前资源和能力匹配。

补充知识

Voyager 使用 GPT-3.5 根据当前状态生成问题并自行回答，为自动课程补充 Minecraft 相关知识。

作者使用 GPT-3.5 处理这部分标准语言任务，主要是为了降低成本。

3. 任务生成示例

假设 Agent 当前状态为：

物品栏：
- 木镐
- 石头
- 木棍
- 工作台

自动课程可能提出：

制作一把石镐。

如果当前状态为：

时间：夜晚
附近实体：僵尸
装备：石剑、盾牌

自动课程可能提出：

击杀一只僵尸。

可以看到，课程不是提前写死的任务列表，而是根据 Agent 当前所处的环境动态生成。

4. 自底向上的能力增长

Voyager 的课程按照自底向上的方式展开：

收集木头
    ↓
制作木板
    ↓
制作工作台
    ↓
制作木镐
    ↓
开采石头
    ↓
制作石镐
    ↓
寻找铁矿
    ↓
制作铁制工具

任务复杂度提高的同时，Agent 也在技能库中积累越来越多的程序。

因此，自动课程不仅决定当前任务，还间接决定了技能库的成长路径。

5. Warm-up 机制

论文附录还设计了一个 Warm-up Schedule。

在 Agent 刚开始探索时，课程模块只接收较少的状态信息，例如：

• 核心物品栏；
• 装备；
• 附近方块；
• 位置。

随着完成任务数量增加，再逐步加入：

• 附近实体；
• 完整物品栏；
• 生物群系；
• 生命值；
• 饥饿值；
• 时间；
• 补充知识。

这样可以减少早期提示词中的复杂信息，让课程先从基础任务开始，再逐渐提出更复杂和多样的目标。

---

五、技能库：把成功行为转化为长期记忆

1. 设计动机

自动课程会不断提出更复杂的任务。如果 Agent 每次都从零生成程序，就无法形成持续增长的能力。

因此，Voyager 将成功完成任务的程序保存为技能。

一个技能不是简单的任务名称，而是一个可执行、可复用的 JavaScript 函数，例如：

async function craftStoneSword(bot) {
    // 获取木棍
    // 获取圆石
    // 放置工作台
    // 制作石剑
}

程序可以封装多个连续动作，也可以被后续程序调用。

2. 为什么使用代码表示技能？

使用代码而不是自然语言摘要，主要有四个优势。

可以直接执行

自然语言经验需要模型重新解释，而代码可以通过控制接口直接运行。

行为更加明确

程序明确规定：

• 调用哪个接口；
• 使用哪些参数；
• 按照什么顺序执行；
• 遇到什么条件时采取什么操作。

可以参数化

一个通用技能可以接受不同参数，而不是只能解决一次具体任务。

可以组合

复杂技能可以调用多个基础技能，例如：

制作铁镐
    ↓
调用收集木头技能
    ↓
调用制作工作台技能
    ↓
调用制作木镐技能
    ↓
调用开采圆石技能
    ↓
调用制作石镐技能
    ↓
调用开采铁矿技能
    ↓
调用熔炼铁锭技能

这使技能库不仅是程序集合，也形成了一套可以逐层组合的能力基础。

3. 技能写入

为了理解技能的写入和检索过程，可以看论文 Figure 4。

图源：论文 Figure 4。
上半部分展示技能写入：GPT-4 生成并验证程序，GPT-3.5 为程序生成自然语言描述，再将描述的向量作为 Key、程序代码作为 Value 写入向量数据库。下半部分展示技能检索：系统根据任务计划和环境状态查询技能库，返回最相关的五个技能。

技能写入流程如下：

GPT-4 生成程序
    ↓
在环境中执行
    ↓
自验证确认任务成功
    ↓
GPT-3.5 生成程序描述
    ↓
计算描述的 Embedding
    ↓
写入向量数据库

技能库中的数据可以理解为：

Key：技能描述的向量
Value：可执行程序代码

例如：

描述：
“收集木头并制作一张工作台。”

程序：
makeCraftingTable(bot)

只有通过自验证的成功程序才会写入技能库。

这相当于为记忆写入增加了一道质量门控：

不是所有尝试都会成为记忆，只有被确认能够完成任务的程序才会沉淀为技能。

4. 技能检索

面对新任务时，Voyager 不会直接用任务名称搜索技能。

它首先让 GPT-3.5 根据新任务生成一个大致解决方案，然后把：

• 新任务；
• 初步计划；
• 当前环境反馈；

组合成查询上下文。

接着计算查询向量，从技能库中检索 Top-5 相关技能，并把这些程序加入 GPT-4 的代码生成上下文。

例如，新任务是：

制作一把铁镐。

系统可能检索到：

• 熔炼铁锭；
• 制作木棍；
• 放置工作台；
• 制作木镐；
• 制作熔炉。

GPT-4 随后在这些已有技能的基础上生成新的铁镐制作程序。

论文附录使用 309 个样本评估技能检索，结果为：

检索范围	准确率
Top-1	$80.2\pm 3.0$
Top-2	$89.3\pm 1.8$
Top-3	$93.2\pm 0.7$
Top-4	$95.2\pm 1.8$
Top-5	$96.5\pm 0.3$

这也是论文选择检索 Top-5 技能的重要依据。

5. 技能库如何缓解灾难性遗忘？

传统持续学习通常会更新模型参数，新任务训练可能破坏旧任务能力。

Voyager 不修改 GPT-4 参数，而是将已经学会的技能保存在外部程序库中。

因此，新技能的加入不会直接覆盖旧技能。

这种方式能够缓解参数级持续学习中的灾难性遗忘，但并不代表技能系统完全没有遗忘问题。

它仍然可能遇到：

• 相关技能没有被检索到；
• 旧技能在新环境中不再适用；
• 多个技能之间发生冲突；
• 技能库持续增长后检索精度下降；
• 旧 API 或环境规则发生变化。

所以更准确地说，Voyager 把“参数遗忘”转化为了“外部技能维护与检索”问题。

---

六、迭代提示：从失败反馈中修正技能

1. 设计动机

LLM 一次生成的程序可能存在错误。

如果只保存第一次生成的代码，技能库会快速积累大量不可执行或不可靠程序。

Voyager 因此设计了一个执行、反馈、修正的循环。

为了理解这个过程，可以看论文 Figure 5。

图源：论文 Figure 5。
左侧展示环境反馈：模型发现制作木棍还缺少木板；右侧展示执行错误：模型发现 Minecraft 中不存在相思木斧，需要改为制作普通木斧。

2. 环境反馈

环境反馈描述程序执行后的实际进度。

例如：

无法制作铁胸甲，还缺少7个铁锭。

这类反馈能够告诉模型：

• 程序执行到了哪里；
• 哪个前置条件没有满足；
• 当前缺少什么资源；
• 下一轮程序应该补充什么步骤。

环境反馈不仅是任务结果，还包含中间状态。

3. 执行错误

如果生成的 JavaScript 代码出现问题，系统会把程序解释器返回的错误传给 GPT-4，例如：

• 函数不存在；
• 参数错误；
• 语法错误；
• 访问了不存在的物品；
• API 调用方式不正确。

这相当于编程 Agent 中的测试反馈：

生成代码
    ↓
执行代码
    ↓
读取报错
    ↓
修改代码

Voyager 的代码生成不是一次性规划，而是与真实执行环境形成闭环。

4. 自验证

仅仅没有报错，并不意味着任务已经完成。

例如，一个程序可能正常结束，但 Agent 并没有成功制作目标物品。

因此，Voyager 使用另一个 GPT-4 调用作为自验证模块。

自验证模块接收：

• 当前任务；
• Agent 当前状态；
• 物品栏；
• 环境信息；
• 程序执行结果。

然后输出：

• 任务是否成功；
• 判断理由；
• 如果失败，下一步应该如何改进。

例如：

任务：击杀3只羊

当前物品栏：
- 2个白色羊毛
- 6个羊肉

判断：
任务失败。当前证据只表明击杀了2只羊。

建议：
继续寻找并击杀1只羊。

自验证与普通反思的区别在于，它不仅分析错误，还承担控制流程的职责：

• 成功：把程序写入技能库，并进入下一个任务；
• 失败：根据批评修改程序，再次执行。

5. 最大重试次数

Voyager 会不断执行：

程序生成
    ↓
环境执行
    ↓
反馈
    ↓
自验证
    ↓
程序修正

如果连续四轮代码生成后仍然无法完成任务，Agent 会暂时放弃当前任务，重新让自动课程提出其他目标。

这一机制避免 Agent 永久卡在一个当前能力无法完成的任务上。

但它也意味着失败经验不会像成功技能一样被结构化保存。系统主要依赖自动课程在未来重新提出相似任务。

---

七、三个模块如何形成终身学习循环

Voyager 的核心并不是任何单独模块，而是三个模块构成的循环。

1. 自动课程暴露能力缺口

自动课程根据当前状态提出略高于已有能力的新任务。

例如：

已经掌握石制工具
    ↓
提出“寻找并开采铁矿”

2. 技能库提供已有能力

系统检索与新任务相关的旧技能，例如：

• 制作石镐；
• 寻找洞穴；
• 放置火把；
• 返回地表。

3. 迭代提示学习新技能

GPT-4 组合旧技能并生成新程序，通过环境反馈不断修正。

4. 成功程序写回技能库

新技能经过验证后进入技能库，例如：

mineIronOre(bot)

5. 能力边界继续扩展

自动课程读取新的探索进度，提出更复杂的任务：

熔炼铁锭
    ↓
制作铁镐
    ↓
寻找钻石

因此，Voyager 的学习不是更新模型参数，而是不断改变 Agent 外部状态：

• 已完成任务越来越多；
• 技能库越来越大；
• 可以组合的程序越来越复杂；
• 自动课程能够提出更困难的任务。

作者将这种机制称为 In-Context Lifelong Learning。

---

八、实验设置

1. 环境

论文在 MineDojo 提供的 Minecraft 环境中进行实验，并使用 Mineflayer JavaScript API 作为控制接口。

这里需要特别注意：

Voyager 不是直接读取 Minecraft 屏幕像素并输出键盘、鼠标等低层动作。

它读取的是结构化状态，例如：

• 物品栏；
• 附近方块；
• 附近实体；
• 位置；
• 生命值；
• 饥饿值。

然后生成调用 Mineflayer API 的 JavaScript 程序。

因此，这篇论文主要研究高层规划、开放式探索和技能积累，而不是视觉感知与低层运动控制。

2. 使用的模型

论文使用：

• gpt-4-0314：自动课程、程序生成和自验证；
• gpt-3.5-turbo-0301：生成技能描述、补充知识等语言任务；
• text-embedding-ada-002：技能向量表示和检索。

除了自动课程使用 $0.1$ 的温度以增加任务多样性外，其余模型调用的温度均设置为 0。

Voyager 不对 GPT-4 进行参数微调，而是通过提示词、环境交互和外部技能库实现持续学习。

3. 对比方法

论文选择了三类 LLM Agent 方法：

ReAct

交替生成推理和行动，并根据新的环境观察继续决策。

Reflexion

在 ReAct 基础上加入反思，并在实验中获得执行错误和自验证反馈。

AutoGPT

使用 GPT-4 将高层探索目标分解为多个子目标，再通过循环执行。

这些方法原本并不是专门为 Minecraft 设计的，因此作者对它们进行了适配。

这意味着实验反映的是特定实现和统一环境下的系统比较，而不是所有 ReAct、Reflexion、AutoGPT 实现的普遍性能。

4. 评估维度

论文从四个方面评估 Voyager：

• 探索过程中发现的不同物品数量；
• Minecraft 科技树解锁速度；
• 地图探索距离；
• 在新世界中解决未见任务的零样本泛化能力。

---

九、实验结果与分析

1. 开放式探索

在 160 次 Prompting Iteration 内，Voyager 发现了 63 种不同物品。

论文报告，这一结果约为其他方法的 3.3 倍。

ReAct 和 Reflexion 面对“尽可能探索世界”这种抽象目标时，很难形成稳定的任务序列；AutoGPT 虽然能够进行任务分解，但缺少与当前能力匹配的自动课程，也没有不断积累的技能库。

我的理解是，这个结果主要说明：

对于开放式任务，Agent 不仅需要执行能力，还需要一个能够持续产生合适中间目标的机制。

如果缺少自动课程，再强的执行模块也可能不知道下一步应该做什么。

2. 科技树解锁

Minecraft 科技树大致需要按照以下顺序发展：

木制工具
    ↓
石制工具
    ↓
铁制工具
    ↓
钻石工具

论文 Table 1 的结果如下。括号表示三次实验中的成功次数，数字表示平均 Prompting Iteration，越小越好。

方法	木制工具	石制工具	铁制工具	钻石工具
ReAct	N/A（0/3）	N/A（0/3）	N/A（0/3）	N/A（0/3）
Reflexion	N/A（0/3）	N/A（0/3）	N/A（0/3）	N/A（0/3）
AutoGPT	$92\pm 72$（3/3）	$94\pm 72$（3/3）	$135\pm 103$（3/3）	N/A（0/3）
Voyager 无技能库	$7\pm 2$（3/3）	$9\pm 4$（3/3）	$29\pm 11$（3/3）	N/A（0/3）
Voyager	$6\pm 2$（3/3）	$11\pm 2$（3/3）	$21\pm 7$（3/3）	102（1/3）

Voyager 解锁木制、石制和铁制工具所需的 Prompting Iteration 明显少于 AutoGPT。

论文据此计算：

• 木制工具最快提高约 15.3 倍；
• 石制工具最快提高约 8.5 倍；
• 铁制工具最快提高约 6.4 倍。

但钻石工具结果需要谨慎解读。

Voyager 是唯一成功解锁钻石工具的方法，但三次运行中只成功了一次，并不是稳定达到钻石阶段。

因此，更准确的结论是：

Voyager 显著提高了科技树探索效率，并展示了到达钻石阶段的能力，但最高难度任务仍然存在较大不稳定性。

另外，无技能库版本在石制工具阶段反而略快于完整 Voyager。这说明技能库的优势主要出现在中后期复杂任务和能力持续增长阶段，并不是每个早期指标都会立即提升。

3. 地图探索

Voyager 的地图移动距离约为对比方法的 2.3 倍。

自动课程会根据当前环境提出不同任务，因此 Agent 不会一直停留在局部区域，而是需要：

• 寻找不同资源；
• 穿越多种地形；
• 接触新的生物；
• 探索不同生物群系。

这说明自动课程不仅推动科技树发展，也产生了更广泛的环境探索行为。

4. 新世界中的零样本泛化

作者清空 Agent 的物品栏，把它放入一个新生成的 Minecraft 世界，并要求完成四个未见任务：

• 制作钻石镐；
• 制作金剑；
• 获得岩浆桶；
• 制作指南针。

最大 Prompting Iteration 为 50。

实验结果如下：

方法	钻石镐	金剑	岩浆桶	指南针
ReAct	N/A（0/3）	N/A（0/3）	N/A（0/3）	N/A（0/3）
Reflexion	N/A（0/3）	N/A（0/3）	N/A（0/3）	N/A（0/3）
AutoGPT	N/A（0/3）	N/A（0/3）	N/A（0/3）	N/A（0/3）
AutoGPT + Voyager 技能库	39（1/3）	30（1/3）	N/A（0/3）	30（2/3）
Voyager 无技能库	36（2/3）	$30\pm 9$（3/3）	$27\pm 9$（3/3）	$26\pm 3$（3/3）
Voyager	$19\pm 3$（3/3）	$18\pm 7$（3/3）	$21\pm 5$（3/3）	$18\pm 2$（3/3）

完整 Voyager 在四项任务中均取得了 3/3 的成功率，而且需要的 Prompting Iteration 更少。

这个实验能够更直接地说明技能库的价值。

Agent 进入的是一个新世界，原来的物品和位置状态已经不存在，但程序技能仍然可以迁移。例如：

• 制作工作台的方法没有改变；
• 制作木棍的方法没有改变；
• 熔炼矿物的方法仍然可以复用；
• 复杂任务仍然可以由基础技能组合完成。

更有意思的是，将 Voyager 技能库提供给 AutoGPT 后，AutoGPT 也能完成部分原本无法完成的任务。

这说明技能库具有一定的可移植性，不是只能由 Voyager 自身使用。

---

十、消融实验

为了观察各模块的作用，可以看论文 Figure 9。

图源：论文 Figure 9。
左图比较自动课程、技能库和不同模型的影响；右图比较环境反馈、执行错误和自验证的影响。完整 Voyager 在持续发现新物品方面表现最好。

1. 自动课程

将自动课程替换为随机课程后，Agent 发现的不同物品数量下降了 93%。

原因是随机课程不考虑能力依赖关系，可能在 Agent 尚未掌握基础技能时，就要求完成过于困难的任务。

手工课程虽然比随机课程更合理，但存在两个问题：

• 需要大量 Minecraft 专业知识；
• 无法根据 Agent 当前环境动态调整。

因此，自动课程的价值不仅是生成任务，还在于让任务难度与实时状态匹配。

2. 技能库

移除技能库后，Agent 在早期仍然能够取得进展，但后期发现物品的数量逐渐进入平台期。

这说明没有技能库时，GPT-4 仍能依赖预训练知识解决一些简单任务，但复杂任务需要反复重新生成和调试基础行为，难以形成能力积累。

技能库的主要价值不是立刻提高单次代码生成，而是：

让 Agent 的能力能够随时间复利增长。

3. 环境反馈

移除环境反馈后，GPT-4 很难知道程序执行到了哪一步，也无法准确判断还缺少哪些资源。

这会导致程序修改缺少现实依据。

4. 执行错误

移除执行错误后，模型无法看到 JavaScript 解释器返回的具体问题，修复代码的效率下降。

对代码 Agent 来说，这类似于只让模型修改代码，却不把编译错误和测试日志提供给它。

5. 自验证

移除自验证后，发现物品数量下降了 73%。

在三种反馈中，自验证的影响最大。

原因是自验证决定了：

• 当前任务是否真的完成；
• 是否应该继续修改程序；
• 是否可以把程序写入技能库；
• 是否应该进入下一个任务。

如果缺少可靠验证，系统可能把失败程序误认为成功技能，也可能在已经完成任务后继续无效重试。

6. GPT-4 与 GPT-3.5

使用 GPT-3.5 替代 GPT-4 进行代码生成后，Agent 发现的不同物品数量明显下降。

论文报告 GPT-4 获得的不同物品数量约为 GPT-3.5 的 5.7 倍。

这说明 Voyager 的系统设计虽然重要，但最终效果仍然高度依赖基础模型的代码生成与推理能力。

---

十一、Voyager 中的记忆机制

Voyager 并没有把所有历史轨迹完整放入上下文，而是保存几类对后续行动有用的信息。

1. 探索进度记忆

系统记录：

• 已经完成的任务；
• 以前失败的任务；
• 已发现的物品；
• 当前能力边界。

这部分信息主要用于自动课程，让 Agent 不会持续重复已经完成的任务。

2. 技能记忆

技能库保存成功程序，是 Voyager 最核心的长期记忆。

它回答的是：

过去有哪些经过验证的方法可以解决当前问题？

3. 环境工作记忆

当前物品栏、附近实体、生命值和位置等信息构成短期状态。

这些信息会随着环境变化不断更新，主要用于当前任务决策。

4. 失败反馈

执行错误、环境反馈和自验证批评会进入下一轮提示词，用于修正当前程序。

不过，这些失败经验主要服务于当前任务，没有像成功程序一样被系统化写入长期技能库。

因此，Voyager 的记忆结构可以概括为：

记忆层次	主要内容	生命周期
当前状态	物品栏、位置、附近实体等	随环境实时变化
当前任务反馈	环境反馈、执行错误、批评	当前任务内使用
探索进度	成功任务、失败任务、已发现物品	跨任务保留
技能库	经过验证的可执行程序	长期保存并复用

---

十二、与其他 Agent 方法的区别

方法	核心机制	是否自主提出任务	是否积累可执行技能	是否使用环境反馈
ReAct	推理与行动交替	否	否	是
Reflexion	失败后生成反思	否	主要保存语言反思	是
AutoGPT	高层目标分解	部分	否	是
Voyager	自动课程 + 程序技能库 + 迭代修正	是	是	是
Mem0 类记忆	长期事实生命周期管理	否	否	取决于 Agent
A-MEM 类记忆	记忆关联与演化	否	不直接保存程序技能	取决于 Agent

Voyager 最重要的差异是：

它把长期学习的结果保存在外部技能库中，而不是保存在模型参数或普通自然语言摘要中。

这使得 Agent 能够在不微调 GPT-4 的情况下持续扩展能力。

---

十三、局限性与未来方向

1. 高度依赖 GPT-4

论文实验表明，使用 GPT-3.5 生成代码时性能明显下降。

这意味着 Voyager 的能力不仅来自系统架构，也来自 GPT-4 较强的：

• 代码生成能力；
• Minecraft 先验知识；
• 任务规划能力；
• 错误修正能力。

在当时的实验设置下，GPT-4 API 成本约为 GPT-3.5 的 15 倍。

因此，大规模长期运行会产生较高成本。

2. 没有解决视觉感知

Voyager 不直接读取 Minecraft 屏幕，而是使用结构化环境状态和高层控制 API。

它没有解决：

• 从图像中识别物体；
• 三维空间视觉理解；
• 精细动作控制；
• 键盘和鼠标操作；
• 真实机器人中的传感器噪声。

因此，不能简单把 Voyager 的结果等价为通用现实具身智能。

3. 自验证仍然可能出错

自验证由 GPT-4 完成，并不是严格的程序验证器。

论文提到，自验证有时无法根据掉落物正确判断是否击杀了目标生物。

错误的自验证可能导致两类问题：

• 成功任务被误判为失败，产生无效重试；
• 失败任务被误判为成功，将错误程序写入技能库。

对于生产系统，更稳妥的方案应该优先使用：

• 单元测试；
• 环境状态断言；
• 规则验证器；
• 任务完成事件；
• LLM 判断作为补充。

4. 会产生环境和 API 幻觉

自动课程有时会提出 Minecraft 中不存在的任务，例如制作“铜剑”。

代码生成也可能：

• 使用无效材料；
• 调用不存在的接口；
• 假设错误的制作配方。

迭代提示能够修复一部分问题，但不能完全消除幻觉。

5. 技能库只增加，不主动维护

Voyager 强调不断增长的技能库，但没有深入解决：

• 重复技能合并；
• 低质量技能删除；
• 旧技能更新；
• 技能版本管理；
• 技能依赖分析；
• 环境变化后的技能失效；
• 恶意或危险代码检测。

当技能库规模持续增长后，这些问题会变得更加重要。

6. 失败经验没有充分长期化

成功程序会进入技能库，但失败尝试主要用于当前任务的下一轮修正。

如果任务最终被放弃，失败过程中的知识未必会被长期保存。

未来可以增加：

• 失败模式库；
• 技能适用条件；
• 常见错误和修复策略；
• 技能成功率统计；
• 技能调用日志；
• 失败后的负向检索信号。

7. 实验次数有限

科技树和零样本任务通常只进行三次实验。

尤其是钻石工具，Voyager 只成功一次。

因此，部分最高难度结果更适合被视为能力展示，而不是已经证明了高稳定性。

---

十四、我的理解和启发

1. Agent 记忆应该从“保存内容”走向“保存能力”

很多记忆系统保存的是：

发生过什么？

Voyager 保存的则是：

这件事情怎样才能成功完成？

对于实际 Agent，这两类记忆都需要。

例如，一个代码 Agent 可以同时保存：

事实记忆：
项目使用 Python 3.11 和 Poetry。

情节记忆：
上次升级依赖时出现了 pydantic 版本冲突。

技能记忆：
检测并修复 Poetry 依赖冲突的可执行流程。

技能记忆比普通摘要更接近可以直接产生价值的知识。

2. 技能写入必须经过验证

Voyager 并不会保存 GPT-4 生成的所有代码，而是只保存经过环境验证的成功程序。

这对 Agent 记忆系统很有启发。

普通记忆系统经常在信息刚出现时立即写入，但此时内容可能：

• 尚未验证；
• 只是模型猜测；
• 之后会被新证据推翻；
• 只在特定环境下有效。

因此，可以给记忆写入增加质量门控：

候选经验
    ↓
实际执行
    ↓
结果验证
    ↓
提取可复用部分
    ↓
写入长期技能库

对于代码 Agent，验证器可以是测试结果；对于数据分析 Agent，可以是查询校验；对于网页操作 Agent，可以是页面状态断言。

3. 技能需要包含适用条件

Voyager 主要通过技能描述的向量相似度进行检索。

但实际工程中的技能通常具有明确前置条件，例如：

技能：修复数据库连接池耗尽

适用条件：
- 数据库连接数达到上限；
- 存在连接未释放；
- 应用使用特定连接池框架。

输入：
- 配置文件路径；
- 日志；
- 数据库监控信息。

输出：
- 修复后的配置；
- 验证结果。

因此，我认为技能库不应该只保存“描述 + 代码”，还可以保存：

• 前置条件；
• 输入参数；
• 输出结果；
• 依赖技能；
• 适用环境；
• 成功率；
• 最近验证时间；
• 失败案例；
• 安全权限。

这样才能从 Demo 级技能库走向生产级 Agent 能力系统。

4. 自动课程可以用于 Agent 自进化

Voyager 的自动课程本质上是在寻找 Agent 当前的能力边界。

这个思想可以迁移到其他 Agent：

编程 Agent

已经会修复单文件 Bug
    ↓
尝试跨模块错误
    ↓
尝试性能问题
    ↓
尝试并发问题

数据分析 Agent

已经会单表统计
    ↓
尝试多表关联
    ↓
尝试异常检测
    ↓
尝试自动解释和报告

浏览器 Agent

已经会搜索和提取信息
    ↓
尝试多网站比较
    ↓
尝试表单填写
    ↓
尝试完整业务流程

自动课程可以根据 Agent 的成功率、失败类型和已有技能，主动生成略高于当前水平的新任务。

5. 反思不能替代验证

Voyager 的消融实验中，自验证是最重要的反馈之一。

这说明 Agent 不能只依赖“我觉得自己完成了”。

在实际项目中，更合理的反馈优先级应该是：

确定性验证器
    >
环境状态检查
    >
测试与规则
    >
LLM-as-a-Judge
    >
模型自我判断

只要任务能够通过程序验证，就应该优先使用程序验证。

LLM 自验证适合处理难以预先编写规则的开放任务，但不能被当作完全可靠的事实来源。

6. 技能库可以成为 Agent 的能力接口层

Voyager 中的技能是普通程序，因此可以被其他 Agent 使用。

论文实验中，AutoGPT 接入 Voyager 技能库后，也能够完成部分原本无法完成的任务。

这说明技能库可以从单个 Agent 的私人记忆，发展为团队共享的能力资产：

Agent A 学会数据清洗
Agent B 学会报告生成
Agent C 学会网页检索
        ↓
共享技能库
        ↓
不同 Agent 按任务检索和组合技能

这与现在的 Agent Skills、工具市场和 MCP 生态非常接近。

7. 生产环境需要为技能执行增加安全边界

Voyager 生成 JavaScript 并直接在环境中运行。

在 Minecraft 中，这种风险相对有限；但如果迁移到真实系统，自动生成和执行代码可能带来：

• 删除文件；
• 修改生产数据；
• 泄露密钥；
• 执行危险命令；
• 无限循环；
• 资源耗尽；
• 越权调用工具。

因此，生产级技能系统还需要：

• 沙箱执行；
• 权限控制；
• 输入校验；
• 超时机制；
• 资源限制；
• 人工审批；
• 完整审计日志；
• 技能签名和版本管理。

---

十五、总结

Voyager 提出了一个由 GPT-4 驱动的 Minecraft 开放式终身学习 Agent。

它包含三个相互配合的核心模块：

1. 自动课程

   根据当前环境状态和能力边界，为 Agent 持续生成难度合适的新任务。

2. 技能库

   将经过验证的成功程序保存为可检索、可执行和可组合的长期技能。

3. 迭代提示机制

   通过环境反馈、执行错误和自验证不断修正代码，直到任务成功或达到重试上限。

实验显示，Voyager 在 160 次 Prompting Iteration 中发现了 63 种不同物品，约为其他方法的 3.3 倍；地图探索距离约为对比方法的 2.3 倍；科技树解锁速度最高提高约 15.3 倍。

在新生成的 Minecraft 世界中，Voyager 能够利用以前积累的技能库完成四个未见任务，说明程序技能具备一定的跨环境迁移能力。

不过，Voyager 并没有解决完整的具身智能问题。

它依赖 GPT-4、结构化环境状态和 Mineflayer 高层 API，没有直接处理视觉感知与低层运动控制；最高难度任务的实验稳定性也仍然有限。与此同时，自验证、技能维护、执行安全和运行成本仍然是实际落地需要解决的问题。

从 Agent 记忆机制的角度看，这篇论文最重要的启发是：

Agent 的长期记忆不应该只保存事实和历史，也应该把经过验证的成功轨迹结晶为能够直接调用的技能。

如果说传统记忆系统解决的是“Agent 如何记住过去”，那么 Voyager 进一步探索的是：

Agent 如何把过去的成功经验转化为未来可以复用和组合的能力。

参考资料

• Guanzhi Wang et al. Voyager: An Open-Ended Embodied Agent with Large Language Models. NeurIPS 2023 Open-Ended Learning Workshop.
• Voyager 代码仓库