04 · 四种 Agent 架构

⏱ 40 分钟 ｜ ⭐⭐ 一条被局限逼出来的演进链：每一种的死穴，就是下一种存在的理由

🎯 一句话

这四种架构不是四个并列选项，是一条链：反应式没有记忆 → 模型式有记忆但不会推演未来 → 规划式会推演 → 学习式让前三种自己变好。

⚠️ 顺带一件很重要的事，本章第七节会专门讲： 这里说的 Agent，和《智能体工程教程》里那个「LLM + 工具 + 循环」不是一回事 —— 但它们的关系比你想的紧密。

🦴 一、先把 agent 写成一个函数

⭐ 一个 agent 就是一个从「感知序列」到「动作」的函数：$f: P^* \to A$。

注意定义域是感知序列 $P^*$，不是单个感知 $P$ —— ⭐ 这一个上标星号就是第一种架构和其余三种的全部差别。 反应式 agent 是 $f: P \to A$，它把历史丢掉了。

理性 agent 的定义就落在这个函数上：对每一条感知序列，选出期望性能度量最高的动作。

⚡ 二、反应式 agent：快，但没有记忆

结构简单到可以一句话说完：看当前感知，匹配一条「条件 → 动作」规则，执行。

Wumpus 里一个能用的反应式 agent 长这样：

if 有闪光      → 抓取
else if 有臭味 → 射箭
else           → 随机 左转 / 右转 / 前进

⭐ 它看起来像在做判断，其实只是查表。而且别小看它 —— Brooks 的 Swiss robots 只用几条这样的规则， 就能把散落的物块聚成堆，却没有任何一个机器人「知道」自己在堆东西。

🔨 十几行跑一遍：两格吸尘器世界

世界只有 A、B 两格。性能度量：每一步每个干净格 +1，每次移动 −1（移动耗电）。

# 反应式 vs 模型式：同一个世界、同一个性能度量
def simulate(agent, steps=8):
    world = {"A": "脏", "B": "脏"}
    loc, score = "A", 0
    for _ in range(steps):
        act = agent((loc, world[loc]))          # ⭐ agent 只看得见当前格
        if   act == "吸": world[loc] = "净"
        elif act == "右": loc = "B"; score -= 1  # 移动耗电，扣 1
        elif act == "左": loc = "A"; score -= 1
        score += sum(1 for v in world.values() if v == "净")
    return score

def reactive(p):                                # 无状态
    loc, st = p
    return "吸" if st == "脏" else ("右" if loc == "A" else "左")

belief = {"A": "?", "B": "?"}                   # ⭐ 唯一的差别：一点点记忆
def model_based(p):
    loc, st = p
    belief[loc] = st
    if st == "脏": return "吸"
    if belief["A"] == belief["B"] == "净": return "待机"
    return "右" if loc == "A" else "左"

print("反应式:", simulate(reactive))            # 8
print("模型式:", simulate(model_based))         # 13

⭐ 8 比 13。 两个 agent 的规则几乎一模一样，差别只有一件事：模型式那个记得住「两格我都扫过了」， 于是第 4 步之后原地待机；反应式那个不知道自己扫完了，只能继续来回跑， 后面 5 步每步白扣 1 分电费，正好是 13 − 8 = 5。

⚠️ 两个死穴

1. 看不见的状态：两个不同的世界状态给出同一个感知，却需要不同的动作。 Wumpus 里：你闻到微风，该往哪退取决于你从哪来 —— ⭐ 而反应式 agent 不知道自己从哪来。
2. 死循环：同样的感知永远给同样的动作 ⇒ 在迷宫里会一直撞同一堵墙。 加随机能跳出循环，但不能让你「记住这里试过了」。

💀 自然界里也有这个 bug。 掘土蜂把猎物拖到洞口，先自己进洞检查一遍再拖进去。 如果你趁它检查时把猎物往外挪几厘米，它出来会把猎物拖回洞口，然后重新进洞检查 —— 观察者记录过重复几十次仍不改的情形。 ⚠️ 一整套看起来很有计划的行为，其实是一条被感知触发的反射链。

🗺️ 三、模型式 agent：能看过去了

只加一样东西：一份内部世界模型，每次感知之后更新它。要维护它需要两块知识 —— 世界自己会怎么变，和我的动作会怎么改变世界。

上面那个 model_based 就是最小版本：一个 belief 字典，加上「每次感知都写进去、不是用完就扔」。

⭐ 把同样的做法放大到 Wumpus，belief 就变成一张 4×4 的地图，每格记着「站过没 / 有没有坑 / 有没有怪」。 上一章那条三步推理（坑在 (3,1)、怪在 (1,3)、(2,2) 安全）只有这种 agent 能做 —— 它要求你站在 (1,2) 时还记得 (1,1) 和 (2,1) 闻到过什么。 ⭐⭐ 而推出来的这两格，agent 一次都没去过。

