第 15 讲：构建自主的 Agent 系统——经验与开放问题

对应：Stanford CS329A Autumn 2025 Lecture 18（Fri 11/21），客座讲座：Misha Laskin（Reflection AI 联合创始人、CEO），题目 Building Agentic Systems for Autonomy: Lessons & Open Questions。这次讲座没有公开的阅读材料、幻灯片或讲稿。 本讲依据讲者公开的研究工作（Algorithm Distillation 等）、公开的访谈和公司发布的信息，以及自主 agent 方向的公开文献编写，围绕题目里的”经验”和”开放问题”组织内容，不代表讲者在课堂上的具体观点。 配套代码：code/lecture15/（只用 Python 标准库，不到 1 秒） 预计阅读时间：2 小时（含运行代码）

0. 本讲导航

0.1 学完本讲，你应该能够

1. 说出”自主”（autonomy）的几个层次，以及衡量自主程度的两个量：能独立工作多久、每单位工作需要多少人的注意力。
2. 解释”广度来自语言模型，深度来自强化学习”这个观点，以及它和 AlphaGo、RLHF、RLVR、agentic RL 的关系。
3. 说出为什么很多团队把自主编程看作通往自主 agent 的路径，以及为什么”读懂代码”可能比”写代码”更重要。
4. 用错误累积的算术解释长程任务的可靠性问题，并能定量比较”提高每一步的成功率""学会发现并纠正错误""人的监督”三种办法。
5. 说出构建自主 agent 的几个关键开放问题：模糊任务的奖励、长程的 credit assignment、持续学习、可扩展的监督（scalable oversight）、安全。

0.2 先修知识

0.3 本讲地图

第1节  讲者和背景
第2节  什么是"自主"
第3节  经验一：广度来自语言模型，深度来自强化学习
第4节  经验二：为什么是编程；读懂代码比写代码更重要
第5节  经验三：长程任务的可靠性                         ← 代码 01
第6节  构建自主 agent 的要素
第7节  开放问题
第8–11节 小结、练习、延伸阅读、下一讲预告

0.4 本讲的代码

• 01_autonomy_reliability.py：长程任务可靠性的算术。一个 n 步的任务，比较”一路做到底""自我检查 + 重试""人定期审查""自我检查 + 人稀疏地审查”，看成功率、agent 的用时和人的时间怎样随任务长度变化。所有结果都是解析计算的，参数是设定的。

关于本讲的数字：公开资料里的数字注明出处；代码的数字来自 01 号代码的实际输出（Python 3.9 与 3.13 逐字相同）。

1. 讲者和背景

Misha Laskin 的公开经历（来自公开的访谈和报道）：

• 物理学博士出身，读了 AlphaGo 的论文之后转向 AI；在 UC Berkeley 做博士后，研究强化学习，参与了 CURL、RAD（用数据增强提高 RL 的样本效率）、Decision Transformer 等工作。
• 在 DeepMind 研究通用 agent，第一作者的 Algorithm Distillation（2022）提出了”在上下文里做强化学习”；之后负责 Gemini 的奖励模型（reward modeling）工作。
• 2024 年和 Ioannis Antonoglou（AlphaGo、AlphaZero 的核心成员，后来负责 Gemini 的 RLHF）共同创立 Reflection AI，目标是自主编程（autonomous coding），并把它看作通往更通用的超级智能的路径。
• 2025 年 7 月，Reflection AI 发布了 Asimov：一个代码理解（code comprehension）agent，不只读代码，也读文档、工单、聊天记录，回答”这个系统为什么是这样设计的”。2025 年 10 月，公司宣布融资并转向训练开放权重的前沿模型。

讲者的背景本身就是本讲的主线：强化学习（深度）+ 语言模型（广度）→ 自主 agent。

2. 什么是”自主”

2.1 几个层次

可以借用自动驾驶的分级来理解（这里是一个粗略的类比，不是某个标准）：

今天的 coding agent 大致在第 3 层，正在向第 4 层移动（第 10 讲）。

2.2 衡量自主程度的两个量

