AG-01_Agent 是什么？—— 从 LLM 到智能体的范式跨越

王解

25人浏览 · 2026-09-05 22:29:29

王解 · 2026-09-05 22:29:29 发布

Agent 是什么？—— 从 LLM 到智能体的范式跨越

系列: AI Agent 工程实践 | 编号: AG-01
关键词: Agent 定义, LLM, 智能体架构, ReAct, Reflexion
阅读时间: 约 15 分钟

前言

2023 年，当 ChatGPT 横扫全球时，大多数人对大语言模型（LLM）的认知停留在"聊天机器人"层面。然而，一线研究者和工程师早已意识到：LLM 的真正潜力不在于对话，而在于行动。

一个能对话的 LLM 是工具；一个能感知环境、制定计划、调用工具、从反馈中学习的 LLM，才是 Agent（智能体）。

这篇文章将从经典人工智能的 Agent 定义出发，梳理 LLM 时代 Agent 的新内涵，解析其四大核心能力，并通过代码实现一个最简 Agent 循环，帮助你建立对 Agent 的完整认知框架。

一、Agent 的经典定义

1.1 Russell & Norvig 的权威定义

在 Stuart Russell 与 Peter Norvig 的经典教材 Artificial Intelligence: A Modern Approach（第 4 版，2020）中，Agent 被定义为：

“Anything that can be viewed as perceiving its environment through sensors and acting upon that environment through actuators.”
（任何能通过传感器感知环境并通过执行器作用于环境的事物。）

这个定义包含三个核心要素：

感知（Perception）：从环境中获取信息
行动（Action）：对环境施加影响
环境（Environment）：Agent 所处的外部世界

Russell & Norvig 进一步区分了多种 Agent 类型：

Agent 类型	特征	示例
Simple Reflex Agent	基于当前感知直接行动	恒温器
Model-Based Reflex Agent	维护内部状态	真空吸尘器（有地图）
Goal-Based Agent	有明确目标，规划行动路径	导航系统
Utility-Based Agent	通过效用函数优化决策	投资顾问
Learning Agent	从经验中改进自身	AlphaGo

1.2 传统 Agent 的局限

经典 AI 的 Agent 概念虽然框架清晰，但在实践中面临巨大挑战：

知识瓶颈：需要手工编码所有规则和知识
脆弱性：面对未预见的情况容易失败
泛化能力差：每个任务需要专门设计

这些局限使得传统 Agent 长期停留在学术实验室中，难以规模化应用。

二、LLM 时代的 Agent 新定义

2.1 范式转移

LLM 的出现根本性地改变了 Agent 的设计范式。传统 Agent 依赖手工规则，而 LLM Agent 依赖语言理解与生成。这不是渐进式改良，而是范式跨越。

在 LLM 时代，Agent 可以重新定义为：

一个以大语言模型为核心推理引擎，具备感知、规划、记忆和工具使用能力的自主系统。

2.2 核心架构模型

LLM Agent 的架构可以用一个简洁的公式表达：

Agent = LLM + Tools + Memory + Planning

这个公式中：

LLM：充当"大脑"，负责理解、推理和决策
Tools：扩展 Agent 的能力边界（搜索、代码执行、API 调用等）
Memory：提供上下文连续性和长期知识积累
Planning：将复杂任务分解为可执行的步骤

2.3 从对话到行动

传统 LLM 交互是单轮或多轮对话，用户提问、模型回答。而 Agent 交互是任务驱动的自主循环：

用户: "帮我分析这份销售数据并生成报告"
→ Agent: 解析文件 → 理解数据结构 → 执行分析 → 生成图表 → 撰写报告 → 交付结果

关键区别在于：Agent 不等待用户每一步指令，而是自主规划并执行完整的工作流。

三、Agent 的四大核心能力

3.1 感知（Perception）

感知是 Agent 获取环境信息的通道。在 LLM Agent 中，感知包括：

用户输入：自然语言指令、文件上传、语音输入
工具返回值：API 响应、代码执行结果、搜索结果
环境状态：系统时间、文件系统状态、网络状态
多模态输入：图像、音频、视频（通过多模态 LLM）

