Transformer 这 8 年到底“升级”了什么：从注意力到 MoE、长上下文、Multimodal 与 Agent

摘要（先看结论）

• 2017 年的 Transformer 可以概括为“注意力 + FFN（Feed‑Forward Network，前馈网络）+ 词嵌入”，而今天的主流大模型更像一套完整的系统：效率、记忆、感官、逻辑、执行五大模块协同工作。
• 真正改变成本曲线的关键之一是 MoE（Mixture of Experts，混合专家）：把“每一步都全量计算”变成“每一步只激活少数专家”，让计算更有选择性（Conditional Computation）。
• 让模型能“读更长”主要靠两条路线：一条是把注意力算得更省（线性注意力/稀疏注意力等），另一条是把历史信息存得更省（KV Cache 的压缩、分页与更聪明的管理）。
• Multimodal（多模态）不是“加个图片入口”这么简单，本质是把不同感官的数据统一成可融合的表示，再让模型在同一套推理框架里做对齐与生成。
• Agent（智能体）不是“模型更聪明了”，而是给模型接上“工具与行动接口”，让它能规划、检索、调用外部系统、产出可验证结果。

---

0. 先搭一个总框架：五大支柱看懂所有升级

这几年关于 Transformer 的新名词很多，如果一条条学很容易碎成知识点。更稳的方式是先把它们放进一个框架里：

• 效率（Compute）：怎么让每生成一个 token 的计算更便宜、更快。
• 记忆（Memory）：怎么让模型“记得更多、记得更久”，尤其是长上下文与长期记忆。
• 感官（Senses）：怎么让模型能看、能听、能说、能处理多模态信息。
• 逻辑（Reasoning）：怎么让模型更会推理、更可靠地做复杂问题。
• 执行（Action）：怎么让模型能调用工具、与环境交互、完成任务闭环。

后面每一个“看起来很新的技术”，基本都能落到这五类里。

---

0.5 10 分钟理解 Transformer：它到底在做什么

只讲你后面看 MoE、长上下文、多模态时一定会用到的三件事：

0.5.1 它每一层都在做两件事：注意力 + FFN

你可以把一层 Transformer 简化成：

• 注意力（Attention）：决定“我现在这个 token 应该重点参考历史里的哪些 token”。
• 前馈网络（FFN，Feed‑Forward Network / MLP）：在“参考完信息”之后，做一次更强的非线性变换（可以理解为把信息加工成更有用的特征）。

注意力为什么能“建立关系”？因为它会把当前 token 变成一个“提问向量”，把历史 token 变成“索引向量”和“内容向量”：

• Q（Query）：我想找什么
• K（Key）：我是谁（给别人匹配用）
• V（Value）：我有什么内容（被别人拿走用）

用一句伪公式表示就是：

Attention(Q, K, V) = softmax(QKᵀ) · V

你不需要把公式背下来，只要记住：Q 去匹配 K，匹配结果用来加权汇总 V。

0.5.2 为什么生成是“自回归”：每次只多写一个 token

多数大模型的文本生成是这样工作的：

1. 先把提示词整段喂进去（Prefill）
2. 然后开始一轮轮解码：每轮只生成 1 个 token，再把它接到序列末尾继续生成（Decode）

所以“每生成一个 token 的成本”会被无限重复放大，这也是为什么后面大家疯狂优化效率与记忆。

0.5.3 你在产品里感知到的三类成本

把 Transformer 当成系统看，最容易踩到的三种成本是：

• 算力成本：矩阵乘法多不多、每步走不走全量参数（MoE 就是来改这个的）。
• 显存成本：历史信息要不要存、存多少、存得是否高效（KV Cache 就是来改这个的）。
• 过程成本：是不是一次拍答案、能不能自检、能不能拿到外部证据（推理增强与 Agent 就是来改这个的）。

---

1. 支柱一：效率——把计算用在刀刃上

1.1 为什么“模型越大越贵”是个结构性问题

