返回专栏
· 25 分钟阅读

长周期任务与自主执行 Agent


一、什么是长周期任务?

传统大模型交互通常围绕一次请求展开:用户提出问题,模型生成答案,交互结束。

但现实中的复杂工作往往无法在一次调用中完成。例如:

  • 持续数小时甚至数天完成一个软件项目。
  • 分析大量资料,整理研究报告并持续更新。
  • 自动执行数据采集、清洗、分析和报告生成。
  • 持续监控业务指标,在满足条件时触发处理流程。
  • 完成跨系统、多步骤的业务流程。
  • 根据外部反馈不断修改方案,直到达到验收标准。

这些任务具有几个共同特点:

  1. 执行时间长:可能跨越多个模型调用、工具调用甚至多个会话。
  2. 步骤复杂:任务包含多个子目标,执行顺序存在依赖关系。
  3. 状态持续变化:每一步都会产生新的结果、约束或待办事项。
  4. 外部环境不确定:工具可能失败,数据可能变化,执行条件可能发生改变。
  5. 需要动态调整:原始计划可能不再适用,Agent 必须重新规划。
  6. 结果需要验证:不能仅凭模型认为任务完成,就判定目标已经实现。

因此,长周期任务的核心并不是让模型持续生成更多文本,而是让 Agent 在一个持久化的执行环境中,长期维护目标、状态、计划和执行结果。

二、长周期任务与普通 Agent 的区别

普通 Agent 通常处理相对短暂的任务,长周期 Agent 则需要承担持续性的任务管理和执行责任。

对比维度 普通 Agent 长周期 Agent
执行时间 单次或短时间 长时间、多阶段
任务结构 相对简单 多层级、强依赖
状态管理 当前上下文为主 持久化任务状态
记忆机制 短期上下文 短期与长期记忆
规划方式 一次性规划为主 动态规划与重规划
错误处理 当前步骤重试 故障恢复与断点续跑
资源管理 单次调用预算 长期预算与资源调度
结果验证 单次输出检查 分阶段验收与最终验收
人工参与 请求时交互 关键节点审批和监督

需要注意,长周期 Agent 不一定意味着模型连续运行数小时。

更合理的设计是:

  • 执行一段时间。
  • 保存当前状态。
  • 释放运行资源。
  • 等待外部条件或调度事件。
  • 恢复任务并继续执行。

这是一种持久化、可恢复的自主执行机制。

三、长周期任务的核心架构

一个完整的长周期 Agent 通常由任务管理、规划、执行、记忆、状态存储、调度和验证等组件组成。

1. 核心架构组件

组件 核心职责
Task Manager 管理任务创建、生命周期和优先级
Planner 制定执行计划并拆解子任务
Orchestrator 协调各个执行阶段和工具
Executor 调用模型、API、浏览器和其他工具
State Manager 管理当前执行状态和进度
Memory Manager 保存历史经验和长期知识
Checkpoint Manager 创建和恢复执行检查点
Scheduler 管理定时执行、延迟任务和唤醒
Verifier 检查阶段结果和最终目标
Recovery Manager 处理失败、重试和任务恢复
Policy Guard 控制权限、预算和高风险操作

2. 整体架构图

flowchart TB
    A["用户目标与任务请求"] --> B["Task Manager 任务管理"]
    B --> C["Planner 任务规划"]
    C --> D["Orchestrator 执行编排"]
    D --> E["Executor 工具执行"]
    E --> F["Verifier 结果验证"]
    F --> G{"是否达到阶段目标"}
    G -->|"否"| H["Recovery Manager 故障恢复"]
    H --> C
    G -->|"是"| I["State Manager 状态更新"]
    I --> J["Checkpoint Manager 检查点"]
    J --> K["Memory Manager 长期记忆"]
    K --> L{"任务是否完成"}
    L -->|"否"| M["Scheduler 等待或唤醒"]
    M --> D
    L -->|"是"| N["最终结果与任务归档"]

    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:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style G fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style H fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style I fill:#EAF3EC,stroke:#83A995,color:#315D49
    style J fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style K fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style L fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style M fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style N fill:#DCEFE5,stroke:#4F8B70,color:#24563F

