在老城区有一家“笑面居”饭馆，主厨老张带徒弟的规矩很特别：新徒弟必须从一道“红烧狮子头”学起。老张说，这道菜的精髓不在于菜谱背得多熟，而在于“尝”这个动作——下锅前要尝、起锅前要尝，觉得咸了加些糖，觉得柴了改小火；尝一口发现不对，就得停下来想清楚是盐放多了还是火候大了，再决定加水稀释还是换一道配菜。“做菜不是闷头一条路走到黑，而是要像一个老练的导航员：走岔了路就停下来，重新看地图，换一条走得通的路。”这句话，说的其实是今天 AI 智能体的一项核心能力——反思式重规划。 Agentic AI 在执行复杂任务时，就像新手徒弟第一次掌勺：它会调用工具、访问网页、写代码、发消息，但任何一步都可能出错——信息过时、接口报错、理解跑偏。反思式重规划就是给智能体装上“尝一口”的本能：做完一步先对照目标自我检查，发现偏差就停下来，诊断问题出在哪，然后重写一份行动计划，绕开刚才的坑继续走。它还给自己立了三条规矩：不许在同一块石头上绊倒三次（死循环预防）、不是每个锅都要反复掀开看（重规划平衡）、每次翻车都要记进菜谱（经验沉淀）。

岗位关联

理解反思式重规划的触发条件、重规划策略与防死循环设计，是构建能自我修复、鲁棒可用的 AI Agent 的必修课，也是让你的智能体从“能跑通”走向“能扛事”的关键一步。

目录
  1. 可视化演示
  2. 反思触发机制：该尝的时候尝
  3. 重规划策略：对症下药换方案
  4. 死循环预防：别在同一个坑里打转
  5. 自我纠错机制：把翻车记进菜谱
  6. 重规划平衡：每一口都值得
  7. 纠错能力评估：用数据说话
  8. AI 应用场景
  9. Python 演示
  10. 常见误区
  11. 面试题

可视化演示

展示AI智能体将高层目标分解为子目标和可执行任务的层次化树结构，实现自主规划与任务编排。

本节配有交互动效（进入视口后自动加载，约 3KB）。

GOAL分解树 根目标：用户输入的高层任务目标 子目标：分解为可规划的中间步骤 叶子任务：可直接执行原子操作 Goal → Sub-goals → Tasks 层次化分解实现复杂目标自主规划

反思触发机制：该尝的时候尝

老张教徒弟的第一课是“什么时候尝”——不是每十秒掀一次锅盖，而是在盐刚下锅后、汤汁收干前、以及闻到焦味的瞬间。徒弟问为什么，老张说：“尝早了看不出变化，尝晚了救不回来。”AI Agent 的反思也一样要挑时机：完成一个子任务后、调用工具前后、以及环境中出现异常信号时，都是“该尝一口”的时刻。

技术上的触发方式有四种，正好对应大厨的几类直觉：结果偏差检测——做出来的味道和菜谱预期差太多；关键节点检查——汤汁收干前必须看火候，对应任务里程碑处的强制复盘；外部反馈触发——顾客喊咸了，对应环境、用户或下游系统的报错信号；定时巡查机制——每隔几分钟看一眼火，防止久不关注糊锅。四种方式组合使用，让 Agent 既不会漏过重大失误，也不会被微小波动牵着鼻子走。

要判断“差距有多大”，我们把当前状态和目标状态都表示成向量，算一个偏差值：

就像老张说的“该尝的时候尝，不是每道菜都要尝一百遍”，Agent 把有限的注意力花在刀刃上，偏差检查才能真正成为效率的守护者，而不是新的负担。

