Session 05: planning — adjusting the plan from execution results

前面几篇已经讨论过 Agent 的基本循环、Tool、Context Engineering 和 Memory。Planning 要解决一个实际问题:用户交给 Agent 的任务比较复杂时,Agent 怎么安排接下来的行动?执行过程中发现资料不够、工具失败,或者出现原计划没有考虑到的新情况,又该怎么办?

Originally in ChineseThis article was written in Chinese. The body below is the Chinese original; the English translation is not available yet.

以研究 Agent 为例。用户要求它“研究近期 AI Agent 的技术趋势,并生成一份有来源依据的报告”。这个任务通常要经历搜索、筛选资料、补充调查、分析和写作。直接让模型一口气完成,过程很难控制;把所有步骤写死在程序里,又会失去 Agent 根据实际情况调整行动的能力。

Planning 可以理解为一套协作机制:LLM 负责理解目标、提出计划,并根据执行结果决定是否调整;程序负责执行工具、保存状态、处理异常,并把真实的执行结果交回 LLM。

本文重点看具体的 System Prompt、LLM 消息、Tool 返回值,以及程序如何把这些内容串起来。

1. 先让 LLM 制定计划

最简单的方式,是在 System Prompt 中要求模型先制定计划,再逐步执行。

text
你是一个研究 Agent,需要根据用户的目标收集资料、分析信息并生成研究报告。

处理复杂任务时:
1. 开始执行前,先制定一个执行计划,将任务拆解为若干可执行的步骤。
2. 每次执行一个步骤。
3. 如果需要外部信息,调用相应的工具。
4. 根据工具返回的结果决定下一步行动。
5. 所有必要工作完成后,生成最终研究报告。

用户发来请求:

text
研究最近一个月 AI Agent 领域的技术趋势,重点关注主流框架、Agent 工程实践和企业落地案例。报告中的关键结论需要有来源依据。

程序把 System Prompt 和 User 消息一起发给 LLM。模型可能先返回一个计划:

json
{
  "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 通常是:

text
LLM 决定下一步
    ↓
如果要调用工具,程序执行工具
    ↓
程序把工具结果返回给 LLM
    ↓
LLM 再决定下一步

即使这个循环运行了很多次,也不代表它一定有显式的 Planning。模型可能每次只考虑眼前的下一步,并没有在开始时生成完整计划。

显式 Planning 会多出一份计划,后续行动围绕它展开:

text
用户目标 → LLM 生成初始计划 → 程序保存计划
  → LLM 根据计划选择下一步 → 程序执行工具
  → 执行结果返回 LLM → 继续原计划或调整计划 → 完成任务

Planning 不要求一定有单独的 Planner 节点。最简单的 Agent 可以让同一个 LLM 节点负责生成计划、选择行动和调整计划。是否拆成 Planner、Executor、Replanner,是后续的架构选择。

3. 为什么要把计划和进度保存在程序状态里

一种直觉上的做法,是让 LLM 在对话中自己记住所有步骤,每次只告诉它“现在是第二步,还剩三步”。简单任务中,这可能够用。但任务一旦变长,计划可能被修改,步骤也可能增加、删除或跳过。只传步骤编号容易产生歧义:原来的第二步和调整后的第二步,可能已经不是同一件事。

更稳妥的方式,是在程序中保存当前有效的计划和执行状态:

python
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 保持通用规则:

text
你是一个研究 Agent。你的任务是根据用户目标收集证据、分析信息并生成研究报告。

你会收到当前计划和执行记录。每一轮都要根据真实的执行结果决定下一步行动。

你可以:
- 继续执行当前计划中的步骤;
- 在原计划不再合适时,调整、增加、删除或跳过步骤;
- 在工具失败时,分析错误并尝试合理的替代方案;
- 在资料不足时继续收集信息;
- 在任务已经完成时输出最终结果。

不要仅仅因为计划中的步骤都已执行,就认定用户目标已经达成。应检查现有证据是否足以支持最终结论。不要声称执行了实际没有执行的工具操作,也不要编造搜索结果。

当前任务状态则作为另一条消息提供,例如使用 developer 消息传入运行时状态:

text
当前任务目标:
研究最近一个月 AI Agent 领域的技术趋势,并生成有来源依据的报告。

当前计划:
1. 搜索近期 AI Agent 新闻(completed)
2. 收集主流框架和工程实践资料(in_progress)
3. 收集企业落地案例并核实事实(pending)
4. 分析趋势并撰写报告(pending)

已完成工作:
- 已搜索到若干近期技术新闻。
- 初步发现 Agent 工作流、工具调用和运行可靠性是多个来源反复提及的主题。

最近一次执行结果:
搜索框架资料的工具返回了 5 个结果,其中 2 个与目标直接相关,3 个结果缺少发布日期。

请根据当前计划和这些结果决定下一步行动。如果资料不足,可以继续搜索或调整计划。

System Prompt 定义相对稳定的行为规则,运行时消息提供这一次任务的状态和事实。不同 API 或框架可能把运行时状态放在 developer、user 消息或专门的状态字段里;关键是把固定规则和动态任务数据区分清楚。

5. 动态计划:执行结果可能改变接下来的步骤

假设 Agent 正在收集主流框架的技术资料。搜索工具返回:

json
{
  "ok": true,
  "results": [
    {
      "title": "Agent Framework X 发布新版本",
      "url": "https://example.com/framework-x",
      "snippet": "介绍了新的状态管理和执行恢复能力。"
    },
    {
      "title": "Agent 系统工程实践",
      "url": "https://example.com/agent-engineering",
      "snippet": "讨论了工具调用、状态管理和执行可靠性。"
    }
  ]
}

LLM 发现第一个来源提到了状态管理和执行恢复,但当前计划没有专门研究这个方向。它可以提出调整后的计划:

json
{
  "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 绕开问题

比如程序调用搜索工具时遇到网络超时。程序应捕获异常,并把失败作为真实的工具结果返回给模型:

python
try:
    result = search_web(query)
except TimeoutError as exc:
    result = {
        "ok": False,
        "error_type": "timeout",
        "message": str(exc),
    }

工具结果可以作为 Tool 消息传回 LLM:

json
{
  "role": "tool",
  "tool_call_id": "call_abc123",
  "content": "{\"ok\": false, \"error_type\": \"timeout\", \"message\": \"Search request timed out\"}"
}

System Prompt 可以预先规定通用错误处理策略:

text
当工具调用失败时:
1. 分析失败类型和错误信息。
2. 如果可以通过修改参数解决,允许在合理次数内重试。
3. 如果当前工具不可用,尝试其他可用工具或替代方法。
4. 如果失败导致当前计划无法继续,调整计划。
5. 如果没有可靠的替代方案,说明限制,不要假装任务已完成。

不必每次失败都把错误追加到 System Prompt。通用错误处理规则放在 System Prompt 中;具体失败原因则作为 Tool 消息或运行时状态传入。程序也不能完全把错误恢复交给 LLM:它仍要限制重试次数、设置超时、记录错误,并对有副作用的操作做权限控制。搜索请求超时后可以有限重试;发送邮件、发布文章或创建付费资源,则需要考虑重复执行的风险。

7. LLM 说步骤完成了,程序应该直接相信吗

LLM 可以判断计划是否需要调整,但它对任务完成状态的判断不一定可靠。

例如,计划要求收集至少三个独立来源来支撑某个技术趋势。模型搜索一次后就说“资料收集完成”,但实际只得到一篇无关文章。如果程序直接把这个判断当作事实,后续分析和报告就可能建立在不足的证据上。

因此,需要区分两类信息:

  • 模型提出的判断:某一步已经完成,或者应该新增一个步骤。
  • 程序能够核实的事实:工具实际返回了多少条结果、哪些调用成功、结果是否为空、哪些任务已经执行。

程序可以检查明确的条件:

python
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。

python
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:

text
Agent Node
   ↓
判断是否有 Tool Call
   ├── 有 → Tool Node → Agent Node
   └── 无 → 结束

Agent Node 可以负责生成初始计划、读取执行结果、决定下一步行动以及修改计划。Tool Node 负责执行模型请求的工具。

State 可以保存:

python
state = {
    "goal": "...",
    "plan": [...],
    "observations": [...],
    "messages": [...],
}

计划中的每个步骤不需要对应一个 Node。“搜索新闻”“搜索框架资料”“搜索企业案例”都可以通过同一个 Tool Node 调用不同工具完成。

当任务需要更复杂的控制时,可以再拆出专门的 Planner、Executor、验证或 Replanner 节点。这样职责更明确,也会增加状态定义和路由逻辑。是否拆分,应由流程复杂度和可维护性决定,而不是由计划有多少步决定。

10. 并行任务是 Planning 的进一步扩展

研究任务不一定是线性的。搜索框架资料和搜索企业案例可以同时进行;分析趋势则要等资料回来后才能执行。此时,只有 current_step 这样的单一编号就不够了,可以在计划中记录任务依赖关系:

json
{
  "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 不只是让模型“先想一想步骤”。真正的工程实现还要把模型提出的计划转换成程序能够保存、执行、验证和恢复的状态。

On this page