感知模块的核心挑战是信息筛选——Agent 需要从海量信息中提取与当前任务相关的信号。

3.2 规划（Planning）

规划是 Agent 将复杂任务分解为可执行步骤的能力。主要策略包括：

任务分解（Task Decomposition）：

任务: "写一篇关于量子计算的技术博客"
分解:
  1. 搜索量子计算最新进展
  2. 整理关键概念和术语
  3. 设计文章大纲
  4. 撰写各章节
  5. 添加代码示例
  6. 审校和排版

策略选择：

Chain of Thought (CoT)：逐步推理（Wei et al., 2022）
Tree of Thoughts (ToT)：多分支探索（Yao et al., 2023）
ReAct：推理与行动交替（Yao et al., 2023）

3.3 记忆（Memory）

记忆系统是 Agent 维持上下文连续性和积累经验的关键。参考认知科学，Agent 的记忆分为：

短期记忆（Short-term Memory）：当前对话上下文，受限于上下文窗口
长期记忆（Long-term Memory）：持久化存储，通常基于向量数据库
工作记忆（Working Memory）：当前任务的中间状态和变量

Shinn et al.（2023）在 Reflexion 论文中展示了记忆如何让 Agent 从失败中学习：

Agent 将失败的尝试和反思存储为长期记忆，在后续任务中检索相关经验以避免重复错误。

3.4 执行（Execution）

执行是 Agent 将决策转化为实际动作的能力。在 LLM Agent 中，执行主要通过**工具调用（Tool Use / Function Calling）**实现：

代码执行：编写并运行 Python、JavaScript 等代码
API 调用：调用外部服务（搜索引擎、数据库、SaaS 工具）
文件操作：读写文件、创建目录
系统操作：执行 shell 命令、管理进程

执行模块的关键设计原则是可观测性——每次执行的结果都需要反馈给 Agent，形成闭环。

四、代码示例：最简 Agent 循环实现

下面我们实现一个最简的 Agent 循环，展示 Agent 的核心运行机制。这个实现剥离了所有框架抽象，直接展示本质逻辑。

"""
最简 Agent 循环实现
展示 Agent 的核心运行机制：感知 → 推理 → 行动 → 观察 的循环
"""
import json
from openai import OpenAI

client = OpenAI()

# ============================================================
# 第一部分：定义工具集
# Agent 的能力边界由工具集决定
# ============================================================

def search_web(query: str) -> str:
    """模拟网络搜索工具"""
    # 实际实现中，这里会调用搜索 API（如 Google、Bing）
    results = {
        "python 异步编程": "Python asyncio 提供了编写单线程并发代码的基础设施...",
        "agent 架构设计": "现代 AI Agent 通常采用 LLM + Tools + Memory 架构...",
    }
    return results.get(query, f"未找到关于 '{query}' 的结果")

def run_python(code: str) -> str:
    """模拟代码执行工具"""
    try:
        # 注意：生产环境中需要沙箱隔离
        local_vars = {}
        exec(code, {}, local_vars)
        return str(local_vars.get("result", "执行完成"))
    except Exception as e:
        return f"执行错误: {str(e)}"

# 工具注册表：工具名 → 工具函数
TOOLS = {
    "search_web": search_web,
    "run_python": run_python,
}

# ============================================================
# 第二部分：工具描述（供 LLM 理解工具用途）
# 这是 Function Calling 的核心——用自然语言描述工具
# ============================================================

TOOL_SCHEMAS = [
    {
        "type": "function",
        "function": {
            "name": "search_web",
            "description": "搜索互联网获取最新信息",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {
                        "type": "string",
                        "description": "搜索关键词"
                    }
                },
                "required": ["query"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "run_python",
            "description": "执行 Python 代码并返回结果。代码中需要将结果赋值给 result 变量。",
            "parameters": {
                "type": "object",
                "properties": {
                    "code": {
                        "type": "string",
                        "description": "要执行的 Python 代码"
                    }
                },
                "required": ["code"]
            }
        }
    }
]

# ============================================================
# 第三部分：Agent 核心循环
# 这是 Agent 的"心脏"——感知、推理、行动的无限循环
# ============================================================