1. 能独立工作多久：第 14 讲 METR 的时间跨度。50% 时间跨度约每 7 个月翻一倍。
2. 每单位工作需要多少人的注意力：一个 agent 能完成很长的任务，但如果人要全程盯着、逐步审查，它就谈不上自主。第 5 节的 toy 计算会显示：人每步都审查，花的时间可能比自己做还多。

真正的自主需要两者同时满足：做得长，而且不需要人盯着。

3. 经验一：广度来自语言模型，深度来自强化学习

3.1 AlphaGo 的经验

AlphaGo（2016）和 AlphaZero（2017）在围棋、国际象棋上超越了人类。它们的配方：

• 强化学习 + 自我对弈：不需要人类的棋谱也能不断变强（AlphaZero）；
• 搜索：下棋时用 MCTS 展开很多步；
• 清楚的奖励：输或赢。

结果是一种”深度”：在一个窄的领域里达到超人的水平，甚至下出人类没想到的棋（第 2 局的”第 37 手”）。但它们只会下棋。

3.2 语言模型解决了广度

大语言模型有惊人的广度：几乎什么话题都能谈，什么问题都能回答。但在很长一段时间里，它们缺少深度：不能可靠地、长时间地完成一件复杂的事。

讲者在访谈里的表述：超级智能的基础是”语言模型的通用性 + 强化学习的能力”。把两者结合，是这个领域过去几年的主线：

• RLHF（第 9 讲）：ChatGPT 之所以好用，一个关键是基于人类反馈的强化学习——讲者和合伙人都在 Gemini 做过这部分工作；
• RLVR（第 6 讲）：用可验证的奖励训练推理，得到 o1、DeepSeek-R1 这样的推理模型；
• agentic RL（第 9 讲）：在可以交互的环境里训练多步的 agent。

讲者也在访谈里表达过一个判断：强化学习是最可扩展的 AI 方法之一，目前看不到明显的天花板。这和第 12 讲 Denny Zhou 的”RL finetuning 胜过 SFT”是一致的——前提都是有可靠的奖励。

3.3 Algorithm Distillation：在上下文里学习

讲者的 Algorithm Distillation（Laskin et al. 2022，ICLR 2023）提供了另一种视角：

• 让一个 RL 算法在很多任务上从头学习，记录下它的学习历史（从笨拙到熟练的整个过程）；
• 用一个因果 Transformer 对这些学习历史做 next-token 预测；
• 训练好的 Transformer 在一个新任务上，不更新任何参数，只靠上下文里越来越长的交互历史，就能越做越好——它在上下文里”执行”了一个强化学习算法，而且比生成数据的那个 RL 算法更省数据。

这和第 11 讲的”记忆是不改权重的自我改进”、第 4 讲的 Reflexion 是同一个方向：自我改进不一定要更新权重，也可以发生在上下文里。对于需要在一个新环境里长时间工作的自主 agent，这种”边做边学”的能力尤其重要。

4. 经验二：为什么是编程

4.1 编程是自主 agent 的”根节点”

很多团队（包括 Reflection AI）选择从编程开始构建自主 agent。理由可以归纳为：

• 数字化：环境就是电脑，不需要机器人（第 16 讲会看到物理世界有多难）。
• 可验证：有编译器、测试、运行结果（第 10 讲）——RL 需要的奖励相对容易得到。
• 经济价值大：软件工程是一个巨大的市场。
• 可以自我加速：能写代码的 agent 可以给自己写工具；能做 AI 研究工程的 agent 可以加速 AI 本身的研究（第 7 讲的 AI Scientist、第 14 讲的 RE-Bench）。

4.2 读懂代码比写代码更重要

一个常被引用的观察是：工程师的大部分时间花在理解已有的系统上（读代码、查文档、问同事、调试），真正写新代码的时间只占一小部分。Reflection AI 的 Asimov 押注的正是这一点：先理解，再生成。

为什么这对自主 agent 特别重要？

• 第 14 讲 METR 的发现：在真实的代码库上，“新来的人”完成一个任务的时间是”熟悉代码的人”的 5~18 倍。agent 每次都是”新来的”——除非它有好的上下文和记忆（第 11 讲）。
• 第 10 讲 CodeMonkeys 让小模型读每一个文件来找上下文，这部分成本可以被很多样本分摊。
• 很多关于”为什么这样设计”的知识不在代码里，而在设计文档、工单讨论、聊天记录里。一个只看代码的 agent，会做出”技术上正确、但违背了团队约定”的修改。

