返回专栏
· 32 分钟阅读

Agent 的核心架构与运行机制


一、Agent 的整体架构

AI Agent 并不是一个单独的大模型,而是由模型、运行时、工具、记忆、状态管理和执行控制等组件组成的智能任务执行系统。

从系统架构角度,可以将 Agent 划分为六个核心层次:

  1. 交互层:接收用户目标,返回任务结果。
  2. 决策层:理解目标、分析上下文、制定计划。
  3. 推理层:调用大模型完成推理和决策。
  4. 执行层:调度工具,执行外部操作。
  5. 状态与记忆层:维护任务状态和历史信息。
  6. 控制与治理层:处理权限、安全、异常、超时和资源限制。

1. 整体架构图

flowchart TB
    U["用户 / 外部系统"] --> API["Agent API"]
    API --> R["Agent Runtime"]

    subgraph Decision["决策与推理层"]
        G["Goal Manager"]
        P["Planner"]
        L["LLM Engine"]
        D["Decision Engine"]
        G --> P
        P --> L
        L --> D
    end

    subgraph Execution["工具执行层"]
        TR["Tool Registry"]
        TE["Tool Executor"]
        EX["External Systems"]
        TR --> TE
        TE --> EX
    end

    subgraph Memory["状态与记忆层"]
        S["State Manager"]
        M["Memory Manager"]
        C["Context Manager"]
        S --> C
        M --> C
    end

    subgraph Governance["控制与治理层"]
        POL["Policy Engine"]
        OBS["Observability"]
        ERR["Error Handler"]
    end

    R --> G
    D --> TR
    EX --> S
    C --> L
    POL --> R
    TE --> OBS
    ERR --> R
    R --> OUT["Result Validator"]
    OUT --> RESP["最终结果"]

    style U fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style API fill:#EAF3EC,stroke:#83A995,color:#315D49
    style R fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style G fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style P fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style L fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style D fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style TR fill:#EAF3EC,stroke:#83A995,color:#315D49
    style TE fill:#EAF3EC,stroke:#83A995,color:#315D49
    style EX fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style S fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style M fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style POL fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style OBS fill:#EAF3EC,stroke:#83A995,color:#315D49
    style ERR fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style OUT fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style RESP fill:#DCEFE5,stroke:#4F8B70,color:#24563F

图中展示的是逻辑架构,不代表所有组件必须独立部署。小型 Agent 可以将多个模块放在同一个进程中,复杂系统则可以拆分为独立服务。

2. Agent 的核心组件

组件 核心职责 关键问题
Agent Runtime 管理 Agent 生命周期和执行循环 如何驱动任务持续运行
Goal Manager 解析目标和约束 如何判断任务要完成什么
Planner 任务拆解和路径规划 下一步应该做什么
LLM Engine 推理、决策和内容生成 如何获得合理决策
Tool Registry 管理工具定义 有哪些工具可以使用
Tool Executor 执行外部操作 如何安全执行工具
Memory Manager 管理长期记忆 哪些信息需要保留
State Manager 管理当前任务状态 任务执行到了哪里
Context Manager 组织模型输入上下文 模型当前应该看到什么
Policy Engine 权限和安全控制 哪些操作允许执行
Error Handler 处理异常和恢复 失败后如何继续
Observability 记录运行过程 如何定位问题和评估效果

需要特别区分三个容易混淆的概念:

  • Runtime:负责驱动 Agent 执行。
  • LLM:负责提供推理和生成能力。
  • Orchestrator:负责组织多个执行组件或 Agent 之间的协作。

不同框架对 Runtime 和 Orchestrator 的职责划分可能不同,但工程上必须明确谁负责调度、谁负责执行、谁负责维护状态。

二、Agent Runtime:整个系统的运行核心

Agent Runtime 是 Agent 的执行引擎,负责将模型决策转化为实际操作,并持续驱动任务直到满足终止条件。

它并不等同于大模型,也不应该把所有业务逻辑都塞进 Prompt。

1. Runtime 的主要职责

任务生命周期管理

  • 创建任务。
  • 初始化执行上下文。
  • 启动执行循环。
  • 维护任务状态。
  • 处理中断和恢复。
  • 结束任务并返回结果。

模型调用管理

  • 构造模型输入。
  • 选择模型和参数。
  • 调用模型接口。
  • 解析模型输出。
  • 处理模型调用异常。