Transformer 的生成过程是自回归的：输出第 1 个 token 后，再基于它输出第 2 个 token……如此循环。

在“稠密（Dense）”架构里，每生成一个 token：

• 基本都会把每一层都走一遍
• 每层里大块的矩阵乘法都会参与

模型小的时候还能撑住；模型一大，吞吐、显存带宽、延迟都会一起变成瓶颈。

1.2 MoE：把“大网络”拆成很多“专家”，每次只让少数人上班

MoE 是 Mixture of Experts 的缩写，直译“混合专家”。它把 Dense 的某些大计算块（常见是 FFN 部分）替换成：

• 多个 Expert（专家）：很多个更小的 FFN
• 一个 Router/Gating（路由/门控）：负责给专家打分、挑选 Top‑K
• 一个 Mixture（混合）：把被选中的专家输出加权融合

你可以用“公司组织架构”类比：

• Dense：所有需求都进同一个大部门，每次都全员开会。
• MoE：拆成很多小组（专家），每次只叫最相关的 K 个小组来处理，调度台（路由）负责派单。

1.3 一个最小数字例子：为什么 MoE 省算力

假设一共有 128 个专家，每次只选 Top‑2（K=2）：

• Dense：每一步都要跑“一个很大的 FFN”
• MoE：每一步只跑“2 个小 FFN + 一个很小的 Router”

因此 MoE 的直觉收益不是“总参数更少”，而是：

• 激活参数更少：每一步真正参与计算的权重更少
• 计算更集中：同样预算下把算力花在更相关的子网络上

这种思想有个更正式的名字：Conditional Computation（条件计算）。

1.4 MoE 的代价：分布式通信与负载均衡

MoE 并非只有收益，它典型会带来两类新成本：

• 负载不均：路由如果老把请求塞给少数专家，热门专家会被打爆，吞吐反而下降。
• 通信压力：专家可能分布在不同设备上，路由与跨设备派发会引入通信瓶颈。

这里很多人会疑惑：专家不也是“同一个模型里的 FFN”吗，怎么还会分布到不同设备？

关键在于：MoE 往往是“参数规模很大，但每次只激活少数块”。为了把这堆专家参数放得下、并且把算力吃满，工程上通常会把专家做跨 GPU 切分：

• 从“逻辑上”看：它们仍然属于同一个模型、同一次前向计算图的一部分。
• 从“物理上”看：不同专家的权重可能放在不同 GPU/机器上（否则单卡显存放不下，或者放下了也不划算）。

于是每一步就会发生一个典型流程：

1. Router 在本地算出每个 token 应该去哪些专家（Top‑K）。
2. 把这些 token 的隐藏状态按“目标专家所在设备”分组打包。
3. 把分组后的数据发到对应的 GPU/机器，让那些专家各自做 FFN 计算。
4. 再把各个专家的输出收回来，按权重混合成最终结果。

你可以把它理解成“同一家公司（同一个模型），但不同小组（专家）坐在不同楼层/不同城市（不同设备）”。派单和取回结果这两趟，就是通信成本的来源。

所以你会看到工程与训练层面通常会做“负载均衡”相关约束，让专家更均匀地被使用。

---

2. 支柱二：记忆——让模型读得更长、记得更久

“记忆”分两类问题：

• 记得更多：上下文窗口更长，能放更多历史 token。
• 记得更久：跨会话的信息能持续保留，而不是新对话就清零。

2.1 为什么长上下文这么难：注意力天然是平方复杂度

经典注意力机制里，一个 token 要和上下文里的很多 token 建立关联。粗略直觉是：

• token 数量翻倍，关联关系可能接近翻四倍

这就是为什么长上下文会同时吃掉：

• 计算量
• 显存/内存
• 推理延迟

更关键的一点是：训练和推理的“贵法”不一样。

