【Agent 设计模式】推理技术

梓仁沐白2026-08-02 8:42

推理技术（Reasoning Techniques）

文章目录

简单任务可以由模型一次生成答案，复杂任务则需要分解、搜索、验证和调整。智能体推理的价值不在于生成更长的"思考文字"，而在于把问题求解组织成可执行、可观察、可验证、可终止的工作流。

核心思想：按任务难度分配推理预算，并用计划、工具结果、验证记录和停止条件约束求解过程。

两个层次的推理

智能体系统中的"推理"至少包含两个层次：

  • 模型层推理：模型在一次调用中完成问题分解、候选生成、比较或代码生成，例如 CoT、Self-Consistency、ToT 和 PAL。
  • 工作流层推理：编排器在多次模型调用与工具调用之间维护状态，根据观察结果决定重试、回溯、换路或结束，例如 ReAct、Plan-and-Execute 和反思循环。

两者可以组合。模型负责提出下一步，工作流负责执行、记录和约束；工具与验证器提供模型之外的事实反馈。

text 复制代码 
目标
  ↓
分析与计划
  ↓
选择动作 ─→ 调用工具/模型 ─→ 获得观察
  ↑                              ↓
  └────── 评估、修正或回溯 ←────┘
                 ↓
          满足验收条件后结束

推理轨迹、忠实性与可监控性

工程系统应记录可审计的计划、动作、参数、观察、证据、验证结果和决策摘要，而不是把完整内部思维链当作必需的产品输出。

这里需要区分两个概念：

  • 忠实性（Faithfulness）：推理轨迹是否真实反映影响最终答案的因素。
  • 可监控性（Monitorability）：监控器能否从轨迹、动作和结果中识别错误、偏差或不安全行为。

推理轨迹可以提供有价值的调试和安全信号，但未必完全忠实，也可能遗漏真正影响答案的因素。因此，它适合作为监控输入之一，不能单独充当正确性证明。

面向用户时，通常输出结论、简明依据、来源和不确定性即可；面向内部审计时，还应保留工具调用、状态变化和验证结果。可靠性最终应建立在外部证据、程序检查、测试和权限控制上。
#mermaid-svg-eCUyeMJ0JSjcBtZy{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-eCUyeMJ0JSjcBtZy .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-eCUyeMJ0JSjcBtZy .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-eCUyeMJ0JSjcBtZy .error-icon{fill:#552222;}#mermaid-svg-eCUyeMJ0JSjcBtZy .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-eCUyeMJ0JSjcBtZy .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-eCUyeMJ0JSjcBtZy .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-eCUyeMJ0JSjcBtZy .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-eCUyeMJ0JSjcBtZy .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-eCUyeMJ0JSjcBtZy .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-eCUyeMJ0JSjcBtZy .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-eCUyeMJ0JSjcBtZy .marker{fill:#333333;stroke:#333333;}#mermaid-svg-eCUyeMJ0JSjcBtZy .marker.cross{stroke:#333333;}#mermaid-svg-eCUyeMJ0JSjcBtZy svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-eCUyeMJ0JSjcBtZy p{margin:0;}#mermaid-svg-eCUyeMJ0JSjcBtZy .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-eCUyeMJ0JSjcBtZy .cluster-label text{fill:#333;}#mermaid-svg-eCUyeMJ0JSjcBtZy .cluster-label span{color:#333;}#mermaid-svg-eCUyeMJ0JSjcBtZy .cluster-label span p{background-color:transparent;}#mermaid-svg-eCUyeMJ0JSjcBtZy .label text,#mermaid-svg-eCUyeMJ0JSjcBtZy span{fill:#333;color:#333;}#mermaid-svg-eCUyeMJ0JSjcBtZy .node rect,#mermaid-svg-eCUyeMJ0JSjcBtZy .node circle,#mermaid-svg-eCUyeMJ0JSjcBtZy .node ellipse,#mermaid-svg-eCUyeMJ0JSjcBtZy .node polygon,#mermaid-svg-eCUyeMJ0JSjcBtZy .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-eCUyeMJ0JSjcBtZy .rough-node .label text,#mermaid-svg-eCUyeMJ0JSjcBtZy .node .label text,#mermaid-svg-eCUyeMJ0JSjcBtZy .image-shape .label,#mermaid-svg-eCUyeMJ0JSjcBtZy .icon-shape .label{text-anchor:middle;}#mermaid-svg-eCUyeMJ0JSjcBtZy .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-eCUyeMJ0JSjcBtZy .rough-node .label,#mermaid-svg-eCUyeMJ0JSjcBtZy .node .label,#mermaid-svg-eCUyeMJ0JSjcBtZy .image-shape .label,#mermaid-svg-eCUyeMJ0JSjcBtZy .icon-shape .label{text-align:center;}#mermaid-svg-eCUyeMJ0JSjcBtZy .node.clickable{cursor:pointer;}#mermaid-svg-eCUyeMJ0JSjcBtZy .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-eCUyeMJ0JSjcBtZy .arrowheadPath{fill:#333333;}#mermaid-svg-eCUyeMJ0JSjcBtZy .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-eCUyeMJ0JSjcBtZy .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-eCUyeMJ0JSjcBtZy .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-eCUyeMJ0JSjcBtZy .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-eCUyeMJ0JSjcBtZy .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-eCUyeMJ0JSjcBtZy .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-eCUyeMJ0JSjcBtZy .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-eCUyeMJ0JSjcBtZy .cluster text{fill:#333;}#mermaid-svg-eCUyeMJ0JSjcBtZy .cluster span{color:#333;}#mermaid-svg-eCUyeMJ0JSjcBtZy div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-eCUyeMJ0JSjcBtZy .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-eCUyeMJ0JSjcBtZy rect.text{fill:none;stroke-width:0;}#mermaid-svg-eCUyeMJ0JSjcBtZy .icon-shape,#mermaid-svg-eCUyeMJ0JSjcBtZy .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-eCUyeMJ0JSjcBtZy .icon-shape p,#mermaid-svg-eCUyeMJ0JSjcBtZy .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-eCUyeMJ0JSjcBtZy .icon-shape .label rect,#mermaid-svg-eCUyeMJ0JSjcBtZy .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-eCUyeMJ0JSjcBtZy .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-eCUyeMJ0JSjcBtZy .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-eCUyeMJ0JSjcBtZy :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 工作流层推理
模型层推理
"提出下一步"
"需要新计划"
"满足条件"
问题输入
CoT/ToT/PAL
候选答案/计划
状态与计划
执行动作
观察结果
评估与决策
最终输出