工具执行管理

  • 解析工具调用请求。
  • 校验工具名称和参数。
  • 检查执行权限。
  • 调用工具执行器。
  • 收集执行结果。

执行控制

  • 限制最大执行步数。
  • 限制模型调用次数。
  • 控制任务超时。
  • 管理并发和资源。
  • 判断是否需要人工介入。

2. Runtime 的执行流程

flowchart TD
    A["创建 Agent Task"] --> B["初始化 Runtime"]
    B --> C["加载任务状态"]
    C --> D["构建模型上下文"]
    D --> E["调用 LLM"]
    E --> F["解析模型决策"]
    F --> G{"决策类型"}
    G -->|"工具调用"| H["执行工具"]
    G -->|"继续推理"| I["更新上下文"]
    G -->|"最终回答"| J["验证任务结果"]
    H --> K["收集工具结果"]
    K --> I
    I --> L{"是否达到执行限制"}
    L -->|"否"| D
    L -->|"是"| M["终止或请求人工介入"]
    J --> N{"是否满足成功条件"}
    N -->|"是"| O["完成任务"]
    N -->|"否"| M

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

3. 为什么需要独立的 Runtime?

假设只使用大模型完成 Agent 任务:

  • 模型生成工具调用。
  • 模型自行描述执行结果。
  • 模型自行判断是否完成。
  • 模型自行决定是否继续。

这会导致一个严重问题:模型输出的内容可能被误认为已经执行的事实。

例如,模型生成:

{
  "tool": "delete_file",
  "arguments": {
    "path": "/tmp/test.txt"
  },
  "status": "success"
}

这段内容只是模型生成的数据,并不能证明文件已经删除。

真正的执行必须由 Runtime 调用工具,并获取工具的实际返回结果。

因此:

模型负责提出行动建议,Runtime 负责控制和落实行动。

三、Goal Manager:目标理解与任务约束

Agent 的执行起点不是工具,而是目标。

用户往往以自然语言描述需求,而 Runtime 需要将其转换为可管理的任务定义。

1. 目标解析

例如:

分析项目中的代码质量,找出严重问题,修复能够自动修复的部分,并运行测试。

Goal Manager 需要提取:

维度 内容
目标 提高项目代码质量
分析范围 当前项目代码
任务要求 找出严重问题
执行动作 自动修复可修复问题
验证条件 运行测试
结果要求 输出问题和修复报告
执行约束 不允许未经授权删除文件

2. 目标结构化

可以将目标转换为结构化对象:

{
  "goal_id": "goal_001",
  "description": "分析并修复项目代码问题",
  "constraints": {
    "scope": "current_project",
    "allow_file_edit": true,
    "allow_file_delete": false,
    "require_test": true
  },
  "success_criteria": [
    "完成代码检查",
    "严重问题得到处理",
    "完成测试验证",
    "生成执行报告"
  ],
  "status": "pending"
}

结构化目标有几个重要作用:

  • 让任务具备明确边界。
  • 让 Planner 有可靠的规划依据。
  • 让 Policy Engine 能够检查操作权限。
  • 让 Result Validator 能够判断完成条件。

3. 目标与计划的区别

目标描述最终想要达到的状态,计划描述达到目标需要执行的步骤。

例如:

  • 目标:修复项目中的严重 Bug。
  • 计划:读取代码、分析问题、修改文件、运行测试、验证结果。

目标不应该与具体执行步骤混为一谈。

否则,当某个步骤失败时,Agent 很难重新规划。

四、Planner:任务拆解与执行规划

Planner 负责把复杂任务拆解为可执行的子任务,并确定任务之间的依赖关系。

1. 任务拆解

一个复杂任务可以表示为任务树:

项目代码质量分析
├── 1. 项目扫描
│   ├── 读取目录结构
│   ├── 识别语言和框架
│   └── 分析依赖关系
├── 2. 代码分析
│   ├── 静态代码检查
│   ├── 安全风险检查
│   └── 逻辑问题分析
├── 3. 问题处理
│   ├── 问题分类
│   ├── 生成修复方案
│   └── 修改代码
└── 4. 结果验证
    ├── 运行测试
    ├── 分析测试结果
    └── 生成报告

2. 常见规划方式