• 训练（Training）：一次会把整段序列喂进去，注意力里会显式形成一个“token×token”的关联（可以理解成一张很大的相关性矩阵），所以计算与中间激活都容易随长度飙升。
• 推理（Inference）：通常分两段：
  • Prefill（首段灌入）：把提示词整段跑一遍，建立历史缓存；这段依然可能很重。
  • Decode（逐 token 生成）：每次只生成 1 个 token，但要“看”所有历史 token，于是每步的成本会随历史长度线性增长；而历史越长，KV Cache 占的显存也越大。

因此你会看到“长上下文”既需要算法改造（把注意力算得更省），也需要工程优化（把历史存得更省）。

2.2 让“注意力更省”：线性/稀疏注意力与替代路线

为了解决“注意力太贵”，常见思路是让计算复杂度更可控：

• 线性注意力：通过改变计算形式/顺序，把复杂度从“近似平方”压到“近似线性”（直觉层面：不再显式计算所有两两关系）。
• 稀疏注意力：不是每个 token 都看所有 token，而是只看部分（例如局部窗口、关键位置等）。
• 状态空间模型（SSM）：用一个随时间演化的内部状态承载历史信息，替代显式的全量注意力对比。

实际产品和论文里，你更常见到的是“混合路线”：注意力 + SSM/线性注意力组合，追求在长上下文下的性价比。

把这三条讲得更“实现层”一点，可以抓住它们各自改变的对象：

• 线性注意力：改变的是“怎么把历史信息聚合成结果”。它常见的做法是把原本要做的巨大两两对比，改写成可累积的统计量（前缀和/累计量），这样历史越长，增量更新越便宜。
• 稀疏注意力：改变的是“看哪些位置”。它把“全看”变成“只看一部分”，所以你会看到窗口注意力、块稀疏、长短程混合等策略，本质都是在选连接边。
• SSM：改变的是“历史如何保存”。它用一个不断更新的状态向量来承载历史，把“显式存所有 token 的细节”变成“用状态压缩历史”，所以对超长序列更友好，但对“精确回忆某个很久以前的细节”可能需要额外机制配合。

2.3 让“历史存得更省”：KV Cache 的工程化优化

即使不改注意力的核心形式，工程上也能用“更聪明的存储”把长上下文做出来。

很多推理系统会缓存历史步骤中间结果（常称 KV Cache）。问题是：

• token 越多，缓存越大
• 显存先顶不住，然后才轮到算力

KV Cache 到底缓存的是什么，可以用一句话说清：

• 注意力里每个 token 都会生成一组 Key/Value（K/V），后续 token 想“看历史”时，需要拿当前 token 的 Query（Q）去和所有历史 token 的 K 做匹配，再用匹配结果对历史 V 做加权求和。
• 这里的 K 和 V 本质都是“向量”（一串浮点数），是把 token 的隐藏状态 h 过两套不同的线性变换得到的：
  • K（Key）是什么：K = h · W_K，更像“标签/索引/地址”，它的作用是让别人的 Q 来做相似度匹配，决定“该关注我多少”。
  • V（Value）存的是什么：V = h · W_V，更像“内容本体”，它的作用是被注意力权重加权求和，真正被“取走并汇总”的信息就在 V 里。
• 为了避免每步都重新算一遍历史 token 的 K/V，推理系统会把“历史 token 的 K/V”缓存起来，这就是 KV Cache（更精确地说，是按每一层、每个注意力头缓存所有历史 token 的 K 和 V 张量）。

为什么 KV Cache 这么吃显存？因为它近似按下面的量级线性增长：

• 近似大小 ∝ 层数 × 上下文长度 × KV 头数 × head 维度 × K/V 两份 × 数据类型字节数

给一个直觉数字（只看量级，不纠结具体模型差异）：

• 设层数 32、KV 头数 8、每头维度 128、数据类型 fp16（2 字节），上下文 64k token
• KV Cache 量级约等于 32 × 64k × 8 × 128 × 2(K/V) × 2(bytes) ≈ 8GB

