AI Agent

1. Agent 的定义与核心架构

1.1 什么是 AI Agent？

AI Agent 是一个能够感知环境、制定计划、调用工具、执行行动并从结果中学习的自主系统。其核心架构包括五个关键组件：

与传统 chatbot 的本质区别在于自主性、工具使用能力、多步规划和持久性：

1.2 Cognitive Architecture（认知架构）

AI Agent 的认知架构描述了系统如何将感知、思考和行动联系起来。一个完整的认知架构包括：

• 感知器（Perception）：理解用户输入、环境状态、工具反馈
• 推理器（Reasoning）：基于 LLM 进行思考和规划
• 内存系统（Memory System）：存储历史交互和学到的知识
• 执行器（Executor）：调用工具并执行具体动作
• 反馈循环（Feedback Loop）：从执行结果中学习并调整策略

1.3 Agent 架构图

2. 规划 (Planning) 详解

2.1 任务分解 (Task Decomposition)

复杂任务的关键是将其分解为可管理的子任务。这个过程涉及：

• 目标识别：明确最终目标是什么
• 依赖分析：识别子任务之间的依赖关系
• 粒度调整：确保子任务足够细化但不过度细化
• 优先级排序：根据重要性和依赖关系排序

2.2 Plan-and-Execute 策略与 BabyAGI

Plan-and-Execute 是一种两阶段方法：先规划后执行。BabyAGI（2023 年）引入了一个经典的循环：

1. 任务创建 (Task Creation)
   - 输入：初始目标
   - LLM 生成初始任务列表
   - 例如："分析市场"→ ["研究竞争对手", "分析用户需求", "评估市场规模"]

2. 优先级排序 (Prioritization)
   - 评估任务优先级、成本、影响力
   - score = importance × urgency / complexity
   - 选出下一个要执行的任务

3. 任务执行 (Execution)
   - Agent 执行顶级任务
   - 调用工具、生成代码、搜索信息
   - 返回结果

4. 结果存储 (Result Storage)
   - 将执行结果存入向量数据库
   - 更新任务列表（添加新任务、修改优先级）
   - 回到步骤 2（循环）

BabyAGI 的成功之处： 它证明了一个简单的循环机制可以解决复杂的多步骤任务。一个 GPT-4 Agent 可以通过这个循环完成市场分析、代码编写等原本需要人工的任务。

2.3 Reflexion 框架 (Shinn et al., 2023)

Reflexion 引入了一个关键的自我改进机制。其核心循环包括四个阶段：

2.4 LATS: Language Agent Tree Search (Liang et al., 2024)

LATS 将蒙特卡洛树搜索（MCTS）的思想应用于 Agent 规划。与 Reflexion 不同，LATS 使用树搜索探索多个执行路径：

1. Selection: 根据 UCB 值选择最有希望的节点
   UCB = Q(s,a) / N(s,a) + C × √(ln(N(s)) / N(s,a))

2. Expansion: 从选定节点展开新的子节点
   每个子节点代表一个可能的 Agent 动作

3. Simulation: 从新节点进行随机模拟到终止状态
   使用 LLM 快速评估该路径的价值

4. Backpropagation: 将结果回传到根节点
   更新所有访问过的节点的统计数据
                

LATS vs Reflexion：

• Reflexion：线性流程（失败 → 反思 → 重试），适合一个尝试多次
• LATS：树形探索，同时评估多个可能路径，更适合高分支因子的问题
• 成本权衡：LATS 因为探索更多分支，通常成本更高，但在复杂问题上精度更高

3. 记忆 (Memory) 系统

3.1 记忆层次与存储形式

Agent 的记忆系统类似人脑，分为多个层次：

3.2 记忆检索与优先级

当 Agent 需要访问记忆时，应该选择最相关的而非所有的记忆。一个常见的检索评分函数：

例子： Agent 收到查询"用户 Alice 的订单状态"。系统应该优先检索：

1. 最近与 Alice 互动的记忆（recency）
2. 关于"订单"和"状态"的记忆（relevance）
3. 用户标记为重要的订单信息（importance）

3.3 Stanford 的 Generative Agents (Park et al., 2023)

这是一个经典的 Agent 记忆架构案例研究。在虚拟小镇模拟中，25 个 Agent 展现出有说服力的社交行为，其核心机制是：