δt=∥st−g∥2,若  δt>τ  ⇒  触发反思\displaystyle \delta_t = \left\| s_t - g \right\|_2, \qquad \text{若} \; \delta_t > \tau \; \Rightarrow \; \text{触发反思}
  1. 当前状态 $s_t$智能体在时刻 $t$ 对“当前局面”的量化描述，比如做菜时的咸度、甜度、火候三个数。
    st=[s1,s2,…,sn]\displaystyle s_t = [s_1, s_2, \dots, s_n]
  2. 目标状态 $g$理想结果对应的向量，相当于菜谱上写着的标准口味。
    g=[g1,g2,…,gn]\displaystyle g = [g_1, g_2, \dots, g_n]
  3. 欧氏距离 $\lVert s_t - g \rVert_2$把多维差距压缩成一个标量偏差，越大说明离目标越远。
    ∥st−g∥2=∑i=1n(st,i−gi)2\displaystyle \lVert s_t - g \rVert_2 = \sqrt{\sum_{i=1}^{n} (s_{t,i} - g_i)^2}
  4. 阈值 $\tau$允许的偏差红线，超过它才启动反思，避免为鸡毛蒜皮频繁折腾。
    τ∈(0,+∞)\displaystyle \tau \in (0, +\infty)
  5. 判定条件偏差大于阈值时启动反思闭环，相当于大厨放下锅铲仔细尝一口。
    δt>τ⇒reflect\displaystyle \delta_t > \tau \Rightarrow \text{reflect}

重规划策略：对症下药换方案

徒弟第一次把盐当糖放了，急得要把整锅倒掉。老张按住他的手：“先看清楚错在哪一步。只是咸了，就加土豆块吸盐；狮子头散了，是火太大，改小火慢炖。”重规划从来不是推倒重来，而是对“病根”开药方。

重规划策略有四个层级，从轻到重依次展开：局部路径修正——只调整接下来的几步，比如换一个 API 参数；工具调用替换——当前工具失效就换一个工具，像炒锅粘底了换不粘锅；全局任务重组——任务结构本身出了问题，需要重排步骤顺序；目标分解调整——目标定得不合理，拆细或改序。越轻的修改成本越低，所以 Agent 会优先尝试局部修正，只有局部手段救不了时才升级到全局重组。

那么如何从一堆备选方案里挑出最划算的那个？核心是比较“预期收益”与“成本”：

会做菜的人不浪费食材，好 Agent 也懂得先小修、再大改、实在不行才换工具、最后才拆目标——步步为营，把重规划的力气用在最划算的地方。

p∗=arg⁡max⁡p∈P[P^succ(p)×V−C(p)]\displaystyle p^* = \arg\max_{p \in \mathcal{P}} \left[ \hat{P}_{\text{succ}}(p) \times V - C(p) \right]
  1. 候选方案集合 $p \in \mathcal{P}$所有可行的备选修正计划，如加水、加土豆、换锅。
    P={p1,p2,…,pm}\displaystyle \mathcal{P} = \{ p_1, p_2, \dots, p_m \}
  2. 成功率估计 $\hat{P}_{\text{succ}}(p)$根据历史经验推算方案 $p$ 成功的概率。
    P^succ(p)∈[0,1]\displaystyle \hat{P}_{\text{succ}}(p) \in [0, 1]
  3. 任务价值 $V$任务最终成功带来的统一收益，让不同方案可以放在同一把秤上比较。
    V>0\displaystyle V > 0
  4. 方案成本 $C(p)$执行该方案要花的时间、算力或金钱。
    C(p)≥0\displaystyle C(p) \geq 0
  5. 期望效用取最大选“预期收益减去成本”最大的那个，即性价比之王。
    p∗=arg⁡max⁡p [P^succ(p)×V−C(p)]\displaystyle p^* = \underset{p}{\arg\max} \, \left[ \hat{P}_{\text{succ}}(p) \times V - C(p) \right]

死循环预防：别在同一个坑里打转

有一天徒弟“魔怔”了：尝一口太咸，加水；再尝，太淡，加盐；又尝，又咸——如此往复，锅都烧穿了。老张一把夺过勺子：“同一个错误重复一百次，那不叫努力，叫死循环。”

AI Agent 同样会陷入“重试→失败→再重试”的怪圈：调用同一个失败的工具、生成同一段报错的代码、访问同一个超时的接口。预防有三板斧：最大重试上限——同一子任务连续失败超过 $N_{\max}$ 次就强制止损；策略多样性约束——新动作不得与最近几步重复，从源头掐断原地打转；经验去重记忆——把已经尝试过且失败的方案记下来，下次直接跳过。最后还有 状态成本控制：当累计消耗超过任务残值，果断放弃或上报人工。

这三板斧可以用两个不等式概括：

老张的规矩后来成了店规：“同一个方法，失败三次就翻菜单。”Agent 有了上限和多样性约束，才能真正分清“坚持”与“固执”的边界。