所以在长上下文推理里，常见现象就是：还没把 GPU 算力吃满，显存先满了，吞吐开始掉，最后直接 OOM。

这里的“显存”指的是 GPU 的显存（VRAM），不是 CPU 的算力，也不是你电脑插的内存条（RAM）：

• RAM（内存条）：给 CPU 用的主存，容量通常更大，但访问延迟更高、带宽也远低于显存（面向 GPU 的那种高并行计算）。
• VRAM（显存）：直接焊在 GPU 或 GPU 板卡上的高速内存，用来放模型权重、KV Cache、激活值等。显存不够时，GPU 往往没法把需要的数据就近放好，只能频繁搬运数据，性能会断崖式下降，甚至直接跑不起来。
• 为什么不能“加内存条解决显存不够”：多数情况下 RAM 和 VRAM 是两块不同的内存池。你加 RAM 只能让 CPU 侧更宽裕，并不能等价增加 GPU 的 VRAM。部分平台支持把一部分 RAM 当作“共享显存/统一内存”使用，但带宽/延迟差一个数量级，更像“救急兜底”，很难替代真正的显存。

因此常见优化方向是：

• 缓存压缩（更低精度、更小体积）
• 分页/分块管理（更少碎片与浪费）
• 更聪明的淘汰与复用策略（把有限显存留给更关键的历史）

还可以补充两条你经常在工程方案里看到、但本质仍然在“省显存”的思路：

• 减少 KV 头数：例如把多头注意力里的 KV 头做共享（工程上常见相关变体），核心收益是 KV Cache 的维度直接下降。
• 缓存下沉/换出（offload）：把一部分 KV Cache 临时放到 CPU 内存或更慢的介质里，但代价是带宽和延迟都会更差，通常只适合作为“跑得起来”的兜底方案。

你可以把它理解成“同样大小的行李箱，用更好的收纳方式装下更多东西”。

2.4 让“记得更久”：长期记忆与 RAG

长上下文仍然是“临时工作记忆”：对话结束就没了。要解决“记得更久”，两条常见路线是：

• 长期记忆模块（模型内）：在推理阶段把一部分“值得记”的信息沉淀成可复用的参数/状态（研究方向很多，但核心模式很像“读写一个记忆库”）。
• RAG（检索增强生成）：把外部知识（文档/代码/历史对话）做索引，需要时检索相关片段塞回上下文，再让模型回答。它更像给模型外挂一个“可检索硬盘”。

这两条路一个偏“让模型自己长记性”，一个偏“让模型学会翻资料”，在工程实践中经常组合使用。

下面把“长期记忆模块”讲到最基础的实现原理层面：不绑定任何论文名词，只讲你真正需要理解的机制。

2.4.1 长期记忆模块的最小实现范式：记忆库 + 读路径 + 写路径

你可以把“模型内长期记忆”抽象成一个组件 Memory，它的形态常见是：

• 一个固定大小的记忆库：若干个槽位（slots），每个槽位是一条向量（长度通常等于 d_model）
• 两条路径：
  • 读（read）：当前 token 在推理时可以从记忆库里取出“相关向量”作为额外上下文
  • 写（write）：在推理时把“值得记”的新信息压缩后写进记忆库，供未来使用

一条可解释的最小读写流程是：

1. 压缩（从长文本到可写入的一条向量）
   • 不是把原文逐字存进去，而是把它压缩成一个向量摘要（类似“写一张卡片”）。
2. 选择（决定写不写、写到哪里）
   • 用一个 gate/router 决定“这段信息是否值得记”，以及写入哪个槽位（或以何种策略替换旧槽位）。
3. 写入（更新记忆库）
   • 最简单的写入是覆盖；更稳的写入是做“融合更新”（例如把新向量与旧向量按比例合并），避免记忆剧烈抖动。
4. 读取（在后续推理中用上）
   • 当前 token 通过相似度匹配或一次跨注意力，从记忆库里取出最相关的 K 条记忆向量，把它们作为额外上下文参与计算。