图：模型层推理与工作流层推理的交互关系。模型层负责生成候选方案，工作流层负责执行、评估和决策，两者形成闭环。

何时需要高级推理

场景 主要难点 推荐组合 关键验证
复杂问答 多跳检索、信息冲突 ReAct + RAG + 反思 引用覆盖、来源一致性
数学与数据分析 计算精度、步骤依赖 CoT + PAL + Self-Consistency 代码执行、代入检查
代码生成与调试 状态复杂、错误需复现 Plan-and-Execute + 工具调用 + 反思 测试、静态检查、真实运行
战略规划 方案多、约束相互影响 ToT + 约束检查 风险清单、情景模拟
长周期研究 信息缺口不断暴露 ReAct + 迭代检索 + 记忆 覆盖率、停止条件
医疗、法律等高风险任务 错误代价高、责任边界严格 检索 + 规则/程序校验 + 人工复核 权威来源、专业人员确认

以下情况通常不需要复杂推理：答案可直接检索、只有一个确定步骤、额外迭代不会改变结论，或延迟和成本比小幅质量提升更重要。

核心推理技术

链式思维（Chain-of-Thought, CoT）

CoT 通过中间步骤帮助模型分解多步问题，而不是立即猜测最终答案。经典实现是在提示中提供少量分步示例，或要求模型先形成结构化解题计划。

text 复制代码 
问题 → 识别条件 → 分解子问题 → 求解与检查 → 答案

CoT 适合算术、常识推理、符号操作和多约束分析，但线性路径一旦早期出错，后续步骤可能沿着错误前提继续展开。

工程上更推荐要求模型输出简明依据或可验证步骤：

text 复制代码 
任务：比较经典计算机与量子计算机，并给出一个量子计算应用。

输出要求：
1. 按"信息单位、计算机制、适用问题"三个维度比较。
2. 给出一个具体应用，并说明为什么适合量子计算。
3. 对无法确认的结论标注不确定性。
4. 只输出简明依据和最终答案，不输出隐藏的内部思维过程。

这种写法保留了任务分解和审计能力，也避免把冗长的自然语言推理误当成事实证明。

自洽性（Self-Consistency）

自洽性不是只采用一条贪心路径，而是采样多个相互独立的候选推理，再通过多数答案、一致性或验证器选出结果。

text 复制代码 
同一问题
  ├→ 候选路径 A ─┐
  ├→ 候选路径 B ─┼→ 聚合或验证 → 最终答案
  └→ 候选路径 C ─┘

它适合存在多种解法且最终答案可比较的任务，如数学题、分类和结构化问答。候选之间若共享同一错误知识，多数投票仍可能得到一致但错误的答案。

工程实现时应明确：

  • 候选数量与采样温度
  • 聚合规则是多数投票、置信加权，还是外部验证
  • 并行调用预算与超时
  • 无法形成共识时的回退策略

树式思维（Tree of Thoughts, ToT）

ToT 把中间"思路"视为可搜索状态。系统从一个状态生成多个候选，评估其前景，并通过广度优先、深度优先或束搜索继续探索。

text 复制代码 
                ┌→ 路径 A → 评估低 → 剪枝
问题 → 候选生成 ├→ 路径 B → 评估高 → 继续展开 → 答案
                └→ 路径 C → 冲突   → 回溯

ToT 适合需要前瞻、回溯和策略搜索的任务，如组合谜题、复杂规划和创意方案比较。它的效果取决于状态表示、分支数、深度、评价器质量和搜索预算。

ToT 的主要风险是分支爆炸。生产系统通常需要限制最大深度、每层候选数、累计 token、工具调用次数和总耗时。

自我纠错与反思（Self-Correction / Reflection）

自我纠错把质量控制嵌入生成流程，形成"生成 → 评估 → 修订"的反馈循环。

text 复制代码 
初稿 → 按验收标准评估 → 发现差距 → 修订 → 再验证 → 最终输出

评估标准必须具体。例如，代码任务应检查测试、类型和边界条件；研究任务应检查来源覆盖、事实冲突和未回答的问题。

仅让同一个模型"再检查一次"属于内在自我纠错，可能重复原有偏差，甚至把正确答案改错。近期研究总体表明，自我纠错在获得测试、搜索、规则或环境等外部反馈后更稳定。

