这是大模型课程系列的第 21 课。
前 20 课我们把一个模型「训练好、调好、发出去、评明白」了------但它始终只会做一件事:接到一段输入,吐出一段输出。这一课换一个问题:一次问答怎么变成循环?一个能自己跑起来的循环必须有哪些零件?为什么「多轮对话」不等于 Agent?为什么每步 95% 正确、十步之后却只有约六成能全对?
给模型工具、让它边做边看、把外部结果拼回上下文------这一篇用 6 个问题把「从 Prompt 到 Agent」的结构差、四件套、错误累积的数学、ReAct 的「边想边做」算清楚,最后回答一个最容易被忽略的问题:什么时候根本不该用 Agent。内容来自课程的第 21 课。
- 在线阅读(免登录、手机可看):https://zhuangzhaoyeye.github.io/llm-course/
- 国内镜像:https://learn.taleverse.cn/
- 源码(MIT 许可):https://github.com/zhuangzhaoyeye/llm_course
问题 1:一次问答和「完成一个任务」,到底差在哪?
因为一次问答是「封闭」的:模型只看当前这段输入,答完就结束,世界没有任何变化。它本质上是一次函数调用------一次输入、一次输出、无状态、无副作用。而一个任务(「帮我把这批客诉工单按严重度分好并回复」)往往要经过好几步,每步都要看上一步的结果才能决定下一步。就像「点一次外卖」和「做一桌菜」:前者一个动作,后者要买菜、下锅、尝味、补救,中间任何一步都要根据现场情况调整。
工程上「Agent」这个词有明确定义。Anthropic 的《Building Effective Agents》(Schluntz & Zhang,2024-12-19)把「模型 + 工具」系统分成两类:workflow (由代码预先编排好每一步)与 Agent(由模型自己决定下一步、并依据环境反馈行动)。这一节先把「完成任务」为什么天然逼出一个循环算清楚。
第一笔账,一次问答与一个 10 步任务:
| 项 | 一次问答 |
|---|---|
| 模型调用次数 | 1 |
| 送入的输入 | 问题本身 ≈ 200 token |
| 总输入量 | 200 token |
循环每走一步,都要把「到目前为止的全部历史」重新送进模型(第 k 步的输入正比于 k):
| 步 k | 该步送进模型的输入 | 累计 |
|---|---|---|
| 第 1 步 | 200 | 200 |
| 第 2 步 | 200 × 2 = 400 | 600 |
| ... | ... | ... |
| 第 10 步 | 200 × 10 = 2,000 | 11,000 |
算术:10 步的总输入 = 200 × (1+2+...+10) = 200 × 55 = 11,000 token ,是单次问答的 55 倍 。增长不是线性的:总输入 ∝ N(N+1)/2,是步数的平方。
步数再翻一倍:
| 步数 N | 总输入(200 token/步) | 相对单次问答 |
|---|---|---|
| 10 | 200 × 55 = 11,000 | 55× |
| 20 | 200 × 210 = 42,000 | 210× |
算术:步数从 10 翻到 20(×2),总输入从 11,000 涨到 42,000(≈ ×3.8),因为 1+...+20 = 210 ≈ 55 × 3.8。若命中 prompt caching,重发的前缀单价会下降,但计费的 token 计数不变。
还有一条更早的做法值得对照:把要求一次全写进一段提示、让模型一口气输出完整结果。但一次调用没有任何中间反馈------10 个字段里有一个填错,整段就得重来;设单字段正确率 0.95,一次全对只有 0.95¹⁰ ≈ 0.599。循环把「一次全对」拆成「每步可检查」,错的那一步可以单独重来。
一句话结论:一次问答是函数调用,一次任务是一个循环;结构差带来状态、外部动作,以及随步数平方增长的成本。
问题 2:一个能自己跑起来的循环,少了哪一样都会转不动?
因为循环要能持续运转,四件事缺一不可:谁决定下一步(模型)、谁能真的改变世界(工具)、上一轮发生了什么放在哪里(状态,即 context 里的历史与观察)、以及什么时候该停(终止条件)。好比一台自动售货机:选货、出货、找零、复位,少任何一环都会卡住------尤其「复位」(终止)最容易被忽视。
| 件 | 作用 | 缺了会怎样 |
|---|---|---|
| 模型 | 决定下一步做什么 | 循环没有大脑 |
| 工具 | 真正改变世界 | 只能空想、答不出事实 |
| 状态 | 记住已经做过什么 | 每步从零开始、反复做同一件事 |
| 终止条件 | 决定何时停 | 可能永远停不下来 |
第一笔账,只写语义终止条件、不设步数上限:假设每一步「判断任务已完成并停下」的概率只有 1%(人为设定的下限示例,并假设每步停下概率恒定),那么循环期望要走的步数 E ≈ 1 ÷ p = 1 ÷ 0.01 = 100 步。没有上限,就等于把成本交给了运气。
| 项 | 无上限 | 加「最多 20 步」 |
|---|---|---|
| 步数 | 期望 100 步 | ≤ 20 步 |
| 总输入(200 token/步、重发历史,同问题 1 口径) | 200×(1+...+100) ≈ 1,010,000 | 200×(1+...+20) = 42,000 |
算术:沿用问题 1 的口径,N 步总输入 = 200×N(N+1)/2。把「期望 100 步」直接代入求和(作量级示意),无上限时约 1,010,000 token ;若严格按几何分布算期望 EN(N+1)/2,无上限时的期望总输入会更大(约 2,000,000 token 量级),所以 1,010,000 是偏保守的下界示意。加「最多 20 步」硬上限后最坏 42,000 token(约 1/24)。
四件套齐了,循环才闭合:
| 回合 | 模型 | 工具 | 状态 | 终止 |
|---|---|---|---|---|
| 1 | 决定「查库存」 | 调用查询接口 | 写下查询结果 | 未完成,继续 |
| 2 | 决定「下单」 | 调用下单接口 | 写下订单号 | 未完成,继续 |
| 3 | 判断目标达成 | 不再调用 | 收尾 | 满足终止,结束 |
一句话结论:一个闭合循环 = 决策 → 动作 → 观察 → 判断;终止条件要两条------任务完成的语义判据 + 一个兜底的步数/时间上限,只写前者等于没有刹车。
问题 3:多轮对话也是「模型一轮轮往下接」,它和 Agent 的分界线到底在哪?
因为多轮对话的每一轮都只是「追加一段文字」,它没有动作、也没有观察------你问十句,世界一句都没变。就像打电话咨询(只动嘴,账户没变)和真的去柜台办业务(会改变账户状态)的区别。工程上的分界线很清楚:Agent 的每一轮里,模型可以调用工具去改变外部状态,并把外部返回的观察重新放进上下文;多轮对话只是把用户与助手的话不断追加进上下文,世界没有任何变化。
用「工具调用次数」当判据:
| 任务 | 工具调用次数 | 世界状态改变次数 | 是多轮对话还是 Agent |
|---|---|---|---|
| 咨询「退票规则是什么」 | 0 | 0 | 多轮对话 |
| 「帮我把这张票退掉」 | 3(查询/下单/确认) | 2 | Agent |
第二笔账,轨迹一长,状态就装不进上下文:
| 项 | 数值 |
|---|---|
| 步数 | 10 |
| 每步轨迹(推理 + 观察,示意) | ≈ 2,000 token |
| 轨迹总长 | 10 × 2,000 = 20,000 token |
| 以 8K 小窗口模型为例 | 8,000 token |
算术:10 步就累积 20,000 token 的轨迹,在 8K 小窗口模型上早已放不下(注意:现代模型窗口已到 200K--1M+,这里只以小窗口模型为例说明「轨迹会超过窗口」)。所以 Agent 的状态必须能「外置」------写进文件、数据库,或做摘要压缩。
| 做法 | 状态载体 | 能撑多长 | 风险 |
|---|---|---|---|
| 多轮对话 | 仅上下文 | 受上下文上限约束 | 超长即丢历史 |
| Agent | 上下文 + 外部存储 | 理论上可长跑 | 要自己管读写与一致性 |
一句话结论:区分多轮对话与 Agent,不看轮数、只看两件事------这一轮有没有工具调用(动作),有没有外部观察回来(反馈);有了这两样,就要承担状态外置与一致性管理的工程成本。
问题 4:如果每一步都有 95% 是对的,为什么一个 10 步的任务经常做不完?
因为任务要求的是「每一步都对」,而这是把每步的正确率连乘起来------步数越多,乘积掉得越快。就像多米诺骨牌:每一块倒错的概率只有 5%,但十块之后整体还站着的概率只剩六成。这就是各家工程指南反复警告的 error compounding(错误累积)。前面的错误还会写进上下文(context,即模型每一步能看到的全部文本),被后面每一步当作「既成事实」继承。下面的连乘默认各步相互独立;若错误彼此相关(Agent 的步间错误常同源),实际全对率会更极端。
| 步数 N | 全对概率 = 0.95^N | 直观 |
|---|---|---|
| 1 | 0.95 | 95% |
| 10 | 0.599 | 约 60% |
| 20 | 0.359 | 约 36% |
| 50 | 0.077 | 约 7.7% |
算术:0.95¹⁰ ≈ 0.599 ------十步全对只有 60% ;到 20 步掉到 36% ;50 步只剩 7.7%。单步看起来很稳,整体却像在赌。
单步再提高一点,长任务也能救回来:
| 单步正确率 | 10 步全对 | 20 步全对 |
|---|---|---|
| 0.95 | 0.599 | 0.359 |
| 0.99 | 0.904 | 0.818 |
算术:把单步从 0.95 提到 0.99 ,10 步全对从 0.599 升到 0.904------从「六成」变成「九成」。提升单步可靠性的收益,在长任务上被步数放大,这也是工程上宁可少几步、也不要多几步的原因。
错误一旦写进上下文,就被后续继承:
| 情形 | 第 3 步出错 | 之后每一步 |
|---|---|---|
| 无纠错 | 把错误结论写进上下文 | 都在错误前提上继续 → 全盘偏 |
| 有外部校验 | 外部结果与预期不符 | 立刻在这一步停下重来 |
一句话结论:多步任务的成功率不是「平均一下」,而是连乘;0.95¹⁰ ≈ 60%、0.95²⁰ ≈ 36%,所以设计 Agent 的第一原则是减少步数,第二原则是让每一步都有能被外部验证的机会。
问题 5:既然错误会一步步累积,有没有一种「边做边纠」的做法?
因为纯推理(思维链,CoT,让模型先写推理再给答案)是「闭着眼睛想完全程」,中间没有东西能反驳它:第 3 步想错,第 4 步仍会当成事实继续推,错误一路带到结尾。ReAct(Yao 等,arXiv:2210.03629,ICLR 2023)提出让模型交错地产生「推理轨迹(Thought)」与「动作(Act)」,再把外部返回的「观察(Observation)」拼回上下文------每步用外部观察对一次账,等于把判定对错的时机从「结尾一次」提前到「每一步一次」。就像开车时不断看路况微调方向,而不是蒙着眼一路踩到底。
把「每一步都看一眼」折算成单步正确率的提升:
| 做法 | 等效单步正确率(示意) | 10 步全对 |
|---|---|---|
| 纯推理(CoT,无外部校验) | 0.95 | 0.599 |
| ReAct(每步有外部观察纠错) | 0.99 | 0.904 |
算术:外部观察的作用,可以近似看成把等效单步正确率从 0.95 抬到 0.99 (0.99 是纯演示参数------既非实测也非论文读数,只为演示「每步对一次账」对连乘的影响),于是 10 步全对从 0.599 升到 0.904。这不是让模型更聪明,而是让错误在写进上下文之前就被外部结果否掉(每一步的轨迹都要作为 token 重新送进模型,这也是它的成本所在)。
论文里的实际增益:
| 基准 | 相对最强基线(模仿/强化学习)的绝对成功率提升 |
|---|---|
| ALFWorld(交互决策) | +34% |
| WebShop(交互决策) | +10% |
| 上下文示例数 | 1--2 个 |
一个 ReAct 回合长这样:
| 阶段 | 模型输出 | 作用 |
|---|---|---|
| Thought | 「我需要先查库存」 | 推理、给下一步定方向 |
| Act | 调用查询工具 | 改变世界 / 取外部信息 |
| Observation | 「库存 3 件」 | 真实反馈,拼回上下文 |
一句话结论:ReAct 的价值不在于让模型多写几句推理,而在于把外部观察插进循环------每个回合都拿真实反馈对一次账,错误在写进上下文之前就被拦住;没有能给出可靠观察的工具,ReAct 就退化成了又一个 CoT。
问题 6:什么时候该用 Agent,什么时候是「多此一举」?
因为 Agent 换来的是灵活性(路径不用提前写死),付出的却是不可预测(步数不定、成本不定、成功率随步数下降)。Anthropic 的《Building Effective Agents》给出的核心建议只有一句:找尽可能简单的方案,只在确实需要时才增加复杂度。它把系统分成 workflow(代码预先编排好路径:提示链、路由、并行、编排-工作者、评估-优化)与 Agent(模型自己决定路径),并明确提醒:agentic 系统用延迟和成本换任务表现,这个交换只在任务确实需要时才划算。
用一次调用能解决时,开循环有多亏(token 与延迟为示意值):
| 方案 | 输入量 | 相对成本 | 延迟 |
|---|---|---|---|
| 单次调用 | 200 token | 1× | ≈ 1 秒 |
| 10 步 Agent | 11,000 token | 55× | ≥ 10 秒 |
算术:同一件事若一次调用就能做好,改成 10 步循环,输入量变成 55 倍 、延迟从约 1 秒升到 10 秒以上,还要额外承担错误累积(0.95¹⁰ ≈ 0.6)。这不是优化,是自找麻烦。
一张决策表定「用哪一档」:
| 问题 | 若「是」 | 选它 |
|---|---|---|
| 一次调用 + 好示例能解决吗? | 是 | 就一次调用 |
| 步骤能提前写死吗? | 是 | workflow(固定流程) |
| 步骤写不死,但每步可验证吗? | 是 | Agent(循环 + 工具) |
| 连验证都无法做吗? | 是 | 先别上 Agent,补上可验证的反馈 |
六张卡片串成一条决策线:
| 卡片 | 结论一句话 |
|---|---|
| 21-1 | 任务 = 循环,成本随步数平方增长 |
| 21-2 | 四件套:模型 / 工具 / 状态 / 终止条件 |
| 21-3 | 有「动作 + 观察」才是 Agent |
| 21-4 | 成功率 = p^N,会随步数衰减 |
| 21-5 | ReAct:把外部观察插进循环、拦住错误 |
| 21-6 | 能简单就别复杂,Agent 是最后的选择 |
一句话结论:先问「一次调用能不能解决」,再问「步骤能不能提前写死」;能就 workflow,写不死但每步可验证才上 Agent------真正适合 Agent 的只有「步骤无法预定义、但每一步都能拿到可信反馈」这一档。
小结
| 问题 | 结论 | 一个数字 |
|---|---|---|
| 问答与任务差在哪 | 函数调用 vs 循环 | 10 步总输入 11,000,是 55 倍 |
| 循环缺哪一件都不行 | 模型/工具/状态/终止条件 | 期望 100 步 → 1,010,000 token;加 20 步上限 42,000 |
| 多轮对话与 Agent 的分界 | 有没有动作 + 观察 | 退票 3 次调用、2 次状态改变 |
| 单步 95% 为何十步失败 | 成功率连乘 p^N | 0.95¹⁰ ≈ 0.599 |
| 怎么边做边纠 | 外部观察插进循环 | 等效 0.99 时 10 步 0.904 |
| 何时不该用 Agent | 从简到繁四问 | 10 步循环 55× 成本 |
参考与说明
- Building Effective Agents:Schluntz & Zhang,Anthropic,2024-12-19,https://www.anthropic.com/engineering/building-effective-agents
- ReAct:Yao et al., arXiv:2210.03629,https://arxiv.org/abs/2210.03629 (ICLR 2023)
- 文中算术我都用代码独立复算过:
0.95^10=0.5987、0.95^20=0.3585、0.95^50=0.0769、0.99^10=0.9044、0.99^20=0.8179、200×55=11000、200×210=42000、200×5050=1010000、42000/11000=3.82、1/0.01=100、10×2000=20000。 - 口径提醒:每步 200 token、每步轨迹 2,000 token、100 步、20 步上限、1 秒/10 秒延迟都是示意值 ;0.95 单步正确率与 0.99 的 ReAct 等效值是演示参数,不是实测或论文读数;ReAct 的 +34% / +10% 与 1--2 个示例是论文读数。
- 说明:这套课程由 AI 在我设计的规则下生成,再经过脚本检查和独立盲审;审查发现过不少问题,已写在仓库 README 里。发现错误欢迎提 Issue,写清位置,我逐条核实。
继续学
这一篇是第 21 课。到这里,Agent 的骨架就讲完了:任务天然是多步的、循环必须四件套齐全、多轮对话因缺少「动作 + 观察」而不算 Agent、错误会沿步数连乘、ReAct 用外部观察把错误拦在原地、而 Agent 本身是一个有明确代价的工程选择。下一篇进入第 22 课「工具调用」:模型只会输出文本,它到底怎么「调用」一个函数,schema、重试、工具选择与结果回填又该怎么算。
- 课程:https://zhuangzhaoyeye.github.io/llm-course/
- 国内镜像:https://learn.taleverse.cn/
- 源码:https://github.com/zhuangzhaoyeye/llm_course ,觉得有帮助欢迎点个 Star
上一篇 :第 20 课「提示工程」
下一篇 :第 22 课「工具调用」