你会发现：这其实就是把“记忆”从“token 序列”变成了“可寻址的向量库”，并把读写机制直接做进模型计算图里。

你会觉得它“很像 RAG”，是因为它们确实共享同一个骨架：把信息压缩成向量 → 按相关性取回 → 再喂给模型。但它们不是一回事，核心差异在“记忆放哪儿、怎么写、谁来管”：

• 长期记忆模块（模型内）：记忆槽位是模型的一部分，读写发生在模型计算图里；它更像“内置的可寻址缓存/工作台”，优势是读写延迟低、可端到端训练，但容量有限、解释与审计更难、写错了不容易回滚。
• RAG（模型外）：记忆在外部存储系统（向量库/搜索系统/数据库），写入通常是离线或显式的工程流程；它更像“可检索的硬盘/知识库”，优势是容量大、可编辑可删除可审计，代价是需要额外检索链路、召回质量不稳定会直接影响答案。

工程上很多系统会把两者组合：用 RAG 管“可管理的大记忆”，用模型内记忆管“低延迟的小记忆/偏好/短期技能”。

2.4.2 “推理阶段更新权重”是怎么回事：Fast Weights / Adapter Memory

另一类更激进的长期记忆，会让模型在推理阶段做非常小步的学习，但通常会遵守两个底线：

• 大模型主体权重尽量不动（否则很容易不可控/不可回滚）
• 只更新一个小而可控的子模块（例如一个小记忆网络、或一组 adapter/低秩参数）

最常见的底层逻辑是：

• 先用某种指标判断“这条信息是否值得学习”（例如“惊喜度/预测误差大/反复出现”）
• 再只对小模块做一次很小的更新（可以理解为“写入经验”，而不是“背下原文”）

这种路线的工程挑战也最明显：可控性、可回滚性、污染风险都更高，所以在量产系统里更常见的是把“长期记忆”交给 RAG 或显式数据库，而不是直接改模型权重。

2.4.3 RAG 为什么在工程上更常用：因为它更像可管理的“存储系统”

RAG 的底层机制可以拆成四个可验收的部件：

• 切块（chunking）：把文档切成可检索的小段，避免一次塞太长。
• 向量化（embedding）：每段变成一个向量，便于按语义检索。
• 检索（retrieval + rerank）：先粗搜相似段，再用更强的打分模型重排，确保“找对段落”。
• 增强（augmentation）：把检索到的段落放回上下文，让模型在“看着材料”的情况下回答。

它被偏爱的一个现实原因是：它的记忆是可观察、可编辑、可删除、可审计的，而权重内化的记忆通常做不到这一点。

---

3. 支柱三：感官——从文本到多模态

多模态的关键变化不是“多加几个输入框”，而是让模型真的能把世界信号纳入同一套推理体系里：同一个 Transformer 既能“看图理解”，又能“按指令生成/编辑”，还能把结果接到工具与行动上。

为了把多模态讲透，可以用一条非常好记的主线：

• 第一阶段：对齐式多模态（以 CLIP 为代表） —— 让“图”和“文”在向量空间里互相找到对方，但理解依然偏“关键词匹配”。
• 第二阶段：原生多模态（以 Google DeepMind 的 Flamingo、Gemini 系列为代表） —— 不再把模态当成外挂，而是把一切都变成 token 丢进同一个 Transformer，让模型在同一个世界里学“理解 + 推理 + 生成”。

3.1 对齐式多模态：为什么 CLIP 很强，但不够“懂”

CLIP 的核心是双塔对比学习：文本编码器输出一个向量，图像编码器输出一个向量，让配对的图文距离更近。

它的问题不在“做不到”，而在“天花板很明显”：