整个架构可以分成三个层次:

  • 决策层:负责理解目标、规划任务、判断下一步行动。
  • 执行层:负责调用工具、执行子任务、处理外部系统交互。
  • 持久化层:负责保存状态、记忆、检查点和执行记录。

三者相互配合,使 Agent 不再依赖单次模型上下文来维持整个任务。

四、任务分解与动态规划

长周期任务通常不能直接交给模型执行,而是需要先转换成结构化任务。

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

例如,用户提出:

建立一个完整的竞品分析报告,持续收集竞争产品的信息,比较价格、功能和市场变化,最终生成分析文档。

这是一个复杂目标,至少包含:

  • 确定竞品范围。
  • 收集产品信息。
  • 获取价格和功能数据。
  • 统一数据格式。
  • 建立比较维度。
  • 分析竞争差异。
  • 生成报告。
  • 定期更新信息。

如果不进行任务分解,Agent 容易出现以下问题:

  1. 遗漏关键步骤。
  2. 重复执行已经完成的工作。
  3. 无法识别任务依赖关系。
  4. 难以判断当前进度。
  5. 失败后无法确定从哪里恢复。

2. 将目标转化为任务树

可以使用树形结构表达任务层级:

竞品分析项目
├── 1. 竞品范围确定
│   ├── 确定目标市场
│   ├── 识别竞争产品
│   └── 建立竞品清单
├── 2. 信息采集
│   ├── 产品功能
│   ├── 产品价格
│   └── 市场动态
├── 3. 数据处理
│   ├── 数据清洗
│   ├── 数据去重
│   └── 数据标准化
├── 4. 竞品分析
│   ├── 功能对比
│   ├── 价格对比
│   └── 优劣势分析
├── 5. 报告生成
│   ├── 生成分析结果
│   └── 输出报告
└── 6. 持续更新
    ├── 定期采集
    ├── 检测变化
    └── 更新报告

任务树负责描述目标结构,但还需要任务依赖关系来决定执行顺序。

3. 任务依赖关系

有些任务可以并行执行,有些任务必须等待前置任务完成。

例如:

  • 产品功能和价格可以并行采集。
  • 数据清洗必须等待对应数据采集完成。
  • 竞品分析必须等待数据标准化完成。
  • 最终报告必须等待分析结果生成。

可以使用有向无环图(DAG)表示依赖关系。

flowchart TD
    A["确定竞品范围"] --> B["采集产品功能"]
    A --> C["采集产品价格"]
    A --> D["采集市场动态"]
    B --> E["功能数据清洗"]
    C --> F["价格数据清洗"]
    D --> G["市场数据清洗"]
    E --> H["竞品综合分析"]
    F --> H
    G --> H
    H --> I["生成分析报告"]
    I --> J["结果验收"]

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

使用 DAG 可以支持:

  • 自动识别可执行任务。
  • 并行调度无依赖关系的任务。
  • 阻止依赖未完成的任务提前执行。
  • 失败后只重试受影响的任务。
  • 计算整个任务的完成进度。

4. 静态规划与动态规划

静态规划是在任务开始时制定完整计划。

优点:

  • 执行路径明确。
  • 便于估算资源。
  • 适合流程稳定的任务。

缺点:

  • 无法充分适应外部变化。
  • 某个步骤失败可能影响后续计划。
  • 容易执行已经失效的任务安排。

动态规划则允许 Agent 根据执行结果调整后续步骤。

例如:

  • 原计划使用某个数据源。
  • 实际执行时发现数据源不可访问。
  • Agent 评估其他可用数据源。
  • 重新安排数据采集任务。
  • 更新依赖关系并继续执行。

实际系统通常采用混合方式:

