返回专栏
· 33 分钟阅读

Agent 如何进行任务规划?


一、什么是 Agent 任务规划?

Agent 任务规划(Task Planning)是指 Agent 根据用户目标、当前环境、可用工具和执行约束,自动生成一组有序或可并行执行的子任务,并根据执行反馈持续调整计划的过程。

普通大模型主要解决如何理解和生成内容的问题,而 Agent 任务规划需要解决:

  • 最终目标是什么?
  • 需要拆分成哪些子任务?
  • 子任务之间有什么依赖关系?
  • 每个任务应该使用什么工具?
  • 哪些任务可以并行执行?
  • 执行过程中出现问题怎么办?
  • 如何判断任务真正完成?

例如,用户提出:

分析最近三个月的销售数据,找出销售下降的主要原因,并生成一份分析报告。

这不是一个简单的文本生成任务,而是一个包含多个执行阶段的复杂任务。

Agent 需要将其拆解为:

  1. 确定分析时间范围。
  2. 查询销售数据。
  3. 检查数据完整性。
  4. 统计销售趋势。
  5. 分析产品、地区和客户维度。
  6. 识别销售下降的关键因素。
  7. 交叉验证分析结论。
  8. 生成分析报告。

任务规划的核心是:将一个抽象目标转化为具有明确输入、输出、依赖关系和完成条件的执行计划。

二、任务规划在 Agent 架构中的位置

任务规划通常由 Planner 组件负责,但它不是独立工作的,而是与 Goal Manager、LLM、Tool Registry、State Manager 和 Agent Runtime 协同运行。

1. Planner 在 Agent 中的位置

flowchart TB
    A["用户提交目标"] --> B["Goal Manager"]
    B --> C["Planner"]
    C --> D["LLM Engine"]
    D --> E["生成任务计划"]
    E --> F["Plan Validator"]
    F --> G{"计划是否有效"}
    G -->|"是"| H["Agent Runtime"]
    G -->|"否"| I["修正计划"]
    I --> C
    H --> J["Tool Executor"]
    J --> K["外部环境"]
    K --> L["执行结果"]
    L --> M["State Manager"]
    M --> C

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style D fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style E fill:#EAF3EC,stroke:#83A995,color:#315D49
    style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style G fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style H fill:#EAF3EC,stroke:#83A995,color:#315D49
    style I fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style J fill:#EAF3EC,stroke:#83A995,color:#315D49
    style K fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style L fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style M fill:#EAE8FA,stroke:#A49BD5,color:#51477D

2. Planner 与其他组件的职责边界

组件 核心职责 与规划的关系
Goal Manager 理解目标和约束 提供规划依据
Planner 拆解任务和制定计划 生成执行方案
LLM Engine 推理和生成 提供规划智能
Tool Registry 管理可用工具 提供行动能力描述
Plan Validator 检查计划合法性 验证计划结构
Agent Runtime 驱动任务执行 调度计划中的任务
State Manager 维护任务状态 记录执行进度
Tool Executor 执行具体操作 完成任务动作
Result Validator 验证执行结果 判断目标是否达成

需要注意:Planner 负责决定执行什么,Runtime 负责控制如何执行。两者不能混为一谈。

三、任务规划的完整过程

一个完整的任务规划过程通常包括八个阶段:

  1. 目标理解。
  2. 约束提取。
  3. 环境与能力分析。
  4. 任务分解。
  5. 依赖关系分析。
  6. 工具和资源分配。
  7. 计划验证。
  8. 计划执行与动态调整。

1. 完整规划流程