• 扩展性差：多一种模态就多一套编码器与对齐关系，模态越多越像在做“全排列对齐”。
• 理解碎片化：能区分“狗”和“纸箱”，但对“狗钻进纸箱里”这种空间关系（包裹/包含/指代绑定）很容易不稳。
• 属性绑定易错：例如“红色的雨伞 + 蓝色的背包”，模型可能把颜色和物体配错，本质还是“谁属于谁”的绑定没建牢。

3.2 原生多模态：万物皆可 token 化到底是什么意思

“万物皆可 token 化”不是口号，它在工程上就是三步：

1. 把非文本信号变成 token 序列
   • 图片：切 patch，经视觉编码器得到向量序列，再投影到和文本 token 相同维度。
   • 音频：变成特征序列，经音频编码器得到向量序列，再投影到同一维度。
   • 视频：本质是“更长的时空序列”，要么做时空编码，要么按帧/块变成更长的 token 序列。
2. 把不同模态 token 放进同一个推理框架
   • 最朴素的做法是把多模态 token 和文本 token 拼成一个序列，让 Transformer 用注意力去学它们之间的关系。
   • 另一类做法是显式加交叉注意力，让“文本在看图/听音频”的依赖更清晰。
3. 让语言有“实体锚点”
   • 只有当“猫”不再只是一个词，而能和像素、形状、空间边界绑定，模型才可能稳定学到“谁在谁里面”“谁属于谁”这种物理直觉。

这也是为什么原生多模态往往看起来更像“在理解世界”，而不只是“在匹配标签”。

3.3 生成侧的关键一跳：扩散模型从 UNet 到 DiT

如果说原生多模态让模型更会“看懂”，那生成质量的跃迁很大程度来自于：生成模型本身也越来越 Transformer 化。

• 早期扩散模型常用 UNet：非常擅长局部纹理与细节，但全局一致性差（典型现象：六指、多臂、人脸抖动）。
• DiT（Diffusion Transformer） 把图像切成 patch，用 Transformer 的全局注意力去建模 patch 之间的关系：
  • 空间关系更稳（边界、遮挡、包裹关系更容易学出来）
  • 更适合大规模数据与并行训练

你可以用一句装逼但不玄学的话总结：UNet 像“修图师”，DiT 更像“有全局构图能力的导演”。

3.4 为什么现在更像“指哪儿改哪儿”：理解 + 生成的合体

新一代生成系统越来越像一个组合体：

• Transformer 更擅长逻辑与关系：理解指令、对齐指代、保持全局一致性。
• 扩散模型更擅长画质：细节、纹理、真实感。

当两者在系统层面融合之后，能力从“画得像”开始转向“画得对”：不仅好看，还要在空间关系、文字生成、局部编辑上更可控。

---

4. 支柱四：逻辑——让推理更强、更可靠

如果你只记住一句话：LLM 的默认目标是“把话说得像”，推理增强的目标是“把事做得对”。

传统语言建模是“猜下一个 token”。这解释了很多现象：

• 对话像人，但数学/代码/多步决策容易翻车
• 过程写得天花乱坠，但最后答案可能是错的（也就是大家说的“人模人样的胡说八道”）

过去几年推理能力的提升，可以非常清晰地归纳为四个方向：

方向	核心做法	代表关键词	直觉收益
思维链延长	允许输出中间步骤，把大问题拆小	Chain of Thought	正确率上升，尤其数学/代码
自检纠错	多次生成候选，再做一致性/投票/验证	Self-Consistency	降低一次性采样的偶然错误
强化学习（可验证奖励）	只用“结果对不对”给奖励，逼模型学会走对路	RLVR / Verifiable Reward	更结果导向，少“像对但不对”
提前规划	一次预测多个 token，逼全局一致	MTP（Multi-token Prediction）	编程/数学更稳，生成更快

4.1 思维链：把计算压力“摊开”，不要把一切压在最后一口气上

一个最小例子：猫早上吃 2 条鱼，晚上吃 3 条，一共几条？

• 直接让模型输出答案，容易一次性采样偏掉。
• 允许模型输出中间步骤（2+3=5），等于把“算对”分解到每一步，最后输出 5 的把握会更大。