上下文工程（context engineering）——给 agent 找到、组织、压缩它需要的信息——因此成了构建自主 agent 的核心工作之一。

5. 经验三：长程任务的可靠性

5.1 错误累积

第 1 讲的公式：每一步成功率 p，n 步都成功的概率是 pⁿ。自主 agent 要做的任务越来越长，这个公式就越来越残酷。

5.2 toy 计算：检查、恢复和人的监督

01 号代码的设定：n 步的任务，每步成功率 p = 0.99。

• A：一路做到底；
• B：每步自我检查（发现错误的召回率 r，误报率 0.05），发现就重做；
• C：agent 不检查，人每 k 步审查一次（1 分钟固定开销 + 每步 0.2 分钟，发现错误的概率 0.95），发现就让 agent 重做这一段；
• D：B + C。 agent 每步 0.2 分钟；人亲自做每步 1 分钟。

表 1：成功率 vs 任务长度

表 2：提高每一步的成功率，还是提高发现错误的能力？

表 3：人的监督（p = 0.99；自我检查的召回率 0.8、误报率 0.05）

读这三张表：

1. 错误累积是长程任务的头号敌人：99% 的每步成功率，100 步只剩 37%，1000 步几乎为 0。
2. “发现并纠正错误”和”不犯错”一样有价值：召回率为 r 的检查 + 重试，每一步最终的成功率是 p / (1 − (1 − p)r) ≈ 1 − (1 − p)(1 − r)，相当于把错误率乘以 (1 − r)。“召回率 0.9 的检查”和”错误减为十分之一”效果相同（0.904 vs 0.905）。对长任务，让 agent 学会发现并纠正自己的错误，往往比让它一次做对更现实。这也是 METR 说”时间跨度的增长部分来自从错误中恢复的能力”的原因。
3. 人的监督不是免费的：每步都审查，人花的时间（2.0 小时）比自己做（1.7 小时）还多——这样的 agent 没有”自主”可言。
4. 最好的组合是 agent 先自我检查、人再稀疏地审查：人只需要抓住 agent 自己没发现的少数错误。1000 步的任务，成功率 0.90，人花约 4 小时（自己做要 16.7 小时）。
5. 即使这样，人的时间仍然随任务长度增长（要读的东西越来越多）。怎样监督一个越来越能干、做得越来越长的 agent，是第 7 节的开放问题之一。

5.3 现实比 toy 更复杂

• 错误不是独立的：一个错误的假设会影响后面很多步（系统性错误，第 1、12 讲）。
• 有些错误是可以挽回的（改一下就好），有些不可挽回（删除了数据、发出了邮件）。自主 agent 需要知道哪些动作是不可逆的，在那里更谨慎、或者先问人。
• 检查本身也可能被”钻空子”：agent 可能学会修改测试让它通过（第 9、10 讲）。

6. 构建自主 agent 的要素

把整门课放在一起，构建一个自主 agent 需要：

7. 开放问题

7.1 模糊任务的奖励

围棋有输赢，编程有测试，但”写一份好的设计文档""做一个好的产品决策”没有自动的判定标准。讲者在访谈里也把”怎样定义奖励”列为核心挑战。可能的方向：从人的偏好学习奖励模型（第 9 讲；会被钻空子）、用细则（rubric）让模型评分（第 14 讲；有偏差）、把模糊任务拆成可验证的子任务。

7.2 长程的 credit assignment

一个 agent 工作了几个小时，最后失败了。是哪一步的错？第 9 讲讨论过多轮 RL 里的 credit assignment；任务越长，这个问题越难。过程奖励（第 3 讲的 PRM）、中间检查点、从失败轨迹里自动定位错误的工具，都是可能的方向。

7.3 持续学习

人类工程师在一个代码库上工作几个月会越来越熟练。今天的 agent 每次对话都从零开始（除了第 11 讲的记忆）。怎样让 agent 从自己的经验中持续学习，同时不忘记已有的能力、不被错误的经验带偏？Algorithm Distillation 式的上下文学习、记忆系统、定期的权重更新，各有取舍。