更可靠的反馈按强度从低到高依次为：

  1. 同一模型按明确清单自评
  2. 独立批评者模型评审
  3. 规则、编译器、测试或求解器验证
  4. 真实环境反馈
  5. 高风险场景中的人工复核

反思模式的完整工作流见 \[AI/Agentic/4.反思模式\|反思模式]。

程序辅助语言模型（Program-Aided Language Models, PAL）

PAL 让模型负责理解问题并生成程序，把算术、符号操作和数据处理交给 Python 等确定性运行时。

text 复制代码 
自然语言问题 → 生成程序 → 沙箱执行 → 获取结果 → 解释结果

PAL 的优势不是"代码一定正确"，而是程序可以运行、测试和复现。模型仍可能生成错误算法，因此必须校验输入、输出、单位和边界条件。

执行模型生成的代码时应使用沙箱，并限制文件系统、网络、进程、运行时间和资源占用。未经确认，不应让生成代码直接修改生产数据或调用有副作用的接口。

ReAct（Reasoning and Acting）

ReAct 将推理与行动交错执行。智能体根据当前状态选择工具，观察真实结果，再更新计划。

text 复制代码 
计划摘要 → 动作 → 观察 → 更新计划 → 动作 → 观察 → ... → 最终答案

ReAct 适合答案依赖外部环境的任务，例如搜索、数据库查询、网页操作和设备控制。它比一次性 CoT 更能利用新信息纠错，但也引入工具失败、循环不终止和副作用等工程问题。

一个生产级 ReAct 循环至少需要：

  • 工具参数的结构化校验
  • 每步的权限与副作用检查
  • 观察结果与模型文本分离
  • 最大步数、超时和预算
  • 重试、退避和幂等控制
  • 结束条件与失败状态

ReAct 与先规划再执行的差异见 \[AI/Agentic/ReAct \& Plan-and-Execute\|ReAct 与 Plan-and-Execute]。

可验证奖励强化学习（RLVR）

RLVR 是训练方法，不是直接替代 CoT 或 ReAct 的工作流模式。它利用可自动验证的奖励训练模型，例如数学答案、代码测试或形式化规则。

text 复制代码 
模型生成候选 → 验证器计算奖励 → 强化学习更新 → 更有效的推理策略

可验证奖励减少了对人工标注完整推理轨迹的依赖，并可能促使模型学会检查、回溯和调整策略。其优势主要集中在奖励可可靠计算的任务。

RLVR 的局限也来自验证器：若奖励只覆盖最终答案，模型可能找到取巧路径；若验证器有漏洞，模型可能优化漏洞而不是真实目标。因此要关注奖励黑客、数据污染和分布外泛化。

结果验证、过程验证与可执行验证

验证器既能在训练时提供奖励，也能在推理时筛选候选或指导搜索。按验证对象可分为三类：

验证方式 检查对象 优势 局限
结果奖励模型（ORM） 最终答案或完整响应 标注和调用相对简单 无法定位中间错误，容易漏掉取巧路径
过程奖励模型（PRM） 每一步或局部状态 能提前剪枝并定位错误 步骤标注昂贵，错误可能在长链中累积
可执行验证器 测试、编译器、求解器、规则 客观、可复现、适合自动化 只覆盖可形式化部分，验证器本身也可能有漏洞

开放式任务通常无法用单一验证器判断。更稳健的方案是组合"规则/程序检查 + 来源证据 + 模型评审 + 必要时人工复核"，并记录每类检查覆盖了什么、没有覆盖什么。

方法选型对比

技术 搜索结构 是否调用外部工具 主要增量成本 典型失败模式
CoT 单条线性路径 否 更多输出 token 早期错误逐步放大
Self-Consistency 多条独立路径 否 多次并行采样 多数候选共享同一偏差
ToT 分支搜索与回溯 可选 候选生成和节点评估 分支爆炸、评价器误判
Reflection 反馈循环 可选 多轮生成与评审 自评重复原错误、无法停止
PAL 程序化求解 是，代码运行时 生成、执行和校验 算法错误、代码副作用
ReAct 状态驱动循环 是 多轮模型和工具调用 工具误用、循环、状态漂移
RLVR 训练期策略优化 验证器 训练与奖励计算 奖励黑客、验证器偏差