规划模式 特点 适用场景
Sequential 按顺序执行 有明确前后依赖的任务
Parallel 并行执行 相互独立的任务
Conditional 根据条件分支 需要根据结果选择路径
Iterative 多轮迭代 需要反复优化的任务
Hierarchical 分层拆解 复杂的多级目标

3. 顺序规划

前一个任务的结果是后一个任务的输入。

flowchart TD
    A["读取项目"] --> B["分析代码"]
    B --> C["定位问题"]
    C --> D["修改代码"]
    D --> E["运行测试"]
    E --> F["生成报告"]

    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:#EAF3EC,stroke:#83A995,color:#315D49
    style F fill:#DCEFE5,stroke:#4F8B70,color:#24563F

4. 并行规划

当多个任务没有数据依赖时,可以同时执行。

flowchart TD
    A["项目分析"] --> B["安全检查"]
    A --> C["性能检查"]
    A --> D["代码规范检查"]
    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

并行执行需要特别关注: - 任务之间是否存在数据依赖。 - 是否会同时修改相同文件。 - 是否存在资源竞争。 - 是否需要结果合并。 - 单个子任务失败时如何处理。

5. 条件规划

根据中间执行结果选择后续路径。

flowchart TD
    A["执行代码检查"] --> B["分析检查结果"]
    B --> C{"是否发现严重问题"}
    C -->|"是"| D["生成修复方案"]
    C -->|"否"| E["生成检查报告"]
    D --> F["执行修复"]
    F --> G["运行测试"]
    G --> H{"测试是否通过"}
    H -->|"是"| E
    H -->|"否"| I["记录失败并请求处理"]

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

6. 规划结果的结构化表示

Planner 不应该只返回一段自然语言计划。工程系统通常需要将计划转化为结构化任务对象。

{
  "plan_id": "plan_001",
  "tasks": [
    {
      "id": "task_1",
      "name": "scan_project",
      "dependencies": [],
      "status": "pending"
    },
    {
      "id": "task_2",
      "name": "analyze_code",
      "dependencies": ["task_1"],
      "status": "pending"
    },
    {
      "id": "task_3",
      "name": "fix_issues",
      "dependencies": ["task_2"],
      "status": "pending"
    },
    {
      "id": "task_4",
      "name": "run_tests",
      "dependencies": ["task_3"],
      "status": "pending"
    }
  ]
}

这样 Runtime 才能对任务进行调度、重试、恢复和追踪。

五、LLM Engine:Agent 的推理引擎

LLM 是 Agent 的核心推理组件,负责理解上下文、判断任务进度、生成计划以及决定下一步行动。

1. LLM 在 Agent 中的职责

主要包括:

  • 意图理解:理解用户目标。
  • 上下文分析:理解历史对话和工具结果。
  • 任务规划:生成或调整执行计划。
  • 工具选择:选择合适的工具。
  • 参数生成:生成工具调用参数。
  • 结果分析:解释工具执行结果。
  • 决策生成:决定继续执行还是结束任务。

2. 模型调用的输入

Agent 并不是简单地将用户问题直接发送给模型。

一次典型的模型请求可能包含:

{
  "system_prompt": "你是一个代码分析 Agent",
  "user_goal": "检查项目并修复严重问题",
  "conversation_history": [],
  "task_state": {
    "current_step": "analyze_code",
    "completed_steps": ["scan_project"]
  },
  "memory_context": [],
  "available_tools": [
    {
      "name": "read_file",
      "description": "读取指定文件"
    },
    {
      "name": "run_tests",
      "description": "运行项目测试"
    }
  ],
  "constraints": {
    "max_steps": 20,
    "allow_file_delete": false
  }
}

这些信息经过 Context Manager 整理后,才会真正进入模型上下文。

3. 模型输出的决策类型

Agent 通常需要将模型输出约束为有限的决策类型。

决策类型 含义
TOOL_CALL 调用某个工具
CONTINUE 继续推理或规划
FINAL 返回最终结果
ASK_USER 请求用户补充信息或确认
HANDOFF 转交其他 Agent 或人工处理
ABORT 终止任务

一种简化的结构化决策:

{
  "action": "TOOL_CALL",
  "tool_name": "read_file",
  "arguments": {
    "path": "src/main.py"
  },
  "reason": "需要检查程序入口逻辑"
}