⚠️ 死穴：有地图，不等于会用地图

它能看过去，不能看未来。 这个 agent 知道 (2,2) 安全、也知道金子在哪， 但没有任何机制让它算出「先去 (2,2)，再去 (3,2)，再去 (3,3)」这条路 —— 规则只能写「安全就往前走」这种局部的东西。

需要这三类事情时它就不够用了：往前搜好几步（象棋、魔方）、很多步才能完成的复杂任务（做一顿饭、装一块表）、 靠逻辑推理拆解目标（「我要去纽约」）。

🔭 四、规划式 agent：在脑子里先做一遍

只加一件事，但这件事改变了一切：⭐ 在内部模型上模拟「如果我做动作 a，世界会变成什么样」，反复展开， 直到找到一条能达成目标的动作序列。

⭐⭐ 规划的本质是一次交换：把「真的做一遍」的代价，换成「在脑子里做一遍」的代价。 现实里踩进坑要付出 −1000，在脑子里踩进坑只花几微秒。这就是搜索。

想规划，必须先有三样东西：① 世界模型（上一章「已知」那一维）② 明确的目标 ③ 后继函数（做了 a 之后状态变成什么）。 ⭐ 把这三样形式化，就是状态空间图，规划就变成了图搜索 —— 这正是第 5 章的全部内容。

⚠️ 它的死穴是分支爆炸。 国际象棋每一步大约有 35 种走法，往前看 4 步就是 $35^4 \approx 150$ 万个局面，看 6 步是 18 亿。 所以第 5–13 章几乎全在讲同一件事：怎么少看一些，还能保证答案不变差。

⚠️ 「假装在规划」怎么识破

本章第二节那三行 if-else，在某些局面下的行为和一个真规划器一模一样。它不是在规划，只是恰好撞对了。

⭐ 判据：换一个目标，看它要不要重写规则。 真规划器只需要换目标函数，搜索代码一行不动；反应式 agent 得把整套规则重写一遍。 ⚠️ 「看起来聪明」从来不是证据，可迁移性才是。

⭐ 顺带说清博弈 agent：讲义把它单列，本章当作规划式在多 agent 环境下的特例，因为差别只有一条 —— 推演未来时有些层不是你说了算：你在自己的层选最大、对手的层选最小，这就是极小化极大（第 10、11 章）。 框架完全没变，变的只是「谁来挑这一层的分支」。

📈 五、学习式 agent：让上面三种自己变好

结构上四块：性能元件（上面任意一种 agent）、评论元件（反馈）、学习元件（据此改性能元件）、问题生成器（主动试新东西）。

⭐ 最重要的一句：学习不是一个独立的模块，是一组「改进已有模块」的技术。 你可以让反应式 agent 去学它的规则，也可以让规划式 agent 去学它的启发式函数 —— 它横切在前三种上面，不是排在它们后面。

⭐ 还有一句：学习的复杂度和使用的复杂度是两回事。 模拟曲棍球选手的策略用演化计算算了好几天， 但一旦算完就能实时运行 —— 大模型是同一个结构：训练几个月，推理几十毫秒。

⛔ 学习本身本板块不重写：《机器学习与深度学习基础》讲从数据里学， 《强化学习基础》讲从「试出来的反馈」里学。

🤖 六、这里的 Agent 和 LLM Agent 不是一回事

⭐⭐ 这一节是全章最容易混、也最值钱的一节。 两边都叫 Agent，但分类的依据根本不同：

⭐⭐ 但联系比差别更有用

LLM Agent 其实就是「模型式 + 规划式」的一个现代实现，只是把决策那一格换成了 LLM：

这个对照立刻能解释三件事：

1. ⚠️ 上下文一满，LLM Agent 就退化成反应式 agent —— 它看不见几步之前发生过什么了。 这正是《智能体工程教程》04b · Agent 记忆存在的理由：给它补一个外置的世界模型。
2. ⭐ 上一章「P 最难写，因为它定义了赢」对 LLM Agent 一字不改地成立 —— 写不清性能度量的 Agent 项目一样会跑偏。
3. ⭐⭐ 06 章的判据「你能提前画出这个任务的流程图吗」和本章第四节的 「换个目标看它要不要重写规则」问的是同一件事：路径是提前定死的，还是现场算出来的。

⚠️ 最后一条别混：那边的「多 Agent 协作」是几个目标一致的 LLM 在分工，难点是工程编排； 本板块说的「多 agent 环境」指的是目标冲突的对手，难点是理论（对方会针对你调整）。同一个词，两件事。