一个实用的渐进策略是：先用直接回答作为基线；失败后依次增加结构化分解、外部工具、验证器和多候选搜索。不要一开始就把所有请求都路由到最昂贵的推理流程。
#mermaid-svg-jH48IdRJrplVEuBb{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-jH48IdRJrplVEuBb .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-jH48IdRJrplVEuBb .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-jH48IdRJrplVEuBb .error-icon{fill:#552222;}#mermaid-svg-jH48IdRJrplVEuBb .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-jH48IdRJrplVEuBb .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-jH48IdRJrplVEuBb .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-jH48IdRJrplVEuBb .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-jH48IdRJrplVEuBb .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-jH48IdRJrplVEuBb .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-jH48IdRJrplVEuBb .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-jH48IdRJrplVEuBb .marker{fill:#333333;stroke:#333333;}#mermaid-svg-jH48IdRJrplVEuBb .marker.cross{stroke:#333333;}#mermaid-svg-jH48IdRJrplVEuBb svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-jH48IdRJrplVEuBb p{margin:0;}#mermaid-svg-jH48IdRJrplVEuBb .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-jH48IdRJrplVEuBb .cluster-label text{fill:#333;}#mermaid-svg-jH48IdRJrplVEuBb .cluster-label span{color:#333;}#mermaid-svg-jH48IdRJrplVEuBb .cluster-label span p{background-color:transparent;}#mermaid-svg-jH48IdRJrplVEuBb .label text,#mermaid-svg-jH48IdRJrplVEuBb span{fill:#333;color:#333;}#mermaid-svg-jH48IdRJrplVEuBb .node rect,#mermaid-svg-jH48IdRJrplVEuBb .node circle,#mermaid-svg-jH48IdRJrplVEuBb .node ellipse,#mermaid-svg-jH48IdRJrplVEuBb .node polygon,#mermaid-svg-jH48IdRJrplVEuBb .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-jH48IdRJrplVEuBb .rough-node .label text,#mermaid-svg-jH48IdRJrplVEuBb .node .label text,#mermaid-svg-jH48IdRJrplVEuBb .image-shape .label,#mermaid-svg-jH48IdRJrplVEuBb .icon-shape .label{text-anchor:middle;}#mermaid-svg-jH48IdRJrplVEuBb .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-jH48IdRJrplVEuBb .rough-node .label,#mermaid-svg-jH48IdRJrplVEuBb .node .label,#mermaid-svg-jH48IdRJrplVEuBb .image-shape .label,#mermaid-svg-jH48IdRJrplVEuBb .icon-shape .label{text-align:center;}#mermaid-svg-jH48IdRJrplVEuBb .node.clickable{cursor:pointer;}#mermaid-svg-jH48IdRJrplVEuBb .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-jH48IdRJrplVEuBb .arrowheadPath{fill:#333333;}#mermaid-svg-jH48IdRJrplVEuBb .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-jH48IdRJrplVEuBb .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-jH48IdRJrplVEuBb .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-jH48IdRJrplVEuBb .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-jH48IdRJrplVEuBb .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-jH48IdRJrplVEuBb .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-jH48IdRJrplVEuBb .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-jH48IdRJrplVEuBb .cluster text{fill:#333;}#mermaid-svg-jH48IdRJrplVEuBb .cluster span{color:#333;}#mermaid-svg-jH48IdRJrplVEuBb div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-jH48IdRJrplVEuBb .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-jH48IdRJrplVEuBb rect.text{fill:none;stroke-width:0;}#mermaid-svg-jH48IdRJrplVEuBb .icon-shape,#mermaid-svg-jH48IdRJrplVEuBb .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-jH48IdRJrplVEuBb .icon-shape p,#mermaid-svg-jH48IdRJrplVEuBb .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-jH48IdRJrplVEuBb .icon-shape .label rect,#mermaid-svg-jH48IdRJrplVEuBb .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-jH48IdRJrplVEuBb .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-jH48IdRJrplVEuBb .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-jH48IdRJrplVEuBb :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 简单/线性
多候选/聚合
搜索/回溯
外部反馈
环境交互
精确计算
验证与筛选
结果验证
过程验证
可执行验证
问题输入
任务复杂度与需求
CoT

单路径分解
Self-Consistency

多路径投票
ToT

树状搜索
Reflection

反思循环
ReAct

推理-行动循环
PAL

程序生成执行
答案
聚合答案
搜索答案
修订答案
环境答案
执行结果
最终输出

图：核心推理技术选型决策流。根据任务特性选择不同技术路径，最终通过验证层确保输出质量。

多智能体推理

多智能体辩论

多智能体辩论让多个模型实例分别提出答案、交叉质疑，再由聚合器生成结论。不同资料也会使用 Chain of Debate、Society of Minds 等名称，但这些缩写并非统一标准。

text 复制代码 
问题 → 独立作答 A/B/C → 交叉质疑 → 补证或反驳 → 聚合器裁决

辩论的价值来自独立性和验证，而不是智能体数量。若所有智能体使用相同模型、提示和上下文，它们可能高度相关，一致意见并不等于正确。

可通过角色差异提高互补性：

  • 求解者：提出完整方案
  • 反对者：寻找反例和隐含假设
  • 事实核查者：验证来源和数据
  • 裁决者：按证据和验收标准聚合

图式辩论

对于存在多条论证线的任务，可以把主张、证据、支持和反驳关系建模为图。结论由证据强度和验证状态决定，而不是简单取最后一轮发言。

text 复制代码 
[主张 A] ←支持─ [证据 1]
    ↑
  反驳
    │
[主张 B] ←支持─ [证据 2]

图式表示便于追踪争议点、重复证据和尚未解决的分支，但需要定义节点类型、边语义、冲突消解和终止规则。

MASS（Multi-Agent System Search）

MASS 将多智能体系统的提示和交互拓扑视为可优化对象，分三个阶段搜索：

  1. 块级提示优化：先优化每个智能体模块的局部提示
  2. 工作流拓扑优化：搜索模块之间的连接、顺序和反馈关系
  3. 工作流级提示优化：在已选拓扑上进行全局协同优化

MASS 的核心启示是：多智能体性能不仅取决于单个模型，也取决于角色提示、信息流和拓扑。它更适合有稳定评测集和充足搜索预算的系统设计阶段，而不是每个用户请求都实时运行。

推理时扩展（Inference-Time Scaling）

