Session 05:Planning——让 Agent 根据执行结果调整计划
前面几篇已经讨论过 Agent 的基本循环、Tool、Context Engineering 和 Memory。Planning 要解决一个实际问题:用户交给 Agent 的任务比较复杂时,Agent 怎么安排接下来的行动?执行过程中发现资料不够、工具失败,或者出现原计划没有考虑到的新情况,又该怎么办?
以研究 Agent 为例。用户要求它“研究近期 AI Agent 的技术趋势,并生成一份有来源依据的报告”。这个任务通常要经历搜索、筛选资料、补充调查、分析和写作。直接让模型一口气完成,过程很难控制;把所有步骤写死在程序里,又会失去 Agent 根据实际情况调整行动的能力。
Planning 可以理解为一套协作机制:LLM 负责理解目标、提出计划,并根据执行结果决定是否调整;程序负责执行工具、保存状态、处理异常,并把真实的执行结果交回 LLM。
本文重点看具体的 System Prompt、LLM 消息、Tool 返回值,以及程序如何把这些内容串起来。
1. 先让 LLM 制定计划
最简单的方式,是在 System Prompt 中要求模型先制定计划,再逐步执行。
你是一个研究 Agent,需要根据用户的目标收集资料、分析信息并生成研究报告。
处理复杂任务时:
1. 开始执行前,先制定一个执行计划,将任务拆解为若干可执行的步骤。
2. 每次执行一个步骤。
3. 如果需要外部信息,调用相应的工具。
4. 根据工具返回的结果决定下一步行动。
5. 所有必要工作完成后,生成最终研究报告。
用户发来请求:
研究最近一个月 AI Agent 领域的技术趋势,重点关注主流框架、Agent 工程实践和企业落地案例。报告中的关键结论需要有来源依据。
程序把 System Prompt 和 User 消息一起发给 LLM。模型可能先返回一个计划:
{
"plan": [
{"id": "step_1", "task": "搜索最近一个月 AI Agent 领域的重要新闻和技术发布"},
{"id": "step_2", "task": "收集主流 Agent 框架和工程实践的资料"},
{"id": "step_3", "task": "收集企业落地案例,并核实关键事实"},
{"id": "step_4", "task": "综合资料,分析技术趋势并生成有来源依据的报告"}
]
}
计划可以作为普通文本返回,也可以要求模型按 JSON 格式输出。结构化输出更方便程序解析、保存和修改;普通文本容易开始,但后续需要程序从文本中提取步骤。JSON 只解决了“如何表示计划”的问题,并不能保证计划合理。模型仍可能遗漏关键工作,后续执行需要根据实际情况调整。
2. Planning 和普通 Agent Loop 有什么区别
一个最简单的 Agent Loop 通常是:
LLM 决定下一步
↓
如果要调用工具,程序执行工具
↓
程序把工具结果返回给 LLM
↓
LLM 再决定下一步
即使这个循环运行了很多次,也不代表它一定有显式的 Planning。模型可能每次只考虑眼前的下一步,并没有在开始时生成完整计划。
显式 Planning 会多出一份计划,后续行动围绕它展开:
用户目标 → LLM 生成初始计划 → 程序保存计划
→ LLM 根据计划选择下一步 → 程序执行工具
→ 执行结果返回 LLM → 继续原计划或调整计划 → 完成任务
Planning 不要求一定有单独的 Planner 节点。最简单的 Agent 可以让同一个 LLM 节点负责生成计划、选择行动和调整计划。是否拆成 Planner、Executor、Replanner,是后续的架构选择。
3. 为什么要把计划和进度保存在程序状态里
一种直觉上的做法,是让 LLM 在对话中自己记住所有步骤,每次只告诉它“现在是第二步,还剩三步”。简单任务中,这可能够用。但任务一旦变长,计划可能被修改,步骤也可能增加、删除或跳过。只传步骤编号容易产生歧义:原来的第二步和调整后的第二步,可能已经不是同一件事。
更稳妥的方式,是在程序中保存当前有效的计划和执行状态:
state = {
"goal": "研究近期 AI Agent 技术趋势并生成报告",
"plan": [
{"id": "step_1", "task": "搜索近期 AI Agent 新闻", "status": "pending"},
{"id": "step_2", "task": "收集框架和工程实践资料", "status": "pending"},
{"id": "step_3", "task": "收集企业案例并核实事实", "status": "pending"},
{"id": "step_4", "task": "分析趋势并撰写报告", "status": "pending"}
],
"observations": []
}
这里的 state 是程序维护的数据,不是 LLM 自动拥有的记忆。程序可以在每次调用模型时,把必要的状态序列化进消息;如果使用 LangGraph,则可以把这些字段放进 Graph State。
程序保存状态,不等于每个状态都要有一个 Node。 Node 表示一段执行逻辑,State 表示这次任务进行到了什么程度。计划有四步还是四十步,都可以由同一组通用节点反复处理。
4. 如何把当前计划交给 LLM
每次调用模型时,程序可以把当前计划、已完成工作和最近一次执行结果放入消息中。
System Prompt 保持通用规则:
你是一个研究 Agent。你的任务是根据用户目标收集证据、分析信息并生成研究报告。
你会收到当前计划和执行记录。每一轮都要根据真实的执行结果决定下一步行动。
你可以:
- 继续执行当前计划中的步骤;
- 在原计划不再合适时,调整、增加、删除或跳过步骤;
- 在工具失败时,分析错误并尝试合理的替代方案;
- 在资料不足时继续收集信息;
- 在任务已经完成时输出最终结果。
不要仅仅因为计划中的步骤都已执行,就认定用户目标已经达成。应检查现有证据是否足以支持最终结论。不要声称执行了实际没有执行的工具操作,也不要编造搜索结果。
当前任务状态则作为另一条消息提供,例如使用 developer 消息传入运行时状态:
当前任务目标:
研究最近一个月 AI Agent 领域的技术趋势,并生成有来源依据的报告。
当前计划:
1. 搜索近期 AI Agent 新闻(completed)
2. 收集主流框架和工程实践资料(in_progress)
3. 收集企业落地案例并核实事实(pending)
4. 分析趋势并撰写报告(pending)
已完成工作:
- 已搜索到若干近期技术新闻。
- 初步发现 Agent 工作流、工具调用和运行可靠性是多个来源反复提及的主题。
最近一次执行结果:
搜索框架资料的工具返回了 5 个结果,其中 2 个与目标直接相关,3 个结果缺少发布日期。
请根据当前计划和这些结果决定下一步行动。如果资料不足,可以继续搜索或调整计划。
System Prompt 定义相对稳定的行为规则,运行时消息提供这一次任务的状态和事实。不同 API 或框架可能把运行时状态放在 developer、user 消息或专门的状态字段里;关键是把固定规则和动态任务数据区分清楚。
5. 动态计划:执行结果可能改变接下来的步骤
假设 Agent 正在收集主流框架的技术资料。搜索工具返回:
{
"ok": true,
"results": [
{
"title": "Agent Framework X 发布新版本",
"url": "https://example.com/framework-x",
"snippet": "介绍了新的状态管理和执行恢复能力。"
},
{
"title": "Agent 系统工程实践",
"url": "https://example.com/agent-engineering",
"snippet": "讨论了工具调用、状态管理和执行可靠性。"
}
]
}
LLM 发现第一个来源提到了状态管理和执行恢复,但当前计划没有专门研究这个方向。它可以提出调整后的计划:
{
"decision": "revise_plan",
"reason": "新发现的框架版本包含值得调查的状态管理与执行恢复能力,原计划没有覆盖这一点。",
"plan": [
{"id": "step_1", "task": "搜索近期 AI Agent 新闻", "status": "completed"},
{"id": "step_2", "task": "收集主流框架和工程实践资料", "status": "completed"},
{"id": "step_2b", "task": "调查新版本中的状态管理与执行恢复能力", "status": "pending"},
{"id": "step_3", "task": "收集企业落地案例并核实事实", "status": "pending"},
{"id": "step_4", "task": "综合资料、分析趋势并撰写报告", "status": "pending"}
],
"next_action": {
"type": "tool_call",
"tool": "search_web",
"arguments": {"query": "Framework X state management execution recovery documentation"}
}
}
这是一种可能的结构化协议。实际实现可以把“计划更新”和“工具调用”设计成同一次输出里的两个部分,也可以分成两轮完成。关键是让字段有明确约定,方便程序解析。
动态计划也不意味着每次有新结果就要改计划。如果原计划仍然可行,就继续执行。无故反复规划会增加模型调用、Token 成本和执行延迟,也容易让任务越跑越偏。
6. Tool 失败时,如何让 Agent 绕开问题
比如程序调用搜索工具时遇到网络超时。程序应捕获异常,并把失败作为真实的工具结果返回给模型:
try:
result = search_web(query)
except TimeoutError as exc:
result = {
"ok": False,
"error_type": "timeout",
"message": str(exc),
}
工具结果可以作为 Tool 消息传回 LLM:
{
"role": "tool",
"tool_call_id": "call_abc123",
"content": "{\"ok\": false, \"error_type\": \"timeout\", \"message\": \"Search request timed out\"}"
}
System Prompt 可以预先规定通用错误处理策略:
当工具调用失败时:
1. 分析失败类型和错误信息。
2. 如果可以通过修改参数解决,允许在合理次数内重试。
3. 如果当前工具不可用,尝试其他可用工具或替代方法。
4. 如果失败导致当前计划无法继续,调整计划。
5. 如果没有可靠的替代方案,说明限制,不要假装任务已完成。
不必每次失败都把错误追加到 System Prompt。通用错误处理规则放在 System Prompt 中;具体失败原因则作为 Tool 消息或运行时状态传入。程序也不能完全把错误恢复交给 LLM:它仍要限制重试次数、设置超时、记录错误,并对有副作用的操作做权限控制。搜索请求超时后可以有限重试;发送邮件、发布文章或创建付费资源,则需要考虑重复执行的风险。
7. LLM 说步骤完成了,程序应该直接相信吗
LLM 可以判断计划是否需要调整,但它对任务完成状态的判断不一定可靠。
例如,计划要求收集至少三个独立来源来支撑某个技术趋势。模型搜索一次后就说“资料收集完成”,但实际只得到一篇无关文章。如果程序直接把这个判断当作事实,后续分析和报告就可能建立在不足的证据上。
因此,需要区分两类信息:
- 模型提出的判断:某一步已经完成,或者应该新增一个步骤。
- 程序能够核实的事实:工具实际返回了多少条结果、哪些调用成功、结果是否为空、哪些任务已经执行。
程序可以检查明确的条件:
def validate_research_results(results, min_sources=3):
valid_results = [
item for item in results
if item.get("title") and item.get("url")
]
if len(valid_results) < min_sources:
return {
"ok": False,
"reason": (
f"有效来源不足:需要至少 {min_sources} 个,"
f"目前只有 {len(valid_results)} 个。"
),
}
return {"ok": True, "valid_count": len(valid_results)}
检查失败后,程序可以把验证结果交回 LLM,让它继续搜索或调整计划。这不要求程序理解所有研究内容:能够明确判断的条件交给程序,更依赖语义的判断则可以交给 LLM,重要场景再增加验证步骤。
8. 一个简化的 Python 执行骨架
前面的示例展示了消息内容和状态结构。下面把核心循环连起来。为了突出 Planning 逻辑,示例用 llm_decide() 表示模型调用适配层;实际项目需要用所选模型 SDK 实现它,并把模型输出解析为结构化决策。
假设模型每轮返回以下类型之一:plan、tool_call、revise_plan、continue 或 final。
from typing import Any
def run_agent(goal: str, llm_decide, tools: dict[str, Any], max_rounds=20):
state = {
"goal": goal,
"plan": [],
"observations": [],
"final": None,
}
for _ in range(max_rounds):
# llm_decide 将 System Prompt、当前 state 和必要的消息历史发给模型,
# 并把模型输出解析成结构化 dict。
decision = llm_decide(state)
action = decision["type"]
if action == "plan":
state["plan"] = decision["plan"]
continue
if action == "revise_plan":
state["plan"] = decision["plan"]
state["observations"].append({
"type": "plan_revision",
"reason": decision.get("reason", ""),
})
continue
if action == "tool_call":
tool_name = decision["tool"]
arguments = decision.get("arguments", {})
if tool_name not in tools:
tool_result = {
"ok": False,
"error_type": "unknown_tool",
"message": f"Tool not found: {tool_name}",
}
else:
try:
value = tools[tool_name](**arguments)
tool_result = {"ok": True, "result": value}
except Exception as exc:
tool_result = {
"ok": False,
"error_type": type(exc).__name__,
"message": str(exc),
}
state["observations"].append({
"type": "tool_result",
"tool": tool_name,
"arguments": arguments,
"result": tool_result,
})
continue
if action == "continue":
state["observations"].append({
"type": "note",
"content": decision.get("reason", ""),
})
continue
if action == "final":
return decision["content"]
raise ValueError(f"Unsupported decision type: {action}")
raise RuntimeError("Agent reached max_rounds without finishing")
这是控制流程骨架,不是开箱即用的生产级 Agent。真实实现还要定义 llm_decide() 的模型请求和消息组装逻辑,验证模型输出的 Schema,限制工具参数和调用次数,并把 state 持久化。生产代码也不应把所有异常都当成可恢复错误;哪些异常可以重试、哪些必须终止,应由工具和业务规则决定。
真实的 Tool Calling API 通常会返回专门的工具调用对象及 tool_call_id。程序应使用 API 返回的调用 ID 构造对应的 Tool 消息,而不是自己随意生成或省略关联信息。
9. LangGraph 里怎么理解这些东西
最简单的 LangGraph Agent 可以只有一个 Agent Node 和一个 Tool Node:
Agent Node
↓
判断是否有 Tool Call
├── 有 → Tool Node → Agent Node
└── 无 → 结束
Agent Node 可以负责生成初始计划、读取执行结果、决定下一步行动以及修改计划。Tool Node 负责执行模型请求的工具。
State 可以保存:
state = {
"goal": "...",
"plan": [...],
"observations": [...],
"messages": [...],
}
计划中的每个步骤不需要对应一个 Node。“搜索新闻”“搜索框架资料”“搜索企业案例”都可以通过同一个 Tool Node 调用不同工具完成。
当任务需要更复杂的控制时,可以再拆出专门的 Planner、Executor、验证或 Replanner 节点。这样职责更明确,也会增加状态定义和路由逻辑。是否拆分,应由流程复杂度和可维护性决定,而不是由计划有多少步决定。
10. 并行任务是 Planning 的进一步扩展
研究任务不一定是线性的。搜索框架资料和搜索企业案例可以同时进行;分析趋势则要等资料回来后才能执行。此时,只有 current_step 这样的单一编号就不够了,可以在计划中记录任务依赖关系:
{
"tasks": [
{
"id": "search_frameworks",
"task": "搜索主流 Agent 框架资料",
"depends_on": [],
"status": "pending"
},
{
"id": "search_cases",
"task": "搜索企业 Agent 落地案例",
"depends_on": [],
"status": "pending"
},
{
"id": "analyze",
"task": "综合资料分析趋势",
"depends_on": ["search_frameworks", "search_cases"],
"status": "pending"
}
]
}
程序可以根据依赖关系找出当前能够执行的任务,再决定是否并行调度。LLM 负责提出任务及其依赖关系,程序负责解析、验证和执行这份计划。
这需要额外的协议,例如任务 ID、依赖字段、状态枚举、失败处理和结果汇总规则。它是动态 Planning 的自然延伸,但可以留到后续研究,不必在第一个版本里同时实现。
11. 当前方案的边界
这一版 Planning 可以概括为:LLM 生成并调整计划,程序保存状态、执行工具并记录真实结果;每一轮再把当前有效计划和执行记录提供给 LLM,让它决定下一步行动。
它适合先实现一个能够完成多阶段研究任务的 Agent。不过,仍有几类问题值得后续单独研究:
- 计划质量:模型生成的计划可能遗漏关键步骤、拆分不合理,或者过早进入写作阶段。
- 完成条件:LLM 认为任务完成,并不代表资料充分或用户目标真的达成。
- 循环与成本:动态调整可能导致反复搜索、重复规划,必须限制轮数、工具调用量和总预算。
- 状态恢复:如果 Agent 执行到一半进程退出,重新启动后需要恢复计划、工具结果和执行进度。
- 并行与依赖:任务之间存在依赖关系时,单一的当前步骤已经不够,需要更明确的任务结构和调度逻辑。
Planning 不只是让模型“先想一想步骤”。真正的工程实现还要把模型提出的计划转换成程序能够保存、执行、验证和恢复的状态。