flowchart TD
    A["接收用户目标"] --> B["理解目标语义"]
    B --> C["提取任务约束"]
    C --> D["分析环境与可用工具"]
    D --> E["分解子任务"]
    E --> F["建立任务依赖关系"]
    F --> G["分配工具与资源"]
    G --> H["生成结构化计划"]
    H --> I["验证计划"]
    I --> J{"计划是否可执行"}
    J -->|"否"| K["修正或重新规划"]
    K --> E
    J -->|"是"| L["提交 Runtime 执行"]
    L --> M["收集执行反馈"]
    M --> N{"是否需要调整"}
    N -->|"是"| K
    N -->|"否"| O["完成任务"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style D fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style E fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style F fill:#EAF3EC,stroke:#83A995,color:#315D49
    style G fill:#EAF3EC,stroke:#83A995,color:#315D49
    style H fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style I fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style J fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style K fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style L fill:#EAF3EC,stroke:#83A995,color:#315D49
    style M fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style N fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style O fill:#DCEFE5,stroke:#4F8B70,color:#24563F

这八个阶段并不意味着必须调用八次大模型。简单任务可以合并多个阶段,复杂任务则可能需要多轮推理和多次计划验证。

四、第一步:目标理解与约束提取

任务规划的质量首先取决于目标理解是否准确。

用户通常使用自然语言描述目标,而自然语言可能存在歧义、信息缺失和隐含约束。

1. 目标结构化

例如:

帮我分析最近三个月的销售数据,找出下降原因,生成报告,不能修改原始数据。

Planner 需要将其解析为:

维度 解析结果
主目标 分析销售下降原因
时间范围 最近三个月
数据来源 销售数据系统
分析内容 销售趋势和影响因素
输出形式 分析报告
操作约束 只读,不允许修改原始数据
完成条件 有数据依据的分析结论和报告

2. 目标与约束必须分离

目标描述要达到什么结果,约束描述执行过程中不能做什么。

例如:

{
  "goal": {
    "description": "分析销售下降原因并生成报告",
    "expected_output": "sales_analysis_report"
  },
  "constraints": {
    "time_range": "last_3_months",
    "data_access": "read_only",
    "allow_data_modification": false,
    "require_evidence": true
  }
}

这种分离有两个重要价值:

  • Planner 可以灵活调整任务步骤,但不能改变用户目标。
  • Runtime 和 Policy Engine 可以独立检查每个动作是否违反约束。

3. 什么时候需要向用户澄清?

如果缺少的信息会显著影响计划,就应该请求用户补充。

例如:

  • 没有指定数据来源。
  • 不清楚分析的时间范围。
  • 用户要求执行某项操作,但没有明确授权。
  • 存在多个相互冲突的目标。
  • 成功标准无法确定。

对于不影响任务正确性的细节,可以使用合理默认值,避免频繁打断用户。

五、第二步:任务分解(Task Decomposition)

任务分解是 Agent 规划中最核心的能力。

复杂目标通常不能直接执行,需要拆分成更小、更明确的子任务。

1. 为什么需要任务分解?

假设直接让 Agent 完成:

分析销售数据并生成报告。

这个任务过于抽象,Agent 无法明确: - 需要读取哪些数据。 - 需要执行哪些统计分析。 - 如何识别销售下降。 - 如何判断影响因素。 - 如何验证结论。 - 报告应该包含哪些内容。

将任务拆分后,每个子任务都可以拥有明确的输入、输出和完成条件。

2. 任务分解的基本原则

原则一:目标明确

每个子任务都应该有清晰的执行目的。

原则二:输入明确

任务需要知道依赖哪些数据或前置结果。

原则三:输出明确

每个任务都应该产生可识别的结果。

原则四:边界清晰

避免多个任务重复处理相同内容。

原则五:粒度适当

任务太粗,难以执行和验证;任务太细,会增加调度成本和模型调用次数。

3. 任务树(Task Tree)

复杂任务可以采用树形结构拆解。

flowchart TD
    A["销售数据分析"] --> B["数据准备"]
    A --> C["销售趋势分析"]
    A --> D["影响因素分析"]
    A --> E["报告生成"]

    B --> B1["查询销售数据"]
    B --> B2["检查数据完整性"]
    B --> B3["清洗异常数据"]

    C --> C1["计算月度销售额"]
    C --> C2["计算同比与环比"]
    C --> C3["识别下降区间"]

    D --> D1["产品维度分析"]
    D --> D2["地区维度分析"]
    D --> D3["客户维度分析"]

    E --> E1["汇总分析结论"]
    E --> E2["生成图表"]
    E --> E3["生成报告"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style B1 fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style B2 fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style B3 fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style C1 fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style C2 fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style C3 fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style D1 fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style D2 fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style D3 fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style E1 fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style E2 fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style E3 fill:#F5F8F4,stroke:#B5CBBB,color:#40594A

需要注意,任务树表达的是层级分解关系,不一定完整表达任务之间的执行依赖。

例如,销售趋势分析和产品维度分析可以并行,但报告生成必须等待相关分析结果。

因此,复杂任务还需要使用依赖图。

六、第三步:任务依赖分析(Dependency Analysis)

任务分解之后,Planner 需要分析各个子任务之间的依赖关系。

任务依赖决定了: - 哪些任务必须先执行。 - 哪些任务可以同时执行。 - 哪些任务需要等待其他任务结果。 - 哪些任务失败会影响整个计划。

1. 任务依赖图

假设销售分析任务包含:

  • A:查询销售数据。
  • B:数据质量检查。
  • C:销售趋势分析。
  • D:产品维度分析。
  • E:地区维度分析。
  • F:汇总报告。

依赖关系:

  • B 依赖 A。
  • C、D、E 依赖 B。
  • F 依赖 C、D、E。
flowchart TD
    A["A:查询销售数据"] --> B["B:数据质量检查"]
    B --> C["C:销售趋势分析"]
    B --> D["D:产品维度分析"]
    B --> E["E:地区维度分析"]
    C --> F["F:汇总报告"]
    D --> F
    E --> F

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style F fill:#DCEFE5,stroke:#4F8B70,color:#24563F

这类结构通常可以表示为有向无环图(DAG)。

2. DAG:有向无环图

DAG(Directed Acyclic Graph)由节点和有向边组成:

  • 节点表示任务。
  • 有向边表示依赖关系。
  • 无环表示任务依赖不存在循环。

例如:

A \rightarrow B \rightarrow C

表示 C 必须等待 B 完成,B 必须等待 A 完成。

如果存在:

A \rightarrow B \rightarrow C \rightarrow A

就形成了循环依赖,任务无法通过普通拓扑调度正常执行。

3. 拓扑排序(Topological Sorting)

对于 DAG,可以使用拓扑排序计算合法执行顺序。

常见算法:

  • Kahn 算法:基于入度和队列。
  • DFS 算法:基于深度优先搜索和完成顺序。

Kahn 算法的基本过程:

  1. 计算所有节点的入度。
  2. 将入度为 0 的节点放入队列。
  3. 取出一个节点并加入执行顺序。
  4. 删除该节点的出边。
  5. 将入度变为 0 的节点加入队列。
  6. 重复处理,直到队列为空。
  7. 如果输出节点数量小于总节点数量,说明存在循环依赖。

Python 实现:

from collections import deque


def topological_sort(tasks, dependencies):
    """
    tasks: 任务 ID 列表
    dependencies: (前置任务, 后置任务)
    """

    graph = {task: [] for task in tasks}
    indegree = {task: 0 for task in tasks}

    for source, target in dependencies:
        graph[source].append(target)
        indegree[target] += 1

    queue = deque(
        task for task in tasks
        if indegree[task] == 0
    )

    result = []

    while queue:
        current = queue.popleft()
        result.append(current)

        for neighbor in graph[current]:
            indegree[neighbor] -= 1

            if indegree[neighbor] == 0:
                queue.append(neighbor)

    if len(result) != len(tasks):
        raise ValueError("检测到循环依赖")

    return result


tasks = ["A", "B", "C", "D", "E", "F"]

dependencies = [
    ("A", "B"),
    ("B", "C"),
    ("B", "D"),
    ("B", "E"),
    ("C", "F"),
    ("D", "F"),
    ("E", "F")
]

print(topological_sort(tasks, dependencies))

时间复杂度:

O(V+E)

其中: - V 表示任务节点数量。 - E 表示任务依赖边数量。

4. 依赖关系不等于执行顺序

这是一个容易混淆的概念。

依赖关系规定任务之间的先后约束,调度器根据依赖关系、资源和优先级决定实际执行顺序。

例如,C、D、E 都依赖 B,但它们之间没有依赖关系。

因此:

  • C、D、E 可以并行执行。
  • 如果资源不足,也可以顺序执行。
  • 如果 D 执行失败,是否阻塞 C 和 E,需要根据失败策略决定。

DAG 描述的是可行的执行约束,而不是唯一的执行顺序。

七、第四步:任务规划的常见算法与模式

Agent 任务规划并不只有一种实现方式。

根据任务复杂度、执行环境和动态变化程度,可以采用不同的规划模式。

1. 顺序规划(Sequential Planning)

顺序规划是最简单的任务规划方式,任务按照明确顺序执行。

适用于: - 数据处理流水线。 - 文件解析。 - 固定业务流程。 - 存在严格前后依赖的任务。

flowchart TD
    A["任务 A"] --> B["任务 B"]
    B --> C["任务 C"]
    C --> D["任务 D"]
    D --> E["任务完成"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style D fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style E fill:#DCEFE5,stroke:#4F8B70,color:#24563F

优点: - 执行逻辑简单。 - 状态管理容易。 - 结果可预测。 - 方便异常定位。

缺点: - 无法充分利用并行资源。 - 前置任务延迟会影响后续所有任务。

2. 并行规划(Parallel Planning)

并行规划将相互独立的任务同时执行。

适用于: - 多数据源查询。 - 多文件分析。 - 多维度数据统计。 - 多个独立子任务。

flowchart TD
    A["主任务"] --> B["任务 A"]
    A --> C["任务 B"]
    A --> D["任务 C"]
    B --> E["结果汇总"]
    C --> E
    D --> E
    E --> F["完成任务"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style F fill:#DCEFE5,stroke:#4F8B70,color:#24563F

并行规划需要考虑:

数据竞争

多个任务是否会同时修改相同资源。

资源竞争

模型调用、数据库连接、API 配额和执行环境是否有限。

结果合并

多个子任务的结果是否具有一致的数据结构。

部分失败

某个任务失败后,其他任务是否继续执行。

3. 条件规划(Conditional Planning)

条件规划根据执行结果决定后续路径。

适用于: - 数据质量检查。 - 审批流程。 - 异常处理。 - 动态业务决策。

flowchart TD
    A["执行数据检查"] --> B{"数据是否完整"}
    B -->|"是"| C["执行数据分析"]
    B -->|"否"| D["补充或修复数据"]
    D --> E{"是否修复成功"}
    E -->|"是"| C
    E -->|"否"| F["终止分析并报告问题"]
    C --> G["生成分析报告"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style E fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style F fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style G fill:#DCEFE5,stroke:#4F8B70,color:#24563F

4. 迭代规划(Iterative Planning)

迭代规划通过不断执行、观察和调整,逐步接近目标。

适用于: - 代码修复。 - 内容优化。 - 参数调优。 - 复杂问题求解。

flowchart TD
    A["生成初始计划"] --> B["执行任务"]
    B --> C["评估执行结果"]
    C --> D{"是否满足目标"}
    D -->|"是"| E["完成任务"]
    D -->|"否"| F["分析差距"]
    F --> G["调整计划"]
    G --> B

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style D fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style E fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style F fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style G fill:#EAE8FA,stroke:#A49BD5,color:#51477D

迭代规划需要设置: - 最大迭代次数。 - 任务总预算。 - 成功判断标准。 - 失败退出条件。 - 计划调整策略。

否则 Agent 可能陷入重复尝试,持续消耗 Token 和工具资源。

5. 分层规划(Hierarchical Planning)

分层规划将复杂任务分成多个抽象层次。

上层负责定义目标和子目标,下层负责具体操作。

例如:

flowchart TD
    A["企业经营分析"]
    A --> B["销售分析"]
    A --> C["成本分析"]
    A --> D["利润分析"]

    B --> B1["查询销售数据"]
    B --> B2["统计销售趋势"]
    B --> B3["分析产品表现"]

    C --> C1["查询成本数据"]
    C --> C2["统计成本变化"]

    D --> D1["计算利润率"]
    D --> D2["分析利润变化"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style B1 fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style B2 fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style B3 fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style C1 fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style C2 fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style D1 fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style D2 fill:#F5F8F4,stroke:#B5CBBB,color:#40594A

分层规划的优势是可以控制复杂度。

上层不需要关注每个工具调用的细节,下层也不需要重新理解整个业务目标。

6. 规划模式对比

规划模式 核心特点 适用场景 主要风险
Sequential 固定顺序 流水线任务 执行效率较低
Parallel 多任务并行 独立子任务 资源竞争
Conditional 条件分支 动态决策 分支复杂
Iterative 反馈迭代 持续优化 无限循环
Hierarchical 多层任务分解 复杂目标 层级协调成本

实际 Agent 通常不是只使用一种模式,而是将多种模式组合成一个任务 DAG。

八、第五步:工具选择与任务分配

任务拆解完成后,Planner 需要确定每个子任务由谁执行,以及使用什么工具。

1. 任务与工具的映射

例如:

子任务 工具 输入 输出
查询销售数据 SQL Tool 时间范围 销售记录
检查数据质量 Python Tool 销售记录 质量报告
统计销售趋势 Data Analysis Tool 销售记录 趋势数据
分析下降原因 LLM / Analysis Tool 分析结果 原因列表
生成报告 Report Tool 分析结论 报告文件

工具选择不能只依赖工具名称,还需要考虑: - 工具描述是否匹配任务。 - 参数是否能够满足要求。 - 工具是否具有必要权限。 - 工具是否可用。 - 执行成本和延迟。 - 工具是否存在副作用。

2. 工具选择机制

工具选择可以由 LLM 进行语义判断,也可以结合规则和工具元数据。

一个常见过程:

flowchart TD
    A["获取待执行任务"] --> B["提取任务能力需求"]
    B --> C["检索可用工具"]
    C --> D["匹配工具描述与参数"]
    D --> E["检查工具权限"]
    E --> F{"是否存在合适工具"}
    F -->|"是"| G["选择工具"]
    F -->|"否"| H["请求补充能力或人工处理"]
    G --> I["生成调用参数"]
    I --> J["提交 Tool Executor"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style E fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style F fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style G fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style H fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style I fill:#EAF3EC,stroke:#83A995,color:#315D49
    style J fill:#DCEFE5,stroke:#4F8B70,color:#24563F

3. 任务分配不等于工具调用

对于复杂系统,一个任务可能由多个工具共同完成。

例如,数据分析任务可能包含:

  • SQL 工具负责读取数据。
  • Python 工具负责统计计算。
  • 图表工具负责生成图形。
  • 文档工具负责生成报告。

Planner 需要决定的是任务执行方案,而不是简单地将所有工作交给一个工具。

九、第六步:结构化计划表示

Planner 最终应该生成结构化计划,而不是只返回自然语言描述。

结构化计划可以被 Runtime 直接调度,并支持状态更新、失败恢复和执行追踪。

1. 任务对象设计

一个标准任务对象可以包含:

字段 说明
task_id 任务唯一标识
name 任务名称
description 任务描述
input 输入数据或引用
output 预期输出
dependencies 前置任务
assigned_tool 执行工具
status 当前状态
priority 优先级
timeout 超时时间
retry_policy 重试策略
success_criteria 完成条件

2. 结构化计划示例

{
  "plan_id": "sales_analysis_001",
  "goal": "分析最近三个月销售下降原因",
  "tasks": [
    {
      "task_id": "T1",
      "name": "query_sales",
      "description": "查询最近三个月销售数据",
      "dependencies": [],
      "assigned_tool": "sql_query",
      "status": "pending",
      "priority": 1,
      "success_criteria": [
        "查询成功",
        "返回销售记录"
      ]
    },
    {
      "task_id": "T2",
      "name": "validate_data",
      "description": "检查数据完整性",
      "dependencies": ["T1"],
      "assigned_tool": "python_analysis",
      "status": "pending",
      "priority": 1,
      "success_criteria": [
        "完成缺失值检查",
        "输出数据质量报告"
      ]
    },
    {
      "task_id": "T3",
      "name": "analyze_trend",
      "description": "分析销售趋势",
      "dependencies": ["T2"],
      "assigned_tool": "python_analysis",
      "status": "pending",
      "priority": 2,
      "success_criteria": [
        "生成月度趋势数据"
      ]
    },
    {
      "task_id": "T4",
      "name": "generate_report",
      "description": "生成销售分析报告",
      "dependencies": ["T3"],
      "assigned_tool": "report_generator",
      "status": "pending",
      "priority": 3,
      "success_criteria": [
        "报告生成成功",
        "包含数据和结论"
      ]
    }
  ]
}

3. 为什么计划需要结构化?

如果计划只是自然语言:

先查数据,再分析,最后生成报告。

Runtime 很难准确判断: - 哪些任务已经完成。 - 哪些任务可以并行。 - 某个任务失败后如何恢复。 - 哪些结果应该传递给后续任务。 - 如何验证任务完成条件。

结构化计划使规划结果从模型文本变成系统可以执行和管理的数据。

十、第七步:计划验证(Plan Validation)

模型生成的计划不一定正确。

它可能包含: - 不存在的工具。 - 无效的参数。 - 错误的依赖关系。 - 循环依赖。 - 缺少必要步骤。 - 不可执行的操作。 - 违反用户约束的任务。

因此,计划必须经过验证。

1. 计划验证维度

验证维度 检查内容
结构验证 计划格式是否合法
目标覆盖 是否覆盖用户要求
依赖验证 是否存在循环依赖
工具验证 工具是否已注册
参数验证 参数是否符合 Schema
权限验证 是否超出授权范围
资源验证 是否超出预算
可执行性 输入和前置条件是否满足
完成条件 是否能够判断任务成功

2. 计划验证流程

flowchart TD
    A["接收 Planner 输出"] --> B["检查结构格式"]
    B --> C["检查目标覆盖"]
    C --> D["检查任务依赖"]
    D --> E["检查工具和参数"]
    E --> F["检查权限与预算"]
    F --> G{"验证是否通过"}
    G -->|"是"| H["提交执行调度"]
    G -->|"否"| I["生成验证错误"]
    I --> J["修正计划"]
    J --> B

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style F fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style G fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style H fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style I fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style J fill:#EAE8FA,stroke:#A49BD5,color:#51477D

3. 计划验证不能完全依赖 LLM

例如,模型可能生成了一个依赖关系:

  • A 依赖 B。
  • B 依赖 C。
  • C 依赖 A。

模型可能没有意识到这是循环依赖。

因此,以下检查应由确定性程序完成: - JSON Schema 校验。 - DAG 环检测。 - 工具注册检查。 - 参数 Schema 校验。 - 权限校验。 - 资源预算检查。

LLM 更适合处理语义层面的目标覆盖和任务合理性判断。

十一、动态规划与 Replanning

传统工作流通常在执行前确定完整流程,而 Agent 面对的环境可能持续变化。

执行过程中可能出现: - 数据缺失。 - 工具调用失败。 - 新信息出现。 - 用户修改目标。 - 任务依赖发生变化。 - 原计划无法继续执行。

因此,Agent 需要动态规划(Dynamic Planning)能力。

1. 什么是动态规划?

这里的动态规划是指 Agent 根据当前任务状态和环境反馈,重新评估并调整执行计划。

它不同于算法领域的 Dynamic Programming(动态规划算法)。

Agent 动态规划的重点是:

  • 保留已经完成的有效工作。
  • 识别当前计划无法完成的部分。
  • 分析失败原因。
  • 重新生成后续任务。
  • 验证新计划与原目标是否一致。

2. Replanning 触发条件

触发条件 典型情况 调整方式
工具失败 API 不可用 更换工具或延迟重试
数据变化 数据源发生更新 重新获取相关数据
任务失败 测试未通过 修改方案并重新测试
新信息出现 发现新的关键因素 增加分析任务
用户修改目标 改变报告范围 更新目标和计划
资源不足 Token 或时间预算不足 缩小范围或降级

3. 动态重规划流程

flowchart TD
    A["执行当前计划"] --> B["获取执行反馈"]
    B --> C["分析当前任务状态"]
    C --> D{"原计划是否仍然可行"}
    D -->|"是"| E["继续执行原计划"]
    D -->|"否"| F["识别受影响任务"]
    F --> G["保留已完成任务"]
    G --> H["重新分析目标与约束"]
    H --> I["生成新计划"]
    I --> J["验证新计划"]
    J --> K{"是否通过验证"}
    K -->|"是"| L["更新任务 DAG"]
    K -->|"否"| M["请求人工处理"]
    L --> E

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style E fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style F fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style G fill:#EAF3EC,stroke:#83A995,color:#315D49
    style H fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style I fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style J fill:#EAF3EC,stroke:#83A995,color:#315D49
    style K fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style L fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style M fill:#F7EAE7,stroke:#C98D7C,color:#754438

4. 局部重规划与全局重规划

局部重规划

只调整受到影响的任务及其下游依赖任务。

例如: - 原计划需要调用工具 A。 - 工具 A 暂时不可用。 - 使用工具 B 完成相同子任务。 - 后续任务保持不变。

优点: - 成本较低。 - 保留已有执行成果。 - 对任务状态影响较小。

全局重规划

重新分析整个目标和任务结构,生成新的执行方案。

适用于: - 用户目标发生重大变化。 - 原有计划整体不可行。 - 关键假设被推翻。 - 任务依赖结构发生重大变化。

生产环境通常优先采用局部重规划,只有必要时才执行全局重规划。

十二、任务调度与并发控制

Planner 负责生成计划,但实际执行还需要 Scheduler 进行任务调度。

Planner 和 Scheduler 的区别:

  • Planner 决定任务应该如何组织。
  • Scheduler 决定当前哪些任务可以执行,以及何时执行。

1. 调度器的职责

  • 检查任务依赖是否满足。
  • 找出当前可执行任务。
  • 根据优先级选择任务。
  • 控制并发数量。
  • 分配执行资源。
  • 处理任务超时和失败。
  • 更新任务状态。

2. 可执行任务集合

假设任务 DAG 中:

  • A 已完成。
  • B、C、D 依赖 A。
  • E 依赖 B 和 C。
  • F 依赖 D。

当 A 完成后,B、C、D 都进入 Ready 状态。

当 B 和 C 完成后,E 才能进入 Ready 状态。

当 D 完成后,F 可以独立执行。

3. 任务调度流程

flowchart TD
    A["Scheduler 获取任务 DAG"] --> B["检查任务状态"]
    B --> C["检查依赖是否满足"]
    C --> D["筛选 Ready 任务"]
    D --> E["按优先级排序"]
    E --> F["检查并发和资源限制"]
    F --> G{"是否有可调度任务"}
    G -->|"是"| H["分配执行资源"]
    H --> I["启动任务"]
    I --> J["收集执行结果"]
    J --> K["更新任务状态"]
    K --> B
    G -->|"否"| L["等待任务完成或外部事件"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style G fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style H fill:#EAF3EC,stroke:#83A995,color:#315D49
    style I fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style J fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style K fill:#EAF3EC,stroke:#83A995,color:#315D49
    style L fill:#F5F8F4,stroke:#B5CBBB,color:#40594A