推理时扩展是指在生成答案阶段增加计算，而不是只依赖更大的预训练模型。常见方式分为两类：

  • 串行扩展：沿一条轨迹继续推理、反思、回溯或调用工具
  • 并行扩展：生成多个相对独立的候选，通过投票、奖励模型或验证器筛选
text 复制代码 
固定推理预算 =
模型调用成本 + 生成 token + 工具调用 + 验证成本 + 时间成本

对于智能体，额外预算还可以分配给多条环境轨迹、选择性反思、交叉验证和结果合并。近期实证研究显示，增加智能体的测试时计算可以提升任务表现，但收益高度依赖反思时机、轨迹多样性和聚合方法。

动态预算与停止策略

更多计算不保证结果单调变好。收益取决于任务难度、基础模型是否具备一定成功率、候选多样性，以及验证器能否区分好坏答案。

因此，生产系统应采用按任务动态分配预算：

  1. 估计任务复杂度与风险
  2. 选择直接回答、单路径或多路径
  3. 设置 token、步骤、工具和时间上限
  4. 根据验证分数、候选分歧和新增信息量决定是否继续
  5. 在边际收益降低、满足验收条件或触及硬预算时停止
  6. 记录质量、成本和延迟，用评测数据更新路由策略

模型自报的置信度只能作为弱信号。停止判断最好同时参考可执行验证结果、候选一致性、信息增益、重复动作比例和剩余预算。

推理越长不一定越好

2025--2026 年的多项实证研究报告了"思考不足"和"过度思考"并存的现象：简单问题可能被无谓展开，复杂问题却过早结束；继续生成还可能推翻已经正确的中间结论。

这些研究仍在快速发展，其中部分属于预印本，但工程启示较稳定：

  • 不把输出长度当作推理质量指标
  • 简单问题优先直接回答或使用较小预算
  • 难题优先增加独立候选和验证，而不是只延长同一条轨迹
  • 保存当前最佳候选，后续迭代变差时可以回退
  • 比较"单位成本的质量增益"，而不只比较最高准确率

自洽性、Best-of-N 和树搜索属于并行或搜索式扩展；长 CoT 和多轮反思属于串行扩展。两类方法没有固定优劣，应在真实任务和相同预算下比较。

这与 \[AI/Agentic/10.资源感知优化\|资源感知优化] 直接相关：推理预算是质量、延迟和成本之间的动态决策，而不是固定的"思考越久越好"。

工程落地

把推理设计为状态机

不要只用一段超长提示模拟所有控制逻辑。将查询、计划、观察、证据、迭代次数、预算和完成状态放入结构化状态，由确定性代码控制跳转。
#mermaid-svg-DEo8vqudc6QnKs3p{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-DEo8vqudc6QnKs3p .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-DEo8vqudc6QnKs3p .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-DEo8vqudc6QnKs3p .error-icon{fill:#552222;}#mermaid-svg-DEo8vqudc6QnKs3p .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-DEo8vqudc6QnKs3p .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-DEo8vqudc6QnKs3p .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-DEo8vqudc6QnKs3p .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-DEo8vqudc6QnKs3p .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-DEo8vqudc6QnKs3p .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-DEo8vqudc6QnKs3p .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-DEo8vqudc6QnKs3p .marker{fill:#333333;stroke:#333333;}#mermaid-svg-DEo8vqudc6QnKs3p .marker.cross{stroke:#333333;}#mermaid-svg-DEo8vqudc6QnKs3p svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-DEo8vqudc6QnKs3p p{margin:0;}#mermaid-svg-DEo8vqudc6QnKs3p .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-DEo8vqudc6QnKs3p .cluster-label text{fill:#333;}#mermaid-svg-DEo8vqudc6QnKs3p .cluster-label span{color:#333;}#mermaid-svg-DEo8vqudc6QnKs3p .cluster-label span p{background-color:transparent;}#mermaid-svg-DEo8vqudc6QnKs3p .label text,#mermaid-svg-DEo8vqudc6QnKs3p span{fill:#333;color:#333;}#mermaid-svg-DEo8vqudc6QnKs3p .node rect,#mermaid-svg-DEo8vqudc6QnKs3p .node circle,#mermaid-svg-DEo8vqudc6QnKs3p .node ellipse,#mermaid-svg-DEo8vqudc6QnKs3p .node polygon,#mermaid-svg-DEo8vqudc6QnKs3p .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-DEo8vqudc6QnKs3p .rough-node .label text,#mermaid-svg-DEo8vqudc6QnKs3p .node .label text,#mermaid-svg-DEo8vqudc6QnKs3p .image-shape .label,#mermaid-svg-DEo8vqudc6QnKs3p .icon-shape .label{text-anchor:middle;}#mermaid-svg-DEo8vqudc6QnKs3p .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-DEo8vqudc6QnKs3p .rough-node .label,#mermaid-svg-DEo8vqudc6QnKs3p .node .label,#mermaid-svg-DEo8vqudc6QnKs3p .image-shape .label,#mermaid-svg-DEo8vqudc6QnKs3p .icon-shape .label{text-align:center;}#mermaid-svg-DEo8vqudc6QnKs3p .node.clickable{cursor:pointer;}#mermaid-svg-DEo8vqudc6QnKs3p .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-DEo8vqudc6QnKs3p .arrowheadPath{fill:#333333;}#mermaid-svg-DEo8vqudc6QnKs3p .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-DEo8vqudc6QnKs3p .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-DEo8vqudc6QnKs3p .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-DEo8vqudc6QnKs3p .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-DEo8vqudc6QnKs3p .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-DEo8vqudc6QnKs3p .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-DEo8vqudc6QnKs3p .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-DEo8vqudc6QnKs3p .cluster text{fill:#333;}#mermaid-svg-DEo8vqudc6QnKs3p .cluster span{color:#333;}#mermaid-svg-DEo8vqudc6QnKs3p div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-DEo8vqudc6QnKs3p .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-DEo8vqudc6QnKs3p rect.text{fill:none;stroke-width:0;}#mermaid-svg-DEo8vqudc6QnKs3p .icon-shape,#mermaid-svg-DEo8vqudc6QnKs3p .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-DEo8vqudc6QnKs3p .icon-shape p,#mermaid-svg-DEo8vqudc6QnKs3p .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-DEo8vqudc6QnKs3p .icon-shape .label rect,#mermaid-svg-DEo8vqudc6QnKs3p .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-DEo8vqudc6QnKs3p .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-DEo8vqudc6QnKs3p .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-DEo8vqudc6QnKs3p :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 否
是
START
分析任务
生成候选动作
权限检查
执行动作
获得观察
评估观察
信息充分

