智能体层级化规划与子目标分解机制 · 深度调研报告

调研日期：2026-05-18 所属领域：Agent / AI Agent 报告版本：v1.0

第一部分：概念剖析

1.1 定义澄清

通行定义

智能体层级化规划（Hierarchical Planning）与子目标分解（Subgoal Decomposition）是指：将高层级、长时域的复杂目标任务，自上而下逐层拆解为更小、更易执行的子目标或子任务，并在执行过程中进行层级化协调与控制的机制。核心思想源于经典人工智能中的分层规划（Hierarchical Task Network, HTN），在 LLM Agent 时代被赋予了新的内涵——利用大语言模型的语义理解能力进行动态、递归的目标分解与规划。

常见误解

1. 误解：层级化规划 = 流水线式任务拆解 实质：真正的层级化规划不是简单的"步骤1→步骤2"线性拆分，而是包含递归分解、依赖关系管理、跨层反馈和动态调整的多层次架构。

2. 误解：子目标分解只需要 LLM 就能自动做好 实质：LLM 的语义分解能力虽强，但缺乏可执行性验证和错误恢复机制。最优做法是将 LLM 的语义理解与符号规划的可验证性相结合（如 ChatHTN 范式）。

3. 误解：层级越多越精确 实质：过度分解会导致规划膨胀、执行延迟增加、错误累积。研究表明，每个节点 2-4 个子目标是较优实践，超出后收益递减。

边界辨析

1.2 核心架构

层级化规划系统通用架构

┌──────────────────────────────────────────────────────────────┐
│                  智能体层级化规划系统架构                        │
├──────────────────────────────────────────────────────────────┤
│                                                               │
│  ╔═══════════════════════════════════════════════════════╗     │
│  ║              战略规划层 (Strategic Layer)              ║     │
│  ║  接收原始目标 → 全局分解 → 里程碑定义 → 优先级排序      ║     │
│  ╚═════════════════════╦═════════════════════════════════╝     │
│                         │ 递归分解                             │
│  ╔══════════════════════╩══════════════════════════════════╗    │
│  ║              战术规划层 (Tactical Layer)                ║    │
│  ║  子目标依赖图(DAG) → 资源分配 → 执行路径选择 → 重规划     ║    │
│  ╚══════════════════════╦══════════════════════════════════╝    │
│                         │ 任务下发                             │
│  ╔══════════════════════╩══════════════════════════════════╗    │
│  ║              操作执行层 (Operational Layer)             ║    │
│  ║  原子动作/工具调用 → 环境交互 → 反馈采集 → 状态更新       ║    │
│  ╚═══════════════════════════════════════════════════════╝     │
│                                                               │
│  ┌─────────────────┐  ┌─────────────────┐  ┌──────────────┐  │
│  │  工作记忆        │  │  技能库/方法库   │  │  监控与异常   │  │
│  │  (Working Mem)   │  │  (Skill/Method) │  │  (Monitor)   │  │
│  └─────────────────┘  └─────────────────┘  └──────────────┘  │
│                                                               │
└──────────────────────────────────────────────────────────────┘

各层职责说明：

• 战略规划层：接收自然语言描述的终极目标，利用 LLM 或符号规划器产出高层子目标序列，定义关键里程碑和优先级
• 战术规划层：维护子目标的 DAG（有向无环图）依赖关系，调度执行路径，在失败时触发部分重规划
• 操作执行层：将原子子目标映射为具体工具调用、API 请求或物理动作，执行并返回结果
• 工作记忆：跨层级共享环境状态、中间结果和上下文信息
• 技能库/方法库：存储已验证的子目标分解模式（即 HTN 中的"方法"），供重用

1.3 数学形式化

公式 1：层级化规划的基本分解递归

$G_0 \rightarrow \{g_1, g_2, ..., g_n\} \mid \bigwedge_{i=1}^{n} \text{Satisfiable}(g_i, s) \land \text{Order}(g_1 \prec g_2 \prec ... \prec g_n)$

一个顶层目标 $G_0$ 被分解为一组有序子目标 $\{g_i\}$，要求每个子目标在当前状态 $s$ 下可满足，且子目标间有偏序约束。

公式 2：子目标可行性判定（SSE 方法）

$\text{Reachable}(g_i \mid s) = \mathbb{1}\left[ \min_{\pi_h} D(s, \pi_h(g_i)) < \epsilon \right]$

来自 Strict Subgoal Execution (SSE) 框架：子目标 $g_i$ 从当前状态 $s$ 可达，当且仅当存在高层策略 $\pi_h$，其与目标的距离度量的最小值小于阈值 $\epsilon$。

公式 3：规划树的搜索复杂度

$C_{\text{total}} = \sum_{d=0}^{D} b^d \cdot (C_{\text{LLM}} + C_{\text{verify}})$

