LLM ≠ Agent:一文搞懂LLM(大语言模型)、Context、Memory 和Agent(智能体)

什么是LLM?

LLM是Large Language Model的缩写,它本质上是一个“超级续写员”:

它非常聪明,因为它学习过海量的人类语言和知识,

所以能够根据你给它的内容,继续创作出非常合理的内容;

它本身是没有任何记忆的,每一次续写,所有给它的输入内容都要重新写到一张“纸”上,它只根据这张“纸”上的内容继续创作;

如果你希望它知道之前发生过什么,就必须把之前的信息和你新给它的信息一起重新写到一张“纸”上给到它。

这张“纸”其实就是大模型的“上下文窗口”,它能写下内容就是“上下文(Context)”,“上下文窗口”是有限的(比如10万字)。

当你和它聊得太长,超出了这张纸的容量,前面的内容就不得不被“裁掉”或者通过某种算法压缩,

这就是为什么聊得太久,AI 会突然“失忆”或者忘了最开始的设定。
    
 不过随着大模型的发展,这张“纸”可以写下的内容越来越多,当前有的大模型上下文窗口可以达到10M以上,等于能塞下几十本书。


什么是 Agent(智能体)?

Agent 这个词本身的意思是代理人、代表、代办者。

比如旅行代理人,你只需要告诉他“帮我安排一次京都旅行”,具体查交通、找酒店、规划路线等事情由他自己完成。

所以 Agent 的核心不是“智能”,而是“代理”——代表你去做事情。

在 AI 领域,我们开始让 AI 来承担这个“代理者”的角色,于是有了 AI Agent。

它不是简单地按照固定步骤执行,而是可以围绕一个目标,自己理解情况、做出判断、调用工具、采取行动,并根据结果继续行动。

那么为什么中文翻译成“智能体”?

因为这里的“体”可以理解为一个能够独立感知、判断和行动的主体。

从这个角度看,人本身就是一种智能体;

而今天我们正在尝试用 LLM 等技术,构建一种能够独立感知、判断和行动的主体。

所以,Agent 和“智能体”其实是一体两面:

Agent 强调“它能做什么”——作为代理者替你做什么;
智能体强调“它是什么”——一个能够自主行动的智能主体。

因此可以把今天的 AI Agent 简单理解为:

一个由 AI 承担代理者角色、能够围绕目标自主思考、行动并完成任务的软件系统。

例如 ChatGPT,豆包、就可以看作一种以聊天为主要交互方式的智能体——聊天智能体;

而编程 Agent、出行 Agent、办公 Agent,则是让这个“智能体”进入不同领域,替我们完成不同类型的任务。

一句话:

Agent 是“替你做事的代理者”,智能体是“能够自主做事的智能主体”,AI Agent 就是让 AI 成为这样的代理者。


AI Agent(智能体)的工作原理

理解了 Agent 是什么,接下来一个自然的问题就是:

LLM 和 Agent 到底是什么关系?一个 LLM 是怎么变成一个能够替我们做事的智能体的?

这里首先要纠正一个容易产生误解的比喻:

LLM 不是完整的“大脑”。

因为人类的大脑本身就包含记忆、感知、推理等多种能力,而 LLM 更接近大脑中的语言理解与推理能力部分。

如果从计算机的角度类比:

LLM 更像 CPU,负责核心计算和推理;
Agent 则更像一台完整的智能计算机系统。

一个典型的 Agent,执行流程如下:

                     用户 / 环境
                          │
                          ▼
                 ┌────────────────┐
                 │ 当前输入 / 目标 │
                 └───────┬────────┘
                         │
                         ▼
            ┌─────────────────────────┐
       ┌───►│      Context 构建        │
       │    │                         │
       │    │ 当前输入                 │
       │    │ + 当前状态              │
       │    │ + Memory 相关信息       │
       │    │ + 环境信息              │
       │    │ + Tool 执行结果          │
       │    └────────────┬────────────┘
       │                 │
       │                 ▼
       │        ┌─────────────────┐
       │        │       LLM       │
       │        │                 │
       │        │  理解 / 推理     │
       │        │  规划 / 决策     │
       │        └────────┬────────┘
       │                 │
       │             下一步行动
       │                 │
       │        ┌────────┴────────┐
       │        │                 │
       │        ▼                 ▼
       │ ┌─────────────┐   ┌─────────────┐
       │ │ 直接输出结果 │  │ 调用Tools    │
       │ └─────────────┘   └──────┬──────┘
       │                          │
       │                       执行结果
       │                          │
       │                          ▼
       │                 ┌────────────────┐
       │                 │ 更新状态       │
       │                 │ 更新Memory      │
       │                 └───────┬────────┘
       │                         │
       └─────────────────────────┘