或达到上限?
验证与最终输出
END

不要只用一段超长提示模拟所有控制逻辑。将查询、计划、观察、证据、迭代次数、预算和完成状态放入结构化状态，由确定性代码控制跳转。

text 复制代码 
START
  ↓
分析任务 → 生成候选动作 → 权限检查 → 执行动作
  ↑                                  ↓
  └──── 信息不足 ← 评估观察 ←────────┘
                       │
                  信息充分/达上限
                       ↓
                  验证与最终输出
                       ↓
                      END

建议的最小状态字段：

python 复制代码 
class ReasoningState(TypedDict):
    goal: str
    plan: list[str]
    observations: list[dict]
    evidence: list[dict]
    candidates: list[dict]
    verifier_results: list[dict]
    iteration: int
    token_budget: int
    tool_budget: int
    best_candidate_id: str | None
    status: Literal["running", "succeeded", "failed", "needs_review"]
    final_answer: str

设置明确的终止条件

每个循环都应回答"为什么继续"和"为什么停止"。常见终止条件包括：

  • 验收标准全部满足
  • 外部验证器通过
  • 没有新的信息增益
  • 达到最大步骤、成本或时间
  • 连续失败超过阈值
  • 需要用户授权或人工判断

达到预算上限不等于任务成功。系统应返回明确的失败或待复核状态，并说明缺失信息。

优先验证高价值节点

不必验证每一句自然语言。优先检查会改变后续路径的关键节点：

  • 搜索查询是否覆盖核心实体
  • 工具参数是否有效且获授权
  • 中间计算是否可复现
  • 关键事实是否有来源支持
  • 最终答案是否满足原始约束

记录可重放轨迹

一个可调试的轨迹应包含：

  • 输入目标与约束
  • 模型和提示版本
  • 每次动作及结构化参数
  • 原始工具结果与解析结果
  • 重试、回溯和停止原因
  • token、延迟和费用
  • 最终验证结果

轨迹中应对密钥、个人信息和敏感业务数据做脱敏，并设置保留期限和访问权限。

评估指标

推理系统不能只评估最终文字是否"像答案"。至少应覆盖五类指标：

维度 示例指标
任务质量 成功率、正确率、约束满足率、测试通过率
证据质量 引用覆盖率、来源正确率、事实一致性
执行可靠性 工具成功率、无效调用率、重试率、回滚率
资源效率 平均步骤数、token、费用、P50/P95 延迟
安全性 越权调用、敏感数据暴露、危险副作用次数

推理时扩展还应报告 pass@k、Best-of-N 增益、验证器选中率、单位 token 的质量增益，以及不同预算下的质量---成本前沿。只报告最高分，会掩盖延迟和成本。

评测集应包含正常样例、边界条件、工具失败、矛盾来源、提示注入和预算耗尽等情况。离线评测用于选方案，线上监控用于发现分布变化和长期退化。

局限性与风险

  • 推理文本不一定忠实：自然语言解释可能合理但不是真实因果过程，不能代替外部验证。
  • 错误会累积：长链条中的早期误判会污染后续计划、检索和答案。
  • 成本与延迟增加：多候选、多智能体和反思循环都会增加 token、工具调用和等待时间。
  • 验证器也会错：模型评审可能与生成器共享偏差，程序测试也可能覆盖不足。
  • 过度思考：额外步骤可能增加方差、重复搜索，甚至推翻原本正确的答案。
  • 循环可能失控：缺少停止条件时，智能体会重复搜索、反思或调用工具。
  • 工具产生真实副作用：写文件、发消息、付款和删除操作需要权限检查、确认和幂等机制。
  • 多智能体可能放大偏差：相关模型会形成虚假共识，辩论也可能增加内容而不增加信息。

高风险领域不应把"更长推理"当作安全保证。系统仍需权威数据、领域规则、审计记录和合格专业人员把关。

代码示例

DeepSearch + LangGraph 实现

python 复制代码 
"""
DeepSearch 风格的推理技术示例（简化版）：
基于 LangGraph 构建"生成查询 → Web 检索 → 反思 → 迭代优化"的推理循环。

参考：Google gemini-fullstack-langgraph-quickstart

流程：
  START → generate_query → web_research → reflection → (继续检索 or 最终答案) → END

依赖安装：
pip install langchain-openai langgraph python-dotenv
"""