需要强调:模型输出的决策必须经过 Runtime 校验,不能直接作为可信执行指令。

六、Tool Registry 与 Tool Executor:工具管理与执行

工具是 Agent 与外部世界交互的接口。

但工具定义、工具选择和工具执行是三个不同的环节。

1. Tool Registry

Tool Registry 是工具注册中心,负责管理 Agent 可以使用的工具。

一个工具通常需要包含:

字段 说明
name 工具名称
description 工具用途描述
parameters 参数 Schema
permissions 所需权限
timeout 最大执行时间
retry_policy 重试策略
side_effects 是否存在副作用
version 工具版本

例如:

{
  "name": "read_file",
  "description": "读取指定路径的文件内容",
  "parameters": {
    "type": "object",
    "properties": {
      "path": {
        "type": "string",
        "description": "文件路径"
      }
    },
    "required": ["path"]
  },
  "permissions": ["filesystem.read"],
  "timeout": 10,
  "side_effects": false
}

工具定义通常会提供给模型,使模型知道有哪些工具可用、每个工具如何调用。

2. Tool Executor

Tool Executor 负责将模型生成的工具调用请求转换为真实执行操作。

其核心职责包括:

  1. 解析工具名称。
  2. 查找工具注册信息。
  3. 校验参数格式。
  4. 检查用户和任务权限。
  5. 检查资源限制。
  6. 执行具体工具。
  7. 捕获异常和超时。
  8. 规范化返回结果。

执行流程:

flowchart TD
    A["接收工具调用请求"] --> B["解析工具名称"]
    B --> C{"工具是否存在"}
    C -->|"否"| X["返回工具不存在错误"]
    C -->|"是"| D["校验参数 Schema"]
    D --> E{"参数是否合法"}
    E -->|"否"| Y["返回参数错误"]
    E -->|"是"| F["检查权限与策略"]
    F --> G{"是否允许执行"}
    G -->|"否"| Z["拒绝执行"]
    G -->|"是"| H["执行工具"]
    H --> I{"执行是否成功"}
    I -->|"是"| J["规范化结果"]
    I -->|"否"| K["异常处理"]
    J --> L["返回工具结果"]
    K --> M["分类错误并决定重试"]
    M --> L

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style D fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style E fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style F fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style G fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style H fill:#EAF3EC,stroke:#83A995,color:#315D49
    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:#DCEFE5,stroke:#4F8B70,color:#24563F
    style M fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style X fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style Y fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style Z fill:#F7EAE7,stroke:#C98D7C,color:#754438

3. 工具执行与模型决策的边界

这是 Agent 工程中非常重要的边界:

  • 模型可以提出调用工具的请求。
  • Runtime 决定请求是否进入执行阶段。
  • Policy Engine 决定操作是否被允许。
  • Tool Executor 执行具体操作。
  • 外部工具返回真实执行结果。

不能因为模型输出了 success,就认为工具已经执行成功。

4. 工具执行结果

工具返回结果最好使用统一结构:

{
  "tool_call_id": "call_001",
  "tool_name": "read_file",
  "status": "success",
  "data": {
    "content": "print('hello')"
  },
  "error": null,
  "duration_ms": 25
}

统一结果结构可以让 Runtime 以一致的方式处理不同工具。

七、Memory、State 与 Context:三个最容易混淆的组件

Memory、State 和 Context 都与信息管理有关,但三者承担不同职责。

1. Memory:记忆系统

Memory 用于保存后续任务可能需要的信息。

常见分类:

类型 内容 生命周期
工作记忆 当前任务需要的临时信息 任务期间
短期记忆 当前会话的历史信息 会话期间
长期记忆 用户偏好、稳定知识和历史经验 跨会话
情景记忆 过去发生的任务和执行经历 按策略保存
语义记忆 已整理的事实和知识 按策略保存

Memory 的关键不是保存所有对话,而是判断哪些信息未来值得复用。

典型记忆处理过程:

flowchart TD
    A["产生新信息"] --> B["判断信息价值"]
    B --> C{"是否值得记忆"}
    C -->|"否"| D["不保存"]
    C -->|"是"| E["提取关键内容"]
    E --> F["整理和规范化"]
    F --> G["分类与打标签"]
    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:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style D fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    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:#DCEFE5,stroke:#4F8B70,color:#24563F

