Agent架构全景
在上一章中，我们学习了ReactAgent——通过交替进行推理和行动来解决问题。但ReactAgent并非唯一的Agent范式，不同的任务需要不同的架构。本章将介绍其他主流的Agent类型。
Agent架构分类
Agent架构
├── 单步Agent
│ ├── Function Calling Agent（直接工具调用）
│ └── Zero-Shot Agent（单次推理）
├── 多步Agent
│ ├── ReAct Agent（边思考边行动）✓ 已学习
│ ├── Plan-and-Execute Agent（先规划后执行）
│ └── Reflexion Agent（反思型）
├── 自主Agent
│ ├── AutoGPT（目标驱动）
│ └── BabyAGI（任务分解）
└── Multi-Agent（多智能体协作）
├── 辩论型（Debate）
└── 协作型（Collaboration）
1. Plan-and-Execute Agent
核心思想
先完整规划，再依次执行，类似于人类做项目的方式：
传统做法（ReAct）：
→ 思考 → 行动 → 观察 → 再思考 → 再行动...
（边做边想）
Plan-and-Execute：
→ 规划阶段（一次性制定完整计划）
→ 执行阶段（按计划逐步执行）
工作流程
┌─────────────────────────────────────┐
│ Planner（规划器） │
│ 输入：用户任务 │
│ 输出：完整的执行计划 │
└──────────────┬──────────────────────┘
↓
┌─────────────────────────────────────┐
│ Executor（执行器） │
│ 按计划逐步执行，调用工具 │
└──────────────┬──────────────────────┘
↓
┌─────────────────────────────────────┐
│ Re-Planner（重新规划器，可选） │
│ 如果执行失败，修改计划 │
└─────────────────────────────────────┘
实现示例
class PlanAndExecuteAgent:
def __init__(self, llm, tools):
self.llm = llm
self.tools = tools
def run(self, task: str) -> str:
# 阶段1：制定计划
plan = self.plan(task)
print(f"Plan:\n{plan}\n")
# 阶段2：执行计划
results = []
for i, step in enumerate(plan.steps):
print(f"Executing Step {i+1}: {step.description}")
result = self.execute_step(step)
results.append(result)
# 如果执行失败，重新规划
if result.status == "failed":
print(f"Step {i+1} failed, re-planning...")
plan = self.replan(task, plan, results)
# 阶段3：合成最终答案
answer = self.synthesize(task, results)
return answer
def plan(self, task: str):
"""制定执行计划"""
prompt = f"""
任务：{task}
请制定一个详细的执行计划，将任务分解为3-5个步骤。
每个步骤应包含：
1. 步骤描述
2. 需要使用的工具
3. 期望输出
输出格式：
Step 1: [描述]
Tool: [工具名]
Expected: [期望结果]
Step 2: ...
"""
response = self.llm.generate(prompt)
plan = self._parse_plan(response)
return plan
def execute_step(self, step):
"""执行单个步骤"""
tool_name = step.tool
tool_input = step.input
try:
tool = self.tools[tool_name]
result = tool(tool_input)
return ExecutionResult(status="success", output=result)
except Exception as e:
return ExecutionResult(status="failed", error=str(e))
def synthesize(self, task: str, results: List):
"""基于所有结果合成最终答案"""
prompt = f"""
原始任务：{task}
执行结果：
{self._format_results(results)}
请基于这些结果，给出最终答案。
"""
answer = self.llm.generate(prompt)
return answer
完整示例
任务：查询"明天北京的天气，并推荐合适的穿衣"
=== 规划阶段 ===
Plan:
Step 1: 获取明天的日期
Tool: get_time
Expected: 2024-03-16
Step 2: 查询北京明天的天气
Tool: search_weather
Expected: 温度、天气状况
Step 3: 基于天气推荐穿衣
Tool: llm_reasoning
Expected: 穿衣建议
=== 执行阶段 ===
Executing Step 1: 获取明天的日期
Result: 2024-03-16
Executing Step 2: 查询北京明天的天气
Result: 晴，温度10-20°C，微风
Executing Step 3: 基于天气推荐穿衣
Result: 建议穿长袖+薄外套
=== 合成答案 ===
明天（3月16日）北京天气晴朗，温度10-20°C。建议穿着：
- 早晚：长袖+薄外套
- 中午：可以只穿长袖
优缺点
优点：
- ✅ 计划清晰，易于理解
- ✅ 可以并行执行独立步骤
- ✅ 便于监控进度
- ✅ Token消耗相对固定（不像ReAct可能多次规划）
缺点：
- ❌ 不灵活，难以应对意外情况
- ❌ 如果早期步骤失败，整个计划可能失效
- ❌ 难以处理需要动态调整的任务
适用场景：
- 任务步骤明确、可预知
- 需要并行执行多个独立操作
- 对可解释性要求高
2. Reflexion Agent（反思型Agent）
核心思想
通过自我反思和评估来改进行动，类似于人类的"trial and error"学习过程。
传统Agent：
尝试 → 失败 → 结束（或重试）
Reflexion Agent：
尝试 → 失败 → 反思（为什么失败？）→ 改进策略 → 重新尝试
三大组件
┌─────────────────────────────────────┐
│ Actor（执行者） │
│ 执行任务，生成输出 │
└──────────────┬──────────────────────┘
↓
┌─────────────────────────────────────┐
│ Evaluator（评估者） │
│ 评估输出质量，判断是否成功 │
└──────────────┬──────────────────────┘
↓
┌─────────────────────────────────────┐
│ Self-Reflection（自我反思） │
│ 分析失败原因，生成改进建议 │
└──────────────┬──────────────────────┘
↓
反馈给Actor
实现示例
class ReflexionAgent:
def __init__(self, llm, evaluator, max_iterations=3):
self.llm = llm
self.evaluator = evaluator
self.max_iterations = max_iterations
self.memory = [] # 存储历史尝试和反思
def run(self, task: str) -> str:
for iteration in range(self.max_iterations):
print(f"\n=== Iteration {iteration + 1} ===")
# 1. Actor：执行任务
context = self._build_context(task)
output = self.actor(task, context)
print(f"Output: {output}")
# 2. Evaluator：评估结果
evaluation = self.evaluator(task, output)
print(f"Evaluation: {evaluation}")
if evaluation.is_correct:
return output
# 3. Self-Reflection：反思
reflection = self.reflect(task, output, evaluation)
print(f"Reflection: {reflection}")
# 4. 存储到记忆
self.memory.append({
"iteration": iteration + 1,
"output": output,
"evaluation": evaluation,
"reflection": reflection
})
return "达到最大迭代次数，任务未完成"
def actor(self, task: str, context: str) -> str:
"""执行者：生成输出"""
prompt = f"""
任务：{task}
{context}
请完成这个任务。
"""
return self.llm.generate(prompt)
def reflect(self, task: str, output: str, evaluation) -> str:
"""反思：分析失败原因"""
prompt = f"""
任务：{task}
你的输出：{output}
评估结果：{evaluation.feedback}
请分析：
1. 为什么这个输出是错误的？
2. 哪些方面需要改进？
3. 下次应该怎么做？
输出格式：
原因：...
改进点：...
下次策略：...
"""
return self.llm.generate(prompt)
def _build_context(self, task: str) -> str:
"""构建上下文（包含历史反思）"""
if not self.memory:
return ""
context = "以下是你之前的尝试和反思，请从中学习：\n\n"
for m in self.memory:
context += f"尝试 {m['iteration']}:\n"
context += f"输出：{m['output']}\n"
context += f"评估：{m['evaluation'].feedback}\n"
context += f"反思：{m['reflection']}\n\n"
return context
实际示例
任务：编写一个Python函数，计算斐波那契数列的第n项
=== Iteration 1 ===
Output:
def fib(n):
if n <= 1:
return n
return fib(n-1) + fib(n+1) # 错误！
Evaluation: 错误。fib(10)导致无限递归
Reflection:
原因：递归调用写错了，应该是fib(n-1) + fib(n-2)
改进点：检查递归的base case和递归公式
下次策略：仔细验证递归逻辑
=== Iteration 2 ===
Output:
def fib(n):
if n <= 1:
return n
return fib(n-1) + fib(n-2) # 正确！
Evaluation: 正确。所有测试用例通过
任务完成！
优缺点
优点：
- ✅ 能够从错误中学习
- ✅ 逐步改进输出质量
- ✅ 适合需要多次迭代的任务
缺点：
- ❌ 需要可靠的评估器（evaluator）
- ❌ 迭代次数多，token消耗大
- ❌ 可能陷入相同错误的循环
适用场景：
- 代码生成（有明确的测试标准）
- 数学问题（有正确答案）
- 需要反复优化的创作任务
3. AutoGPT类型的自主Agent
核心思想
完全自主的目标驱动型Agent，给定一个高层目标，自己分解任务、执行、监控进度，直到完成。
用户：帮我调研并写一份关于AI的报告
AutoGPT：
1. 分解任务：
- 搜索AI相关资料
- 整理要点
- 撰写报告
- 审阅修改
2. 自主执行每个步骤
3. 监控进度（到哪一步了？）
4. 完成目标
关键特性
1. 目标驱动
goal = "创建一个Python爬虫，抓取新闻网站"
agent.run(goal) # 完全自主完成
2. 长期记忆
# 短期记忆：当前任务上下文
# 长期记忆：之前完成的任务、学到的经验
3. 自我评估
# 每一步后问：我是否朝目标前进？还需要做什么？
简化实现
class AutoGPTAgent:
def __init__(self, llm, tools):
self.llm = llm
self.tools = tools
self.task_history = []
self.long_term_memory = []
def run(self, goal: str, max_iterations=10):
"""运行自主Agent"""
print(f"Goal: {goal}\n")
for i in range(max_iterations):
print(f"\n=== Iteration {i+1} ===")
# 1. 生成下一步行动
next_action = self.think(goal)
print(f"Next Action: {next_action}")
if next_action.type == "finish":
print(f"Goal achieved: {next_action.result}")
return next_action.result
# 2. 执行行动
result = self.execute(next_action)
print(f"Result: {result}")
# 3. 评估进度
progress = self.evaluate_progress(goal, self.task_history)
print(f"Progress: {progress}")
# 4. 记录历史
self.task_history.append({
"action": next_action,
"result": result,
"progress": progress
})
return "达到最大迭代次数"
def think(self, goal: str):
"""思考下一步做什么"""
prompt = f"""
目标：{goal}
当前进度：
{self._format_history()}
可用工具：
{self._format_tools()}
请决定下一步行动：
1. 我们已经完成了什么？
2. 还需要做什么才能达成目标？
3. 下一步应该执行什么操作？
输出格式：
Thought: [思考]
Action: [工具名或finish]
Action Input: [参数]
"""
response = self.llm.generate(prompt)
return self._parse_action(response)
def evaluate_progress(self, goal: str, history: List) -> str:
"""评估当前进度"""
prompt = f"""
目标：{goal}
已完成的步骤：
{self._format_history()}
请评估：
1. 我们离目标还有多远？（0-100%）
2. 当前策略是否有效？
3. 是否需要调整方向？
输出格式：
Progress: [数字]%
Assessment: [评估]
Recommendation: [建议]
"""
return self.llm.generate(prompt)
实际示例
目标：创建一个简单的待办事项网页应用
=== Iteration 1 ===
Thought: 需要先设计应用的功能和结构
Action: plan
Action Input: 设计待办事项应用
Result: 应用需要：添加任务、删除任务、标记完成
Progress: 10%
Assessment: 方向正确，开始规划
Recommendation: 继续细化技术栈
=== Iteration 2 ===
Thought: 确定使用HTML+CSS+JavaScript
Action: create_file
Action Input: index.html
Result: 创建了基础HTML文件
Progress: 30%
Assessment: 有了基础结构
Recommendation: 添加样式和交互
=== Iteration 3 ===
Thought: 添加CSS样式
Action: create_file
Action Input: style.css
Result: 创建了CSS文件，设计了界面
Progress: 50%
...
=== Iteration 6 ===
Thought: 所有功能已实现，测试通过
Action: finish
Action Input: 待办事项应用已完成
Goal achieved: 应用已创建，包含添加、删除、标记功能
优缺点
优点：
- ✅ 高度自主，无需逐步指导
- ✅ 能够处理开放式、长期任务
- ✅ 自我监控和调整
缺点：
- ❌ Token消耗巨大（每步都要完整推理）
- ❌ 容易偏离目标（需要强约束）
- ❌ 可能产生意外操作（安全风险）
- ❌ 调试困难（自主性太高）
适用场景：
- 开放式研究任务
- 创作类任务（写作、设计）
- 不需要实时响应的后台任务
注意事项：
- 🚨 必须有权限控制（不能随意执行系统命令）
- 🚨 需要监控token消耗
- 🚨 建议在沙箱环境运行
4. Function Calling Agent
核心思想
利用大模型原生的Function Calling能力，让模型自动决定何时调用哪个函数。
传统Agent：通过prompt engineering让模型输出工具名
Function Calling：模型原生支持，输出结构化的函数调用
OpenAI Function Calling示例
import openai
class FunctionCallingAgent:
def __init__(self, api_key):
openai.api_key = api_key
self.messages = []
self.functions = self._define_functions()
def _define_functions(self):
"""定义可用函数"""
return [
{
"name": "search_web",
"description": "在互联网上搜索信息",
"parameters": {
"type": "object",
"properties": {
"query": {
"type": "string",
"description": "搜索关键词"
}
},
"required": ["query"]
}
},
{
"name": "calculate",
"description": "执行数学计算",
"parameters": {
"type": "object",
"properties": {
"expression": {
"type": "string",
"description": "数学表达式，如 '2+2' 或 '10*5'"
}
},
"required": ["expression"]
}
}
]
def run(self, user_message: str) -> str:
"""运行Agent"""
self.messages.append({
"role": "user",
"content": user_message
})
while True:
# 调用模型
response = openai.ChatCompletion.create(
model="gpt-4",
messages=self.messages,
functions=self.functions,
function_call="auto" # 自动决定是否调用函数
)
message = response.choices[0].message
# 如果模型决定调用函数
if message.get("function_call"):
function_name = message["function_call"]["name"]
function_args = json.loads(message["function_call"]["arguments"])
print(f"Calling: {function_name}({function_args})")
# 执行函数
function_result = self._execute_function(
function_name,
function_args
)
print(f"Result: {function_result}")
# 将函数结果添加到对话历史
self.messages.append(message)
self.messages.append({
"role": "function",
"name": function_name,
"content": str(function_result)
})
else:
# 模型给出最终回答
return message["content"]
def _execute_function(self, name: str, args: dict):
"""执行函数"""
if name == "search_web":
return self.search_web(args["query"])
elif name == "calculate":
return self.calculate(args["expression"])
else:
return f"Unknown function: {name}"
def search_web(self, query: str) -> str:
# 实际搜索实现
return f"Search results for: {query}"
def calculate(self, expression: str) -> str:
try:
result = eval(expression)
return str(result)
except Exception as e:
return f"Error: {e}"
使用示例
agent = FunctionCallingAgent(api_key="your-key")
response = agent.run("明天北京的天气怎么样？")
# 执行过程：
# 1. 模型识别需要查询天气
# 2. 自动调用 search_web(query="明天北京天气")
# 3. 获得结果
# 4. 基于结果生成自然语言回答
优缺点
优点：
- ✅ 原生支持，无需复杂prompt engineering
- ✅ 结构化输出，易于解析
- ✅ 参数验证（模型会尝试匹配参数类型）
- ✅ 可靠性高
缺点：
- ❌ 依赖特定模型（OpenAI、Claude等）
- ❌ 不如ReAct灵活（无法细粒度控制思考过程）
- ❌ 成本可能较高（需要支持Function Calling的高级模型）
适用场景：
- 使用支持Function Calling的模型
- 工具调用频繁但逻辑简单的任务
- 需要高可靠性的生产环境
5. Multi-Agent系统
核心思想
多个Agent协作完成任务，每个Agent有专门的角色和能力。
单Agent：一个人干所有活
Multi-Agent：团队协作，各司其职
架构模式
模式1：Manager-Worker（管理者-工人）
┌─────────────────┐
│ Manager Agent │ ← 分配任务、协调工作
└────────┬────────┘
│
┌────┴────┬────────┬────────┐
↓ ↓ ↓ ↓
┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐
│Worker 1│ │Worker 2│ │Worker 3│ │Worker 4│
│(搜索) │ │(计算) │ │(写作) │ │(代码) │
└────────┘ └────────┘ └────────┘ └────────┘
实现示例：
class ManagerWorkerSystem:
def __init__(self, llm):
self.llm = llm
self.manager = ManagerAgent(llm)
self.workers = {
"searcher": SearchAgent(),
"calculator": CalculatorAgent(),
"writer": WriterAgent(),
"coder": CoderAgent()
}
def run(self, task: str) -> str:
# Manager分解任务
plan = self.manager.plan(task)
# 分配给各个Worker
results = {}
for subtask in plan.subtasks:
worker_name = subtask.assigned_to
worker = self.workers[worker_name]
result = worker.execute(subtask)
results[subtask.id] = result
# Manager综合结果
final_answer = self.manager.synthesize(task, results)
return final_answer
模式2：Debate（辩论型）
多个Agent从不同角度分析问题，通过辩论达成共识。
┌────────────┐ ┌────────────┐ ┌────────────┐
│ Agent A │───▶│ Agent B │───▶│ Agent C │
│ (正方) │ │ (反方) │ │ (裁判) │
└────────────┘ └────────────┘ └────────────┘
│ │ │
└──────────────────┴──────────────────┘
多轮辩论，达成共识
示例：
class DebateSystem:
def __init__(self, llm):
self.advocate = Agent(llm, role="advocate") # 正方
self.critic = Agent(llm, role="critic") # 反方
self.judge = Agent(llm, role="judge") # 裁判
def run(self, question: str, rounds=3) -> str:
conversation = []
for round in range(rounds):
# 正方发言
advocate_arg = self.advocate.speak(
question, conversation
)
conversation.append({
"role": "advocate",
"argument": advocate_arg
})
# 反方反驳
critic_arg = self.critic.speak(
question, conversation
)
conversation.append({
"role": "critic",
"argument": critic_arg
})
# 裁判总结
final_answer = self.judge.summarize(
question, conversation
)
return final_answer
应用示例：
Question: 人工智能是否会取代程序员？
Round 1:
Advocate: AI将大幅提升生产力，能自动生成代码...
Critic: 但AI无法理解复杂的业务逻辑，缺乏创造力...
Round 2:
Advocate: AI正在快速进步，GPT-4已经能写出专业代码...
Critic: 代码质量和维护性仍然是问题，需要人类审查...
Round 3:
Advocate: AI可以作为辅助工具，让程序员更高效...
Critic: 同意，AI是工具而非替代品，程序员角色会演变...
Judge Summary:
AI不会完全取代程序员，但会改变工作方式。程序员需要：
1. 学会使用AI工具
2. 专注于高层设计和创造性工作
3. 掌握AI无法替代的技能（如沟通、业务理解）
模式3：Collaboration（协作型）
多个专家Agent平等协作，共同解决问题。
class CollaborationSystem:
def __init__(self, llm):
self.agents = {
"researcher": ResearchAgent(llm),
"analyst": AnalystAgent(llm),
"writer": WriterAgent(llm),
"reviewer": ReviewerAgent(llm)
}
def run(self, task: str) -> str:
"""协作完成任务"""
shared_memory = SharedMemory()
# Researcher收集信息
research_data = self.agents["researcher"].work(task)
shared_memory.add("research", research_data)
# Analyst分析数据
analysis = self.agents["analyst"].work(
task, shared_memory.get("research")
)
shared_memory.add("analysis", analysis)
# Writer撰写报告
draft = self.agents["writer"].work(
task,
shared_memory.get("research"),
shared_memory.get("analysis")
)
shared_memory.add("draft", draft)
# Reviewer审阅修改
final_report = self.agents["reviewer"].work(
shared_memory.get("draft")
)
return final_report
Multi-Agent的优缺点
优点：
- ✅ 专业化：每个Agent擅长特定任务
- ✅ 并行化：多个Agent同时工作
- ✅ 鲁棒性：单个Agent失败不影响整体
- ✅ 可扩展：容易添加新的Agent
缺点：
- ❌ 复杂度高：需要协调和通信机制
- ❌ Token消耗大：多个Agent都要调用LLM
- ❌ 可能产生冲突：不同Agent意见不一致
- ❌ 调试困难：多个Agent交互复杂
适用场景：
- 复杂的跨领域任务
- 需要多种专业能力
- 任务可以并行处理
- 对质量要求高（通过debate提升）
Agent架构对比
综合对比表
| Agent类型 | 复杂度 | Token消耗 | 灵活性 | 可控性 | 适用场景 |
|---|---|---|---|---|---|
| Function Calling | 低 | 低 | 低 | 高 | 简单工具调用 |
| ReAct | 中 | 中 | 高 | 中 | 通用任务 |
| Plan-Execute | 中 | 中 | 低 | 高 | 明确步骤的任务 |
| Reflexion | 中 | 高 | 中 | 中 | 需要迭代优化 |
| AutoGPT | 高 | 很高 | 很高 | 低 | 开放式长期任务 |
| Multi-Agent | 很高 | 很高 | 高 | 中 | 复杂跨领域任务 |
决策树：如何选择Agent？
任务是否只需一次工具调用？
├─ 是 → Function Calling Agent
└─ 否 → 任务步骤是否明确可预知？
├─ 是 → Plan-and-Execute Agent
└─ 否 → 是否需要从错误中学习？
├─ 是 → Reflexion Agent
└─ 否 → 是否是开放式长期任务？
├─ 是 → AutoGPT
└─ 否 → 是否需要多个专业能力？
├─ 是 → Multi-Agent System
└─ 否 → ReAct Agent（通用选择）
实际选择建议
生产环境推荐：
- 首选：Function Calling Agent（简单可靠）
- 次选：ReAct Agent（灵活通用）
- 特殊需求：Plan-Execute（明确任务）或Multi-Agent（复杂任务）
研究/实验：
- Reflexion（迭代改进）
- AutoGPT（探索自主性）
- Multi-Agent Debate（提升决策质量）
实战：构建一个Multi-Agent系统
场景：智能客服系统
class CustomerServiceSystem:
def __init__(self, llm):
self.agents = {
# 前台接待
"receptionist": Agent(
llm,
role="分析用户问题，分类并路由",
tools=["classify_intent"]
),
# 技术支持
"tech_support": Agent(
llm,
role="解决技术问题",
tools=["search_docs", "run_diagnostics"]
),
# 账户管理
"account_manager": Agent(
llm,
role="处理账户相关问题",
tools=["query_db", "update_account"]
),
# 销售顾问
"sales_advisor": Agent(
llm,
role="产品推荐和咨询",
tools=["search_products", "check_inventory"]
),
# 质检
"quality_checker": Agent(
llm,
role="检查回复质量，确保满意度",
tools=[]
)
}
def handle_request(self, user_message: str) -> str:
# 1. Receptionist分类问题
classification = self.agents["receptionist"].classify(
user_message
)
# 2. 路由到相应的专业Agent
if classification.category == "technical":
handler = self.agents["tech_support"]
elif classification.category == "account":
handler = self.agents["account_manager"]
elif classification.category == "sales":
handler = self.agents["sales_advisor"]
else:
return "抱歉，我无法理解您的问题"
# 3. 专业Agent处理
response = handler.handle(user_message)
# 4. Quality Checker审核
quality_check = self.agents["quality_checker"].check(
user_message, response
)
if quality_check.score < 0.7:
# 质量不达标，重新处理
response = handler.handle(
user_message,
feedback=quality_check.suggestions
)
return response
使用示例
system = CustomerServiceSystem(llm)
# 技术问题
response = system.handle_request("我的应用登录不了")
# Receptionist: 分类为"technical"
# Tech Support: 运行诊断，查询文档
# Quality Checker: 检查回复完整性
# 输出: "请尝试以下步骤：1. 清除缓存 2. 重启应用..."
# 账户问题
response = system.handle_request("我想修改绑定手机号")
# Receptionist: 分类为"account"
# Account Manager: 查询账户信息，提供修改步骤
# 输出: "您可以通过以下方式修改..."
新兴Agent范式
1. BabyAGI
核心思想：任务列表 + 自动执行 + 优先级排序
class BabyAGI:
def __init__(self, llm):
self.llm = llm
self.task_list = []
def run(self, objective: str):
# 初始化任务列表
self.task_list = [Task(1, "初始任务：" + objective)]
while self.task_list:
# 1. 获取优先级最高的任务
task = self.task_list.pop(0)
# 2. 执行任务
result = self.execute_task(task)
# 3. 基于结果创建新任务
new_tasks = self.create_new_tasks(
objective, task, result
)
self.task_list.extend(new_tasks)
# 4. 重新排序任务
self.task_list = self.prioritize_tasks(
objective, self.task_list
)
2. CAMEL (Communicative Agents)
核心思想：两个Agent通过对话完成任务
# AI User: 提出需求
# AI Assistant: 实现需求
# 通过多轮对话，逐步细化和实现
user_agent = Agent(role="user", task="设计一个网站")
assistant_agent = Agent(role="assistant")
for round in range(10):
user_message = user_agent.speak()
assistant_response = assistant_agent.respond(user_message)
if assistant_response.task_complete:
break
3. Generative Agents（生成式智能体）
核心思想：模拟人类的记忆和行为
- 记忆流：记住所有经历
- 反思：定期总结和学习
- 规划：基于记忆和目标规划行为
class GenerativeAgent:
def __init__(self, name, traits):
self.name = name
self.traits = traits # 性格特征
self.memory_stream = [] # 记忆流
self.reflections = [] # 反思
def perceive(self, observation):
"""感知环境"""
self.memory_stream.append({
"time": now(),
"type": "observation",
"content": observation
})
def reflect(self):
"""定期反思"""
if len(self.memory_stream) > 100:
reflection = self.llm.reflect(
self.memory_stream[-100:]
)
self.reflections.append(reflection)
def plan(self, goal):
"""基于记忆规划行为"""
relevant_memories = self.retrieve_memories(goal)
plan = self.llm.plan(
goal, relevant_memories, self.traits
)
return plan
最佳实践
1. 何时使用哪种Agent？
简单任务（单次工具调用）
✅ Function Calling Agent
❌ AutoGPT（杀鸡用牛刀）
中等任务（需要3-5步）
✅ ReAct Agent（灵活）
✅ Plan-Execute Agent（如果步骤明确）
❌ Multi-Agent（过于复杂）
复杂任务（跨领域、长期）
✅ Multi-Agent System
✅ AutoGPT（如果可控性要求不高）
❌ 单个ReAct Agent（能力有限）
2. 成本控制
Token消耗对比（100步任务）：
| Agent类型 | 平均Token | 成本（GPT-4） |
|---|---|---|
| Function Calling | 5,000 | $0.15 |
| ReAct | 20,000 | $0.60 |
| Plan-Execute | 15,000 | $0.45 |
| Reflexion | 30,000 | $0.90 |
| AutoGPT | 50,000+ | $1.50+ |
| Multi-Agent | 40,000+ | $1.20+ |
优化建议：
- 缓存常用查询结果
- 使用更便宜的模型处理简单步骤
- 设置最大迭代次数
- 监控和报警
3. 安全考虑
权限控制：
class SafeAgent:
def __init__(self, llm, tools, allowed_operations):
self.allowed_operations = allowed_operations
def execute_tool(self, tool_name, args):
# 检查权限
if tool_name not in self.allowed_operations:
raise PermissionError(
f"Tool '{tool_name}' not allowed"
)
# 检查参数
if self._is_dangerous(tool_name, args):
raise SecurityError(
f"Dangerous operation detected"
)
return self.tools[tool_name](args)
沙箱化：
# 在Docker容器中运行Agent
# 限制文件系统访问
# 限制网络访问
# 监控系统调用
小结
核心要点
Agent架构选择：
- Function Calling：简单、可靠，首选
- ReAct：通用、灵活，次选
- Plan-Execute：明确任务，高可控
- Reflexion：需要迭代优化
- AutoGPT：开放式任务，需谨慎
- Multi-Agent：复杂任务，需要协调
关键设计原则
1. 从简单开始
- 先尝试单Agent
- 再考虑Multi-Agent
2. 可观测性
- 记录每一步
- 监控token消耗
- 追踪错误
3. 容错机制
- 设置最大步数
- 捕获异常
- 提供降级方案
4. 用户控制
- 关键操作需要确认
- 提供中断机制
- 允许人工干预
未来趋势
1. 混合架构
- ReAct + Planning
- Function Calling + Reflexion
- 自适应选择架构
2. 更好的协调
- Multi-Agent通信协议
- 共享记忆和知识
- 冲突解决机制
3. 自我改进
- 从经验中学习
- 自动优化prompt
- 发现新的工具组合
4. 标准化
- Agent通信标准
- 工具定义标准
- 评估基准
掌握多种Agent架构，能够根据不同场景选择最合适的方案，是构建实用AI系统的关键能力！