其中 $D$ 为树的最大深度，$b$ 为平均分支因子（建议 2-4），$C_{\text{LLM}}$ 为单次 LLM 调用的成本，$C_{\text{verify}}$ 为可行性验证成本。该公式解释了为何层级化规划的计算成本随深度指数增长。

公式 4：多分辨率技能的价值函数

$V^{\text{MRS}}(s) = \max_{k \in \{1,...,K\}} \left[ Q^k_{\text{meta}}(s, k) + \gamma^{\tau_k} \cdot \mathbb{E}_{s' \sim P^k(\cdot|s, \pi_k)}[V^{\text{MRS}}(s')] \right]$

来自 Multi-Resolution Skills (MRS)：元控制器选择最适合当前状态的技能分辨率 $k$，其中 $\tau_k$ 为时间跨度，时间跨度越长的技能折扣因子越强。

公式 5：重规划触发条件

$\text{Replan} \iff \exists i : \text{Confidence}(g_i \mid s_t) < \theta_{\text{fail}} \lor \Delta_{\text{state}}(s_t, \hat{s}_t) > \delta_{\text{drift}}$

重规划触发于两种情况：某个子目标在当前状态的可信度低于阈值 $\theta_{\text{fail}}$，或实际状态 $s_t$ 与预期状态 $\hat{s}_t$ 的偏离度超过漂移容忍度 $\delta_{\text{drift}}$。

1.4 实现逻辑（Python 伪代码）

class HierarchicalPlanner:
    """层级化规划系统的核心抽象"""

    def __init__(self, llm_backend, max_depth=5, max_children=4):
        self.strategic = StrategicPlanner(llm_backend)      # 战略分解
        self.tactical = TacticalPlanner(llm_backend)         # 依赖管理与调度
        self.operational = OperationalExecutor(llm_backend)  # 原子动作执行
        self.memory = WorkingMemory()                        # 跨层工作记忆
        self.max_depth = max_depth
        self.max_children = max_children

    def plan_and_execute(self, goal: str, state: dict) -> Result:
        """主入口：从目标到执行的完整流程"""
        # 1. 战略层：递归分解
        plan_tree = self.strategic.decompose(
            goal=goal,
            state=state,
            depth=0,
            max_depth=self.max_depth,
            max_children=self.max_children
        )
        # plan_tree 是一个 DAG，节点为子目标，边为偏序依赖

        # 2. 战术层：调度执行 + 动态重规划
        execution_order = self.tactical.topological_sort(plan_tree)
        for subgoal in execution_order:
            actual_state = self.memory.get_current_state()

            # 检查是否需要重规划
            if self._should_replan(subgoal, actual_state):
                plan_tree = self._replan(plan_tree, subgoal, actual_state)
                execution_order = self.tactical.topological_sort(plan_tree)
                continue

            # 3. 操作层：执行
            result = self.operational.execute(subgoal, actual_state)
            self.memory.update(subgoal, result)

        return self.memory.get_final_result()

    def _should_replan(self, subgoal, current_state) -> bool:
        confidence = self.tactical.estimate_confidence(subgoal, current_state)
        drift = self.tactical.measure_drift(current_state, subgoal.expected_state)
        return confidence < 0.3 or drift > 0.5

    def _replan(self, tree, failed_node, current_state) -> DAG:
        """局部重规划：仅重分解失败节点及下游"""
        affected = self.tactical.get_downstream_nodes(tree, failed_node)
        tree.remove_subtree(failed_node)
        new_subtree = self.strategic.decompose(
            goal=failed_node.original_goal,
            state=current_state,
            depth=failed_node.depth
        )
        tree.merge(new_subtree)
        return tree


class StrategicPlanner:
    """战略层：递归目标分解"""

    def decompose(self, goal, state, depth, max_depth, max_children=4):
        if depth >= max_depth or self._is_primitive(goal):
            return GoalNode(goal, is_primitive=True)

        subgoals = self.llm.decompose(goal, state, n=max_children)
        # subgoals = [{"description": "...", "dependencies": [...]}, ...]

        children = []
        for sg in subgoals:
            child_tree = self.decompose(
                sg["description"], state, depth + 1, max_depth, max_children
            )
            children.append(child_tree)

        return GoalNode(goal, children=children, dependencies=sg.get("dependencies", []))

1.5 性能指标

1.6 扩展性与安全性

水平扩展

• 多 Agent 并行分解：同一层级的不同子目标可分配给独立 Agent 节点并行执行（如 ReAcTree 的控制流节点支持并行分支）
• 技能库分布式共享：已验证的分解模式可存入共享技能库，跨会话复用，减少重复 LLM 调用
• 分治调度：大规模任务可拆分为独立的子问题分发到不同计算节点