2. State:任务状态

State 用于记录当前任务的执行状态。

例如:

{
  "task_id": "task_001",
  "status": "running",
  "current_node": "run_tests",
  "completed_nodes": [
    "scan_project",
    "analyze_code",
    "fix_code"
  ],
  "retry_count": 1,
  "started_at": "2026-11-20T10:00:00Z"
}

State 关注的是:

  • 当前执行到哪里。
  • 哪些步骤已经完成。
  • 哪些步骤等待执行。
  • 当前任务是否失败。
  • 是否允许继续或恢复。

State 通常需要具备明确的数据结构、版本和持久化机制。

3. Context:模型上下文

Context 是当前模型调用能够看到的信息集合。

通常包括:

  • System Prompt。
  • 用户目标。
  • 历史消息。
  • 当前任务状态摘要。
  • 相关记忆。
  • 工具定义。
  • 工具执行结果。
  • 当前执行约束。

Context Manager 负责将这些信息整理为模型可以理解的输入。

4. 三者的核心区别

对比维度 Memory State Context
核心目的 保存可复用信息 记录任务进度 提供模型推理输入
关注重点 记住什么 当前发生什么 模型需要知道什么
生命周期 可跨任务 通常绑定任务 绑定一次模型调用
存储方式 数据库、向量库等 状态存储、数据库 Prompt 和消息结构
是否直接提供给模型 按需检索 按需摘要 直接提供
是否要求完整持久化 视记忆策略 通常需要 通常不需要

三者之间的关系:

flowchart TD
    A["任务执行"] --> B["产生状态变化"]
    A --> C["产生可复用信息"]
    B --> D["State Manager"]
    C --> E["Memory Manager"]
    D --> F["Context Manager"]
    E --> G["记忆检索"]
    G --> F
    F --> H["构建模型输入"]
    H --> I["LLM 推理"]

    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:#EAF3EC,stroke:#83A995,color:#315D49
    style F fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style G fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style H fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style I fill:#DCEFE5,stroke:#4F8B70,color:#24563F

工程上,不能把 Memory、State 和 Context 简单合并成一段对话历史。它们的数据结构、更新时机和持久化要求都不同。

八、Context Manager:上下文构建与管理

Context Manager 决定每一次模型调用应该提供哪些信息。

这对 Agent 尤其重要,因为 Agent 可能运行几十轮甚至数百轮。

1. 为什么需要 Context Manager?

假设一个 Agent 执行复杂任务:

  • 读取了 100 个文件。
  • 调用了 30 次工具。
  • 产生了大量中间结果。
  • 进行了多轮计划调整。

如果每次模型调用都把所有历史信息完整传入,就会遇到:

  • Token 消耗快速增长。
  • 模型上下文窗口不足。
  • 重要信息被大量无关信息淹没。
  • 推理成本和延迟增加。

2. 上下文管理策略

策略 作用
Sliding Window 只保留最近一部分历史
Summarization 将旧消息压缩成摘要
Retrieval 按需检索相关记忆
Truncation 删除低价值内容
Context Partitioning 将不同类型信息分区管理
Structured State 使用结构化状态代替冗长对话
Tool Result Filtering 过滤工具返回中的无关内容

3. Context 构建过程

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["生成最终 Context"]
    K --> 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:#EAF3EC,stroke:#83A995,color:#315D49
    style G fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style H fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style I fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style J fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style K fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style L fill:#DCEFE5,stroke:#4F8B70,color:#24563F

4. Context 预算

Context Manager 需要为不同内容分配 Token 预算。

例如:

内容 预算占比示例
系统指令和约束 15%
用户目标 10%
当前任务状态 15%
历史摘要 15%
工具定义 15%
当前任务相关资料 25%
预留空间 5%

这只是示例分配,不是固定比例。实际预算需要根据模型上下文窗口、工具数量和任务类型动态调整。

九、Agent Loop:核心运行机制

Agent Loop 是 Agent 最核心的执行机制。

它将模型推理、工具执行和环境反馈组织成一个持续循环。

1. 标准 Agent Loop

通常可以抽象为五个阶段:

阶段 英文 核心职责
感知 Observe 获取当前环境信息
思考 Think 分析目标和当前状态
规划 Plan 决定下一步行动
行动 Act 调用工具执行操作
评估 Evaluate 判断执行结果是否满足目标