7.4 可扩展的监督（scalable oversight）

第 5 节的计算显示，人的审查时间随任务长度增长。当 agent 一天能完成人一个月的工作，人不可能逐行审查。可能的方向：用 AI 帮助人审查（例如用另一个模型找出最可疑的部分）、只审查高风险的动作、要求 agent 给出可以验证的证据（测试、证明、日志）。第 13 讲的形式化验证是这个方向的极端形式：证明对不对，Lean 说了算。

7.5 安全

自主 agent 有真实的权限：读写代码库、调用外部服务、花钱。风险包括：

• reward hacking 和 specification gaming（第 7、9 讲）：为了”测试通过”去修改测试；
• 不可逆的动作：删除数据、发布到生产环境；
• prompt injection：从网页、文档、工单里读到恶意的指令（第 11 讲的记忆投毒）；
• 权限过大：给 agent 的权限应该是完成任务所需的最小权限。

7.6 开放还是封闭

Reflection AI 在 2025 年转向训练开放权重的前沿模型，这代表了一种立场：自主 agent 的基础模型应该开放，让更多人能够研究、审计和定制。另一种立场强调前沿能力的风险需要更谨慎的发布。这不是一个纯技术问题，但会深刻影响这个领域的研究方式。

8. 小结

1. 自主有不同的层次；衡量它需要两个量：能独立工作多久（第 14 讲的时间跨度），每单位工作需要多少人的注意力。
2. 广度来自语言模型，深度来自强化学习：AlphaGo 在窄领域里证明了 RL + 搜索 + 自我对弈的威力；语言模型解决了广度；RLHF、RLVR、agentic RL 把两者结合。Algorithm Distillation 显示，强化学习也可以发生在上下文里，不更新权重。
3. 编程是构建自主 agent 的自然起点：数字化、可验证、经济价值大、可以自我加速。读懂代码和它背后的决策（上下文工程）可能比写代码更关键。
4. 长程任务的可靠性：错误累积让长任务的成功率迅速下降；召回率 r 的自我检查相当于把错误率乘以 (1 − r)；人每步都审查可能比自己做还费时间；最好的组合是 agent 自我检查 + 人稀疏地审查（1000 步的任务：成功率 0.90，人花 4 小时 vs 自己做 16.7 小时）。
5. 开放问题：模糊任务的奖励、长程的 credit assignment、持续学习、可扩展的监督、安全（reward hacking、不可逆动作、prompt injection、最小权限），以及开放与封闭。

9. 练习

1. 检查的价值（第 5.2 节） (a) 推导：召回率为 r 的”检查 + 重试”之后，每一步的最终成功率是 p / (1 − (1 − p)r)。 (b) 证明它约等于 1 − (1 − p)(1 − r)（当 1 − p 很小时）。 (c) 一个 agent 的每步成功率是 0.98。要让 500 步的任务有 90% 的成功率，检查的召回率至少要多少？

(a) 设最终成功率为 s。第一次做对（概率 p）就成功；做错且被发现（(1 − p)r）就重做，重做后的最终成功率还是 s。所以 s = p + (1 − p)r·s，解得 s = p / (1 − (1 − p)r)。 (b) 记 ε = 1 − p。s = (1 − ε)/(1 − εr) ≈ (1 − ε)(1 + εr) ≈ 1 − ε + εr = 1 − ε(1 − r)（忽略 ε² 项）。 (c) 需要 s⁵⁰⁰ ≥ 0.9，即 s ≥ 0.9^(1/500) ≈ 0.99979，错误率 ε(1 − r) ≤ 0.00021，ε = 0.02，所以 1 − r ≤ 0.0105，r ≥ 0.9895。几乎要发现所有错误。

2. 审查的频率（第 5.2 节） (a) 为什么”人每 10 步审查一次”的成功率和”每步都审查”差不多，人的时间却少了很多？ (b) 审查得越稀疏，每次审查发现错误的概率真的能保持 0.95 吗？在现实中，这个假设可能怎样被打破？