import os
from typing import List, Annotated
from typing_extensions import TypedDict
from dotenv import load_dotenv

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langgraph.graph import StateGraph, START, END

load_dotenv()

if not os.getenv("OPENAI_API_KEY"):
    raise EnvironmentError("请在 .env 文件中设置 OPENAI_API_KEY。")

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)


# --- 状态定义 ---
class ResearchState(TypedDict):
    """研究工作流的状态。"""
    question: str               # 用户原始问题
    search_queries: List[str]   # 生成的搜索查询
    search_results: List[str]   # 搜索结果
    reflection: str             # 反思内容
    iteration: int              # 当前迭代次数
    max_iterations: int         # 最大迭代次数
    answer: str                 # 最终答案


# --- 节点 1：生成搜索查询 ---
def generate_query(state: ResearchState) -> ResearchState:
    """根据用户问题和已有信息，生成搜索查询。"""
    question = state["question"]
    iteration = state.get("iteration", 0)
    reflection = state.get("reflection", "")

    if iteration == 0:
        prompt_text = f"针对以下问题，生成 2 个不同角度的搜索查询（每行一个）：\n\n{question}"
    else:
        prompt_text = (
            f"用户问题：{question}\n\n"
            f"之前的反思发现以下知识空缺：\n{reflection}\n\n"
            f"请生成 2 个新的搜索查询来填补这些空缺（每行一个）："
        )

    print(f"\n  [生成查询] 第 {iteration + 1} 轮迭代")
    response = llm.invoke(prompt_text)
    queries = [q.strip() for q in response.content.strip().split("\n") if q.strip()]
    print(f"  [生成查询] 查询：{queries}")

    return {
        **state,
        "search_queries": queries,
        "iteration": iteration + 1,
    }


# --- 节点 2：Web 检索（模拟）---
def web_research(state: ResearchState) -> ResearchState:
    """执行搜索查询并收集结果。实际项目中应接入搜索 API。"""
    queries = state["search_queries"]
    existing_results = state.get("search_results", [])

    print(f"  [Web 检索] 正在搜索 {len(queries)} 个查询...")

    # 模拟搜索：用 LLM 生成"搜索结果"
    # 实际项目中应替换为 Google Search API / Bing API / SerpAPI 等
    new_results = []
    for query in queries:
        response = llm.invoke(
            f"假设你是一个搜索引擎，针对查询 '{query}' 返回一段简短的搜索结果摘要（2-3句话）："
        )
        new_results.append(f"[查询: {query}]\n{response.content.strip()}")

    all_results = existing_results + new_results
    print(f"  [Web 检索] 累计收集 {len(all_results)} 条结果")

    return {**state, "search_results": all_results}


# --- 节点 3：反思 ---
def reflection(state: ResearchState) -> ResearchState:
    """反思当前检索结果是否充分，识别知识空缺。"""
    question = state["question"]
    results = state["search_results"]
    results_text = "\n\n".join(results)

    print(f"  [反思] 正在评估检索结果是否充分...")

    prompt = ChatPromptTemplate.from_template(
        """你是一个研究助手。用户问题是：{question}

目前收集到的搜索结果：
{results}

请评估：
1. 当前信息是否足以全面回答用户问题？
2. 如果不够，具体缺少哪些信息？

如果信息已充分，回复"SUFFICIENT"。
否则，列出需要补充的信息点。"""
    )

    chain = prompt | llm | StrOutputParser()
    reflection_text = chain.invoke({"question": question, "results": results_text})
    print(f"  [反思] {reflection_text[:100]}...")

    return {**state, "reflection": reflection_text}


# --- 节点 4：生成最终答案 ---
def finalize_answer(state: ResearchState) -> ResearchState:
    """综合所有检索结果，生成最终回答。"""
    question = state["question"]
    results = state["search_results"]
    results_text = "\n\n".join(results)

    print(f"\n  [最终答案] 正在综合 {len(results)} 条结果生成回答...")

    prompt = ChatPromptTemplate.from_template(
        """你是一个知识渊博的研究助手。请根据以下搜索结果，全面回答用户问题。
回答要准确、有条理，引用关键信息。

用户问题：{question}

搜索结果：
{results}

请给出全面的回答："""
    )

    chain = prompt | llm | StrOutputParser()
    answer = chain.invoke({"question": question, "results": results_text})

    return {**state, "answer": answer}


# --- 条件边：评估是否继续研究 ---
def evaluate_research(state: ResearchState) -> str:
    """根据反思结果决定继续检索还是生成最终答案。"""
    reflection = state.get("reflection", "")
    iteration = state.get("iteration", 0)
    max_iterations = state.get("max_iterations", 3)

    if "SUFFICIENT" in reflection:
        print(f"  [评估] 信息充分，准备生成最终答案")
        return "finalize_answer"

    if iteration >= max_iterations:
        print(f"  [评估] 已达最大迭代次数 ({max_iterations})，生成最终答案")
        return "finalize_answer"

    print(f"  [评估] 信息不足，继续第 {iteration + 1} 轮检索")
    return "generate_query"


# --- 构建 LangGraph 工作流 ---
builder = StateGraph(ResearchState)

