Agent 类型分类
Agent 世界丰富多彩，从简单的问答助手到复杂的多智能体协作系统。理解 Agent 的分类体系，是选型和设计的关键。
一、分类维度概览
Agent 可以从三个维度进行分类：
┌─────────────────────────────────────────────────────────────────┐
│ Agent 分类三维模型 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────┐ │
│ │ 应用领域 │ │
│ │ (What) │ │
│ └──────┬──────┘ │
│ │ │
│ ┌─────────────────────┼─────────────────────┐ │
│ │ │ │ │
│ │ │ │ │
│ ┌──────┴──────┐ ┌──────┴──────┐ ┌──────┴──────┐ │
│ │ 架构复杂度 │ │ Agent │ │ 决策模式 │ │
│ │ (How Much) │◄──────┤ 核心 │──────►│ (How) │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
│ │
│ • 简单 Agent • 代码助手 • 反应式 Agent │
│ • 复杂 Agent • 研究助手 • 慎思式 Agent │
│ • 多 Agent 系统 • 智能客服 • 混合式 Agent │
│ • 数据分析 │
│ │
└─────────────────────────────────────────────────────────────────┘二、按架构复杂度分类
2.1 三层架构模型
┌─────────────────────────────────────────────────────────────────┐
│ 架构复杂度金字塔 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ╱╲ │
│ ╱ ╲ │
│ ╱ 多 ╲ 多 Agent 系统 │
│ ╱ Agent ╲ • 多角色协作 │
│ ╱ 系统 ╲ • 分布式架构 │
│ ╱──────────╲ • MetaGPT, AutoGen │
│ ╱ ╲ │
│ ╱ 复杂 Agent ╲ 单 Agent 多组件 │
│ ╱ (Complex) ╲ • 多工具协作 │
│ ╱ ╲ • AutoGPT, BabyAGI │
│ ╱────────────────────╲ │
│ ╱ ╲ │
│ ╱ 简单 Agent ╲ 单 Agent 单工具 │
│ ╱ (Simple) ╲ • 快速响应 │
│ ╱ ╲• Perplexity, Claude │
│ ╱────────────────────────────────╲ │
│ │
└─────────────────────────────────────────────────────────────────┘2.2 简单 Agent（Simple Agent）
定义：单 LLM 核心 + 单一工具，专注单一任务的 Agent。
┌─────────────────────────────────────────────────────────────────┐
│ 简单 Agent 架构 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ 用户请求 ──→ ┌───────────────────────────────┐ ──→ 响应结果 │
│ │ 简单 Agent │ │
│ │ ┌─────────────────────────┐ │ │
│ │ │ LLM │ │ │
│ │ │ (单一决策逻辑) │ │ │
│ │ └───────────┬─────────────┘ │ │
│ │ │ │ │
│ │ ↓ │ │
│ │ ┌───────────────┐ │ │
│ │ │ 单一工具 │ │ │
│ │ │ (搜索/查询) │ │ │
│ │ └───────────────┘ │ │
│ └───────────────────────────────┘ │
│ │
│ 特点：快速响应、低成本、易部署、能力有限 │
│ │
└─────────────────────────────────────────────────────────────────┘典型代表：
- Perplexity AI：搜索 + 总结
- ChatGPT with Browsing：对话 + 网页搜索
- Claude with Artifacts：对话 + 代码预览
代码示例：
# 简单 Agent 实现
class SimpleAgent:
"""单一工具的简单 Agent"""
def __init__(self, llm, tool):
self.llm = llm
self.tool = tool # 单一工具
def run(self, user_input: str) -> str:
# 1. LLM 判断是否需要工具
if self.needs_tool(user_input):
# 2. 调用工具
tool_result = self.tool.execute(user_input)
# 3. LLM 基于结果生成回答
return self.llm.generate(f"基于以下信息回答：{tool_result}")
else:
# 4. 直接回答
return self.llm.generate(user_input)
def needs_tool(self, input_text: str) -> bool:
# 简单判断逻辑
keywords = ["搜索", "查询", "最新", "实时"]
return any(kw in input_text for kw in keywords)
# 使用示例
search_agent = SimpleAgent(
llm=GPT4(),
tool=SearchTool()
)
response = search_agent.run("今天北京的天气怎么样？")适用场景：
- 信息查询（搜索引擎 + 总结）
- 单一功能助手（翻译、摘要）
- 快速问答场景
- 成本敏感的简单任务
优劣势对比：
| 维度 | 优势 | 劣势 |
|---|---|---|
| 开发成本 | 低，几行代码即可实现 | 能力有限，无法处理复杂任务 |
| 运行成本 | 低，通常 1-2 次 LLM 调用 | 无法执行多步骤任务 |
| 响应速度 | 快，秒级响应 | 无规划能力，只能被动响应 |
| 部署难度 | 简单，单一服务 | 无法自我纠错 |
2.3 复杂 Agent（Complex Agent）
定义：单 LLM 核心 + 多组件协作，具备规划、记忆、多工具能力的 Agent。
┌─────────────────────────────────────────────────────────────────┐
│ 复杂 Agent 架构 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ 用户目标 ──→ ┌───────────────────────────────────────┐ │
│ │ 复杂 Agent │ │
│ │ │ │
│ │ ┌─────────────────────────────────┐ │ │
│ │ │ 规划器 (Planning) │ │ │
│ │ │ 任务分解 → 计划生成 → 优先级 │ │ │
│ │ └────────────────┬────────────────┘ │ │
│ │ │ │ │
│ │ ┌────────────────┴────────────────┐ │ │
│ │ │ LLM 核心 │ │ │
│ │ │ (推理与决策中心) │ │ │
│ │ └────────────────┬────────────────┘ │ │
│ │ │ │ │
│ │ ┌────────────────┼────────────────┐ │ │
│ │ │ │ │ │ │
│ │ ↓ ↓ ↓ │ │
│ │ ┌──────┐ ┌──────────┐ ┌──────┐ │ │
│ │ │记忆库│ │ 工具集 │ │执行器│ │ │
│ │ │(RAG) │ │(多工具) │ │(沙箱)│ │ │
│ │ └──────┘ └──────────┘ └──────┘ │ │
│ │ │ │ │
│ │ ↓ │ │
│ │ ┌─────────────────────────────┐ │ │
│ │ │ 反思机制 (Reflection) │ │ │
│ │ │ 验证 → 纠错 → 优化 │ │ │
│ │ └─────────────────────────────┘ │ │
│ └───────────────────────────────────────┘ │
│ │ │
│ ↓ │
│ 最终结果 │
│ │
└─────────────────────────────────────────────────────────────────┘典型代表：
- AutoGPT：自主目标分解与执行
- BabyAGI：任务驱动自主循环
- LangChain Agent：工业级 Agent 框架
- OpenAI Assistants API：官方托管的 Agent 服务
代码示例：
# 复杂 Agent 实现（基于 ReAct 架构）
class ComplexAgent:
"""具备规划、记忆、多工具能力的复杂 Agent"""
def __init__(self, llm, tools, memory):
self.llm = llm
self.tools = {tool.name: tool for tool in tools} # 多工具
self.memory = memory # 记忆系统
self.max_iterations = 10
def run(self, goal: str) -> str:
# 1. 从记忆库检索相关上下文
context = self.memory.recall(goal)
# 2. 规划任务
plan = self.plan(goal, context)
# 3. ReAct 循环执行
iteration = 0
while iteration < self.max_iterations:
iteration += 1
# Thought: 思考下一步
thought = self.think(goal, plan, context)
# Action: 决定行动
action, action_input = self.decide_action(thought)
if action == "FINISH":
# 任务完成
return self.generate_final_answer()
# 执行工具
observation = self.execute_tool(action, action_input)
# 更新上下文
context = self.update_context(thought, action, observation)
# 存储到记忆库
self.memory.store(f"Thought: {thought}\nAction: {action}\nObservation: {observation}")
return "达到最大迭代次数，任务未完成"
def plan(self, goal: str, context: str) -> list:
"""规划任务分解"""
prompt = f"""
目标: {goal}
上下文: {context}
请将目标分解为具体的执行步骤。
"""
return self.llm.generate(prompt)
def think(self, goal, plan, context) -> str:
"""思考下一步行动"""
prompt = f"""
目标: {goal}
计划: {plan}
当前状态: {context}
思考下一步应该做什么？
"""
return self.llm.generate(prompt)
def execute_tool(self, tool_name: str, tool_input: str) -> str:
"""执行工具并处理错误"""
try:
return self.tools[tool_name].execute(tool_input)
except Exception as e:
return f"工具执行错误: {str(e)}"
# 使用示例
agent = ComplexAgent(
llm=GPT4(),
tools=[SearchTool(), CodeTool(), FileTool(), DatabaseTool()],
memory=VectorMemory(embedding_model="text-embedding-3-small")
)
result = agent.run("帮我分析销售数据，生成报告并发送给团队")适用场景：
- 复杂多步骤任务
- 需要规划能力的场景
- 需要长期记忆的场景
- 需要自我纠错的场景
优劣势对比：
| 维度 | 优势 | 劣势 |
|---|---|---|
| 任务能力 | 能处理复杂多步骤任务 | 开发和调试成本高 |
| 自主性 | 具备规划和反思能力 | 运行成本高（多次 LLM 调用） |
| 容错性 | 能自我纠错和重试 | 响应时间长（分钟级） |
| 扩展性 | 可集成多种工具 | 架构复杂，维护难度大 |
2.4 多 Agent 系统（Multi-Agent System）
定义：多个专业 Agent 角色协作，共同完成复杂任务的系统。
┌─────────────────────────────────────────────────────────────────┐
│ 多 Agent 系统架构 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────┐ │
│ │ 用户/调度器 │ │
│ └────────┬────────┘ │
│ │ │
│ ┌───────────────────┼───────────────────┐ │
│ │ │ │ │
│ ↓ ↓ ↓ │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ 产品经理 │ │ 工程师 │ │ 测试工程师 │ │
│ │ Agent │ │ Agent │ │ Agent │ │
│ │ │ │ │ │ │ │
│ │ • 需求分析 │ │ • 代码编写 │ │ • 测试用例 │ │
│ │ • 功能设计 │ │ • 架构设计 │ │ • 质量验证 │ │
│ └──────┬──────┘ └──────┬──────┘ └──────┬──────┘ │
│ │ │ │ │
│ └───────────────────┼───────────────────┘ │
│ │ │
│ ↓ │
│ ┌─────────────────┐ │
│ │ 共享工作空间 │ │
│ │ • 任务队列 │ │
│ │ • 共享记忆 │ │
│ │ • 消息通道 │ │
│ └─────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘典型代表：
- MetaGPT：软件公司模拟，多角色协作开发
- AutoGen：微软多 Agent 对话框架
- CrewAI：角色扮演式多 Agent 协作
- ChatDev：虚拟软件公司
代码示例：
# 多 Agent 系统实现
from dataclasses import dataclass
from typing import List, Dict
@dataclass
class AgentRole:
name: str
role: str
goal: str
tools: List[str]
class MultiAgentSystem:
"""多 Agent 协作系统"""
def __init__(self):
self.agents: Dict[str, Agent] = {}
self.shared_memory = SharedMemory()
self.message_queue = MessageQueue()
def add_agent(self, role: AgentRole):
"""添加专业 Agent"""
agent = Agent(
name=role.name,
role=role.role,
goal=role.goal,
tools=self._init_tools(role.tools),
memory=self.shared_memory # 共享记忆
)
self.agents[role.name] = agent
def run(self, task: str) -> str:
"""执行多 Agent 协作任务"""
# 1. 任务分发
subtasks = self.dispatcher.assign(task, self.agents)
# 2. 协作执行
results = {}
for agent_name, subtask in subtasks.items():
# Agent 执行子任务
result = self.agents[agent_name].run(subtask)
results[agent_name] = result
# 广播结果给其他 Agent
self.message_queue.broadcast(agent_name, result)
# 3. 汇总结果
return self.aggregator.summarize(results)
# 定义软件开发的 Agent 角色
software_team = MultiAgentSystem()
# 产品经理 Agent
software_team.add_agent(AgentRole(
name="product_manager",
role="产品经理",
goal="分析需求，设计产品功能",
tools=["doc_writer", "diagram_tool"]
))
# 工程师 Agent
software_team.add_agent(AgentRole(
name="engineer",
role="软件工程师",
goal="根据需求编写高质量代码",
tools=["code_editor", "debugger", "git"]
))
# 测试工程师 Agent
software_team.add_agent(AgentRole(
name="qa_engineer",
role="测试工程师",
goal="编写测试用例，验证代码质量",
tools=["test_runner", "coverage_analyzer"]
))
# 执行协作任务
result = software_team.run("开发一个用户登录功能")适用场景：
- 软件开发（需求 → 设计 → 编码 → 测试）
- 研究项目（文献调研 → 实验 → 分析 → 报告）
- 企业级复杂业务流程
- 需要多专业技能协作的任务
优劣势对比：
| 维度 | 优势 | 劣势 |
|---|---|---|
| 专业分工 | 每个 Agent 专注擅长领域 | 系统架构极其复杂 |
| 协作能力 | 能处理企业级复杂任务 | Agent 间通信开销大 |
| 可扩展性 | 可动态增减 Agent | 调试和监控困难 |
| 容错性 | 单 Agent 故障不影响整体 | 成本高昂（多个 LLM 实例） |
2.5 架构选型决策表
┌─────────────────────────────────────────────────────────────────┐
│ Agent 架构选型决策树 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ 任务是否需要多步骤？ │
│ │ │
│ ┌────────────┴────────────┐ │
│ │ 否 │ 是 │
│ ↓ ↓ │
│ ┌──────────┐ 是否需要多专业技能？ │
│ │简单 Agent│ │ │
│ └──────────┘ ┌──────────┴──────────┐ │
│ │ 否 │ 是 │
│ ↓ ↓ │
│ 是否需要规划能力？ ┌──────────┐ │
│ │ │多 Agent │ │
│ ┌─────────┴─────────┐ │ 系统 │ │
│ │ 否 │ 是 └──────────┘ │
│ ↓ ↓ │
│ ┌──────────┐ ┌──────────┐ │
│ │简单 Agent│ │复杂 Agent│ │
│ └──────────┘ └──────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘| 任务复杂度 | 推荐架构 | 典型场景 |
|---|---|---|
| 低（单步骤、单一能力） | 简单 Agent | 信息查询、简单问答、翻译 |
| 中（多步骤、单一专业领域） | 复杂 Agent | 代码生成、数据分析、自动化流程 |
| 高（多步骤、多专业领域） | 多 Agent 系统 | 软件开发、研究项目、企业流程 |
三、按决策模式分类
3.1 决策模式对比图
┌─────────────────────────────────────────────────────────────────┐
│ 决策模式对比 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ 反应式 Agent 慎思式 Agent 混合式 Agent │
│ (Reactive) (Deliberative) (Hybrid) │
│ │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐│
│ │ 感知 → 行动 │ │ 感知 → 规划 │ │ 感知 → 判断 ││
│ │ │ │ │ │ ││
│ │ 无记忆 │ │ 深度思考 │ │ 简单→反应 ││
│ │ 无规划 │ │ 深度规划 │ │ 复杂→慎思 ││
│ │ 即时响应 │ │ 执行执行 │ │ ││
│ └─────────────┘ └─────────────┘ └─────────────┘│
│ │
│ 速度: ★★★★★ 速度: ★★☆☆☆ 速度: ★★★★☆ │
│ 智能: ★★☆☆☆ 智能: ★★★★★ 智能: ★★★★☆ │
│ 成本: ★☆☆☆☆ 成本: ★★★★☆ 成本: ★★★☆☆ │
│ │
└─────────────────────────────────────────────────────────────────┘3.2 反应式 Agent（Reactive Agent）
定义：基于"感知-行动"循环，无内部状态，对环境刺激即时响应。
┌─────────────────────────────────────────────────────────────────┐
│ 反应式 Agent 工作流程 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────┐ │
│ │ 环境输入/感知 │ │
│ └────────┬────────┘ │
│ │ │
│ ↓ │
│ ┌─────────────────┐ │
│ │ 规则匹配引擎 │ │
│ │ │ │
│ │ IF 条件 THEN │ │
│ │ 执行动作 │ │
│ └────────┬────────┘ │
│ │ │
│ ↓ │
│ ┌─────────────────┐ │
│ │ 立即执行动作 │ │
│ └─────────────────┘ │
│ │
│ 特点：无需规划、即时响应、无记忆、规则驱动 │
│ │
└─────────────────────────────────────────────────────────────────┘代码示例：
# 反应式 Agent 实现
class ReactiveAgent:
"""基于规则的反应式 Agent"""
def __init__(self, llm):
self.llm = llm
# 预定义规则库
self.rules = {
"greeting": self._handle_greeting,
"question": self._handle_question,
"command": self._handle_command,
}
def perceive_and_act(self, input_text: str) -> str:
"""感知-行动循环"""
# 1. 感知：识别输入类型
input_type = self._classify_input(input_text)
# 2. 匹配规则并执行
action = self.rules.get(input_type, self._handle_unknown)
# 3. 直接响应（无规划、无记忆）
return action(input_text)
def _classify_input(self, text: str) -> str:
"""快速分类（无深度思考）"""
if any(word in text for word in ["你好", "hello", "hi"]):
return "greeting"
elif "?" in text or "什么" in text:
return "question"
elif any(word in text for word in ["帮我", "执行", "运行"]):
return "command"
return "unknown"
def _handle_greeting(self, text: str) -> str:
return "你好！有什么可以帮助你的？"
def _handle_question(self, text: str) -> str:
return self.llm.generate(text) # 直接调用 LLM
def _handle_command(self, text: str) -> str:
return self.llm.generate(f"执行指令：{text}")
# 使用示例
agent = ReactiveAgent(llm=GPT4())
response = agent.perceive_and_act("今天天气怎么样？") # 即时响应典型场景：
- 智能客服（FAQ 自动回复）
- 简单问答机器人
- 实时监控系统（异常告警）
- 游戏中的 NPC（非玩家角色）
优劣势对比：
| 优势 | 劣势 |
|---|---|
| 响应速度极快（毫秒级） | 无法处理复杂任务 |
| 计算成本低 | 无规划能力 |
| 实现简单 | 无学习能力 |
| 可预测行为 | 无法处理未知场景 |
3.3 慎思式 Agent（Deliberative Agent）
定义：基于"感知-规划-执行"模型，具备内部世界模型，能够深度思考和规划。
┌─────────────────────────────────────────────────────────────────┐
│ 慎思式 Agent 工作流程 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────┐ │
│ │ 环境输入/感知 │ │
│ └────────┬────────┘ │
│ │ │
│ ↓ │
│ ┌─────────────────┐ ┌─────────────────┐ │
│ │ 更新世界模型 │◄────►│ 知识库/记忆 │ │
│ └────────┬────────┘ └─────────────────┘ │
│ │ │
│ ↓ │
│ ┌─────────────────────────────────────────────────┐ │
│ │ 深度规划引擎 │ │
│ │ ┌───────────┐ ┌───────────┐ ┌───────────┐ │ │
│ │ │ 目标分析 │→│ 任务分解 │→│ 路径规划 │ │ │
│ │ └───────────┘ └───────────┘ └───────────┘ │ │
│ └───────────────────────┬─────────────────────────┘ │
│ │ │
│ ↓ │
│ ┌─────────────────────────────────────────────────┐ │
│ │ 执行与监控 │ │
│ │ ┌───────────┐ ┌───────────┐ ┌───────────┐ │ │
│ │ │ 执行动作 │→│ 观察结果 │→│ 调整计划 │ │ │
│ │ └───────────┘ └───────────┘ └───────────┘ │ │
│ └─────────────────────────────────────────────────┘ │
│ │
│ 特点：深度规划、长期记忆、目标驱动、可处理复杂任务 │
│ │
└─────────────────────────────────────────────────────────────────┘代码示例：
# 慎思式 Agent 实现
class DeliberativeAgent:
"""具备深度规划能力的慎思式 Agent"""
def __init__(self, llm, memory, tools):
self.llm = llm
self.memory = memory # 长期记忆
self.tools = tools
self.world_model = {} # 世界模型
def run(self, goal: str) -> str:
"""慎思式执行流程"""
# 1. 感知与理解
perception = self.perceive(goal)
# 2. 更新世界模型
self.update_world_model(perception)
# 3. 深度规划
plan = self.plan(goal)
# 4. 执行与监控
return self.execute_and_monitor(plan)
def perceive(self, goal: str) -> dict:
"""感知环境"""
return {
"goal": goal,
"context": self.memory.recall(goal),
"available_tools": list(self.tools.keys())
}
def update_world_model(self, perception: dict):
"""更新内部世界模型"""
self.world_model["current_goal"] = perception["goal"]
self.world_model["relevant_context"] = perception["context"]
def plan(self, goal: str) -> list:
"""深度规划（使用 ToT - Tree of Thought）"""
prompt = f"""
目标: {goal}
请使用思维树方法进行深度规划：
1. 分析目标的多个可能路径
2. 评估每个路径的可行性
3. 选择最优路径
4. 生成详细的执行步骤
可用工具: {list(self.tools.keys())}
"""
planning_result = self.llm.generate(prompt)
return self.parse_plan(planning_result)
def execute_and_monitor(self, plan: list) -> str:
"""执行并持续监控"""
results = []
for step in plan:
# 执行步骤
result = self.execute_step(step)
results.append(result)
# 检查是否需要重新规划
if self.needs_replanning(result):
# 反思并调整
new_plan = self.replan(result)
plan = self.merge_plans(plan, new_plan)
return self.summarize_results(results)
# 使用示例
agent = DeliberativeAgent(
llm=GPT4(),
memory=VectorMemory(),
tools={"search": SearchTool(), "code": CodeTool()}
)
result = agent.run("设计并实现一个高性能的缓存系统")典型场景：
- 复杂问题求解（数学证明、科学发现）
- 战略规划（商业决策、项目规划）
- 自主导航（机器人路径规划）
- 游戏策略（围棋、国际象棋 AI）
优劣势对比：
| 优势 | 劣势 |
|---|---|
| 能处理复杂任务 | 响应速度慢 |
| 具备规划能力 | 计算成本高 |
| 有长期记忆 | 实现复杂 |
| 能处理不确定环境 | 可能过度规划 |
3.4 混合式 Agent（Hybrid Agent）
定义：结合反应式和慎思式的优点，根据任务复杂度动态选择决策模式。
┌─────────────────────────────────────────────────────────────────┐
│ 混合式 Agent 架构 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────┐ │
│ │ 环境输入/感知 │ │
│ └────────┬────────┘ │
│ │ │
│ ↓ │
│ ┌─────────────────┐ │
│ │ 复杂度评估器 │ │
│ └────────┬────────┘ │
│ │ │
│ ┌──────────────┴──────────────┐ │
│ │ │ │
│ 简单任务 复杂任务 │
│ │ │ │
│ ↓ ↓ │
│ ┌─────────────────┐ ┌─────────────────┐ │
│ │ 反应式子系统 │ │ 慎思式子系统 │ │
│ │ │ │ │ │
│ │ • 规则匹配 │ │ • 深度规划 │ │
│ │ • 快速响应 │ │ • 执行监控 │ │
│ │ • 低成本 │ │ • 反思调整 │ │
│ └────────┬────────┘ └────────┬────────┘ │
│ │ │ │
│ └──────────────┬──────────────┘ │
│ │ │
│ ↓ │
│ ┌─────────────────┐ │
│ │ 统一输出接口 │ │
│ └─────────────────┘ │
│ │
│ 特点：兼顾效率与智能、动态模式切换、成本可控 │
│ │
└─────────────────────────────────────────────────────────────────┘代码示例：
# 混合式 Agent 实现
class HybridAgent:
"""混合式 Agent：结合反应式和慎思式"""
def __init__(self, llm, memory, tools):
# 反应式子系统
self.reactive = ReactiveEngine(llm)
# 慎思式子系统
self.deliberative = DeliberativeEngine(llm, memory, tools)
# 复杂度评估器
self.complexity_analyzer = ComplexityAnalyzer(llm)
def run(self, input_text: str) -> str:
"""混合式执行"""
# 1. 评估任务复杂度
complexity = self.complexity_analyzer.analyze(input_text)
# 2. 根据复杂度选择模式
if complexity == "simple":
# 简单任务 → 反应式处理
return self.reactive.process(input_text)
elif complexity == "complex":
# 复杂任务 → 慎思式处理
return self.deliberative.process(input_text)
else:
# 中等复杂度 → 两者结合
return self.hybrid_process(input_text)
def hybrid_process(self, input_text: str) -> str:
"""混合处理策略"""
# 慎思式规划
plan = self.deliberative.plan(input_text)
results = []
for step in plan:
if self.is_simple_step(step):
# 简单步骤 → 反应式执行
result = self.reactive.execute(step)
else:
# 复杂步骤 → 慎思式执行
result = self.deliberative.execute(step)
results.append(result)
return self.summarize(results)
# 复杂度分析器
class ComplexityAnalyzer:
def __init__(self, llm):
self.llm = llm
def analyze(self, input_text: str) -> str:
"""分析任务复杂度"""
# 基于规则的快速判断
simple_keywords = ["你好", "几点", "天气", "翻译"]
complex_keywords = ["设计", "实现", "分析", "规划", "构建"]
if any(kw in input_text for kw in simple_keywords):
return "simple"
elif any(kw in input_text for kw in complex_keywords):
return "complex"
# 使用 LLM 进行深度判断
return self.llm_classify(input_text)
# 使用示例
agent = HybridAgent(
llm=GPT4(),
memory=VectorMemory(),
tools={"search": SearchTool(), "code": CodeTool()}
)
# 简单任务 → 反应式
response1 = agent.run("今天天气怎么样？")
# 复杂任务 → 慎思式
response2 = agent.run("设计一个分布式缓存系统")
# 中等任务 → 混合处理
response3 = agent.run("分析这份销售数据并生成报告")典型场景：
- 智能助手（简单问答快速响应，复杂任务深度规划）
- 自动驾驶（常规驾驶反应式，复杂路况慎思式）
- 游戏智能体（简单操作反应式，复杂策略慎思式）
- 企业服务系统（FAQ 快速响应，复杂工单深度处理）
优劣势对比：
| 优势 | 劣势 |
|---|---|
| 兼顾效率和智能 | 架构最为复杂 |
| 成本可控 | 需要准确的复杂度判断 |
| 适应性强 | 两种模式切换可能有延迟 |
| 适用范围广 | 开发和维护成本高 |
3.5 决策模式选型指南
| 任务特征 | 推荐模式 | 原因 |
|---|---|---|
| 实时性要求高、任务简单 | 反应式 | 响应快、成本低 |
| 任务复杂、需要规划 | 慎思式 | 能处理复杂任务 |
| 任务复杂度变化大 | 混合式 | 兼顾效率和智能 |
| 成本敏感 | 反应式 | 计算成本最低 |
| 质量敏感 | 慎思式 | 深度思考质量更高 |
四、按应用领域分类
4.1 应用领域全景图
┌─────────────────────────────────────────────────────────────────┐
│ Agent 应用领域全景 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ┌───────────────────────────────────────────────────────────┐ │
│ │ 开发与工程 │ │
│ │ ┌────────────┐ ┌────────────┐ ┌────────────┐ │ │
│ │ │ 代码助手 │ │ DevOps │ │ 测试助手 │ │ │
│ │ │ (Devin) │ │ (运维) │ │ (自动化) │ │ │
│ │ └────────────┘ └────────────┘ └────────────┘ │ │
│ └───────────────────────────────────────────────────────────┘ │
│ │
│ ┌───────────────────────────────────────────────────────────┐ │
│ │ 研究与分析 │ │
│ │ ┌────────────┐ ┌────────────┐ ┌────────────┐ │ │
│ │ │ 研究助手 │ │ 数据分析 │ │ 科学发现 │ │ │
│ │ │(Perplexity)│ │ (报表) │ │ (实验) │ │ │
│ │ └────────────┘ └────────────┘ └────────────┘ │ │
│ └───────────────────────────────────────────────────────────┘ │
│ │
│ ┌───────────────────────────────────────────────────────────┐ │
│ │ 服务与交互 │ │
│ │ ┌────────────┐ ┌────────────┐ ┌────────────┐ │ │
│ │ │ 智能客服 │ │ 个人助理 │ │ 教育助手 │ │ │
│ │ │ (对话) │ │ (日程) │ │ (辅导) │ │ │
│ │ └────────────┘ └────────────┘ └────────────┘ │ │
│ └───────────────────────────────────────────────────────────┘ │
│ │
│ ┌───────────────────────────────────────────────────────────┐ │
│ │ 创意与内容 │ │
│ │ ┌────────────┐ ┌────────────┐ ┌────────────┐ │ │
│ │ │ 写作助手 │ │ 设计助手 │ │ 视频制作 │ │ │
│ │ │ (文案) │ │ (UI/UX) │ │ (剪辑) │ │ │
│ │ └────────────┘ └────────────┘ └────────────┘ │ │
│ └───────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘4.2 代码助手 Agent
定义：辅助软件开发的 Agent，具备代码生成、调试、重构、测试能力。
┌─────────────────────────────────────────────────────────────────┐
│ 代码助手 Agent 架构 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ 开发者需求 ──→ ┌───────────────────────────────────┐ │
│ │ 代码助手 Agent │ │
│ │ │ │
│ │ ┌──────────────────────────────┐ │ │
│ │ │ 代码理解引擎 │ │ │
│ │ │ • AST 解析 │ │ │
│ │ │ • 代码摘要 │ │ │
│ │ └──────────────┬───────────────┘ │ │
│ │ │ │ │
│ │ ┌──────────────┴───────────────┐ │ │
│ │ │ 核心能力 │ │ │
│ │ │ ┌────────┐ ┌────────┐ │ │ │
│ │ │ │代码生成│ │代码审查│ │ │ │
│ │ │ └────────┘ └────────┘ │ │ │
│ │ │ ┌────────┐ ┌────────┐ │ │ │
│ │ │ │调试修复│ │测试生成│ │ │ │
│ │ │ └────────┘ └────────┘ │ │ │
│ │ └──────────────────────────────┘ │ │
│ │ │ │ │
│ │ ┌──────────────┴───────────────┐ │ │
│ │ │ 工具集 │ │ │
│ │ │ Git │ IDE │ Terminal │ DB │ │ │
│ │ └──────────────────────────────┘ │ │
│ └───────────────────────────────────┘ │
│ │ │
│ ↓ │
│ 代码交付 / Pull Request │
│ │
└─────────────────────────────────────────────────────────────────┘典型代表：
- Devin：首个 AI 软件工程师
- GitHub Copilot Workspace：GitHub 官方开发助手
- Cursor：AI 原生代码编辑器
- Amazon Q Developer：AWS 开发助手
核心能力：
| 能力 | 说明 | 示例 |
|---|---|---|
| 代码生成 | 根据需求生成代码 | "实现一个用户登录功能" |
| 代码审查 | 发现潜在问题和优化点 | 检测安全漏洞、性能问题 |
| 调试修复 | 定位和修复 Bug | 分析错误日志，定位问题 |
| 测试生成 | 自动生成测试用例 | 单元测试、集成测试 |
| 重构建议 | 代码质量改进建议 | 消除重复、优化结构 |
| 文档生成 | 自动生成代码文档 | API 文档、注释生成 |
代码示例：
# 代码助手 Agent 实现
class CodeAssistantAgent:
"""代码助手 Agent"""
def __init__(self, llm, code_tools):
self.llm = llm
self.tools = code_tools # Git, IDE, Terminal 等
def develop(self, requirement: str) -> str:
"""开发流程"""
# 1. 需求理解
spec = self.analyze_requirement(requirement)
# 2. 代码生成
code = self.generate_code(spec)
# 3. 代码审查
review = self.review_code(code)
# 4. 自动修复
if review.has_issues:
code = self.fix_issues(code, review.issues)
# 5. 生成测试
tests = self.generate_tests(code)
# 6. 执行测试验证
test_result = self.run_tests(tests)
# 7. 提交代码
if test_result.passed:
self.commit_code(code)
return "开发完成，代码已提交"
return "测试未通过，需要修复"
def debug(self, error_log: str) -> str:
"""调试修复流程"""
# 1. 分析错误日志
error_analysis = self.analyze_error(error_log)
# 2. 定位问题代码
problematic_code = self.locate_problem(error_analysis)
# 3. 生成修复方案
fix = self.generate_fix(problematic_code)
# 4. 应用修复
self.apply_fix(fix)
return f"问题已定位：{error_analysis}\n修复方案：{fix}"
# 使用示例
code_agent = CodeAssistantAgent(
llm=GPT4(),
code_tools={
"git": GitTool(),
"ide": IDETool(),
"terminal": TerminalTool(),
"test_runner": TestRunnerTool()
}
)
# 开发新功能
result = code_agent.develop("实现用户注册功能，包含邮箱验证")
# 调试问题
fix = code_agent.debug("TypeError: Cannot read property 'id' of undefined")4.3 研究助手 Agent
定义：辅助研究和信息收集的 Agent，具备搜索、整理、分析、总结能力。
典型代表：
- Perplexity AI：AI 搜索引擎
- Consensus：学术研究助手
- Elicit：科研文献助手
- Semantic Scholar：学术搜索引擎
核心能力：
- 多源信息搜索与整合
- 文献摘要与提取
- 研究趋势分析
- 引用管理与生成
4.4 智能客服 Agent
定义：处理客户咨询的 Agent，具备对话、知识检索、工单处理能力。
典型代表：
- Intercom Fin：AI 客服
- Zendesk AI：智能客服系统
- Klarna AI：电商客服助手
核心能力：
- 意图识别与分类
- 知识库问答
- 多轮对话管理
- 工单自动创建与流转
4.5 数据分析 Agent
定义：执行数据分析任务的 Agent，具备数据清洗、分析、可视化能力。
典型代表：
- Julius AI：数据分析助手
- Tableau AI：可视化分析
- Microsoft Copilot for Excel：数据分析助手
核心能力：
- 数据清洗与预处理
- 统计分析与建模
- 可视化报表生成
- 数据洞察与建议
4.6 应用领域对比表
| 领域 | 核心能力 | 技术重点 | 典型场景 |
|---|---|---|---|
| 代码助手 | 生成、调试、测试 | 代码理解、AST | 软件开发、代码审查 |
| 研究助手 | 搜索、整理、总结 | RAG、知识图谱 | 学术研究、市场调研 |
| 智能客服 | 对话、检索、工单 | NLU、知识库 | 客户服务、售后支持 |
| 数据分析 | 清洗、分析、可视化 | 统计、可视化 | 商业智能、决策支持 |
| 个人助理 | 日程、提醒、执行 | 任务管理、API | 日程管理、信息整理 |
| 写作助手 | 创作、润色、翻译 | 文本生成、风格迁移 | 内容创作、文案优化 |
五、Agent 选型决策框架
5.1 选型决策流程
┌─────────────────────────────────────────────────────────────────┐
│ Agent 选型决策流程 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ Step 1: 明确任务特征 │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ • 任务复杂度：简单 / 中等 / 复杂 │ │
│ │ • 实时性要求：低 / 中 / 高 │ │
│ │ • 是否需要规划：是 / 否 │ │
│ │ • 是否需要多步骤：是 / 否 │ │
│ │ • 是否需要多专业技能：是 / 否 │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │ │
│ ↓ │
│ Step 2: 确定架构复杂度 │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ 简单任务 + 单步骤 → 简单 Agent │ │
│ │ 中等任务 + 多步骤 → 复杂 Agent │ │
│ │ 复杂任务 + 多专业协作 → 多 Agent 系统 │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │ │
│ ↓ │
│ Step 3: 选择决策模式 │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ 高实时性 + 简单决策 → 反应式 Agent │ │
│ │ 低实时性 + 复杂规划 → 慎思式 Agent │ │
│ │ 混合场景 → 混合式 Agent │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │ │
│ ↓ │
│ Step 4: 匹配应用领域 │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ 选择对应领域的成熟方案或框架 │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘5.2 选型对照表
| 任务特征 | 架构类型 | 决策模式 | 推荐框架 |
|---|---|---|---|
| 简单问答、信息查询 | 简单 Agent | 反应式 | LangChain SimpleAgent |
| 代码生成、数据分析 | 复杂 Agent | 慎思式 | AutoGPT, LangChain Agent |
| 软件开发、研究项目 | 多 Agent | 混合式 | MetaGPT, AutoGen |
| 实时监控、告警 | 简单 Agent | 反应式 | Custom Rule-based |
| 智能客服 | 复杂 Agent | 混合式 | Rasa, Dialogflow |
| 个人助理 | 复杂 Agent | 混合式 | OpenAI Assistants API |
六、常见面试题
Q1: 单 Agent 和多 Agent 系统有什么区别？如何选择？
A:
核心区别：
| 对比维度 | 单 Agent | 多 Agent 系统 |
|---|---|---|
| 架构 | 一个 Agent 完成所有任务 | 多个专业 Agent 协作 |
| 能力边界 | 受单一 LLM 能力限制 | 可组合多种专业能力 |
| 复杂度 | 简单，易于部署和调试 | 复杂，需要协调机制 |
| 成本 | 较低 | 较高（多个 LLM 实例） |
| 适用场景 | 单一领域任务 | 跨领域协作任务 |
选择标准：
是否需要多种专业技能协作？
├── 否 → 单 Agent
│ ├── 任务简单 → 简单 Agent
│ └── 任务复杂 → 复杂 Agent
└── 是 → 多 Agent 系统Q2: 反应式 Agent 和慎思式 Agent 的区别是什么？
A:
| 对比维度 | 反应式 Agent | 慎思式 Agent |
|---|---|---|
| 决策模式 | 感知 → 行动 | 感知 → 规划 → 执行 |
| 内部状态 | 无 | 有（世界模型） |
| 规划能力 | 无 | 有 |
| 响应速度 | 快（毫秒级） | 慢（秒/分钟级） |
| 适用场景 | 实时响应、简单任务 | 复杂任务、长期规划 |
| 代表系统 | 游戏NPC、监控系统 | AutoGPT、机器人导航 |
Q3: 什么是混合式 Agent？它的优势是什么？
A:
混合式 Agent 是结合反应式和慎思式优点的 Agent 架构：
架构特点：
- 包含反应式和慎思式两个子系统
- 根据任务复杂度动态选择决策模式
- 简单任务用反应式（快速、低成本）
- 复杂任务用慎思式（深度、高质量）
优势：
- 兼顾效率和智能：简单任务快速响应，复杂任务深度处理
- 成本可控：避免对简单任务进行不必要的深度规划
- 适应性强：能处理各种复杂度的任务
Q4: 常见的 Agent 应用类型有哪些？各自的特点？
A:
| 应用类型 | 核心能力 | 技术重点 | 典型代表 |
|---|---|---|---|
| 代码助手 | 代码生成、调试、测试 | AST解析、代码理解 | Devin, Cursor |
| 研究助手 | 搜索、整理、总结 | RAG、知识图谱 | Perplexity, Elicit |
| 智能客服 | 对话、检索、工单 | NLU、知识库 | Intercom Fin |
| 数据分析 | 清洗、分析、可视化 | 统计、报表生成 | Julius AI |
| 个人助理 | 日程、提醒、执行 | 任务管理 | Siri, Alexa |
Q5: 如何为特定场景选择合适的 Agent 类型？
A:
选型决策流程：
def select_agent_type(task):
# 1. 评估任务复杂度
complexity = analyze_complexity(task)
# 2. 评估实时性要求
real_time = check_real_time_requirement(task)
# 3. 评估是否需要多专业技能
multi_skill = check_multi_skill(task)
# 4. 决策
if complexity == "simple" and real_time:
return "简单Agent + 反应式"
elif complexity == "complex" and not multi_skill:
return "复杂Agent + 慎思式"
elif multi_skill:
return "多Agent系统"
else:
return "复杂Agent + 混合式"关键决策点：
- 任务是否需要多步骤执行？
- 是否需要规划能力？
- 是否需要多种专业技能？
- 实时性要求如何？
Q6: 多 Agent 系统中，Agent 之间如何协作？
A:
常见协作模式：
1. 层级协作（Hierarchical）
┌─────────┐
│ Manager │ ──── 决策、分配任务
└────┬────┘
│
┌────┴────┐
↓ ↓
┌─────┐ ┌─────┐
│Agent│ │Agent│ ──── 执行具体任务
│ 1 │ │ 2 │
└─────┘ └─────┘
2. 对等协作（Peer-to-Peer）
┌─────┐ ←──────→ ┌─────┐
│Agent│ │Agent│
│ 1 │ ←──────→ │ 2 │
└─────┘ └─────┘
↑ ↑
└──────→ ┌─────┐ ┘
│Agent│
│ 3 │
└─────┘
3. 黑板协作（Blackboard）
┌─────────┐
│ 黑板 │ ←── 共享工作空间
│(共享状态)│
└────┬────┘
│
┌─────────────┼─────────────┐
↓ ↓ ↓
┌─────┐ ┌─────┐ ┌─────┐
│Agent│ │Agent│ │Agent│
│ 1 │ │ 2 │ │ 3 │
└─────┘ └─────┘ └─────┘协作机制：
- 消息传递：Agent 间发送结构化消息
- 共享记忆：共享向量数据库或工作空间
- 任务队列：统一的任务分发和结果收集
- 投票机制：多 Agent 投票决定最终结果
Q7: Agent 类型的未来发展趋势是什么？
A:
发展趋势：
-
从单 Agent 到多 Agent 协作
- 行业趋势：MetaGPT、AutoGen 等多 Agent 框架兴起
- 核心价值：专业分工，协作处理复杂任务
-
从反应式到混合式
- 行业趋势：Claude Computer Use、GPT-4o 实时模式
- 核心价值：兼顾效率和智能
-
从通用到垂直领域专精
- 行业趋势：法律、医疗、金融等领域 Agent
- 核心价值：更深的领域知识和更高的专业度
-
从被动执行到主动规划
- 行业趋势：Agent 主动提出建议、发现问题
- 核心价值：从"工具"到"伙伴"
Q8: 如何评估不同类型 Agent 的性能？
A:
评估指标体系：
| Agent 类型 | 关键指标 | 评估方法 |
|---|---|---|
| 简单 Agent | 响应时间、准确率 | 延迟测试、准确率统计 |
| 复杂 Agent | 任务成功率、步数 | 端到端任务测试 |
| 多 Agent 系统 | 协作效率、通信开销 | 协作完成率、消息统计 |
| 反应式 Agent | 响应延迟 | 实时性压测 |
| 慎思式 Agent | 规划质量 | 人工评估规划合理性 |
| 混合式 Agent | 模式切换准确率 | 复杂度判断准确率 |
七、总结
Agent 类型分类总览表
| 分类维度 | 类型 | 特点 | 适用场景 |
|---|---|---|---|
| 架构复杂度 | 简单 Agent | 单工具、快速响应 | 信息查询、简单问答 |
| 复杂 Agent | 多工具、有规划 | 代码生成、数据分析 | |
| 多 Agent 系统 | 多角色协作 | 软件开发、研究项目 | |
| 决策模式 | 反应式 | 感知-行动、无规划 | 实时监控、智能客服 |
| 慎思式 | 深度规划、有记忆 | 复杂任务、战略决策 | |
| 混合式 | 动态模式切换 | 通用助手、个人助理 | |
| 应用领域 | 代码助手 | 生成、调试、测试 | 软件开发 |
| 研究助手 | 搜索、整理、总结 | 学术研究 | |
| 智能客服 | 对话、检索、工单 | 客户服务 | |
| 数据分析 | 清洗、分析、可视化 | 商业智能 |
选型核心原则
- 任务驱动：根据任务复杂度和特征选择
- 成本平衡：在能力和成本之间找到平衡点
- 渐进式：从简单开始，逐步增加复杂度
- 领域适配：选择与领域匹配的成熟方案
最后更新：2026年3月19日