Agent 规划与推理机制

一、为什么 Agent 需要规划能力

没有规划能力的 Agent 就像一个没有地图的旅行者——走一步看一步，容易迷失方向。规划能力让 Agent 能够：

分解复杂任务：把"写一本书"拆成"列提纲→写章节→统稿校对"
预见未来步骤：不是走一步看一步，而是规划好路线
自我修正：发现计划有误时及时调整

二、主流推理框架

2.1 CoT（思维链，Chain-of-Thought）

CoT 是最基础的推理增强方法，通过"让我们一步步思考"引导 LLM 显式展示推理过程。

标准 Prompt：Q：一件商品打 8 折后再减 50 元，原价 500 元，最后多少钱？
LLM：350 元。（直接输出答案，可能出错）

CoT Prompt：Q：... 让我们一步步思考。
LLM：原价 500 元。打 8 折：500 × 0.8 = 400 元。
再减 50 元：400 - 50 = 350 元。答案：350 元。
<link rel="stylesheet" href="/assets/css/code-blocks.css?v=20261019_03">

2.2 ReAct（推理 + 行动）

ReAct 是 Reasoning + Action 的缩写，让 Agent 交替进行推理和行动，是目前最主流的 Agent 框架。

思考（Thought）：用户问我北京天气，我需要调用天气查询工具。
行动（Action）：search_weather(city="北京")
观察（Observation）：{"temperature": 22, "condition": "晴"}
思考（Thought）：天气信息已获取，可以回答用户了。
回答（Answer）：北京今天 22°C，天气晴朗。

2.3 ReAct 的实现

def react_agent(query: str, tools: Dict, llm, max_steps: int = 10):
    """ReAct 推理循环"""

    prompt = """请使用以下格式回答：
思考：你需要做什么
行动：工具名称(参数)
观察：工具返回的结果
...（可重复多次）
思考：我现在可以回答了
回答：最终答案

可用工具：
{tool_descriptions}
"""

    messages = [
        {"role": "system", "content": prompt.format(
            tool_descriptions="\n".join(
                f"- {name}: {tool['description']}"
                for name, tool in tools.items()
            )
        )},
        {"role": "user", "content": query}
    ]

    for step in range(max_steps):
        response = llm.chat(messages)
        content = response.content

        # 检查是否已给出最终答案
        if "回答：" in content:
            return content.split("回答：")[-1].strip()

        # 提取并执行工具调用
        if "行动：" in content:
            action_line = content.split("行动：")[1].split("\n")[0]
            tool_name, args = parse_action(action_line)

            if tool_name in tools:
                result = tools[tool_name]["func"](**args)
                messages.append({"role": "user", "content": f"观察：{result}"})
            else:
                messages.append({"role": "user", "content": f"观察：未知工具 {tool_name}"})

    return "无法在指定步数内完成"

2.4 Plan-and-Solve

先制定完整计划，再逐步执行：

def plan_and_solve(task: str, llm):
    """Plan-and-Solve 策略"""

    # Phase 1: 制定计划
    plan_prompt = f"""任务：{task}
请制定一个详细的执行计划，列出每个步骤。
格式：
步骤1：...
步骤2：...
..."""

    plan_response = llm.chat(plan_prompt)
    plan = parse_plan(plan_response)

    # Phase 2: 逐步执行
    results = []
    for step in plan:
        result = execute_step(step, llm)
        results.append(result)

        # Phase 3: 可选的自适应调整
        if need_replan(result):
            plan = revise_plan(plan, result, llm)

    return synthesize_results(results)

三、CoT vs ReAct vs Plan-and-Solve

维度	CoT	ReAct	Plan-and-Solve
策略	逐步推理	推理+行动交替	先计划后执行
灵活性	低（固定步骤）	高（动态调整）	中
工具使用	不支持	核心能力	支持
适用场景	数学题、逻辑题	复杂多步任务	明确可规划的任务
错误恢复	无	观察结果后可调整	步骤间可调整

四、自我反思（Self-Reflection）

让 Agent 对自己的输出进行评估和修正，是提升准确率的关键。

4.1 反思流程

① 生成初始输出
② 评估输出质量（自我检查）
③ 发现不足 → 修正
④ 再次评估 → 确认通过

4.2 实现示例

class SelfReflectiveAgent:
    """具备自我反思能力的 Agent"""

    def generate_with_reflection(self, task: str, max_reflections: int = 3):
        """生成 + 自我反思"""

        # 初始生成
        initial = self._generate(task)

        for i in range(max_reflections):
            # 反思评估
            feedback = self._critique(task, initial)

            if feedback["score"] >= 0.8:
                return initial  # 质量达标

            # 根据反馈修正
            initial = self._revise(task, initial, feedback["issues"])

        return initial

    def _critique(self, task: str, output: str) -> Dict:
        """评估输出质量"""
        response = self.llm.chat(f"""
        任务：{task}
        生成的回答：{output}

        请评估这个回答的质量（0-1分）并列出问题。
        格式：
        评分：<分数>
        问题：
        - <问题1>
        - <问题2>
        """)
        return parse_critique(response)

    def _revise(self, task: str, output: str, issues: List[str]) -> str:
        """根据反馈修正"""
        return self.llm.chat(f"""
        任务：{task}
        当前回答：{output}
        需要改进的问题：
        {chr(10).join(f'- {i}' for i in issues)}

        请修改回答以解决上述问题。
        """)

五、高级推理技术

5.1 ToT（思维树，Tree of Thoughts）

在每一步探索多个可能的推理分支，搜索最优路径。

问题 → 分支 A → 子分支 A1 → ...
     → 分支 B → 子分支 B1 → ✓ 最优
     → 分支 C → 子分支 C1 → ...

5.2 CoT-SC（思维链自一致性）

多次运行 CoT，对结果进行投票，选出现频次最高的答案：

def self_consistency(task: str, llm, n: int = 5):
    """自一致性：多次推理 + 投票"""
    results = []
    for _ in range(n):
        result = cot_reasoning(task, llm)
        results.append(result)

    # 投票选出最常见的结果
    from collections import Counter
    final = Counter(results).most_common(1)[0][0]
    return final

5.3 分层规划（Hierarchical Planning）

将大任务递归分解为子任务：

def hierarchical_plan(task: str, depth: int = 0, max_depth: int = 3):
    """递归分解任务"""
    if depth >= max_depth:
        return execute_primitive(task)

    # 分解
    subtasks = decompose(task)

    results = []
    for subtask in subtasks:
        if is_primitive(subtask):
            result = execute_primitive(subtask)
        else:
            result = hierarchical_plan(subtask, depth + 1, max_depth)
        results.append(result)

    return merge_results(results)

六、规划能力的局限与应对

局限	表现	应对方案
过度规划	花太多时间规划，执行时间不足	设置规划时间上限
规划偏差	计划基于错误假设	加入执行中的校验点
循环依赖	步骤 A 等 B、B 等 A	检测循环依赖并打破
遗忘上下文	长链任务丢失上下文	定期总结进度

七、总结

推理规划是 Agent 的"大脑"，决定了 Agent 能否有效解决复杂问题：

CoT 适合需要展示推理过程的任务
ReAct 是构建工具型 Agent 的首选框架
Plan-and-Solve 适合流程明确的复杂任务
自我反思 能显著提升输出质量

实际项目中往往需要组合多种技术：ReAct 做主体框架 + CoT 辅助推理 + 自我反思做质量保障。

下一篇将对比主流 Agent 框架的选型。

目录