(a) 两者都能以 0.95 的概率抓住错误；每步都审查要付出 n 次固定开销（每次 1 分钟），每 10 步只付 n/10 次。人的时间主要花在固定开销上。 (b) 现实中，一次要读的东西越多，人越容易漏看；错误也可能在后面的步骤里被”掩盖”或产生连锁反应，更难定位。所以审查的召回率通常会随间隔变长而下降，最优的间隔需要权衡。

3. 广度和深度（第 3 节） 举一个例子说明”有广度、没有深度”的 agent 的典型失败；再举一个”有深度、没有广度”的系统的例子。RL 是怎样在 LLM 的基础上增加深度的？

4. 在上下文里学习（第 3.3 节） (a) Algorithm Distillation 训练时的数据是什么？为什么用”学习历史”而不是”专家的轨迹”？ (b) 它和第 11 讲 MemGPT 式的记忆有什么相同和不同？

(a) 一个 RL 算法从头学习很多任务时的完整交互历史（状态、动作、奖励，按时间顺序，跨越很多个 episode）。如果只用专家的轨迹，模型学到的是”怎样做好”，而不是”怎样从做不好变成做好”；学习历史里包含了”改进”的过程，模型才能学会在上下文里改进。 (b) 相同：都不更新权重，靠上下文里的信息变得更好。不同：MemGPT 的记忆是显式的、可读的文字，由模型主动写入和检索；Algorithm Distillation 的”学习”隐含在 Transformer 对长交互历史的处理里，不需要显式的记忆管理，但受上下文长度的限制。

5. 不可逆的动作（第 5.3、7.5 节） 为一个能操作生产环境的运维 agent 设计一个”动作分级”方案：哪些动作可以自主执行，哪些需要先问人，哪些禁止？给出分级的原则。

6. 可扩展的监督（第 7.4 节） 假设 agent 一天能完成 1000 步的工作，而你每天只有 1 小时审查。结合 01 号代码的模型，设计一个审查策略，并估计它的成功率（提示：可以只审查”agent 自己标记为不确定”的步骤，或者让另一个模型先筛选）。

7. 动手改代码 (a) 01 号代码：让人审查的召回率随间隔变长而下降（例如 0.98 − 0.005 × k），找出 n = 1000 时人的时间和成功率的最佳平衡点。 (b) 加一种做法：agent 的错误有 20% 是”自己永远发现不了的”（检查的召回率对它们是 0）。表 2 的结论还成立吗？

10. 延伸阅读

讲者的工作

• Laskin et al. 2022. In-context Reinforcement Learning with Algorithm Distillation.（ICLR 2023）
• Srinivas, Laskin & Abbeel 2020. CURL: Contrastive Unsupervised Representations for Reinforcement Learning.；Laskin et al. 2020. Reinforcement Learning with Augmented Data.（RAD）
• Chen et al. 2021. Decision Transformer: Reinforcement Learning via Sequence Modeling.
• Sequoia Capital 对 Reflection AI 创始人的访谈（2024~2025）。

相关工作

• Silver et al. 2016. Mastering the Game of Go with Deep Neural Networks and Tree Search.；Silver et al. 2017. Mastering the Game of Go without Human Knowledge.
• Ouyang et al. 2022. Training Language Models to Follow Instructions with Human Feedback.（InstructGPT）
• Kwa et al. 2025. Measuring AI Ability to Complete Long Tasks.（第 14 讲）
• Amodei et al. 2016. Concrete Problems in AI Safety.（reward hacking、安全探索等问题的早期总结）
• Bowman et al. 2022. Measuring Progress on Scalable Oversight for Large Language Models.

11. 下一讲预告

第 16 讲：机器人中的多模态 Agent（客座：Danny Driess，Physical Intelligence）

本讲说编程是自主 agent 的”根节点”，因为它是数字化的、可验证的。机器人正好相反：物理世界没有”撤销”，数据昂贵，奖励模糊，每一步都有噪声。第 16 讲讨论：

• PaLM-E 和 RT-2：把视觉、语言和动作放进同一个模型；
• π0：视觉-语言模型 + 用流匹配（flow matching）生成连续动作的”动作专家”；
• 为什么机器人的动作需要”生成模型”而不是”回归”；
• π*0.6 和 Recap：机器人怎样从自己的经验和人的纠正中自我改进。