垂直扩展

• 单节点优化：通过结构化输出（Pydantic Schema）约束 LLM 输出格式，减少解析错误和重试
• 上下文压缩：子目标感知的上下文压缩（HiAgent 方案）可将无关上下文压缩掉，降低 token 消耗
• 缓存分解模式：对常见任务模式进行方法级缓存（如 ChatHTN 中的学习方法）

安全考量

1. 目标漂移：长时间执行中 Agent 可能偏离原始目标。解决方案：引入"目标锚定"机制，每轮检查当前活动与顶层目标的语义对齐度
2. 分解爆炸：递归分解可能无限膨胀。解决方案：最大深度限制（典型值 5）+ 最大子目标数限制（典型值 4）
3. 幻觉传播：上层分解错误会逐级放大到下层执行。解决方案：每个子目标执行后增加可行性验证门控，失败时触发局部重规划
4. 权限级联：高层 Agent 可能赋予低层 Agent 超出其安全边界的权限。解决方案：最小权限原则，每层 Agent 只能调用其被授权范围的工具

第二部分：行业情报

2.1 GitHub 热门项目

说明：标注"新项目"的为 2025-2026 年间发布，stars 仍在快速增长中；"活跃开发"的为框架/库级别的项目，stars 数据随版本发布而变动。

2.2 关键论文（12 篇）

经典高影响力论文（奠基性工作，约 40%）

最新 SOTA 论文（前沿进展，约 60%）

2.3 系统化技术博客（10 篇）

2.4 技术演进时间线

2022 ── ReAct 提出（Yao et al.）── 推理-行动闭环成为 Agent 基础范式
2023 ── Tree of Thoughts（树状推理）── 多分支搜索引入 Agent 推理
2023 ── Voyager（开放式具身 Agent）── 自动课程 + 技能库，首次展示 LLM 驱动的终身学习
2023 ── GITM（三层分层架构）── 首次显式使用分层规划(Decomposer→Planner→Interface)
2023 ── HTN 方法开始被 LLM Agent 社区重新发掘
2024 ── Subgoal-based HRL for Multi-Agent Collaboration
2024 ── EPO（环境偏好优化）── 引入分层 LLM Agent 的训练信号从环境反馈中获得
2025 ── ChatHTN（LLM+符号HTN 交错）── 结合 LLM 灵活性与符号规划的可证明正确性
2025 ── ReAcTree（动态 Agent 树）── 控制流节点实现灵活的并行/串行/条件规划
2025 ── GoalAct（全局规划+分层执行）── 持续更新全局规划与分层执行的紧耦合
2025 ── STEP Planner（子目标树具身规划）── 闭路分解+终止判断双模型
2025 ── Strict Subgoal Execution (SSE) ── 单步子目标可达性约束的理论保证
2026 ── Multi-Resolution Skills (MRS) ── 多时间跨度技能 + 元控制器选择
2026 ── HCL-GP（层次化广义规划）── 可复用策略组件，AppWorld 98.2%
2026 ── HTN Planning with LLM Heuristics ── LLM 生成启发式函数引导符号规划器
2026 ── 当前状态：层级化规划从理论走向工程落地，LLM + 符号系统融合成为主流范式

第三部分：方案对比

3.1 历史发展时间线

2022-2023 ─┬─ ReAct 范式确立，Agent 进入"推理+行动"时代
           └─ HTN 分层思想开始重新受到关注
2023-2024 ─┬─ GITM/Voyager 展示 LLM Agent 做长程任务规划的可行性
           └─ 分层 HRL (HIRO/HRAC) 提出可达性子目标生成理论
2024-2025 ─┬─ LLM + 符号 HTN 融合（ChatHTN）提供可证明正确的规划
           └─ 动态 Agent 树（ReAcTree）实现规划时动态扩展
           └─ 全局规划+分层执行（GoalAct）引入紧耦合设计
2025-2026 ─┬─ 多分辨率技能（MRS）建模精度-平滑度权衡
           └─ 严格子目标执行（SSE）提供理论可达性保证
           └─ LLM 生成启发式引导符号规划器（HTN+Heuristics）
           └─ Agent 框架原生支持层级化规划（LangGraph/CrewAI/AutoGen）

3.2 5 种核心方案横向对比

方案 A：纯 LLM 提示驱动分解（Zero-shot / Few-shot）

方案 B：结构化分解框架（LLM + 约束 Schema）

代表项目：Cogents Core (Goalith)、GoalAct

方案 C：LLM + 符号规划器混合（LLM-HTNs）

代表项目：ChatHTN、HTN+LLM Heuristics、HCL-GP

方案 D：动态 Agent 树（ReAcTree 范式）

代表项目：ReAcTree、STEP Planner

方案 E：层级化强化学习（HRL + Subgoal）

