一、什么是长周期任务?
传统大模型交互通常围绕一次请求展开:用户提出问题,模型生成答案,交互结束。
但现实中的复杂工作往往无法在一次调用中完成。例如:
- 持续数小时甚至数天完成一个软件项目。
- 分析大量资料,整理研究报告并持续更新。
- 自动执行数据采集、清洗、分析和报告生成。
- 持续监控业务指标,在满足条件时触发处理流程。
- 完成跨系统、多步骤的业务流程。
- 根据外部反馈不断修改方案,直到达到验收标准。
这些任务具有几个共同特点:
- 执行时间长:可能跨越多个模型调用、工具调用甚至多个会话。
- 步骤复杂:任务包含多个子目标,执行顺序存在依赖关系。
- 状态持续变化:每一步都会产生新的结果、约束或待办事项。
- 外部环境不确定:工具可能失败,数据可能变化,执行条件可能发生改变。
- 需要动态调整:原始计划可能不再适用,Agent 必须重新规划。
- 结果需要验证:不能仅凭模型认为任务完成,就判定目标已经实现。
因此,长周期任务的核心并不是让模型持续生成更多文本,而是让 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 容易出现以下问题:
- 遗漏关键步骤。
- 重复执行已经完成的工作。
- 无法识别任务依赖关系。
- 难以判断当前进度。
- 失败后无法确定从哪里恢复。
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. 上下文构建策略
每次模型调用时,可以根据当前阶段动态构建上下文:
- 读取任务目标和核心约束。
- 读取当前任务状态。
- 读取当前子任务及其依赖。
- 检索相关历史结果。
- 获取必要的文件或外部数据。
- 注入相关经验和规则。
- 控制上下文长度并调用模型。
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):
例如:
- 第一次失败等待 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 中。