1. 观察 (Observation)
   - Agent 感知环境：其他 Agent 的行为、物体状态、事件
   - 存储为原始事件："Alice 在厨房看到 Bob"

2. 反思 (Reflection)
   - 定期（如每天 8 次），Agent 回顾过去的观察
   - 聚合低级观察成高级反思
   - 例如：多个观察 "看到 Bob 做 X 行为"
        → 反思 "Bob 最近很忙"
   - 使用 LLM 自动生成反思

3. 规划 (Planning)
   - 基于反思和当前时间制定日程
   - 例如："反思：我需要准备晚餐"
       → 规划："14:00-15:00 买菜，18:00-19:00 做饭"
   - 高级计划指导具体动作

3.4 Episodic vs Semantic Memory

不同类型的记忆服务不同的目的：

• 情景记忆 (Episodic)： "我过去做过什么"。时间敏感，包含上下文。
  例如："2024-03-15 与用户 X 讨论了 Y 问题，结果是 Z"
• 语义记忆 (Semantic)： "我知道什么"。时间无关，事实性。
  例如："Python 的 list.append() 方法向列表末尾添加元素"

高级 Agent 系统（如 MemGPT）同时维护两种记忆，混合查询和推理。

3.5 MemGPT: 虚拟上下文管理 (Packer et al., 2023)

核心问题：LLM 上下文窗口有限（通常 4K-128K tokens），而 Agent 需要访问无限大小的知识库。

                    ├─ 主记忆 (Main Context)：8K tokens
                    │  └─ 经常访问的数据、当前对话
                    │
                    ├─ 辅助记忆 (Archive)：磁盘上的大型存储
                    │  └─ 历史对话、背景知识
                    │
                    └─ 对换机制 (Swapping)：自动管理
                       └─ LLM 决定什么时候从归档中加载/保存数据
                       └─ 类似 OS page fault handling
                

MemGPT 让 Agent 可以有效地处理任意大小的任务（论文演示了 8-hour 对话）。关键创新是让 LLM 显式控制自己的上下文（`core_memory_append`, `core_memory_replace` 等函数调用）。

4. 工具使用 (Tool Use) 详解

4.1 工具类型综览

一个完整的 Agent 系统需要多种工具来与外部世界交互：

4.2 代码执行环境与安全

代码执行是 Agent 最强大的工具，但也最危险。关键的沙箱环境包括：

• E2B：云端 Python sandbox，支持长期运行、文件持久化、包管理
• Docker：容器隔离，完整的操作系统级别安全边界
• Restricted Python：限制危险操作（如 `open()`, `exec()`），但仍保留计算能力
• WASM：WebAssembly 沙箱，在浏览器中安全执行代码

4.3 API 调用与函数调用（Function Calling）

现代 LLM（OpenAI、Claude、Gemini）都支持结构化的函数调用，而非自由文本的工具使用。这大大提高了可靠性：

// 定义可用的工具
tools = [
  {
    "name": "search_web",
    "description": "搜索网页内容",
    "parameters": {
      "type": "object",
      "properties": {
        "query": {"type": "string"},
        "num_results": {"type": "integer", "default": 10}
      },
      "required": ["query"]
    }
  },
  {
    "name": "get_stock_price",
    "parameters": {
      "type": "object",
      "properties": {
        "ticker": {"type": "string"}
      },
      "required": ["ticker"]
    }
  }
]

// Agent 的响应
{
  "type": "function_call",
  "function": "search_web",
  "arguments": {
    "query": "Python 最新版本特性",
    "num_results": 5
  }
}

vs 自由文本方式： "请搜索 Python 最新版本" → Agent 需要用自然语言表达，容易出错（如遗漏参数、格式不对）

4.4 Toolformer: 自动学习何时使用工具 (Schick et al., 2023)

一个根本的问题：Agent 如何学会何时调用工具？Toolformer 的方案是：

1. 离线学习： 在训练数据中自动插入 API 调用标记
   例如："2 + 2 是多少？" → "2 + 2 是多少？ [CALCULATOR(2+2)] 4"
2. 标注： 使用执行反馈：如果调用 API 会改进生成的质量，就保留；否则删除
3. 蒸馏： 在小模型上蒸馏学到的 API 使用模式，保持模型大小不变

结果：Toolformer-T5-3B 在多个基准上超过了仅用参数的 GPT-3（175B）。关键洞察：学会何时调用工具比盲目扩大参数更重要。

