Agent（智能体）的范式
范式 （Paradigm） 是一种通用的模式、思路或框架，用来指导我们如何理解和解决问题。每种范式背后有不同的思路、优缺点和适用场景，但它们解决的是同一个问题。
Agent（智能体）是指一个能自主感知环境、做出决策、采取行动来完成目标的系统。
在大模型语境下，Agent 通常指的是：
一个以 LLM 为"大脑"，配合记忆、工具、规划能力 ，能够自主完成任务的系统。
它不只是"你问一句我答一句"的聊天机器人，而是能：
- 主动分解任务
- 调用外部工具（搜索、代码执行、API 等）
- 根据中间结果调整策略 多步执行直到完成目标
一、按推理模式划分
1. ReAct（Reasoning + Acting）
核心思想 ：在于"思考-行动-观察 "（Thought-Action-Observation）循环机制，形成 Thought → Action → Observation 的循环。
特点 ：每一步都先思考当前状态，再决定下一步行动，观察结果后继续推理。
优势 ：推理过程可解释，行动有依据。使Agent能根据环境反馈 动态调整策略。
缺点：缺乏全局规划；Token 消耗大；Prompt 敏感。
代表：Yao et al. 2022 的 ReAct 论文。
2. Plan-and-Execute（先规划后执行）
核心思想 ：先制定全局计划，再逐步执行。
特点 ：将任务分解为子任务序列，按计划顺序或并行执行。
优势 ：适合复杂、多步骤任务；减少盲目试错。
变体：可以是静态规划（一次性规划），也可以是动态规划（执行中根据反馈调整计划）。
bash
# LangGraph 实现 Plan-and-Execute 的核心结构
from langgraph.graph import StateGraph
def plan(state):
"""生成计划"""
...
def execute_step(state):
"""执行当前子任务"""
...
def replan(state):
"""判断是否需要调整计划"""
...
def should_continue(state):
"""是否还有未完成的子任务"""
if state["remaining_steps"]:
return "execute" # 继续执行下一个子任务
else:
return "finish" # 全部完成
# 构建图
graph = StateGraph(State)
graph.add_node("plan", plan)
graph.add_node("execute", execute_step)
graph.add_node("replan", replan)
graph.add_edge("plan", "execute")
graph.add_conditional_edges("execute", should_continue, {
"execute": "execute",
"finish": END
})
app = graph.compile()3. Reflexion（自我反思）
核心思想：Agent 执行后对结果进行自我评估和反思，将反思结论作为经验用于下一轮迭代。
特点：形成"执行 → 反思 → 改进"的闭环。
优势：能够从错误中学习，无需梯度更新参数。
代表：Shinn et al. 2023 的 Reflexion 论文。
bash
from typing import TypedDict, List
from langgraph.graph import StateGraph, END
from openai import OpenAI
client = OpenAI()
# ========================
# 1. 定义状态
# ========================
class ReflexionState(TypedDict):
task: str
output: str
reflections: List[str] # 历史反思记录
evaluation_pass: bool
feedback: str
iteration: int
max_iterations: int
# ========================
# 2. 定义节点
# ========================
def execute(state: ReflexionState) -> dict:
"""执行节点：生成回答"""
prompt = f"任务：{state['task']}"
if state["reflections"]:
prompt += "\n\n过往经验（请避免重复犯错）：\n"
for i, r in enumerate(state["reflections"], 1):
prompt += f" 第{i}次教训：{r}\n"
response = client.chat.completions.create(
model="gpt-4o",
messages=[
{"role": "system", "content": "你是一个有帮助的助手。"},
{"role": "user", "content": prompt}
]
)
output = response.choices[0].message.content
return {
"output": output,
"iteration": state["iteration"] + 1
}
def evaluate(state: ReflexionState) -> dict:
"""评估节点：检查输出质量"""
import json
prompt = f"""评估以下回答是否正确解决了任务。
任务：{state['task']}
回答：{state['output']}
返回 JSON：
- "pass": true/false
- "feedback": 不通过时的具体问题
"""
response = client.chat.completions.create(
model="gpt-4o",
messages=[
{"role": "system", "content": "你是严格评审员，用 JSON 回答。"},
{"role": "user", "content": prompt}
],
response_format={"type": "json_object"}
)
result = json.loads(response.choices[0].message.content)
return {
"evaluation_pass": result["pass"],
"feedback": result.get("feedback", "")
}
def reflect(state: ReflexionState) -> dict:
"""反思节点：总结失败原因"""
prompt = f"""任务失败了，请反思原因。
任务：{state['task']}
你的回答：{state['output'][:500]}
评审反馈：{state['feedback']}
总结改进策略（不超过 3 句话）：
"""
response = client.chat.completions.create(
model="gpt-4o",
messages=[
{"role": "system", "content": "你是善于总结经验的反思者。"},
{"role": "user", "content": prompt}
]
)
new_reflection = response.choices[0].message.content
return {
"reflections": state["reflections"] + [new_reflection]
}
# ========================
# 3. 定义条件路由
# ========================
def route_after_evaluate(state: ReflexionState) -> str:
if state["evaluation_pass"]:
return "end"
elif state["iteration"] >= state["max_iterations"]:
return "end"
else:
return "reflect"
# ========================
# 4. 构建图
# ========================
graph = StateGraph(ReflexionState)
graph.add_node("execute", execute)
graph.add_node("evaluate", evaluate)
graph.add_node("reflect", reflect)
# 流程：execute → evaluate → (end | reflect → execute)
graph.set_entry_point("execute")
graph.add_edge("execute", "evaluate")
graph.add_conditional_edges("evaluate", route_after_evaluate, {
"end": END,
"reflect": "reflect"
})
graph.add_edge("reflect", "execute")
app = graph.compile()
# ========================
# 5. 运行
# ========================
result = app.invoke({
"task": "用 Python 实现一个 LRU Cache，要求 get 和 put 操作都是 O(1)",
"output": "",
"reflections": [],
"evaluation_pass": False,
"feedback": "",
"iteration": 0,
"max_iterations": 3
})
print("最终输出：", result["output"])
print("总轮次：", result["iteration"])
print("反思记录：", result["reflections"])4. Chain-of-Thought / Tree-of-Thought（思维链/思维树）
CoT：逐步推理，每步展示推理过程。
ToT：探索多条推理路径，通过搜索（如 BFS/DFS）找到最优路径。
LATS：将蒙特卡洛树搜索（MCTS）与 LLM 结合，适用于需要深度探索的场景。
二、按架构设计划分
5. 单智能体（Single Agent）
一个 LLM 配备工具和记忆，独立完成任务。
典型实现：ReAct Agent、Function Calling Agent。
6. 多智能体系统（Multi-Agent）
多个 Agent 协作或竞争完成任务，常见模式：
| 模式 | 描述 | 代表框架 |
| 协作式 | 多个角色分工合作（如产品经理、程序员、测试员） | CrewAI、AutoGen |
| 辩论式 | 多个 Agent 各自推理，通过辩论达成共识 | ChatEval |
| 层级式 | 一个总控 Agent 调度多个子 Agent LangGraph、MetaGPT 竞争式 多个 Agent 独立求解，取最优结果 | --- |
7. 工作流式（Workflow-based / Agentic Workflow）
核心思想：用预定义的 DAG（有向无环图）或状态机编排 Agent 的执行流程。
特点：比完全自主的 Agent 更可控、更可预测。
代表：LangGraph、Dify、Coze 等平台。
与纯 Agent 的区别：不是让 Agent 完全自主决策，而是在关键节点由人或规则控制流程走向。
三、按交互与能力划分
8. 工具增强型（Tool-Augmented Agent）
Agent 可以调用外部工具（搜索引擎、代码执行器、API、数据库等）。
本质是将 LLM 从"纯文本生成器"扩展为"能与外部世界交互的系统"。
代表：OpenAI Function Calling、LangChain Tools。
9. 计算机使用型（Computer Use Agent）
Agent 直接操作计算机界面（点击、输入、截图等）。
代表：Anthropic 的 Computer Use、OpenAI 的 Operator。
10. 检索增强型（Agentic RAG）
Agent 主动决定何时检索、检索什么、如何整合检索结果。
与传统 RAG 的区别：传统 RAG 是"先检索后生成"的固定流程，Agentic RAG 让 Agent 自主判断是否需要检索以及如何使用检索结果。
11. 自主智能体（Autonomous Agent）
Agent 有长期目标，自主分解任务、持续执行、记忆积累。
代表：AutoGPT、BabyAGI、Devin。
特点：目标驱动，最少人工干预，但可控性是挑战。