关键点是：思维链不是“让模型更聪明”，而是让它把隐含计算显式化，便于稳定生成。

4.2 自检纠错：把“生成”升级成“生成 + 评估 + 选择”

Self-Consistency 类方法非常朴素：多生成几条不同思路的推理链，再对最终答案做统计/一致性选择。

它背后的工程直觉是：单次采样有偶然性，多次采样 + 投票等于用计算换稳定性。

4.3 强化学习（可验证奖励）：过程写得再漂亮，算错就扣分

RLVR（带可验证奖励的强化学习）强调一件事：奖励只看最终可验证结果。

这会让模型更倾向于探索“能把题做对”的路径，而不是“能把过程写得像人”的路径。对于数学/代码这类有明确判定的任务，尤其有效。

4.4 提前规划：MTP 让模型戒掉“短视的逐 token 决策”

传统 GPT 每次预测 1 个 token，本质上容易局部最优：前面看似合理，后面开始自相矛盾。

MTP（Multi-token Prediction）把训练目标改成“一次预测多个 token”，逼模型在更长的跨度上保持一致性。你可以把它类比成写代码时：写下 if 的时候，脑子里已经预演了 else 该怎么收尾。

这里顺手澄清两个常见疑问：

• GPT‑5.2 用了吗？目前主流闭源大模型通常不会公开训练目标细节，所以无法从公开信息确认某个具体型号是否使用了 MTP。但你在产品体验里感受到的“更快/一次吐出更多 token”，往往也可能来自推理侧的加速技巧（例如 speculative decoding），它和 MTP 不是同一个东西。
• 会导致 Transformer 架构大改吗？一般不会。MTP 更像是在训练时给模型加了“提前看几步”的约束，常见实现是保持 Transformer 主干不变，只在输出侧增加对多个未来位置的预测/辅助损失；对外部接口来说，模型仍然可以按 1 token 自回归生成，只是内部更有全局规划倾向。

4.5 结论：到 2026，推理竞争点从“堆参数”转向“训练方法与架构”

把这四条合起来看，你会得到一个非常装逼但很真实的判断：推理能力的差距越来越像“训练与系统工程差距”，而不是“参数量差距”。

---

5. 支柱五：执行——Agent 让模型真正“能干活”

Agent 不是“更强的模型”，而是“围绕模型搭出来的一套可执行系统”。它解决的是一个非常现实的问题：模型只会输出文本，世界需要的是可验收的结果。

把 Agent 拆开看，你会发现它基本由三件事组成：

• 工具接口：搜索、代码执行、数据库、浏览器、文件系统、业务 API……
• 流程编排：把目标拆成步骤，决定什么时候用哪个工具。
• 证据闭环：每一步都能读回结果，失败可恢复，最后能交付可验证产物。

5.1 最小闭环：计划 → 执行 → 观察 → 纠正

Agent 的骨架可以用一个状态机讲清楚：

Plan(goal)
  ↓
Act(tool_call)
  ↓
Observe(tool_result)
  ↓
Refine(plan, evidence)
  ↺

这套闭环的本质不是“更聪明”，而是“能从环境拿证据”。没有证据闭环，再强的模型也容易卡在幻觉里。

5.2 典型工作流：从“点一份杨枝甘露”看懂全流程

一个标准 Agent 流程（不依赖任何特定产品形态）通常是：

1. 意图理解：用户要什么（点外卖/查路线/写代码）。
2. 任务拆解：把需求拆成可执行步骤（打开平台、搜索、筛选、确认、下单）。
3. 工具调用：连接外部系统（App/网站/API）。
4. 过程监督：读取订单状态、异常处理、重试/回滚。
5. 结果反馈：把可验收结果交付给用户。

5.3 好 Agent 的标准：不是“全自动”，而是“可控协作”

一个“能上生产”的 Agent，往往更像 Andrew Ng 强调的那类协作工具：