def run_agent(user_task: str, max_iterations: int = 10) -> str:
    """
    运行 Agent 核心循环。
    
    循环流程:
    1. 将用户任务和历史交互发送给 LLM
    2. LLM 决定：直接回答 或 调用工具
    3. 如果调用工具，执行并将结果反馈给 LLM
    4. 重复直到 LLM 给出最终答案或达到最大迭代次数
    """
    # 初始化对话历史
    messages = [
        {
            "role": "system",
            "content": (
                "你是一个智能助手，可以使用工具来帮助用户完成任务。"
                "请根据需要调用工具获取信息或执行操作，然后给出最终答案。"
                "如果不需要工具，可以直接回答。"
            )
        },
        {"role": "user", "content": user_task}
    ]
    
    # Agent 主循环
    for iteration in range(max_iterations):
        print(f"\n{'='*50}")
        print(f"🔄 迭代 {iteration + 1}")
        print(f"{'='*50}")
        
        # 步骤 1: 调用 LLM 进行推理
        response = client.chat.completions.create(
            model="gpt-4",
            messages=messages,
            tools=TOOL_SCHEMAS,
            tool_choice="auto",  # 让 LLM 自主决定是否调用工具
        )
        
        message = response.choices[0].message
        messages.append(message)
        
        # 步骤 2: 检查 LLM 是否需要调用工具
        if not message.tool_calls:
            # LLM 认为已经完成任务，返回最终答案
            print(f"✅ Agent 完成任务（共 {iteration + 1} 次迭代）")
            return message.content
        
        # 步骤 3: 执行工具调用
        for tool_call in message.tool_calls:
            func_name = tool_call.function.name
            func_args = json.loads(tool_call.function.arguments)
            
            print(f"🔧 调用工具: {func_name}")
            print(f"   参数: {json.dumps(func_args, ensure_ascii=False, indent=2)}")
            
            # 执行工具
            if func_name in TOOLS:
                result = TOOLS[func_name](**func_args)
            else:
                result = f"错误：未知工具 '{func_name}'"
            
            print(f"   结果: {result[:200]}...")
            
            # 步骤 4: 将工具结果反馈给 LLM
            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": str(result)
            })
    
    return "达到最大迭代次数，任务未完成。"

# ============================================================
# 使用示例
# ============================================================

if __name__ == "__main__":
    task = "搜索一下 Python 异步编程的最新实践，然后写一个简单的异步 HTTP 请求示例"
    result = run_agent(task)
    print(f"\n📋 最终结果:\n{result}")

代码要点解析：

工具注册机制：通过 TOOLS 字典和 TOOL_SCHEMAS 列表，将工具的执行逻辑和语义描述分离。LLM 通过 TOOL_SCHEMAS 理解工具用途，通过 TOOLS 实际执行。
自主决策循环：tool_choice="auto" 让 LLM 自主判断是否需要调用工具。这是 Agent 与传统脚本的本质区别——控制流由 LLM 动态决定，而非预编码。
反馈闭环：每次工具调用的结果都通过 role: "tool" 消息回传给 LLM，形成"行动→观察→推理"的闭环。这正是 ReAct 模式的核心思想。

五、Agent 与传统软件的区别

理解 Agent，最直观的方式是将其与传统软件对比：

维度	传统软件	AI Agent
控制流	预定义的 if-else / 状态机	LLM 动态决策
输入处理	结构化数据，严格校验	自然语言，容错理解
错误处理	预定义异常处理路径	LLM 理解错误并自主调整
扩展性	添加新功能需改代码	添加新工具描述即可
适应性	固定行为模式	根据上下文动态调整策略
可解释性	代码即文档	推理过程可见（Thought）
不确定性	确定性执行	概率性决策，可能产生幻觉

关键差异深度分析

1. 控制流的本质变化

传统软件的控制流是确定性的——给定相同的输入，总是执行相同的路径。而 Agent 的控制流是涌现性的——LLM 根据当前上下文动态选择下一步行动。

这意味着：

Agent 能处理开发者未预见的场景
但也意味着行为不可完全预测
需要新的测试和验证方法