这里有一个非常重要的概念:Context 和 Memory 不是一回事。

Context:这一次给 LLM 的“纸”上的内容

我们前面讲 LLM 时已经提到:

LLM 本身没有持续记忆,每一次推理都依赖当前输入的 Context。

所以 Agent 需要把当前任务所需要的信息组织起来,形成一次推理的上下文:

Context
=
当前用户输入
+
当前任务状态
+
相关历史信息
+
Memory 中取出的信息
+
环境信息
+
工具执行结果

然后把这些内容交给 LLM。

Memory:Agent 的“长期记忆库”

比如:

“用户喜欢坐地铁。”

“这个项目使用 Retrofit。”

“上一次任务已经完成到第三步。”

这些信息不会自动存在 LLM 里面,而是由 Agent 的记忆系统保存。

需要的时候,再把相关内容取出来,放进 Context,交给 LLM。

所以二者的关系可以简单理解成:

Memory 是“仓库”,Context 是“这一次拿出来使用的资料”。

这也是为什么:

Memory ≠ Context。

LLM 和 Agent 的区别

到这里,两者的区别就非常清楚了。

LLM:

给我一份输入Context,我根据这份输入Context 进行推理并生成输出。

Agent:

给我一个目标,我负责组织 输入Context,让 LLM 基于Context进行推理,再决定调用什么工具、采取什么行动,并根据结果继续执行。

所以:

LLM
=
核心推理能力


Agent
=
LLM
+
Context 管理
+
Memory
+
Tools
+
任务状态
+
行动循环

这也是我们前面“超级续写员”这个比喻的自然延伸:

LLM 是一个超级续写员,它负责根据当前 Context 继续“写下去”;

而 Agent 则负责决定“每次应该给它什么 Context、拿到输出后应该做什么,做完之后要积累下来哪些东西”。

因此,LLM 是 Agent 的核心能力之一,但 LLM 本身并不等于 Agent。

而 Agent 真正带来的变化,就是:

让一个原本只能根据一次输入生成一次回答的LLM,围绕目标进入一个完整的“感知 → 推理 → 行动 → 反馈”循环,开始真正替你做事情。

附录:OpenAI LLM 最基本的 API 调用

第一次调用

response1 = client.responses.create(
    model="gpt-5.6",
    input="什么是LLM?"
)

print(response1.output_text)

调用结果:

LLM 是大语言模型……

第二次调用

把第一次的输入 + 第一次的输出 + 第二次的新输入一起传给 LLM:

response2 = client.responses.create(
    model="gpt-5.6",
    input="""
用户:什么是LLM?
AI:LLM 是大语言模型……

用户:那它有记忆吗?
"""
)

print(response2.output_text)

第二次结果:

LLM 本身没有持久记忆……

整个过程就是:

第一次调用
输入 ──────────► LLM ──────────► 第一次结果
“什么是LLM?”                    “LLM是……”

第二次调用
第一次输入
+ 第一次结果
+ 第二次输入 ───► LLM ──────────► 第二次结果
“那它有记忆吗?”                  “LLM本身没有……”

这就是最简单的 Context 传递:上一轮的内容如果需要被 LLM 知道,就必须在下一轮再次作为输入传给它。

©著作权归作者所有,转载或内容合作请联系作者
【社区内容提示】社区部分内容疑似由AI辅助生成,浏览时请结合常识与多方信息审慎甄别。
平台声明:文章内容(如有图片或视频亦包括在内)由作者上传并发布,文章内容仅代表作者本人观点,简书系信息发布平台,仅提供信息存储服务。

相关阅读更多精彩内容

友情链接更多精彩内容