代表项目：SSE、MRS、HalfWeg、DHP

3.3 技术细节对比

3.4 选型建议

2026 年推荐实践

对于 80% 以上的工业场景，当前最务实的方案组合是：以结构化分解框架（方案 B）为骨架，嵌入动态 Agent 树（方案 D）处理长时域复杂任务的关键路径。在需要正确性保证的核心流程中，引入符号规划器进行可行性验证（方案 C 的轻量级子集）。避免纯提示驱动（方案 A）直接上生产，也避免过早引入完整的 HRL（方案 E）。

第四部分：精华整合

4.1 The One 公式

4.2 一句话解释

就像一位项目经理把 "建一栋楼" 这个大目标拆成 "打地基→盖框架→装水电→内部装修" 等一系列可执行的小任务，并在执行过程中根据实际情况调整计划——智能体层级化规划就是用 AI 来做这件事，只不过是在数字世界里。

4.3 核心架构图

用户目标: "帮我做一份 Q2 市场分析报告"
        ↓
┌──────────────── 战略分解 ────────────────┐
│  [收集数据] → [分析趋势] → [撰写报告] → [审校发布] │
└────────────────┬──┬──┬──────────────────┘
                 │  │  │
        ┌────────┘  │  └────────┐
        ↓           ↓           ↓
   ┌────────┐ ┌──────────┐ ┌────────┐
   │ 爬取数据│ │ 数据分析 │ │ 内容生成│
   │ 清洗处理│ │ 图表制作 │ │ 格式排版│
   └──┬─────┘ └────┬─────┘ └───┬────┘
      ↓            ↓            ↓
┌──────────────────────────────────────┐
│           操作执行层                   │
│  工具调用: API / 代码 / 数据库 / 文件  │
└──────────────────────────────────────┘
        ↓            ↓            ↓
┌──────────────────────────────────────┐
│         监控 & 重规划门控              │
│  执行失败 → 局部回滚 → 重新分解       │
└──────────────────────────────────────┘

4.4 STAR 总结

4.5 理解确认问题

问题：在层级化规划系统中，当一个子目标在执行时因环境状态变化而变得不可达，应该如何响应？请从"最小影响"原则出发描述处理流程。

参考答案：应当不重启整个规划，而是执行局部重规划（Local Replanning）：(1) 检测到子目标 g_i 不可达（置信度 < 阈值或状态偏离 > 容忍度）；(2) 确定 g_i 的依赖影响范围——找到所有直接或间接依赖 g_i 输出的下游子目标集合 D(g_i)；(3) 从规划树中移除 g_i 及其下游 D(g_i) 构成的子树；(4) 以 g_i 的原始父目标为输入，在当前实际状态下重新调用分解（而非回退到初始状态）；(5) 将新的子树合并回原规划树；(6) 按新的拓扑排序继续执行。这一过程的关键在于"局部"——只影响失败节点及其下游，不波及无关的并行分支。ReAcTree 和 SSE 框架均在不同程度上实现了这一机制。

参考资料索引

1. ReAcTree - arXiv:2511.02424 (AAMAS 2026) - https://arxiv.org/abs/2511.02424
2. STEP Planner - arXiv:2506.21030 (IROS 2025) - https://arxiv.org/abs/2506.21030
3. Strict Subgoal Execution - arXiv:2506.21039 (ICLR 2026) - https://arxiv.org/abs/2506.21039
4. Multi-Resolution Skills - arXiv:2505.21410 - https://arxiv.org/abs/2505.21410
5. GoalAct - arXiv:2504.16563 - https://arxiv.org/abs/2504.16563
6. ChatHTN - PMLR v288 (NeuS 2025) - https://proceedings.mlr.press/v288/munoz-avila25a.html
7. HTN Planning with LLM Heuristics - arXiv:2605.07707 - https://arxiv.org/abs/2605.07707
8. HCL-GP - arXiv:2605.06957 - https://arxiv.org/abs/2605.06957
9. Voyager - arXiv:2305.16291 - https://arxiv.org/abs/2305.16291
10. GITM - arXiv:2305.17144 - https://arxiv.org/abs/2305.17144
11. SkyworkAI/DeepResearchAgent - https://github.com/SkyworkAI/DeepResearchAgent
12. Cogents Core (Goalith) - https://deepwiki.com/mirasurf/cogents-core/6-configuration-and-environment
13. Nevron Hierarchical Planning - https://github.com/axioma-ai-labs/nevron/issues/163
14. Select-then-Solve - arXiv:2604.06753 - https://arxiv.org/abs/2604.06753
15. Deep Agent Planner 教程 - https://www.cnblogs.com/yangykaifa/p/19560083
16. 华为云 任务分解博客 - https://bbs.huaweicloud.com/blogs/466424