2. 接口的范式转换

传统软件通过API 接口交互（精确的函数签名、参数类型）。Agent 通过自然语言接口交互——用户说"帮我分析一下"，Agent 自行理解具体要做什么。

这大大降低了使用门槛，但也引入了语义模糊性。

3. 错误恢复能力

传统软件遇到未处理的异常会崩溃。Agent 遇到错误时，LLM 可以：

理解错误信息
分析失败原因
调整策略重试
或者告知用户无法完成并解释原因

六、Agent 的应用场景

6.1 代码开发 Agent

以 GitHub Copilot Workspace、Cursor、Devin 为代表，这类 Agent 能：

理解需求并规划实现方案
编写、修改、调试代码
运行测试并修复失败
提交代码和创建 PR

6.2 数据分析 Agent

以 ChatGPT Code Interpreter 为代表：

读取数据文件
执行数据清洗和转换
生成可视化图表
撰写分析报告

6.3 研究助理 Agent

以 Perplexity、GPT Researcher 为代表：

搜索多源信息
综合分析和对比
生成结构化报告
引用来源

七、从 LLM 到 Agent：技术栈的演进

7.1 LLM 的三种使用模式

模式 1: 直接调用（Chatbot）
  用户输入 → LLM → 输出

模式 2: 链式调用（Chain）
  用户输入 → LLM₁ → 处理 → LLM₂ → 输出

模式 3: Agent 循环（Loop）
  用户输入 → [LLM → 工具 → 观察] × N → 输出

模式 3 是 Agent 的核心特征——一个自主循环，直到任务完成。

7.2 框架生态

当前主流的 Agent 框架包括：

框架	特点	适用场景
LangChain / LangGraph	生态丰富，图结构编排	通用 Agent 开发
AutoGen	多 Agent 对话	多角色协作
CrewAI	角色扮演，团队协作	任务分工明确的场景
OpenAI Assistants API	原生集成，开箱即用	快速原型
Anthropic Claude MCP	工具标准化协议	工具生态建设

八、总结

核心观点回顾

Agent 不是聊天机器人的升级版，而是一种全新的软件范式。它将 LLM 从"应答工具"提升为"自主行动者"。
Agent = LLM + Tools + Memory + Planning，四大组件缺一不可。LLM 提供推理能力，Tools 扩展行动能力，Memory 提供连续性，Planning 实现复杂任务分解。
Agent 的本质特征是自主循环——感知环境、推理决策、执行行动、观察结果，循环往复直到任务完成。
Agent 与传统软件的根本区别在于控制流——从预定义的确定性流程，转变为 LLM 驱动的动态决策。
当前仍处于 Agent 技术的早期阶段。可靠性、安全性、可控性是需要持续攻克的工程挑战。

展望

正如 Russell & Norvig 在教科书中所预言的，真正的智能体需要"在不确定环境中自主行动"。LLM 第一次让这个愿景变得可工程化。

在接下来的文章中，我们将深入 Agent 的每个核心模块：认知架构（AG-02）、ReAct 模式（AG-03）、工具调用（AG-04）和记忆系统（AG-05），从理论到源码，构建完整的 Agent 工程知识体系。

参考文献

Russell, S., & Norvig, P. (2020). Artificial Intelligence: A Modern Approach (4th ed.). Pearson. Chapter 2: Intelligent Agents.
Yao, S., Zhao, J., Yu, D., et al. (2023). “ReAct: Synergizing Reasoning and Acting in Language Models.” ICLR 2023. arXiv:2210.03629.
Shinn, N., Cassano, F., Gopinath, A., et al. (2023). “Reflexion: Language Agents with Verbal Reinforcement Learning.” NeurIPS 2023. arXiv:2303.11366.
Wei, J., Wang, X., Schuurmans, D., et al. (2022). “Chain-of-Thought Prompting Elicits Reasoning in Large Language Models.” NeurIPS 2022. arXiv:2201.11903.
Yao, S., Yu, D., Zhao, J., et al. (2023). “Tree of Thoughts: Deliberate Problem Solving with Large Language Models.” NeurIPS 2023. arXiv:2305.10601.