第01章 为什么规划很难：从命令到目标的跨越
第01章 为什么规划很难：从命令到目标的跨越
“给一个工人一把锤子，他会钉钉子。给他一座房子要建，他就需要规划。AI Agent面临的正是后者。” —— 自动规划领域研究者
你告诉一个 Agent：“帮我写一份竞品分析报告。”
这不是一个命令——这是一个目标。在目标和可执行动作之间，横亘着一个巨大的鸿沟。怎么收集竞品信息？收集哪些维度？先写哪部分？如果某个网站访问失败怎么办？格式要求是什么？
规划，就是填平这个鸿沟的能力。它是 Agent 从"工具调用机器"升级为"自主智能体"的关键跨越。
1.1 命令执行 vs. 目标规划：根本区别
# ====================================================
# 对比：命令执行模式 vs. 目标规划模式
# ====================================================
# ---- 模式一：命令执行（传统Assistant）----
# 用户给出精确指令，Agent逐条执行
class CommandExecutor:
"""命令执行模式：一问一答，无规划能力"""
async def execute(self, command: str) -> str:
# 每次调用都是独立的，无记忆，无规划
# 用户必须把任务分解好，才能交给Agent
response = await openai_call(command)
return response
# 使用方式：用户自己做规划
steps = [
"搜索竞品A的功能列表",
"搜索竞品B的定价页面",
"总结以上信息成表格",
"生成报告大纲",
"写报告第一节",
# ... 用户必须想清楚所有步骤
]
for step in steps:
result = await executor.execute(step)
# ---- 模式二：目标规划（Planning Agent）----
# 用户给出高层目标，Agent自己分解并执行
class PlanningAgent:
"""目标规划模式：接收目标，自主制定并执行计划"""
async def pursue_goal(self, goal: str) -> str:
# 第一步：理解目标
goal_analysis = await self.analyze_goal(goal)
# 第二步：制定计划（这是关键！）
plan = await self.create_plan(goal_analysis)
# 第三步：执行计划（可能动态调整）
result = await self.execute_plan(plan)
return result
# 使用方式：用户只需说清楚目标
agent = PlanningAgent()
report = await agent.pursue_goal(
"帮我写一份关于AI Agent平台的竞品分析，"
"对比Langchain、LlamaIndex、CrewAI三家，"
"重点分析功能完整性、定价和开发者体验"
)
# ====================================================
# 核心区别总结
# ====================================================
DIFFERENCE = {
"命令执行": {
"谁来规划": "用户",
"Agent的角色": "执行器",
"灵活性": "低（计划刚性，无法应对意外）",
"适用场景": "步骤清晰、不会变化的固定流程",
"失败方式": "用户没想清楚 → 执行了错误的步骤",
},
"目标规划": {
"谁来规划": "Agent自己",
"Agent的角色": "自主体",
"灵活性": "高（可动态调整、重规划）",
"适用场景": "复杂、多步骤、结果不确定的任务",
"失败方式": "规划器质量不足 → 生成了坏计划",
}
}
1.2 规划失败的七大根源
# ====================================================
# 规划失败案例分析
# ====================================================
import asyncio
from openai import AsyncOpenAI
client = AsyncOpenAI()
# ---- 失败根源 1：目标不明确 ----
async def demo_unclear_goal():
"""模糊目标会导致规划方向错误"""
vague_goal = "帮我分析一下市场"
# Agent可能理解为：
# - 分析股票市场？
# - 分析某产品的目标市场？
# - 分析竞争对手的市场份额？
clear_goal = "分析2026年中国AI Agent SaaS市场，重点关注企业用户规模和头部厂商份额"
# 教训：规划的第一步是澄清目标，而不是立即分解任务
response = await client.chat.completions.create(
model="gpt-4o",
messages=[
{"role": "system", "content": "你是一个规划助手。分析以下目标是否清晰，如不清晰请列出歧义点。"},
{"role": "user", "content": f"目标：{vague_goal}"}
]
)
print("目标分析：", response.choices[0].message.content)
# ---- 失败根源 2：步骤粒度错误 ----
# 粒度太粗：无法执行
bad_plan_too_coarse = [
"Step 1: 了解竞品", # 太模糊，不知道怎么执行
"Step 2: 写报告", # 太模糊，从哪里开始？
]
# 粒度太细：效率极低，难以跟踪
bad_plan_too_fine = [
"打开浏览器",
"在地址栏输入google.com",
"按下回车键",
"在搜索框输入关键词",
"点击搜索按钮",
# ... 几百个步骤
]
# 正确粒度：一步对应一个可测试、可完成的工作单元
good_plan = [
"搜索竞品A的官网，提取产品功能列表", # 1个工具调用可完成
"搜索竞品B的定价页，提取价格信息", # 1个工具调用可完成
"对比功能和价格，生成结构化比较表", # 1次LLM调用可完成
"基于比较表，生成分析报告", # 1次LLM调用可完成
]
# ---- 失败根源 3：忽略前提条件 ----
async def demo_missing_preconditions():
"""忽略步骤前提条件导致执行失败"""
# 错误计划：直接写报告，没检查信息是否充分
broken_plan = [
"写竞品分析报告", # 失败！没有数据，什么都写不出来
]
# 正确计划：先满足前提条件
correct_plan = [
{
"step": "收集竞品信息",
"preconditions": [], # 无前提
"outputs": ["competitor_data"],
},
{
"step": "验证数据完整性",
"preconditions": ["competitor_data"], # 需要上一步完成
"outputs": ["validated_data"],
},
{
"step": "生成分析报告",
"preconditions": ["validated_data"], # 需要上一步完成
"outputs": ["final_report"],
},
]
return correct_plan
# ---- 失败根源 4：不考虑工具局限 ----
TOOL_LIMITATIONS = {
"web_search": {
"限制": "无法访问需要登录的页面",
"错误计划": "搜索competitor的内部定价文档",
"正确做法": "搜索公开定价页面，必要时说明数据不完整",
},
"code_execution": {
"限制": "无法访问外部网络",
"错误计划": "运行代码直接调用第三方API",
"正确做法": "生成代码让用户在本地运行，或使用有网络权限的工具",
},
"file_operations": {
"限制": "只能访问指定目录",
"错误计划": "读取用户根目录下的所有文件",
"正确做法": "只操作工作目录内的文件",
},
}
# ---- 失败根源 5：对结果没有验证 ----
async def plan_without_validation():
"""没有中间验证的计划，错误会级联放大"""
# 每一步都需要验证，而不是假设成功
async def execute_with_validation(step: str, expected_output_type: str) -> dict:
result = await execute_step(step)
# 验证结果
if not result:
raise ValueError(f"步骤 '{step}' 返回空结果")
if expected_output_type == "list" and not isinstance(result, list):
raise TypeError(f"期望列表，得到 {type(result)}")
return {"status": "success", "output": result}
plan = [
("搜索竞品列表", "list"),
("提取每个竞品的功能", "dict"),
("生成比较矩阵", "dataframe"),
]
results = []
for step, output_type in plan:
try:
result = await execute_with_validation(step, output_type)
results.append(result)
except Exception as e:
print(f"步骤失败，需要重规划：{e}")
# 触发重规划逻辑
break
return results
async def execute_step(step: str) -> any:
"""模拟执行步骤"""
return {"result": f"执行了: {step}"}
# ---- 失败根源 6：无法处理并发 ----
async def sequential_vs_parallel():
"""串行 vs. 并行执行对比"""
import time
# 串行执行（效率低）
async def sequential_search():
start = time.time()
result_a = await search("竞品A功能") # 等待3秒
result_b = await search("竞品B功能") # 再等3秒
result_c = await search("竞品C功能") # 再等3秒
elapsed = time.time() - start
print(f"串行执行耗时: {elapsed:.1f}秒") # ~9秒
return [result_a, result_b, result_c]
# 并行执行（规划器识别无依赖关系）
async def parallel_search():
start = time.time()
results = await asyncio.gather(
search("竞品A功能"), # 同时开始
search("竞品B功能"), # 同时开始
search("竞品C功能"), # 同时开始
)
elapsed = time.time() - start
print(f"并行执行耗时: {elapsed:.1f}秒") # ~3秒
return list(results)
# 规划器需要识别：这三步之间没有依赖关系 → 可以并行
# 这是规划质量的重要指标之一
async def search(query: str) -> str:
"""模拟搜索操作"""
await asyncio.sleep(3)
return f"搜索结果: {query}"
# ---- 失败根源 7：过度规划（Analysis Paralysis）----
OVER_PLANNING_EXAMPLE = """
目标：发一条推文
糟糕的过度规划：
1. 市场调研推文效果最佳发布时间
2. A/B测试10个不同文案版本
3. 分析目标受众画像
4. 制定内容日历
5. 设计配图风格指南
6. 规划话题标签策略
... （计划本身花了比写推文更多的时间）
合适的规划：
1. 确定推文主题
2. 起草文案（<280字符）
3. 选择相关话题标签
4. 发布
"""
1.3 规划能力的三个层次
# ====================================================
# Agent规划能力分级模型
# ====================================================
from dataclasses import dataclass
from typing import List, Optional
from enum import Enum
class PlanningLevel(Enum):
REACTIVE = 1 # 反应式：无规划
DELIBERATIVE = 2 # 审慎式：有规划
METACOGNITIVE = 3 # 元认知式：对规划本身进行规划
@dataclass
class AgentCapability:
level: PlanningLevel
description: str
example: str
limitations: List[str]
PLANNING_LEVELS = [
AgentCapability(
level=PlanningLevel.REACTIVE,
description="接到指令立即执行，无任何前瞻性思考",
example="""
# Level 1: 反应式Agent
async def reactive_agent(user_input: str) -> str:
# 直接把输入扔给LLM，不做任何规划
response = await client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": user_input}]
)
return response.choices[0].message.content
# 特点：简单、快速，但无法处理复杂多步骤任务
result = await reactive_agent("帮我分析这份500页的财务报告")
# 结果：直接尝试"分析"，但不知道如何分块、不知道重点，质量极差
""",
limitations=[
"无法分解复杂任务",
"无法处理多步骤依赖",
"遇到障碍不知如何调整",
"无法利用工具完成超出单次调用的任务",
]
),
AgentCapability(
level=PlanningLevel.DELIBERATIVE,
description="在执行前先制定计划，按计划执行，遇到问题可以重规划",
example="""
# Level 2: 审慎式Agent
async def deliberative_agent(goal: str) -> str:
# 步骤1：分析目标，制定计划
plan = await create_plan(goal)
print(f"制定计划: {[s['title'] for s in plan]}")
# 步骤2：按计划执行，跟踪进度
results = []
for step in plan:
try:
result = await execute_step(step)
results.append(result)
except Exception as e:
# 步骤3：遇到障碍，动态重规划
new_steps = await replan(step, e, results)
plan = plan[:plan.index(step)] + new_steps + plan[plan.index(step)+1:]
# 步骤4：综合结果
return await synthesize(results)
# 特点：能处理中等复杂度任务，有基本的错误恢复能力
""",
limitations=[
"规划质量受限于LLM能力",
"无法进行前瞻性风险评估",
"在高度不确定环境中可能规划失效",
]
),
AgentCapability(
level=PlanningLevel.METACOGNITIVE,
description="不仅规划任务，还评估规划质量、预测风险、优化规划策略",
example="""
# Level 3: 元认知式Agent
async def metacognitive_agent(goal: str) -> str:
# 步骤1：分析目标
goal_analysis = await analyze_goal(goal)
# 步骤2：生成多个候选计划
candidate_plans = await generate_multiple_plans(goal_analysis, n=3)
# 步骤3：评估每个计划（元认知！）
plan_scores = []
for plan in candidate_plans:
score = await evaluate_plan(plan, criteria=[
"可行性", "效率", "鲁棒性", "资源消耗"
])
plan_scores.append((plan, score))
# 步骤4：选择最优计划
best_plan = max(plan_scores, key=lambda x: x[1]["total_score"])[0]
# 步骤5：执行，持续监控并调整
return await execute_with_monitoring(best_plan)
# 特点：高质量规划，强鲁棒性，接近人类专家水平
""",
limitations=[
"计算成本高",
"延迟较大（需要多轮LLM调用）",
"实现复杂度高",
]
),
]
# ====================================================
# 本书的覆盖范围
# ====================================================
BOOK_COVERAGE = {
"第1-4章": "掌握 Level 2（审慎式）的核心技术",
"第5-8章": "实现 Level 2 的高级特性（依赖图、动态重规划、树形搜索）",
"第9-11章": "工程实践：让规划系统真正可用",
"第12章": "展望 Level 3（元认知式）的前沿方向",
}
1.4 衡量规划质量的基准框架
# ====================================================
# 规划质量评估框架（贯穿全书）
# ====================================================
from typing import Dict, Any
import json
async def evaluate_plan_quality(
goal: str,
plan: list,
model: str = "gpt-4o"
) -> Dict[str, Any]:
"""
用LLM评估规划质量的简单框架
后续章节会深入展开每个维度
"""
evaluation_prompt = f"""
请评估以下行动计划的质量。
目标：{goal}
计划：
{json.dumps(plan, ensure_ascii=False, indent=2)}
请从以下5个维度评分（1-10分），并给出具体理由：
1. **完整性**：计划是否覆盖了实现目标所需的所有关键步骤？
2. **可行性**：每个步骤是否真实可执行，前提条件是否满足？
3. **效率**：是否有不必要的步骤？是否错过了可并行的机会？
4. **鲁棒性**：计划是否考虑了可能的失败情况和备选方案？
5. **清晰度**：每个步骤的描述是否清晰，执行者能否理解并独立完成？
以JSON格式返回评分结果。
"""
response = await client.chat.completions.create(
model=model,
messages=[{"role": "user", "content": evaluation_prompt}],
response_format={"type": "json_object"}
)
evaluation = json.loads(response.choices[0].message.content)
# 计算总分
scores = [v for k, v in evaluation.items() if k.endswith("_score")]
evaluation["total_score"] = sum(scores) / len(scores) if scores else 0
return evaluation
# ---- 快速测试 ----
async def main():
goal = "写一份AI竞品分析报告"
# 一个糟糕的计划
bad_plan = [
{"step": "了解市场", "action": "搜索"},
{"step": "写报告", "action": "写作"},
]
# 一个较好的计划
good_plan = [
{"step": "明确分析范围", "action": "与用户确认竞品名单和分析维度"},
{"step": "收集竞品A信息", "action": "搜索官网、文档、用户评价"},
{"step": "收集竞品B信息", "action": "搜索官网、文档、用户评价"},
{"step": "收集竞品C信息", "action": "搜索官网、文档、用户评价"},
{"step": "建立比较矩阵", "action": "对齐功能、定价、优劣势"},
{"step": "生成分析报告", "action": "基于矩阵撰写结构化报告"},
{"step": "验证与修订", "action": "检查数据准确性，完善结论"},
]
print("评估糟糕计划：")
bad_score = await evaluate_plan_quality(goal, bad_plan)
print(json.dumps(bad_score, ensure_ascii=False, indent=2))
print("\n评估较好计划：")
good_score = await evaluate_plan_quality(goal, good_plan)
print(json.dumps(good_score, ensure_ascii=False, indent=2))
if __name__ == "__main__":
asyncio.run(main())
本章小结
-
规划是 Agent 的核心能力：从命令执行到目标规划，是 Agent 从工具到自主体的质变。没有规划，Agent 只能做简单、线性、用户已想清楚的任务。
-
规划失败有迹可循：七大失败根源（目标模糊、粒度错误、忽略前提、工具局限、缺少验证、无法并发、过度规划），每一个都有对应的工程解法，本书将逐一覆盖。
-
规划能力分三层：反应式 → 审慎式 → 元认知式。大多数实用系统处于 Level 2，追求 Level 3 是方向，但需权衡成本。
-
质量评估是规划系统的基础设施：完整性、可行性、效率、鲁棒性、清晰度——五个维度缺一不可，贯穿全书。
-
先理解难点，再学解法：规划之所以难，是因为它需要 Agent 具备目标理解、知识推理、工具感知、不确定性处理等多项综合能力。后续章节将分模块深入讲解。
# 核心行动：建立你的第一个规划评估基线
import asyncio
from openai import AsyncOpenAI
async def your_first_planning_baseline():
"""
在你的项目中，选取一个真实任务，
用本章的评估框架衡量现有方案的规划质量。
这将成为后续优化的基准线。
"""
client = AsyncOpenAI()
# 替换为你的真实场景
your_goal = "你的Agent需要完成的目标"
your_current_plan = [
{"step": "步骤1", "action": "具体行动"},
# ... 你现有的方案
]
score = await evaluate_plan_quality(your_goal, your_current_plan)
print(f"当前规划质量评分: {score.get('total_score', 0):.1f}/10")
print("这是你的优化起点。")
asyncio.run(your_first_planning_baseline())
本章提示词模板
【模板1：目标澄清提示词】
你是一个规划助手。用户给出了以下目标，但可能不够清晰：
目标：{user_goal}
请分析：
1. 这个目标中有哪些歧义或不明确之处？
2. 为了制定有效的计划，你需要用户回答哪些澄清问题？（最多3个最重要的问题）
3. 如果用户无法进一步澄清，你会如何做出合理假设？
以结构化格式回答，包含"歧义点"、"澄清问题"和"默认假设"三个部分。
【模板2：计划质量自检提示词】
请检查以下行动计划的质量，作为一个批判性审查者：
目标：{goal}
计划：{plan_json}
逐步检查：
1. 每个步骤的前提条件是否明确且可满足？
2. 步骤之间的依赖关系是否正确？有没有顺序错误？
3. 有哪些步骤可以并行执行以提高效率？
4. 哪些步骤最可能失败？失败时应该怎么处理？
5. 整个计划完成后，目标是否会被完全实现？有没有遗漏？
给出具体的改进建议，而不仅仅是评分。