4.5 Computer Use (Anthropic, 2024)

最通用的工具是整个计算机本身。Anthropic 最近推出的 Computer Use 能力让 Claude Agent 可以：

• 获取屏幕截图（任何分辨率）
• 理解截图中的 UI 元素（OCR + 视觉理解）
• 执行键鼠操作（点击、输入、拖动）

1. 获取截图（PNG）
2. Vision → 理解当前屏幕状态和可交互的元素
3. 决定下一个动作
   - 点击按钮（x, y 坐标）
   - 输入文本
   - 滚动
   - 等待
4. 执行动作
5. 回到步骤 1（循环直到完成）
                

挑战：

• 坐标精度： 从视觉理解到像素级准确的点击位置很难
• 延迟： 每个循环 1-3 秒，对于许多点击的任务会很慢
• 跨平台： 不同操作系统的 UI 差异大

5. 经典 Agent 模式

5.1 ReAct: Reasoning + Acting (Yao et al., 2023)

ReAct 是目前最广泛使用的 Agent 架构。其核心是一个简单但强大的循环：

Thought: [Agent 的思考和推理]
Action: [具体的行动，e.g. tool_name(args)]
Observation: [执行结果]
... (循环重复)
Final Answer: [最终结果]
                

问题: "火星到地球的距离是多少？"

Thought: 我需要查找当前火星与地球的距离。这取决于它们在各自轨道上的位置。
Action: search_web(火星地球距离 2024)
Observation: [搜索结果] 根据最新数据，火星离地球约 2.25 亿公里...

Thought: 这个距离似乎是合理的，但我应该验证这是最近的距离还是平均距离。
Action: search_web(火星地球最近距离最远距离)
Observation: [搜索结果] 火星最近距离（对冲）约 5400 万公里，最远（冲）约 2.01 亿公里。

Thought: 现在我有了完整的信息。
Final Answer: 火星到地球的距离取决于它们在轨道上的位置：
  - 最近距离（对冲）：约 5400 万公里
  - 最远距离（冲）：约 2.01 亿公里
  - 平均距离：约 1.35 亿公里

ReAct 的成功因素：

• 可解释：每一步都有明确的推理和行动，容易调试
• 灵活：适应各种任务（QA、数学、编程、网络任务）
• 实用：无需特殊训练，只需 few-shot prompting
• 可靠：相比端到端的黑盒方法，更容易发现和修正错误

5.2 Function Calling Agent

ReAct 的进化版本，使用结构化的工具调用而非自由文本。由于 LLM 可以直接输出 JSON，这通常更可靠：

// 初始化
system_prompt = """你是一个可以使用工具的 Agent。
可用的工具包括：search_web, get_weather, calculate...
当需要使用工具时，输出 JSON 格式的函数调用。"""

// 主循环
while True:
  response = llm.chat(
    system=system_prompt,
    messages=conversation_history,
    tools=available_tools
  )

  if response.type == "text":
    return response.text  // 最终答案

  elif response.type == "function_call":
    result = execute_tool(response.function, response.arguments)
    conversation_history.append({
      "role": "assistant",
      "content": response
    })
    conversation_history.append({
      "role": "user",
      "content": {
        "type": "function_result",
        "result": result
      }
    })
    // 循环继续，LLM 看到结果并决定下一步

5.3 Code Agent (Smolagents)

一个有趣的替代方案：让 Agent 生成 Python 代码而非 JSON，然后执行代码。优势：

• 灵活性： Python 可以表达任意复杂的逻辑，不仅仅是工具调用
• 可组合性： 可以在代码中循环、条件、调用多个工具
• 完全性： 生成的代码是完整的解决方案，不需要外部循环

# Agent 生成的代码
results = []
for city in ["北京", "上海", "深圳"]:
    weather = get_weather(city)
    if weather["temperature"] > 30:
        results.append(f"{city} 今天很热 ({weather['temperature']}°C)")
    else:
        results.append(f"{city} 天气温和")

answer = "\n".join(results)
print(answer)

5.4 Conversational Agent

维持对话历史同时使用工具。关键要素：

• 保留完整的对话上下文（用户消息 + Agent 回应）
• 基于历史上下文理解用户的隐含意图
• 混合使用工具调用和文本生成

例如，在用户问"上次我问过的那个问题的答案是什么？"时，Agent 需要从对话历史中找出"那个问题"。