总体目标和关键约束保持稳定,具体执行计划允许动态调整。

五、持久化状态:让任务跨越会话继续执行

长周期任务最重要的技术问题之一,是如何保存执行状态。

如果 Agent 运行了几个小时,随后服务重启,那么系统必须知道:

  • 当前任务是什么?
  • 已经完成哪些步骤?
  • 哪些步骤正在执行?
  • 哪些步骤失败?
  • 已经收集了什么数据?
  • 下一步应该执行什么?
  • 是否存在尚未处理的外部事件?

这些信息不能只保存在模型的对话上下文中。

1. 任务状态结构

一个简单的任务状态可以使用 JSON 表示:

{
  "task_id": "task_20261121_001",
  "goal": "完成竞品分析报告",
  "status": "running",
  "current_stage": "data_analysis",
  "progress": 0.65,
  "completed_tasks": [
    "competitor_discovery",
    "feature_collection",
    "price_collection"
  ],
  "pending_tasks": [
    "market_analysis",
    "report_generation"
  ],
  "failed_tasks": [],
  "retry_count": 0,
  "checkpoint_version": 12,
  "updated_at": "2026-11-21T10:30:00Z"
}

这里需要区分几个概念:

  • task_id:任务的唯一标识。
  • status:任务整体生命周期状态。
  • current_stage:当前执行阶段。
  • progress:整体进度估算。
  • completed_tasks:已经完成的子任务。
  • pending_tasks:等待执行的子任务。
  • failed_tasks:执行失败的子任务。
  • checkpoint_version:检查点版本。

实际工程中,还需要保存子任务输入输出、依赖关系、执行记录、资源消耗和版本信息。

2. 任务状态与执行状态的区别

任务状态表示整个任务处于什么阶段。

例如:

状态 含义
pending 等待开始
running 正在执行
paused 主动暂停
waiting 等待外部条件
blocked 被依赖或权限阻塞
failed 任务失败
completed 已完成
cancelled 已取消

子任务则可能拥有独立状态:

  • pending
  • ready
  • running
  • succeeded
  • retrying
  • failed
  • skipped
  • cancelled

任务整体状态不能简单等同于某一个子任务的状态。

例如,一个子任务失败,不一定意味着整个任务立即失败。系统可以根据任务策略决定重试、跳过、降级或等待人工处理。

3. 状态持久化机制

通常可以使用数据库保存任务状态。

例如:

CREATE TABLE agent_tasks (
    task_id VARCHAR(128) PRIMARY KEY,
    goal TEXT NOT NULL,
    status VARCHAR(32) NOT NULL,
    current_stage VARCHAR(128),
    progress DECIMAL(5, 4) DEFAULT 0,
    checkpoint_version BIGINT DEFAULT 0,
    created_at TIMESTAMP NOT NULL,
    updated_at TIMESTAMP NOT NULL
);

子任务可以单独保存:

CREATE TABLE agent_subtasks (
    subtask_id VARCHAR(128) PRIMARY KEY,
    task_id VARCHAR(128) NOT NULL,
    name VARCHAR(255) NOT NULL,
    status VARCHAR(32) NOT NULL,
    dependencies JSON,
    input_data JSON,
    output_data JSON,
    retry_count INT DEFAULT 0,
    FOREIGN KEY (task_id) REFERENCES agent_tasks(task_id)
);

生产环境还应考虑:

  • 状态更新的事务一致性。
  • 乐观锁或版本号控制。
  • 多 Worker 并发执行时的任务锁。
  • 执行记录与状态变更的审计。
  • 大型任务结果与元数据分离存储。

4. 检查点机制(Checkpoint)

Checkpoint 是长周期 Agent 的关键机制。

它表示在某个执行节点保存一份可恢复的任务快照。

检查点通常包含:

  • 当前任务状态。
  • 当前执行阶段。
  • 已完成的子任务。
  • 中间结果引用。
  • 下一步执行计划。
  • 重试次数。
  • 执行版本。
  • 必要的上下文摘要。