• 可控性：人类可随时接管，关键步骤必须确认。
• 协作性：能和人一起完成任务，而不是擅自替你做决定。
• 容错性：失败能恢复，不会卡死在一个步骤。
• 学习能力：能从示范中学习流程模板（更像积累工作流，而不是修改底层模型）。
• 记忆能力：记住偏好与约束（但要可编辑、可删除、可审计）。

5.4 为什么权限边界是硬约束

一旦 Agent 能读写文件、执行命令、调用 API，它就获得了真实权限。工程上必须明确：

• 能写哪些目录、不能写哪些目录
• 能跑哪些命令、不能跑哪些命令
• 哪些操作必须二次确认
• 交付必须附带哪些证据（日志、差异、测试结果）

---

6. 把整张图串起来：现代 Transformer 更像一套系统

如果你把 2017 年的 Transformer 看成一个“核心发动机”，那今天的升级更像是给它加了整套系统工程：

• MoE 改变了“每步计算是否必须全量”的成本结构
• 长上下文 + KV Cache 优化 改变了“能读多少、读多贵”的上限
• 多模态 让输入输出从文本扩展到多种感官
• 推理增强 让复杂问题的可靠性提升
• Agent + 工具 让模型能把能力落到任务与产出上

---

7. 自检问答（读完你应该能直接讲给初学者）

• MoE 是哪几个单词的缩写？答：MoE = Mixture of Experts（混合专家）。
• Dense 和 MoE 的核心差异是什么？答：Dense 每步全量计算；MoE 每步只激活 Top‑K 个专家 + 一个路由器，属于条件计算。
• MoE 为什么能更快？答：主要因为每步激活参数更少，矩阵乘法与带宽压力更小；但会引入路由负载均衡与通信的新问题。
• 长上下文为什么难？答：经典注意力的计算与存储随 token 数增长很快，长了会同时卡计算、显存与延迟。
• KV Cache 优化在解决什么？答：用更聪明的缓存管理在有限显存里存下更多历史中间结果，从而支持更长上下文。
• RAG 在“记忆”里扮演什么角色？答：它是外部可检索记忆，把相关资料检索回上下文，让模型在推理时“翻资料再回答”。
• CLIP 与原生多模态的差别一句话怎么讲？答：CLIP 更像“对齐”，原生多模态更像“统一成同一种 token 语言后一起推理”。
• UNet 与 DiT 的差别一句话怎么讲？答：UNet 更像“局部修图强”，DiT 更像“全局关系强”。
• 推理增强的四大方向是什么？答：思维链、自检纠错、可验证奖励强化学习、提前规划（MTP）。
• Agent 的闭环四步是什么？答：计划、执行、观察、纠正（证据驱动的状态机）。

---

8. 你真正需要记住的“装逼框架”：看到新名词就能归类

从今天开始，遇到任何大模型新名词，你先问自己一个问题：它在解决哪一类成本？

• 省算力：MoE、条件计算、并行/吞吐优化
• 省显存：KV Cache 压缩、分页、KV 头共享、offload
• 更会看：原生多模态、统一 token 空间、视频/语音序列建模
• 更会想：思维链、自检、可验证奖励、提前规划（MTP）
• 更会做：Agent、工具调用、证据闭环、权限边界

只要能归类，你就不会被名词淹没；只要能解释“为什么能省/为什么更稳”，你就能讲得很专业。

9. 下一阶段的难点：为什么很多人开始怀疑“堆 Transformer 就能到 AGI”

把热闹抛开，当前系统的瓶颈非常集中：

• 高质量数据越来越难找，但泛化能力仍然不够稳
• benchmark 很漂亮，但低级错误没有消失
• 对物理空间与因果关系的理解仍不牢
• 缺少真实世界互动学习带来的持续成长
• 长期记忆要么不可控，要么不可审计

所以你会看到一个明显风向：在继续优化五大支柱的同时，研究者也开始探索“是否需要突破现有框架的新范式”。