AI Agent 核心算法：任务规划（Planning）的深度技术解析

冷小鱼

97人浏览 · 2026-07-11 20:47:33

冷小鱼 · 2026-07-11 20:47:33 发布

摘要：任务规划是 AI Agent 从"对话模型"跃迁为"自主智能体"的核心瓶颈。本文深入剖析当前主流规划算法的数学本质、工程实现与前沿演进，涵盖 ReAct、Tree of Thoughts、LLM+P、Reflexion 等关键范式，并提供可直接落地的代码框架与性能评估视角。

一、引言：为什么 Planning 是 Agent 的"阿喀琉斯之踵"

大语言模型（LLM）在知识储备与语言理解上已展现惊人能力，但从"会说"到"会做"之间，隔着一条名为 Planning 的鸿沟。

一个典型的 Agent 执行闭环包含：感知（Perception）→ 规划（Planning）→ 执行（Action）→ 反思（Reflection）。其中，Planning 决定了 Agent 能否将复杂目标分解为可执行的子任务序列，并在动态环境中根据反馈调整策略。

当前 Planning 面临三大核心挑战：

挑战维度	具体问题	本质难点
组合爆炸	长程任务的状态-动作空间指数级增长	$O(A^H)$ 的搜索复杂度
环境不确定性	工具调用失败、外部信息变化	非平稳马尔可夫决策过程
推理与执行的耦合	计划与执行脱节导致"想得好但做不对"	认知架构的断层

二、规划算法的范式演进

2.1 第一代：基于提示的链式推理（Chain-of-Thought）

核心思想：通过 few-shot 示例引导 LLM 进行逐步推理。

# CoT 基础模板
COT_PROMPT = """
Q: 一个农场有鸡和兔共35只，脚共94只。鸡兔各几只？
A: 让我逐步思考。设鸡x只，兔y只。
   方程1: x + y = 35
   方程2: 2x + 4y = 94
   由方程1得 x = 35 - y
   代入方程2: 2(35-y) + 4y = 94 → 70 + 2y = 94 → y = 12
   所以鸡23只，兔12只。答案正确。
"""

局限性：线性推理无法回溯，一旦中间步骤出错，错误会级联传播。

2.2 第二代：推理与行动交织（ReAct）

论文：ReAct: Synergizing Reasoning and Acting in Language Models (Yao et al., 2022)

ReAct 将推理（Reasoning）与行动（Acting）交织，形成 Thought → Action → Observation 的循环架构：