6. Agent 编排模式 — 关键架构知识

6.1 单 Agent 模式 (Single Agent)

最简单的配置：一个 LLM Agent 处理所有任务。适用于：

• 简单、单一目标的任务
• 快速原型开发
• 成本敏感的应用

缺点： 单一 Agent 可能在复杂任务上不专业，容易出错。

6.2 Router 模式 (路由模式)

基于输入类别，将请求路由到不同的处理器。

例子： 客服系统，根据用户问题分类：

• "如何安装？" → 文档搜索 Agent
• "我的订单呢？" → 数据库查询 Agent
• "代码有 bug" → 代码调试 Agent

6.3 Orchestrator-Worker 模式 (编排-工作者)

一个中央编排器理解任务，分解并分配给多个工作者 Agent，最后汇总结果。适合复杂的多步任务。

例子： "撰写一份关于 AI Agent 的技术报告"

1. Orchestrator 分解任务：(1) 研究当前最新论文，(2) 对比不同框架，(3) 编写代码示例，(4) 编写最终报告
2. Worker 1（研究员）：搜索论文、总结关键发现
3. Worker 2（工程师）：对比 LangGraph vs AutoGen vs Smolagents
4. Worker 3（编码员）：编写可运行的代码示例
5. Worker 4（作者）：编写最终报告并汇总
6. Orchestrator 回顾质量，要求修订如有必要

6.4 Pipeline / Sequential 模式

任务按固定顺序流经多个处理阶段。每个阶段产生的输出是下一阶段的输入。

优点： 简单、可预测、易于调试
缺点： 不灵活，无法处理条件分支或循环

6.5 分层多 Agent 系统 (Hierarchical Multi-Agent)

一个树形结构，顶层管理器递归地分解任务，分配给下层 Agent。

class HierarchicalAgent:
    def solve(task):
        if task.is_simple():
            return execute_directly(task)
        else:
            # 分解为子任务
            subtasks = decompose(task)
            results = []
            for subtask in subtasks:
                # 递归调用下层 Agent
                result = child_agent.solve(subtask)
                results.append(result)
            return aggregate(results)

# 使用例子
manager = HierarchicalAgent(level=0)  // 顶层管理器
result = manager.solve("分析全球 AI 市场")
// 内部会分解为：
//   - 分析北美市场 (分配给子 Agent)
//   - 分析欧洲市场 (分配给子 Agent)
//   - 分析亚洲市场 (分配给子 Agent)
// 每个子 Agent 可能进一步分解为国家级分析

6.6 Evaluator-Optimizer 模式

一个 Generator 生成候选解，Evaluator 评估质量，然后优化。常用于：

• 代码生成： 生成候选代码 → 运行测试 → 根据失败改进
• 创意写作： 生成多个版本 → 评估清晰性/创意 → 选择最佳
• 参数调优： Agent 改变系统参数 → 评估性能 → 优化

这其实是 Reflexion 框架的通用化。

7. 多 Agent 系统 — 2024-2026 核心趋势

7.1 为什么单 Agent 不够？

• 专业化分工： 一个 Agent 的"通用性"往往导致"不够专业"。多个 Agent 各司其职，效果更好。
• 复杂性处理： 复杂任务涉及多个领域（法律、财务、技术）。单 Agent 在所有领域都精通很难。
• 容错能力： 多 Agent 可以互相检查和纠正，增强鲁棒性。
• 并行处理： 多个独立 Agent 可以并行工作，提高效率。
• 可扩展性： 添加新功能只需添加新 Agent，不需修改现有系统。

7.2 多 Agent 通信模式

7.3 多 Agent 框架对比

7.4 框架深度分析

LangGraph (LangChain)

核心： 将 Agent 工作流表示为有向图，每个节点是 Agent/Tool，边是条件路由。

from langgraph.graph import StateGraph

# 定义状态
class State(TypedDict):
    messages: List[str]
    current_task: str
    results: List[str]

# 创建图
graph = StateGraph(State)

# 添加节点（Agent 或工具）
graph.add_node("planner", planner_agent)
graph.add_node("executor", executor_agent)
graph.add_node("reviewer", reviewer_agent)

# 添加边（路由）
graph.add_edge("planner", "executor")
graph.add_conditional_edges(
    "executor",
    review_quality,  // 根据 review_quality() 的输出决定
    {
        "pass": "output",
        "fail": "planner"  // 如果失败，回到规划
    }
)