检查点不一定需要保存全部历史对话。更合理的方式是保存结构化状态,并将大型文件、数据集和日志放在独立存储中。

flowchart TD
    A["任务开始"] --> B["读取任务状态"]
    B --> C["执行当前步骤"]
    C --> D["生成执行结果"]
    D --> E["验证执行结果"]
    E --> F{"结果是否有效"}
    F -->|"否"| G["记录错误并恢复"]
    G --> C
    F -->|"是"| H["更新任务状态"]
    H --> I["写入检查点"]
    I --> J{"任务是否完成"}
    J -->|"否"| K["调度下一阶段"]
    K --> C
    J -->|"是"| L["保存最终结果"]

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

关键原则:先确保结果可靠,再推进任务状态。

如果执行结果已经产生,但状态还没有保存,系统可能重复执行。

因此,状态更新和结果持久化必须设计好一致性边界。

六、上下文管理:突破模型上下文窗口限制

长周期任务可能产生大量信息:

  • 用户需求和约束。
  • 历史对话。
  • 工具调用记录。
  • 中间分析结果。
  • 文件内容。
  • 任务计划。
  • 失败原因。
  • 外部系统返回的数据。

这些内容不可能无限制地放在模型上下文中。

即使模型支持较大的上下文窗口,也不意味着应该将所有历史内容反复传入。

1. 上下文与记忆的区别

类型 主要作用 生命周期
当前上下文 支持当前模型推理 单次或短期
工作记忆 保存当前阶段的重要信息 当前任务阶段
任务状态 保存任务进度和执行位置 整个任务周期
长期记忆 保存可复用的经验与知识 跨任务
历史日志 记录完整执行过程 按审计策略保存

需要特别注意:

记忆不等于状态,状态也不等于上下文。

例如:

  • “已经完成价格采集”属于任务状态。
  • “某个数据源经常出现访问限制”属于可复用经验。
  • 当前正在分析的三份数据摘要属于工作记忆。
  • 模型本次调用中实际看到的内容属于当前上下文。

2. 上下文压缩

上下文压缩的目标不是简单删除旧消息,而是提取对后续执行仍然重要的信息。

例如,原始执行记录可能包含几十次工具调用。

压缩后可以保存:

任务:完成竞品分析报告

当前阶段:
已完成竞品识别、功能采集和价格采集。

关键结果:
已识别 5 个竞品,功能数据完整率 92%,价格数据完整率 88%。

已知问题:
竞品 C 的价格页面无法访问,暂时使用官方历史公开数据。

未完成事项:
1. 补充竞品 C 的价格验证。
2. 完成市场趋势分析。
3. 生成最终报告。

约束:
所有价格数据必须记录来源和采集时间。
未经人工审批,不得发布外部报告。

这样,Agent 不必反复读取全部历史记录。

3. 上下文构建策略

每次模型调用时,可以根据当前阶段动态构建上下文:

  1. 读取任务目标和核心约束。
  2. 读取当前任务状态。
  3. 读取当前子任务及其依赖。
  4. 检索相关历史结果。
  5. 获取必要的文件或外部数据。
  6. 注入相关经验和规则。
  7. 控制上下文长度并调用模型。
flowchart TD
    A["准备模型调用"] --> B["读取任务目标"]
    B --> C["读取当前状态"]
    C --> D["检索相关记忆"]
    D --> E["加载必要的历史结果"]
    E --> F["提取关键约束"]
    F --> G["上下文压缩与排序"]
    G --> H["检查 Token 预算"]
    H --> I{"是否满足上下文预算"}
    I -->|"否"| J["进一步摘要与裁剪"]
    J --> H
    I -->|"是"| K["构建模型输入"]
    K --> L["执行模型推理"]

    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:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style G fill:#EAF3EC,stroke:#83A995,color:#315D49
    style H fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style I fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style J fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style K fill:#EAF3EC,stroke:#83A995,color:#315D49
    style L fill:#DCEFE5,stroke:#4F8B70,color:#24563F