# 定义节点
builder.add_node("generate_query", generate_query)
builder.add_node("web_research", web_research)
builder.add_node("reflection", reflection)
builder.add_node("finalize_answer", finalize_answer)

# 设置入口
builder.add_edge(START, "generate_query")

# 生成查询 → Web 检索
builder.add_edge("generate_query", "web_research")

# Web 检索 → 反思
builder.add_edge("web_research", "reflection")

# 反思 → 条件分支（继续检索 or 最终答案）
builder.add_conditional_edges(
    "reflection",
    evaluate_research,
    ["generate_query", "finalize_answer"]
)

# 最终答案 → 结束
builder.add_edge("finalize_answer", END)

# 编译
graph = builder.compile()


# --- 运行 ---
def research(question: str, max_iterations: int = 3):
    """运行研究智能体。"""
    print(f"\n{'=' * 60}")
    print(f"  研究问题：{question}")
    print(f"  最大迭代：{max_iterations} 轮")
    print('=' * 60)

    result = graph.invoke({
        "question": question,
        "search_queries": [],
        "search_results": [],
        "reflection": "",
        "iteration": 0,
        "max_iterations": max_iterations,
        "answer": "",
    })

    print(f"\n{'=' * 60}")
    print(f"  最终答案")
    print('=' * 60)
    print(result["answer"])
    print(f"\n（共进行 {result['iteration']} 轮检索）\n")
    return result


if __name__ == "__main__":
    # 示例：需要多步检索和推理的复杂问题
    research("量子计算对现代密码学的影响有哪些？目前有哪些应对方案？")

示例使用 LangGraph 构建"生成查询 → Web 检索 → 反思 → 继续检索或输出"的循环，用于演示状态、条件边和最大迭代次数。

text 复制代码 
START → 生成查询 → Web 检索 → 反思：信息充分吗？
              ↑                  │
              └──── 不充分 ──────┤
                                 └→ 充分或达到上限 → 最终答案 → END

核心组件：

  • generate_query：根据原问题和知识空缺生成查询
  • web_research：执行检索并累计观察结果
  • reflection：评估信息覆盖并指出缺口
  • evaluate_research：决定继续检索还是结束
  • finalize_answer：综合结果生成最终回答

当前代码中的 web_research 使用 LLM 模拟搜索结果，仅用于演示工作流，不能视为真实 Web 证据。生产环境应接入搜索 API，保留 URL、标题、发布时间和原文片段，并验证引用是否支持结论。

关键要点

  • 推理能力来自模型、工作流、工具和验证器的组合，不只是更长的自然语言输出
  • CoT 适合线性分解，自洽性适合多候选聚合，ToT 适合搜索与回溯
  • PAL 把精确计算交给程序，ReAct 把推理放入持续的环境交互循环
  • 自我纠错接入外部反馈后更可靠；验证器应区分结果、过程和可执行检查
  • RLVR 属于训练方法，其效果受可验证奖励的覆盖范围与可靠性限制
  • 推理时扩展需要动态分配预算；更长的轨迹不保证更好的答案
  • 推理轨迹是有用的监控信号，但不能代替证据和外部验证
  • 高风险任务必须结合外部验证、权限控制和人工复核

参考资料

总结

高级推理技术的共同目标，是把一次性生成升级为可分解、可搜索、可验证、可恢复的求解过程。不同方法改变的是候选路径、外部反馈和计算预算的组织方式。

可靠的智能体不以"思考得很长"为目标，而以任务成功、证据充分和成本可控为目标。工程上应从简单基线出发，只在必要时增加搜索、反思、多智能体和工具调用，并用状态机、动态预算、验证器和权限边界控制复杂度。

相关推荐
Kinghiee1 小时前
从使用场景切入前端常见设计模式
前端·设计模式
啦啦啦啦啦zzzz1 天前
设计模式：单例模式和工厂模式
c++·单例模式·设计模式·工厂模式
小白说大模型1 天前
Python 工程化设计模式：AI 项目中的异步流水线与策略模式实战
人工智能·python·设计模式
choumin1 天前
行为型模式——中介者模式
c++·设计模式·中介者模式·行为型模式
geovindu2 天前
Java: Chain of Responsibility Pattern
java·开发语言·后端·设计模式·责任链模式·行为模式
workflower2 天前
装备企业的 AI 路线图
人工智能·深度学习·机器学习·设计模式·机器人
geovindu3 天前
CSharp:Chain of Responsibility Pattern
开发语言·后端·设计模式·c#·.net·责任链模式·行为模式
梓仁沐白3 天前
【Agent 设计模式】路由模式（Routing）
大数据·设计模式
梓仁沐白3 天前
【Agent 设计模式】多智能体协作
microsoft·设计模式·php
热门推荐
01如何新建文件夹？ 电脑新建文件夹的4种方法02GitHub 镜像站点03国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）042026年7月AI圈大地震：GPT-5.6被政府限制、Claude入驻Slack、Anthropic自研芯片05AI 编程 IDE 全景解析 2026：Agent 全面接管开发链路06微信历史版本含下载地址（ Windows PC | 安卓 | MAC ）及设置微信不更新072026 国产 AI 大模型横评：DeepSeek、通义千问、Kimi、文心一言、星火、豆包谁更能打？08AI科技热点日报 | 2026年07月01日09Agnes AI 免费 API 接入指南：文本、生图、生视频，一套接口全免费102026 年 AI 大模型 & AI 编程工具实战全总结