# 编译和运行
app = graph.compile()
result = app.invoke({"messages": [...], "current_task": "..."})

优势： 强大的 Checkpointing（保存中间状态）、Human-in-the-loop、完全可视化
劣势： 学习曲线陡

CrewAI

核心： 将 Agent 视为团队中的"角色"，每个角色有目标、背景和专业领域。

from crewai import Agent, Task, Crew

# 定义 Agent（具有角色）
researcher = Agent(
    role="市场研究员",
    goal="收集关于 AI 市场的准确数据",
    backstory="有 10 年市场研究经验...",
    tools=[search_tool, analysis_tool],
    llm=client.models.claude
)

analyst = Agent(
    role="数据分析师",
    goal="提供深入的市场分析",
    backstory="专门研究 AI 趋势...",
    tools=[sql_tool, visualization_tool],
    llm=client.models.claude
)

# 定义任务
research_task = Task(
    description="分析 2024 年 AI Agent 市场规模",
    agent=researcher,
    expected_output="市场规模报告"
)

analysis_task = Task(
    description="基于研究结果提供分析",
    agent=analyst,
    expected_output="详细分析报告"
)

# 创建团队
crew = Crew(
    agents=[researcher, analyst],
    tasks=[research_task, analysis_task],
    process=Process.sequential  // 或 .hierarchical
)

result = crew.kickoff()

优势： 易用、角色化设计自然、集成内存和工具
劣势： 灵活性不如 LangGraph

AutoGen (Microsoft)

核心： 多个 Agent 通过对话互相协作。包括：

• UserProxy Agent： 代表用户，可要求人工输入或干预
• Assistant Agent： 通常是 GPT 或其他 LLM
• GroupChat Manager： 管理多 Agent 的对话

8. 代码 Agent — 2024 年的新时代

8.1 代码 Agent 的崛起

从 Copilot 到 Devin，AI 在代码领域的自主性飞速提升。最新的代码 Agent 可以：

• 理解整个代码库架构
• 自主搜索 npm/PyPI 文档
• 编写、调试、测试代码
• 提交 PR 或直接部署

8.2 Devin (Cognition AI)

2024 年引入的自主软件工程 Agent。工作流：

8.3 Claude Code (Anthropic)

Anthropic 的代码 Agent，集成了 MCP（Model Context Protocol），可以：

• 访问整个文件系统，理解大型项目
• 直接运行终端命令（git, npm, make 等）
• 执行代码并即时看到结果
• 自主调试和修复错误

8.4 其他代码 Agent 工具

• GitHub Copilot Workspace： IDE 中的 Agent，支持多文件编辑和提交
• Cursor / Windsurf / Cline： AI-first IDE，集成了 Agent 能力
• OpenAI Codex / o1-preview： 直接在模型层面支持更强的代码推理

8.5 SWE-bench: 代码 Agent 评估标准

衡量代码 Agent 性能的标准基准。包含 300+ GitHub 开源项目的真实 issues，评估 Agent 的完整解决能力。

9. 浏览器与 Computer Use Agent

9.1 Browser Use

一个开源项目（78K GitHub stars），让 Agent 可以自动化网页任务。工作原理：

1. 获取网页 HTML 结构
2. 使用 LLM 理解 DOM，识别可交互元素
3. 执行键鼠操作（点击、输入、滚动）
4. 获取新的页面状态，继续迭代

9.2 Crawl4AI

专注于网页内容提取的 Agent（51K stars）。相比 Browser Use 的通用性，Crawl4AI 更专业化，提供：

• 智能内容提取（去除噪声、广告）
• Markdown 格式转换
• JavaScript 渲染支持
• 批量处理优化

9.3 Anthropic Computer Use

完全通用的桌面 Agent。可以操作任何应用和网站，不仅仅是浏览器。

while not task_completed:
    # 1. 获取屏幕截图
    screenshot = take_screenshot()

    # 2. Vision LLM 分析
    analysis = claude.vision_analyze(
        image=screenshot,
        context=task_description
    )
    # 输出：识别的 UI 元素、可能的下一步操作

    # 3. 执行动作
    if analysis.action_type == "click":
        mouse.click(x=analysis.x, y=analysis.y)
    elif analysis.action_type == "type":
        keyboard.type(analysis.text)
    elif analysis.action_type == "scroll":
        mouse.scroll(amount=analysis.scroll_amount)

    # 等待页面加载
    time.sleep(1-2)