k≤Nmax⁡,at∉{at−1,at−2,…,at−w}\displaystyle k \leq N_{\max}, \qquad a_t \notin \{ a_{t-1}, a_{t-2}, \dots, a_{t-w} \}
  1. 重试次数 $k$对同一子目标连续失败的累计计数，每失败一次加一。
    k=k+1\displaystyle k = k + 1
  2. 上限 $N_{\max}$允许的最大重试次数，超过后强制切换策略或上报。
    Nmax⁡=3\displaystyle N_{\max} = 3
  3. 最近动作窗口最近 $w$ 步执行过的动作集合，记录“已经试过什么”。
    Aw={at−1,at−2,…,at−w}\displaystyle A_w = \{ a_{t-1}, a_{t-2}, \dots, a_{t-w} \}
  4. 动作不重复约束下一步动作不得与窗口内的任何动作重复。
    at∉Aw,k≤Nmax⁡\displaystyle a_t \notin A_w, \quad k \leq N_{\max}

自我纠错机制：把翻车记进菜谱

老张有一本泛黄的“翻车笔记”，每一页写着：日期、菜名、错误表现、原因分析、对策。徒弟惊讶地发现，师父每次翻车后都会回来补一笔，下次做菜之前先翻一翻。

自我纠错机制就是智能体版本的“翻车笔记”，由四步组成：错误分类识别——先分诊，是工具调用失败、信息缺失还是逻辑错误？修正方案生成——根据分诊结果对症下药，生成修正动作；执行反馈闭环——执行后再检查一次，确认偏差是否真的被消除；经验知识沉淀——把“错误—对策”写回记忆库，下次直接复用。这四步环环相扣，缺一环纠错就不完整。

分类与沉淀用数学表达就是：先按概率挑出最可能的错误类别，再把对策写进记忆库：

“翻车不可怕，可怕的是翻两次同样的车。”有了记忆和反馈闭环，Agent 越用越聪明，就像徒弟慢慢把笔记上的经验变成了肌肉记忆。

e∗=arg⁡max⁡e∈EP(e∣ctx,δt),K←K∪{(e∗,fix)}\displaystyle e^* = \arg\max_{e \in \mathcal{E}} P(e \mid \text{ctx}, \delta_t), \qquad \mathcal{K} \leftarrow \mathcal{K} \cup \{ (e^*, \text{fix}) \}
  1. 错误类别集合 $\mathcal{E}$所有可能的病根枚举，如“信息过时”“接口异常”“目标分解错误”。
    E={e1,e2,e3}\displaystyle \mathcal{E} = \{ e_1, e_2, e_3 \}
  2. 条件概率 $P(e \mid \text{ctx}, \delta_t)$在给定上下文和偏差值的情况下，判断每种错误的概率。
    P(e∣ctx,δt)∈[0,1]\displaystyle P(e \mid \text{ctx}, \delta_t) \in [0, 1]
  3. 最大后验分类 $e^*$挑出概率最高的错误类别作为诊断结论，避免头痛医脚。
    e∗=arg⁡max⁡e P(e∣ctx,δt)\displaystyle e^* = \underset{e}{\arg\max} \, P(e \mid \text{ctx}, \delta_t)
  4. 经验沉淀更新把“错误—对策”对写回记忆库 $\mathcal{K}$。
    K←K∪{(e∗,fix)}\displaystyle \mathcal{K} \leftarrow \mathcal{K} \cup \{ (e^*, \text{fix}) \}

重规划平衡：每一口都值得

徒弟又走向了另一个极端：每炒一道菜都要重新看一遍菜谱，连凉拌黄瓜都要先炖一锅高汤试试。老张叹气：“反思是让菜更好吃，不是让你把厨房掀了重装。”

重规划本身是有成本的：重新规划要消耗额外的推理时间、算力和上下文长度。因此 反思时机权衡 很重要——只在关键节点和显著偏差时反思，而不是每步都停下来；过度反思抑制——通过置信度门槛，只有当“现有方案八成不行”时才动手；成本收益分析——把重规划的代价和新方案带来的增益放在一起算账。老张的直觉“每次掀锅盖，锅里的气就散一分”，在工程上就是一条严格的公式：