┌───────────────────────────────────────────┐
│  User Query: "2024年诺贝尔物理学奖得主"     │
│                                           │
│  Thought 1: 我需要搜索最新信息             │
│  Action 1: Search["2024 Nobel Physics"]   │
│  Observation 1: John Hopfield, Geoffrey   │
│                 Hinton                    │
│                                           │
│  Thought 2: 我需要确认获奖原因             │
│  Action 2: Search["Hopfield Hinton Nobel  │
│                 Physics 2024 reason"]     │
│  Observation 2: For foundational work...  │
│                                           │
│  Thought 3: 我已获得足够信息，可以回答      │
│  Action 3: Finish["John Hopfield and      │  
│                 Geoffrey Hinton..."]      │
└───────────────────────────────────────────┘

核心代码骨架：

class ReActAgent:
    def __init__(self, llm, tools, max_iterations=10):
        self.llm = llm
        self.tools = {t.name: t for t in tools}
        self.max_iterations = max_iterations
        
    def run(self, query: str) -> str:
        trajectory = []  # 存储 (thought, action, observation) 三元组
        
        for i in range(self.max_iterations):
            # 构建上下文：历史轨迹 + 当前查询
            prompt = self._build_prompt(query, trajectory)
            
            # LLM 生成 Thought + Action
            response = self.llm.generate(prompt)
            thought, action = self._parse(response)
            
            if action.type == "Finish":
                return action.argument
            
            # 执行工具调用
            observation = self.tools[action.name].run(action.argument)
            trajectory.append((thought, action, observation))
            
        raise MaxIterationExceeded()

关键洞察：ReAct 将 Planning 建模为 部分可观察马尔可夫决策过程（POMDP） 的在线求解，每一步的 Thought 是对信念状态的隐式更新。

2.3 第三代：树状搜索与系统探索（Tree of Thoughts）

论文：Tree of Thoughts: Deliberate Problem Solving with Large Language Models (Yao et al., 2023)

ToT 将线性推理扩展为树状搜索，允许 Agent 探索多条推理路径并主动回溯。

算法核心：

状态表示: s = (text_context, 当前推理步骤)
动作空间: A = {生成下一步推理, 评估当前路径, 回溯到父节点}

ToT 循环:
  1. 扩展（Expansion）: 从当前节点生成 k 个候选 Thought
  2. 评估（Evaluation）: 用 LLM 或启发式函数打分每个候选
  3. 搜索（Search）: 选择得分最高的节点继续扩展（BFS/DFS/Beam Search）
  4. 终止（Termination）: 达到目标深度或找到可行解

ToT vs ReAct 的本质差异：

维度	ReAct	ToT
搜索空间	单路径（贪婪）	多路径（分支）
回溯能力	无	有
计算成本	$O (H)$	$O(k^H)$ （可通过剪枝控制）
适用场景	简单工具调用	数学证明、创意写作、策略游戏

评估函数设计（ToT 的关键）：

def evaluate_thought(thought: str, problem: str) -> float:
    """
    使用 LLM 作为价值函数评估推理质量
    可采用 1-10 打分、投票、或相对比较
    """
    eval_prompt = f"""
    评估以下推理步骤对解决问题的帮助程度：
    问题: {problem}
    推理: {thought}
    
    请给出 1-10 的评分，并简要说明理由。
    评分: """
    
    score_text = llm.generate(eval_prompt)
    return parse_score(score_text)

2.4 第四代：符号规划与 LLM 的融合（LLM+P）

论文：LLM+P: Empowering Large Language Models with Optimal Planning Proficiency (Liu et al., 2023)

核心洞见：对于需要严格最优解的规划问题（如路径规划、资源调度），纯 LLM 的启发式推理不如经典符号规划器（如 PDDL + FastDownward）。

LLM+P 的架构是 双系统协作：

┌──────────────┐      自然语言描述     ┌──────────────┐
│   用户查询    │ ───────────────────→ │     LLM      │
│  "帮我规划    │                      │  1. 理解意图  │
│   旅行路线"   │                      │  2. 提取约束  │
└──────────────┘                      │  3. 生成PDDL  │
                                      └──────┬────────┘
                                             │ PDDL
                                             ▼
                                      ┌────────────────┐
                                      │  符号规划器     │
                                      │ (FastDownward) │
                                      │  最优求解       │
                                      └──────┬─────────┘
                                             │ 计划
                                             ▼
                                      ┌────────────────┐
                                      │     LLM        │
                                      │  翻译为自然语言 │
                                      └────────────────┘

PDDL 生成示例：

def nl_to_pddl(natural_language: str, domain_template: str) -> str:
    """
    将自然语言问题转化为 PDDL 规划定义
    """
    prompt = f"""
    将以下旅行规划问题转化为 PDDL (Planning Domain Definition Language)。
    
    问题: {natural_language}
    
    要求:
    - 定义 objects (城市、交通工具)
    - 定义 init (初始状态)
    - 定义 goal (目标状态)
    - 使用给定的 domain 模板: {domain_template}
    
    输出完整的 problem.pddl 内容。
    """
    return llm.generate(prompt)

优势：保证最优性、可解释性、可验证性；局限：依赖精确的 PDDL 生成，对开放域问题适应性差。

2.5 第五代：自我反思与迭代优化（Reflexion）

论文：Reflexion: Self-Reflective Agents (Shinn et al., 2023)

Reflexion 引入 元认知（Metacognition） 层，让 Agent 从失败中学习：

执行循环:
  ┌──────────┐
  │  尝试执行 │
  └────┬─────┘
       ▼
  ┌──────────┐     失败    ┌───────────┐
  │ 成功?     │ ─────────→ │  反思     │
  └────┬─────┘             │ 1. 哪错了 │
       │ 是                │ 2. 怎么改 │
       ▼                   └─────┬─────┘
  ┌──────────┐                   │
  │  完成     │←─────────────────┘
  └──────────┘      更新记忆

记忆结构：

@dataclass
class ReflexionMemory:
    successes: List[str]      # 成功的经验模式
    failures: List[str]       # 失败案例与教训
    heuristics: List[str]    # 累积的启发式规则
    
    def get_context(self) -> str:
        return f"""
        过往成功经验: {self.successes[-5:]}
        过往失败教训: {self.failures[-5:]}
        累积启发式: {self.heuristics[-5:]}
        """

反思提示模板：

REFLEXION_PROMPT = """
你之前的尝试失败了。请分析原因并总结教训。

原始任务: {task}
你的计划: {previous_plan}
执行结果: {result}
错误信息: {error}

请回答:
1. 计划中的哪一步导致了失败？
2. 失败的根本原因是什么？
3. 下次遇到类似情况应如何避免？
4. 总结一条通用启发式规则。

反思:
"""

三、前沿方向：2024-2025 的关键突破

3.1 基于强化学习的规划（RL for Planning）

将 Planning 建模为 RL 问题，LLM 作为策略网络：

ReAct + RL：将 Thought-Action 序列视为轨迹，用 PPO 优化长期回报
MCTS + LLM：用蒙特卡洛树搜索指导 LLM 的生成，AlphaGo 的 LLM 版本
Tool Learning as RL：工具调用视为动作空间，奖励函数设计为任务完成度

3.2 多 Agent 协作规划

MetaGPT / AutoGen 范式：将复杂任务分解为角色协作：

# 简化版多 Agent 规划框架
class MultiAgentPlanner:
    def __init__(self):
        self.planner = Agent(role="架构师", skills=["分解任务"])
        self.executor = Agent(role="工程师", skills=["编码", "调试"])
        self.reviewer = Agent(role="审查员", skills=["代码审查"])
        
    def run(self, task: str):
        # 1. 架构师制定计划
        plan = self.planner.plan(task)
        
        # 2. 工程师执行（可并行）
        results = self.executor.execute_parallel(plan.subtasks)
        
        # 3. 审查员验证
        feedback = self.reviewer.review(results)
        
        # 4. 迭代优化
        if not feedback.approved:
            plan = self.planner.revise(plan, feedback)
            return self.run(task)  # 递归优化

3.3 世界模型驱动的规划（World Model）

借鉴 JEPA（Joint Embedding Predictive Architecture）思想，构建环境的内部表征：

预测：给定当前状态 $s_t$ 和动作 $a_t$ ，预测下一状态 $s_{t+1}$
想象：在"脑海"中模拟多步执行，选择最优路径
验证：将想象结果与现实对比，修正世界模型

四、工程实践：构建生产级 Planning 系统

4.1 架构设计原则

┌─────────────────────────────────────────────┐
│              Planning Engine                │
├─────────────────────────────────────────────┤
│  Planner Selector                           │
│  ├── Heuristic Router (根据任务复杂度选择)   │
│  │   ├── Simple → ReAct (延迟 < 200ms)      │
│  │   ├── Medium → ToT (Beam Search, k=3)    │
│  │   └── Complex → LLM+P + Reflexion        │
│  │                                          │
│  ├── Memory Manager                         │
│  │   ├── Short-term (当前会话上下文)         │
│  │   └── Long-term (向量数据库 + Reflexion)  │
│  │                                          │
│  └── Execution Monitor                      │
│      ├── 超时检测 (Timeout Guard)            │
│      ├── 循环检测 (Loop Detection)           │
│      └── 成本预算 (Token Budget)             │
└─────────────────────────────────────────────┘

4.2 关键性能指标（KPI）

指标	定义	目标值
Plan Success Rate	计划成功执行的比例	> 85%
Recovery Rate	失败后通过 Reflexion 恢复的比例	> 60%
Planning Latency	从接收任务到输出首步计划的时间	< 500ms
Token Efficiency	完成任务所需 Token 数	最小化
Plan Optimality	与最优解的成本差距	< 20%

4.3 调试与可观测性

生产环境中必须实现 Planning Trace：

@dataclass
class PlanningTrace:
    trace_id: str
    query: str
    selected_planner: str
    steps: List[PlanStep]      # 每步的 Thought, Action, Observation
    latency_ms: float
    token_usage: int
    final_result: str
    is_success: bool
    reflexion_count: int       # 反思迭代次数