上下文管理还需要关注信息时效性。对于价格、库存、状态等可能变化的数据,应在需要时重新查询,而不是无限期依赖历史记忆。

七、自主执行与调度机制

长周期 Agent 不应该一直占用模型调用资源等待下一步。

它需要具备任务调度能力。

1. 为什么需要 Scheduler?

假设 Agent 需要每天上午 9 点采集一次竞争产品价格。

如果采用持续循环的方式:

  • Agent 一直运行。
  • 每隔一段时间检查当前时间。
  • 到达指定时间后执行采集。

这种方式会浪费计算资源。

更合理的做法是使用外部调度器:

  • 创建定时任务。
  • 到达执行时间时触发事件。
  • 恢复对应任务。
  • 执行当前阶段。
  • 保存结果并安排下一次执行。

2. 常见调度类型

调度方式 使用场景
定时调度 每小时、每天或每周执行
延迟调度 等待一段时间后继续
事件驱动 收到消息、文件或业务事件时触发
条件调度 满足某个条件后执行
依赖调度 前置任务完成后执行
人工触发 用户审批或手动恢复
重试调度 失败后按照策略重新执行

3. 自主执行循环

Agent 可以采用有限循环执行任务,每一轮只负责一个阶段或一组受控操作。

flowchart TD
    A["调度器唤醒 Agent"] --> B["加载任务状态"]
    B --> C["检查任务约束与预算"]
    C --> D["选择当前可执行任务"]
    D --> E["制定本轮行动计划"]
    E --> F["执行工具或模型操作"]
    F --> G["验证执行结果"]
    G --> H{"是否需要人工审批"}
    H -->|"是"| I["暂停并等待审批"]
    I --> J["接收审批结果"]
    J --> K{"是否批准"}
    K -->|"否"| L["取消或重新规划"]
    K -->|"是"| M["更新任务状态"]
    H -->|"否"| M
    L --> N["保存检查点"]
    M --> N
    N --> O{"是否完成或需要等待"}
    O -->|"继续"| D
    O -->|"等待"| P["释放运行资源"]
    O -->|"完成"| Q["输出最终结果"]
    P --> R["等待下一次唤醒"]
    R --> A

    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:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style F fill:#EAF3EC,stroke:#83A995,color:#315D49
    style G fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style H fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style I fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style J fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style K fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style L fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style M fill:#EAF3EC,stroke:#83A995,color:#315D49
    style N fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style O fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style P fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style Q fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style R fill:#F5F8F4,stroke:#B5CBBB,color:#40594A

4. 事件驱动与自主执行

长周期 Agent 可以由事件触发,而不必始终主动轮询。

常见事件包括:

  • 定时任务到期。
  • 用户发送新指令。
  • 数据库出现新记录。
  • 文件上传完成。
  • 外部 API 返回结果。
  • 人工审批完成。
  • 依赖任务执行成功。
  • 监控系统发现异常。

事件驱动架构通常会使用消息队列、事件总线或任务调度服务。

例如:

事件来源
  - 定时器
  - 用户操作
  - 外部 API
  - 业务系统
        |
        v
事件总线
        |
        v
任务路由器
        |
        v
加载任务状态
        |
        v
Agent 执行
        |
        v
保存结果与检查点

实际文章中的流程关系应以 Mermaid 表达。工程上需要注意,事件可能重复投递,因此必须设计幂等处理和事件去重。

八、异常恢复:让 Agent 能够从失败中继续

长周期任务不可避免地会遇到异常。

例如:

  • 模型 API 超时。
  • 外部数据源不可用。
  • 工具调用失败。
  • 文件写入失败。
  • 数据库连接中断。
  • 子任务依赖失败。
  • 模型生成了不符合要求的结果。
  • 执行进程被意外终止。