完整执行流程:

flowchart TD
    A["Observe:获取环境信息"] --> B["Think:分析当前状态"]
    B --> C["Plan:制定行动计划"]
    C --> D["Act:执行工具操作"]
    D --> E["Evaluate:评估执行结果"]
    E --> F{"目标是否完成"}
    F -->|"否"| A
    F -->|"是"| G["返回最终结果"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    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:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style G fill:#DCEFE5,stroke:#4F8B70,color:#24563F

2. Observe:感知环境

Observe 负责获取当前任务相关信息。

信息来源包括:

  • 用户输入。
  • 历史对话。
  • 当前任务状态。
  • 工具执行结果。
  • 外部 API 响应。
  • 文件和数据库数据。
  • 环境运行日志。

Observe 的核心问题是:Agent 当前掌握了哪些事实?

要特别注意,外部环境返回的信息不一定可信。网页、邮件、文档等内容需要作为不可信数据处理,不能直接覆盖系统指令和安全策略。

3. Think:分析当前状态

Think 阶段使用 LLM 对当前上下文进行分析。

主要判断:

  • 用户真正想完成什么。
  • 当前任务处于什么状态。
  • 已经获得哪些信息。
  • 当前还缺少什么。
  • 是否存在执行风险。
  • 下一步是否需要调用工具。

Think 的重点不是生成长篇解释,而是形成可用于决策的判断。

4. Plan:制定行动计划

Plan 阶段决定接下来执行什么操作。

可能的结果包括:

  • 调用某个工具。
  • 拆分新的子任务。
  • 调整已有计划。
  • 请求用户补充信息。
  • 等待外部任务完成。
  • 结束当前任务。

简单任务可以直接生成下一步行动;复杂任务则需要维护显式任务计划。

5. Act:执行行动

Act 阶段由 Runtime 和 Tool Executor 完成。

可能执行: - 查询数据库。 - 读取文件。 - 修改文件。 - 调用 API。 - 执行代码。 - 发送消息。 - 调用其他 Agent。

Act 不是模型生成一段文本,而是系统真正执行外部操作。

6. Evaluate:评估结果

Evaluate 阶段需要判断行动是否有效。

例如:

  • 工具是否执行成功?
  • 是否获取到预期数据?
  • 是否满足当前子任务的完成条件?
  • 是否需要重新规划?
  • 整体目标是否已经完成?

评估可以结合: - 规则校验。 - 单元测试。 - 数据一致性检查。 - 独立模型评估。 - 人工审核。

对于重要任务,应尽可能采用确定性验证方式,而不是完全依赖 LLM 自我判断。

十、完整运行机制:从用户请求到任务完成

将前面的组件组合起来,可以得到一个相对完整的 Agent 执行过程。

以自动代码修复 Agent 为例。

1. 任务启动

用户提交任务:

检查项目中的代码问题,修复严重 Bug,并确保测试通过。

Runtime 创建任务,并初始化: - Task ID。 - 用户目标。 - 执行约束。 - 初始状态。 - 工具权限。 - 最大执行预算。

2. 目标解析与规划

Goal Manager 解析目标。

Planner 将任务拆解为:

  1. 扫描项目。
  2. 分析代码。
  3. 定位问题。
  4. 制定修复方案。
  5. 修改代码。
  6. 执行测试。
  7. 验证结果。
  8. 输出报告。

3. 上下文构建

Context Manager 加载: - 系统指令。 - 用户目标。 - 当前任务计划。 - 当前状态。 - 相关历史信息。 - 可用工具定义。

然后构建模型请求。

4. 模型决策

LLM 判断当前需要读取项目文件,并返回工具调用请求。

Runtime 解析请求,交给 Tool Executor。

5. 工具执行

Tool Executor 检查工具、参数和权限,执行文件读取操作,并返回结果。

6. 状态更新

State Manager 更新当前任务状态,保存已完成步骤和工具执行结果。

7. 反馈与重新决策

Runtime 将工具结果加入上下文,再次调用模型。

模型根据新信息决定继续分析、修改代码或执行测试。

8. 结果验证与结束

Result Validator 检查测试结果和任务完成条件。

如果符合要求,任务结束;如果未达到目标,则继续处理或进入失败恢复流程。