老张还有句口头禅：“每次掀锅盖，锅里的气就散一分。”好的 Agent 也把反思当成稀缺资源：该出手时才出手，把反思的力气留给真正需要翻盘的时刻。

E[ΔU]=P^succ(p′)×V−Creplan−P^succ(p)×V>0\displaystyle \mathbb{E}[\Delta U] = \hat{P}_{\text{succ}}(p') \times V - C_{\text{replan}} - \hat{P}_{\text{succ}}(p) \times V > 0
  1. 当前方案 $p$正在执行的计划，对应“正在炖的这锅汤”。
    p∈P\displaystyle p \in \mathcal{P}
  2. 新方案 $p'$重规划后的备选计划，对应“换一个做法”。
    p′∈P,p′≠p\displaystyle p' \in \mathcal{P}, \quad p' \neq p
  3. 成功率估计两个方案各自的成功概率，分别记为 $\hat{P}_{\text{succ}}(p)$ 与 $\hat{P}_{\text{succ}}(p')$。
    P^succ(p′),  P^succ(p)∈[0,1]\displaystyle \hat{P}_{\text{succ}}(p'), \; \hat{P}_{\text{succ}}(p) \in [0, 1]
  4. 重规划成本 $C_{\text{replan}}$重新规划本身要花的推理时间与算力。
    Creplan>0\displaystyle C_{\text{replan}} > 0
  5. 净收益判断只有当换方案带来的期望增益大于零才值得重规划。
    P^succ(p′)×V−Creplan>P^succ(p)×V\displaystyle \hat{P}_{\text{succ}}(p') \times V - C_{\text{replan}} > \hat{P}_{\text{succ}}(p) \times V

纠错能力评估：用数据说话

月底考核，老张让徒弟做同一桌菜连做十次：一半盲做，不反思；一半按“尝—想—改”来做。结果反思组十次有九次达标，盲做组三次翻车；反思组的平均用时反而更短。数据一摆，徒弟彻底服了。

评估一个智能体的纠错能力，也是同样的思路。任务成功率——加了反思机制后，多少任务从“救不回来”变成“起死回生”；步数效率对比——成功率和平均步数是否双赢，还是靠蛮力堆出来的；鲁棒性测试——同一任务在不同噪声、不同干扰下是否依然稳定；泛化能力验证——换一个全新的任务场景，反思机制还能不能起作用。两个最核心的量化指标：

老张把考核成绩单贴在厨房墙上：“好的纠错机制，不是把复杂藏在流程里，而是让结果更稳、更快、更不容易翻车。”Agent 团队的验收清单，也是同一句话。

SR=NsuccessNtotal,η=Tbaseline−TreflectTbaseline\displaystyle SR = \frac{N_{\text{success}}}{N_{\text{total}}}, \qquad \eta = \frac{T_{\text{baseline}} - T_{\text{reflect}}}{T_{\text{baseline}}}
  1. 成功任务数 $N_{\text{success}}$测试集里被智能体顺利完成的任务数量。
    Nsuccess≤Ntotal\displaystyle N_{\text{success}} \leq N_{\text{total}}
  2. 总任务数 $N_{\text{total}}$测试集里的任务总规模。
    Ntotal>0\displaystyle N_{\text{total}} > 0
  3. 成功率 $SR$成功率越高，说明纠错机制越能把任务从失败边缘拉回来。
    SR=NsuccessNtotal\displaystyle SR = \frac{N_{\text{success}}}{N_{\text{total}}}
  4. 基线耗能 $T_{\text{baseline}}$不加反思机制时的平均执行步数或成本。
    Tbaseline>0\displaystyle T_{\text{baseline}} > 0
  5. 反思后耗能 $T_{\text{reflect}}$加入反思重规划后的平均执行步数或成本。
    Treflect≥0\displaystyle T_{\text{reflect}} \geq 0
  6. 效率增益 $\eta$正值说明反思让 Agent 更快更稳，负值则提醒反思过重、需要回调阈值。
    η=Tbaseline−TreflectTbaseline\displaystyle \eta = \frac{T_{\text{baseline}} - T_{\text{reflect}}}{T_{\text{baseline}}}

AI 应用场景

智能客服工单处理智能体

阶段：执行—偏差检查—反思—重规划

解决的问题：传统客服机器人按固定脚本走，答非所问后只会重复同一段话，用户满意度直线下降。引入反思式重规划后，客服 Agent 在用户反馈“不对”时先分类错误——是理解错了、信息缺了还是政策变了——再选择修正策略：追问澄清、检索最新知识库、或升级人工坐席，且限制重试两次后必须转人工，彻底告别“车轱辘话”。

具体案例：某电商客服助手处理“退货是否包运费”工单时，Agent 先按旧政策回复“需自理运费”，用户表示不满。Agent 立即触发偏差检查，反思发现政策库已更新，于是重规划为查询最新条款，回答“免运费”并补一句致歉。上线后工单一次解决率提升约 35%。

代码生成与自修复 Agent

阶段：执行—反馈—反思—重规划—经验沉淀

解决的问题：传统代码生成 Agent 交付的代码一跑就报错，报错后又生成一段与刚才几乎相同的代码，陷入无效重试。反思式 Agent 会把单测失败的报错信息分类——语法错误、API 误用还是逻辑缺陷——再据此重规划：换一个 API、改参数、把大函数拆小，最多重试三次，并把错误样例存进经验库，下次同类问题直接命中。

具体案例：某数据工程 Agent 自动编写 SQL 清洗脚本，遇到内存溢出（OOM）后反思发现是 JOIN 基数过大，重规划为分批聚合再合并，任务从“连续失败 3 次”变为“首次运行即通过”，执行时长反而降低 40%。

仓储机器人路径规划

阶段：实时执行—偏差监控—重规划—经验共享

解决的问题：传统 AGV 搬运机器人遇到路障时只会原地重试，甚至反复撞击同一障碍物。反思式 Agent 实时检测自身坐标与规划路径的偏差，超阈值就停下来判断障碍类型——临时堆放还是永久封路——然后选择局部绕行或全局换线，重试上限两次，并把障碍位置写回车队共享地图。

具体案例：某智能仓库的搬运机器人发现主通道被托盘堵住，反思后放弃原地等待，重规划走相邻货架通道，同时在地图上标记黑名单，后续车队全部自动避让，整体搬运效率提升约 28%。

Python 演示

python49 行
import random  def run_reflective_agent(target, start, threshold, max_retries, max_steps, noise):    state = list(start)    retry_count = 0    reflect_count = 0    memory = []     for step in range(1, max_steps + 1):        dev = sum(abs(a - b) for a, b in zip(state, target)) / len(target)         # 1 偏差检查: 达到目标就提前成功返回        if dev <= threshold:            return True, state, reflect_count, retry_count, step         # 2 反思: 先翻经验笔记, 没命中才对错误分类        pattern = tuple(1 if a < b else (-1 if a > b else 0) for a, b in zip(state, target))        fix = next((m for m in memory if m[0] == pattern), None)        if fix is None:            reflect_count += 1            fix = (pattern, [1 if x > 0 else (-1 if x < 0 else 0) for x in pattern])            memory.append(fix)         # 3 执行修正动作, 但有概率手抖放错调料(环境噪声)        action = fix[1]        if random.random() < noise:            action = [-a for a in action]        state = [min(max(s + a, 0), 10) for s, a in zip(state, action)]         # 4 死循环预防: 连续重试超限就随机跳变换策略        retry_count += 1        if retry_count >= max_retries:            state = [min(max(s + random.choice([-2, 2]), 0), 10) for s in state]            retry_count = 0     return False, state, reflect_count, retry_count, max_steps  random.seed(42)ok, final_state, refl, retry, steps = run_reflective_agent(    target=[5, 5], start=[2, 8], threshold=0.8,    max_retries=3, max_steps=40, noise=0.3)print("成功:", ok)print("最终口味:", final_state)print("反思次数:", refl)print("重试次数:", retry)print("总步数:", steps)
目的：模拟一个“做菜学徒”智能体：它把口味调向目标值，遇到偏差就反思、查经验、重规划，并用重试上限和随机跳变防止死循环。
  1. dev = sum(abs(a - b) for a, b in zip(state, target)) / len(target)计算当前状态与目标之间的平均偏差，相当于“尝一口”。
  2. if dev <= threshold:偏差检查：达标即成功返回，未达标才进入反思环节。
  3. pattern = tuple(1 if a < b else (-1 if a > b else 0) for a, b in zip(state, target))把“哪一味偏淡/偏浓”编码成模式，方便查经验笔记。
  4. fix = next((m for m in memory if m[0] == pattern), None)先翻“翻车笔记”，命中就直接复用旧对策。
  5. reflect_count += 1记忆未命中才触发一次反思，记录反思次数供评估使用。
  6. if random.random() < noise: action = [-a for a in action]模拟环境噪声：偶尔执行动作反了，制造需要纠错的真实场景。
  7. state = [min(max(s + a, 0), 10) for s, a in zip(state, action)]执行修正动作，并把口味数值夹在 0 到 10 之间。
  8. if retry_count >= max_retries:死循环预防：超出重试上限就强制随机跳变，打破重复循环。

常见误区

误区我以为反思式重规划就是让 Agent 失败后把刚才的步骤再跑一遍，多试几次总能碰对。

正解反思首先要“诊断”：偏差来自哪一步、属于哪类错误，然后据此生成一个不一样的新方案。盲目重跑同一个动作只会得到同一个失败结果，就像反复把盐撒进同一锅已经咸透的汤里。

为何常见：因为人犯错后常说“再来一次”很有干劲，容易把“坚持重试”误当成“有效反思”。

误区我以为反思触发得越频繁，Agent 越不容易出错，最好每执行一步都停下来想一遍。

正解反思有成本：时间、算力、上下文窗口都是稀缺资源。过度反思就像每炒一道菜都重新装修厨房，收益远小于开销。工程上会用阈值、置信度门槛和成本收益分析来约束反思频率，只在最有价值的时候停下来。

为何常见：讲“纠错能力”时我们天然认为检查更仔细是优点，却忽略了现实中的资源约束。

误区我以为一旦触发重规划，就得把原始任务目标推倒，重新设计整个方案。

正解大多数偏差只需要局部修正：换一个工具、改一个参数、调整一小段子路径。全局重组成本高、风险大，只适用于错误波及整个任务结构的场景。大厨救一锅咸汤，绝不会把整桌宴席倒掉重做。

为何常见：“重规划”这个词听起来动作很大，让人误以为必须全盘推倒、从头再来。

误区我以为只要设一个“最多重试 3 次”的上限，就再也不会死循环了。

正解上限只是兜底保险。真正防止原地打转还需要策略多样性约束（不许连续用同样动作）和经验去重（已失败的方案不再尝试）。否则只是把“无限循环”变成“循环三次后继续重复同一个动作”，依然浪费预算、没有进展。

为何常见：死循环最直观的表现是“次数无限”，于是很容易误以为限制次数就是解药。

误区我以为反思记录只是运行时生成的日志，给人做事后审计用，对 Agent 本身没有实际作用。

正解经验记忆是反思闭环的燃料：分类错误、查记忆库、复用对策、写回记忆，让 Agent 在相似场景下直接跳过重复探索。没有记忆的反思，等于每次都在同一个坑前重新踩一遍、重新疼一遍。

为何常见：传统日志确实是事后审计用的，容易把“记录”误解为纯被动的行为，忽略了它在闭环中主动复用的一面。

面试题

Q1. 反思式重规划中，“反思触发”最合理的时机是？

单选题 · easy

  • A.所有步骤执行完毕后统一检查
  • B.偏差超过阈值或到达关键节点← 正确答案
  • C.任务宣告失败之后再来补救
  • D.任意随机时间点顺路触发

答案：B。偏差超过阈值说明已经明显偏离目标，关键节点复盘则能在风险扩大前纠偏，两者都是“该尝一口”的时刻。全部做完再反思太迟，失败后才补救浪费了中间机会，随机触发则既不经济也不可靠。

Q2. 死循环预防最核心的手段是？

单选题 · easy

  • A.无限重试直到任务成功收尾
  • B.设最大重试次数并强制策略多样化← 正确答案
  • C.禁止任何形式的重复尝试行为
  • D.调高偏差阈值以减少反思触发

答案：B。最大重试次数负责兜底止损，策略多样化约束负责让每次尝试都不一样，两者配合才能打破“重试—失败—再重试”的怪圈。无限重试正是死循环本身；完全禁止重复会误伤合理的交替尝试；调高阈值只是减少触发，并不能阻止已触发后的原地打转。

Q3. 选择“局部修正”还是“全局重组”的主要依据是？

单选题 · mid

  • A.一律先做局部修正再观察效果
  • B.先评估错误的波及范围和重规划成本← 正确答案
  • C.一律做全局重组避免残留下隐患
  • D.靠随机抛硬币来决定用哪种方案

答案：B。局部修正成本低，能解决小范围偏差；全局重组成本高，只在错误波及整个任务结构时使用。正确做法是先评估波及范围与成本收益再决定。一律局部可能救不了大病，一律重组则大材小用，随机选择更是缺乏依据。

Q4. 关于反思日志与经验记忆的作用，正确的是？

单选题 · mid

  • A.只用于事后审计并不干预实际运行
  • B.记录错误模式与对策并指导后续决策← 正确答案
  • C.会占用存储空间应当随时清理删除
  • D.只对当前任务有效对其他任务无效

答案：B。经验记忆是反思闭环的燃料：记录“错误—对策”对，下次遇到相似模式直接复用，能显著减少重复探索。它不只是审计工具，而是会主动影响决策；删除或限定单任务使用，都会让 Agent 失去越用越聪明的能力。

Q5. 过度反思最典型的危害是？

单选题 · mid

  • A.让任务成功率下降到零
  • B.消耗额外时间算力导致效率低下← 正确答案
  • C.让反思触发次数自然减少
  • D.增强智能体对环境的适应能力

答案：B。反思本身要消耗推理时间和算力，每步都停下来想一遍会让任务变得极慢，类似大厨每炒一道菜都重新装修厨房。它不会让成功率直接归零，也不会减少触发次数或增强适应性，主要代价就是效率。

Q6. 偏差检查阈值 τ 设置过小会怎样？

单选题 · mid

  • A.反思触发频繁效率反而下降← 正确答案
  • B.偏差迟迟不触发错失纠错机会
  • C.任务成功率必然显著提升
  • D.对系统整体行为不会产生影响

答案：A。阈值过小意味着一点风吹草动就触发反思，Agent 频繁停下重规划，时间和算力被大量消耗，整体效率下降。阈值过大才会“迟迟不触发”，成功率也不会必然提升，更不可能毫无影响。

Q7. 反思式重规划闭环的正确顺序是？

单选题 · mid

  • A.先执行再反思最后才检查
  • B.执行、检查、反思、重规划← 正确答案
  • C.先重规划再执行再检查再反思
  • D.先检查再执行再反思再重规划

答案：B。标准闭环是：先按当前计划执行，再对照目标做偏差检查，偏差超标就进入反思诊断根因，最后生成新方案重规划，然后带着新方案回到执行。其他顺序都把诊断放到纠错之后或前置，逻辑上不成立。

Q8. 防止死循环的有效手段有哪些？

多选题 · hard

  • A.设定最大重试次数上限兜底止损← 正确答案
  • B.强制策略多样性避免原地重复← 正确答案
  • C.记录已尝试方案实现经验去重← 正确答案
  • D.连续重试同一动作直到成功为止

答案：ABC。最大重试上限负责止损，策略多样性保证每次尝试不重复，经验去重让失败方案不再被选中，三者配合才能根治死循环。D 选项恰恰是造成死循环的元凶——连续重试同一动作只会得到同一个失败。

Q9. 哪些情况适合触发反思式重规划？

多选题 · hard

  • A.偏差超过预设阈值需要纠偏← 正确答案
  • B.长时间停滞不前毫无任务进展← 正确答案
  • C.到达关键里程碑节点复盘计划← 正确答案
  • D.任务已经完全成功后追加操作

答案：ABC。偏差超阈值、长时间无进展、到达关键里程碑，都是典型且高价值的反思时机。任务完全成功后应该结束流程，追加反思只会浪费算力并可能画蛇添足，属于过度反思。

Q10. 评估自我纠错能力合适的指标是？

多选题 · hard

  • A.测试集上的任务成功率← 正确答案
  • B.反思前后步数与成本对比← 正确答案
  • C.多场景压测下鲁棒性表现← 正确答案
  • D.反思次数越少说明越优秀

答案：ABC。成功率反映纠错效果，步数与成本对比反映效率，多场景压测反映鲁棒性，三者共同构成完整评估。反思次数少并不一定优秀——可能是阈值设得太高导致漏掉错误，必须结合成功率和效率一起看。