如果 Agent 没有异常恢复机制,一次偶发错误就可能导致整个任务终止。

1. 常见异常类型

异常类型 典型原因 处理策略
临时网络异常 网络波动 指数退避重试
API 限流 请求频率过高 等待限流窗口
模型调用失败 超时或服务错误 重试或切换模型
工具执行失败 参数错误、权限不足 修正参数或请求审批
数据异常 缺失、格式错误 数据校验和补充
依赖失败 前置任务未完成 阻塞下游任务
资源耗尽 Token、内存或费用超限 暂停或降级
状态不一致 并发写入或进程中断 恢复检查点并核对结果

2. 重试机制

最简单的重试方式是固定间隔:

import time

def retry_task(task, max_retries=3, delay=2):
    for attempt in range(max_retries):
        try:
            return task()
        except Exception:
            if attempt == max_retries - 1:
                raise

            time.sleep(delay)

但生产环境通常需要更完善的策略。

指数退避(Exponential Backoff):

delay_n = \min(delay_{max}, delay_{base} \times 2^n)

例如:

  • 第一次失败等待 1 秒。
  • 第二次失败等待 2 秒。
  • 第三次失败等待 4 秒。
  • 第四次失败等待 8 秒。

还可以加入随机抖动(Jitter),避免大量任务同时重试。

需要注意:

  • 只对适合重试的异常进行重试。
  • 参数错误通常应该修正,而不是重复提交。
  • 权限不足不能靠不断重试解决。
  • 对有副作用的操作,必须考虑幂等性。
  • 超过最大重试次数后,应进入人工处理或失败状态。

3. 断点续跑

断点续跑的核心是:恢复最近一次可靠检查点,并判断哪些任务已经完成。

不能简单地从上次模型调用的位置继续,因为模型调用和外部工具操作可能存在副作用。

例如:

  • 支付接口已经成功,但进程在保存结果前崩溃。
  • 系统重启后重新执行支付。
  • 用户可能因此被重复扣款。

所以,断点续跑必须与执行记录、幂等键和外部结果核对结合。

4. 失败恢复流程

flowchart TD
    A["检测到任务异常"] --> B["识别异常类型"]
    B --> C{"是否为临时异常"}
    C -->|"是"| D["检查重试次数"]
    D --> E{"是否超过重试上限"}
    E -->|"否"| F["执行退避等待"]
    F --> G["恢复任务执行"]
    G --> H["验证执行结果"]
    H --> I{"是否成功"}
    I -->|"是"| J["更新状态与检查点"]
    I -->|"否"| A
    E -->|"是"| K["转入人工处理"]
    C -->|"否"| L{"是否可以自动修复"}
    L -->|"是"| M["调整计划或执行参数"]
    M --> G
    L -->|"否"| K
    K --> N["记录失败原因与上下文"]
    N --> O["等待人工决策或终止"]

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

九、长周期 Agent 的自主决策与边界控制

自主执行不意味着 Agent 可以不受限制地执行任何操作。

真正可靠的自主 Agent,必须在目标、权限、资源和风险约束下运行。

1. 自主决策的层级

可以将自主程度划分为四个层级:

层级 决策方式 示例
L1 执行固定流程 按既定步骤采集数据
L2 选择执行路径 根据数据情况选择采集方式
L3 动态调整计划 失败后重新安排任务
L4 自主管理目标 在约束内持续优化执行策略

自主程度越高,越需要完善的权限控制和审计机制。

2. 明确任务边界

在任务启动时,应明确:

  • 允许访问哪些系统?
  • 允许读取哪些数据?
  • 允许修改哪些文件?
  • 是否允许发送邮件?
  • 是否允许发布内容?
  • 是否允许产生付费操作?
  • 预算上限是多少?
  • 任务最晚何时结束?
  • 哪些行为必须经过人工审批?

这些约束应该作为结构化策略保存,而不是仅仅放在 Prompt 中。