关键挑战：

• 坐标精度： OCR 识别"提交"按钮 → 计算像素坐标。VLM 有时会错估位置。
• 状态跟踪： 页面加载、异步操作、弹窗等会改变状态。需要强大的状态机制。
• 反爬虫： 网站的 CAPTCHA、速率限制会阻止 Agent。
• 延迟： 每个循环 1-3 秒。完成 100 步操作需要 2-5 分钟。

9.4 OpenAI Operator

OpenAI 最新的浏览器 Agent，专门针对网页自动化优化。利用 Vision 和强化学习改进指针精度。

10. Agent 基础设施与协议

10.1 MCP: Model Context Protocol (Anthropic, 2024)

一个开放的协议标准，统一 LLM 与各种工具/数据源的连接。解决的问题：每个 LLM 都需要自己定义工具接口，导致碎片化。MCP 统一这一点。

1. Tools（工具）
   - LLM 可以调用的函数
   - JSON schema 定义
   - 例如：file_read, web_search, database_query

2. Resources（资源）
   - LLM 可以访问的数据源
   - URI 模式匹配
   - 例如：file://path/to/file, db://table_name

3. Prompts（提示模板）
   - 预定义的提示词
   - 支持参数化
   - 例如："分析 {file} 中的安全问题"
                

传输模式：

• stdio：本地进程通信，适合本地工具（文件系统、git）
• SSE/HTTP：远程服务器，适合网络 API

生态规模： 已有 1000+ MCP servers（文件系统、GitHub、Slack、数据库等），形成了完整的工具生态。

10.2 A2A: Agent-to-Agent Protocol (Google)

一个互补的标准，专注于 Agent 之间的通信（而非 Agent 与工具）。核心概念：

• Agent Card： JSON 格式，描述 Agent 的能力、输入/输出格式
• Task： Agent A 请求 Agent B 完成的任务，支持异步
• Streaming： 实时推送结果，而非等待完成

{
  "id": "market-researcher-agent",
  "name": "Market Research Agent",
  "description": "搜索和分析市场数据",
  "capabilities": [
    {
      "name": "search_market",
      "input": {"market": "string", "region": "string"},
      "output": {"data": "json", "sources": "string[]"}
    }
  ],
  "supportedFormats": ["json", "markdown"],
  "endpoint": "https://agent-service.example.com/api"
}

与 MCP 的区别：

• MCP： Agent ↔ Tool/Resource，强调工具调用
• A2A： Agent ↔ Agent，强调协作和任务分解

10.3 Agent 可观测性与监控

在生产环境中运行 Agent 需要完整的可观测性。关键工具：

• LangSmith（LangChain）：完整的 Agent 执行追踪、成本监控
• Langfuse：开源替代品，支持成本分析、用户反馈
• Arize Phoenix：LLM 模型监控专家，追踪 drift 和性能

• 执行时间（Latency）：Task 从开始到完成的总时间
• Token 使用量（Cost）：输入 + 输出 token 数，计算成本
• 错误率（Error Rate）：失败的任务占比
• 工具调用成功率（Tool Success Rate）：工具调用成功的占比
• 用户满意度（User Satisfaction）：用户反馈评分
• 幻觉率（Hallucination Rate）：LLM 生成不真实内容的比例
                

11. 安全与可控性

11.1 执行环境隔离

当 Agent 执行代码时，必须在隔离的沙箱中运行，防止恶意或错误的代码损害主机系统。

11.2 权限模型

显式声明 Agent 能做什么，防止超权。最小权限原则：

agent_permissions = {
    "file_system": {
        "read": ["/data/input/*"],    // 只读输入目录
        "write": ["/data/output/*"],  // 只写输出目录
        "delete": []                   // 不允许删除
    },
    "network": {
        "allowed_domains": ["api.example.com", "search.bing.com"],
        "forbidden_domains": ["internal.company.com"],
        "rate_limit": "100 req/min"
    },
    "code_execution": {
        "languages": ["python", "javascript"],
        "timeout": 30,  // 秒
        "memory_limit": "2GB",
        "forbidden_modules": ["os.system", "subprocess"]
    }
}