🔗 这一章连到哪里

✅ 检查点

1. agent 作为函数，定义域为什么是「感知序列」而不是「单个感知」？这个区别对应哪两种架构的分界？
2. 反应式 agent 的两个死穴分别是什么？加随机数能解决哪一个、不能解决哪一个？
3. 吸尘器那个实验里两个 agent 分别得几分？差值是怎么来的？两者的规则差别只有什么？
4. 模型式 agent 比反应式多了什么？维护世界模型需要哪两块知识？
5. 模型式 agent 的死穴是什么？举出三类它做不了的任务。
6. 规划的本质是哪一次「交换」？必须先有哪三样东西？分支爆炸有多严重（给数字）？
7. 怎么识破一个「假装在规划」的系统？博弈 agent 和规划式 agent 的差别只有哪一条？
8. 本板块的 Agent 和 LLM Agent 的分类依据各是什么？ReAct 循环对应本章的哪个结构？为什么说上下文满了 LLM Agent 就退化成反应式？

🛑 可以停在这里

⚡ 走神救援

⭐⭐ 这一章是一条链，不是四个并列选项：每一种的死穴就是下一种的理由。 起点是把 agent 写成函数 $f: P^* \to A$ —— ⭐ 定义域是感知序列不是单个感知，这个星号就是反应式和其余三种的全部分界。① 反应式：看当前感知、查一条规则、执行，没有内部状态，⭐ 看起来在判断其实只是查表。🔨 两格吸尘器实验（每步每个净格 +1、每次移动 −1）：反应式 8 分，模型式 13 分，差的 5 分正是反应式后面 5 步来回空跑的电费 —— ⭐ 两者规则几乎一样，唯一差别是模型式记得住「两格我都扫过了」。⚠️ 两个死穴：看不见的状态（同一个感知对应两种局面却要求不同动作 —— 闻到微风该往哪退取决于你从哪来，而它不知道自己从哪来）和死循环；加随机能跳出死循环，但不能让你记住这里试过了。💀 掘土蜂：把猎物挪几厘米它就拖回洞口重新检查，重复几十次 —— 一整套看着很有计划的行为其实是反射链。② 模型式：加一份内部世界模型，维护它需要两块知识（世界自己会怎么变、我的动作会怎么改变世界）。上一章那条三步 Wumpus 推理（坑在 (3,1)、怪在 (1,3)、(2,2) 安全）只有它能做，⭐ 而推出来的这两格 agent 一次都没去过。⚠️ 死穴是只能看过去不能看未来 —— 有地图不等于会用地图：它知道 (2,2) 安全、知道金子在哪，却算不出那条路。③ 规划式：在模型上模拟未来。⭐⭐ 本质是一次交换 —— 把「真的做一遍」换成「在脑子里做一遍」，这就是搜索。要三样：世界模型、目标、后继函数，形式化成状态空间图就是第 5 章。⚠️ 死穴是分支爆炸：象棋每步约 35 种走法，看 4 步 $35^4\approx$ 150 万局面，看 6 步 18 亿。⭐ 识破「假装在规划」的判据：换个目标看它要不要重写规则 —— 真规划器只换目标函数，反应式得全重写。博弈 agent 只是它在多 agent 下的特例，差别只有 ⭐ 推演时有些层不是你说了算（你选最大、对手选最小 = 极小化极大）。④ 学习式：⭐ 学习不是独立模块，是一组改进已有模块的技术，横切在前三种上面。⭐⭐ 最值钱的是最后一节：本板块的 Agent 和《智能体工程教程》的 LLM Agent 分类依据不同 —— 这边按内部结构（有没有状态、会不会推演未来），那边按谁决定路径（代码写死 = 工作流 / 模型现场决定 = Agent）；这边有保证（A* 在可容许启发式下保证最优），那边没有。但联系比差别有用：LLM Agent 就是「模型式 + 规划式」的现代实现 —— ReAct 的 Thought → Action → Observation 一一对应感知 → 决策 → 行动，上下文窗口 = 内部世界模型，工具调用/返回 = 执行器/传感器。⚠️ 由此立刻推出：上下文一满，LLM Agent 就退化成反应式 agent，这正是那边 04b 章「补一个外置世界模型」的理由；而 06 章的判据「你能提前画出流程图吗」和本章的「换个目标看要不要重写规则」是同一个问题的两面。⚠️ 别混：那边的「多 Agent 协作」是目标一致的 LLM 分工，这边的「多 agent 环境」是目标冲突的对手。

下一节 👉 05-状态空间与搜索框架.md