11.3 Human-in-the-Loop

对关键操作（如文件删除、API 调用、数据修改）暂停，等待人工确认。

• 硬暂停： 某些操作必须获得批准。如："你想删除 10GB 文件吗？"
• 软暂停： 提示但不阻止。如："即将执行 SQL 删除语句，继续吗？"
• 事后审查： 操作完成后，人工检查日志并可以回滚。

11.4 Prompt Injection 防御

Agent 特别容易受到 prompt injection 攻击，因为它们从多个来源读取数据（网页、数据库、用户输入）。防御策略：

• 输入验证： 检查用户输入是否包含异常字符或命令
• 角色分离： 系统提示与用户内容分离
• 沙箱化： 外部数据只有有限的权限
• 日志和审计： 记录所有输入，便于事后分析

11.5 Guardrails

使用专门的库验证 LLM 输出，确保不会执行危险或非预期的操作。

• NeMo Guardrails (NVIDIA)： 规则引擎，支持拓扑和规则约束
• Guardrails AI： 开源，支持自定义 validator

from guardrails import Guard, validators

guard = Guard.from_pydantic(
    output_class=AgentAction,
    validators=[
        validators.ValidLength(min=1, max=500),
        validators.ValidChoices(
            choices=["search", "execute", "think"],
            on_fail="fix"
        ),
        validators.NoSubstrings(
            substrings=["delete all", "drop table"],
            on_fail="exception"
        )
    ]
)

raw_output = llm.generate(prompt)
validated_output = guard.validate(raw_output)

12. 未来展望 (2026+)

12.1 市场预测与趋势

Gartner 预测： 到 2028 年，33% 的企业应用将包含某种形式的自主 Agent。这意味着：

• Agent 不再是新鲜事物，而是标准配置
• 竞争会从"有没有 Agent"转向"Agent 有多强"
• Agent 编排和管理会成为新的 DevOps 领域

12.2 Agent Operating System

未来可能出现"Agent OS"，类似传统操作系统，但针对 Agent：

• 资源管理： 多个 Agent 竞争 GPU、网络等资源
• 进程调度： 优化 Agent 任务执行顺序
• IPC（进程间通信）： Agent 之间的标准通信协议
• 文件系统： 共享知识库，Agent 可以读写
• 权限管理： 细粒度的 Agent 权限控制

12.3 Agent Economy

未来 Agent 可能会形成一个自动化的"经济体系"：

• Agent Marketplace： Agent 发布任务，其他 Agent 竞标完成
• 微交易： Agent 为服务互相支付（使用加密货币或代币）
• 声誉系统： 高质量的 Agent 获得更高评分，更容易被雇用
• 价格发现： 市场自动确定各种服务的价格

这可能是实现"AI 自我复制和自我改进"的一个路径。

12.4 多模态 Agent

当前的 Agent 主要处理文本和代码。未来的 Agent 将：

• 视觉理解： 不仅是 Computer Use 的截图，还包括图像分析、视频理解
• 音频处理： 语音识别、语音合成、音频信息提取
• 多环境交互： 机器人控制、物理模拟
• 跨模态推理： 联合理解文本、图像、代码、物理世界的因果关系

12.5 自我改进 Agent

最激动人心的方向：Agent 通过反思和经验自动改进。机制：

• Feedback 循环： 每次任务完成后，Agent 评估自己的表现
• 微调： 基于 feedback，Agent 更新自己的参数或提示词
• 知识积累： 学到的技能存储在记忆库中，供未来任务使用
• 元学习： Agent 学会如何更快地学习（学会学习）

这与强化学习的思想一致，但应用于通用 Agent。

12.6 AGI 路径

Agent 在通向 AGI 的路径中扮演什么角色？

当前（2024）：LLM + ReAct Agent（有限推理、有限工具）
    ↓
短期（2025-2026）：高级规划 + 自我反思（类似 o1）+ 完整工具生态
    ↓
中期（2027-2030）：自主改进 + 多模态 + Agent 经济
    ↓
长期（2030+）：完全自主学习 + 目标形成 + 可能导向 AGI
                

关键成分：

• 更强的推理能力（长思维链、树搜索）
• 更好的工具使用（理解何时、如何使用工具）
• 自我改进和学习（从经验中优化）
• 长期目标和自主性（不仅回答问题，还能形成自己的目标）

13. AI Agent 面试高频问题