第一次看到 Kimi K3 的参数规模时，人的注意力很容易被几个数字带走：

• 2.8T 总参数；
• 896 个专家；
• 百万 Token 上下文；
• 每个 Token 只激活少量专家；
• 8 张顶级 GPU 可以完成模型加载和正确性验证。

这些数字确实足够震撼。

但如果只把 K3 理解成“又一个更大的模型”，反而会错过它真正值得学习的部分。

因为 K3 展示的并不是一条简单的路线：

参数越来越多，模型自然越来越强。

它真正解决的是四个完全不同的问题：

1. 历史信息越来越长，模型怎样记得住？
2. 网络越来越深，前面层的能力怎样不被淹没？
3. 参数越来越多，怎样避免每次都全部计算？
4. Agent 工作越来越久，怎样不中断、不失忆、不把环境搞坏？

换句话说，K3 的关键不是单纯扩大 Transformer，而是重新设计了大模型内部的信息调度方式。

如果把传统 Transformer 看成一台不断堆算力的机器，那么 K3 更像是在给这台机器加上：

• 分层缓存；
• 选择性路由；
• 压缩记忆；
• 异步执行；
• 状态恢复；
• 专家调度系统。

这篇文章不打算重复罗列 K3 的参数，而是试图真正讲明白：KDA、AttnRes、MoE 和 Agent Harness 到底分别解决了什么问题，以及它们为什么必须同时出现。

---

一、Transformer 真正遇到的瓶颈，不只是算力不够

传统 Transformer 有一个非常直接的工作方式。

当模型需要理解一段文本时，它会保留历史 Token 对应的 Key 和 Value。新 Token 到来后，Query 再去历史记录中逐一检索。

这很像一个没有索引压缩的档案系统：

过去发生过什么，全部保存；现在需要什么，再从头查找。

这种方式的优点是准确。

某个变量名即使出现在几十万 Token 之前，只要当前 Query 能够匹配到它，模型理论上仍然可以直接取回相关 Value。

但代价也非常明显。

假设序列长度为 (L)，标准 Attention 需要处理大量 Token 两两之间的关系，训练复杂度近似为：

O(L^2)

推理阶段虽然不需要重新计算所有历史关系，但 KV Cache 会随着上下文持续增长。

于是上下文越长，模型越容易遇到三个问题：

• KV Cache 占用越来越大；
• 每生成一个 Token，需要读取的历史数据越来越多；
• 显存带宽逐渐成为比计算本身更严重的瓶颈。

当上下文从 8K 增长到 128K，问题还可以通过增加显存和优化 Kernel 缓解。

但当目标变成数十万甚至百万 Token 时，继续保存全部历史明细就开始变得不经济。

KDA 的出发点，正是改变这件事。

---

二、KDA 不是“更便宜的 Attention”，而是一套在线记忆系统

理解 KDA，首先要放弃一个常见误区：

KDA 只是把 Softmax 去掉，然后把复杂度降成线性。

如果只理解到这里，几乎等于没有理解 KDA。

KDA 更接近一个不断训练自己的小型记忆模型。

每读入一个 Token，它都会完成三件事：

1. 根据当前 Key，查看记忆中已经保存了什么；
2. 判断当前记忆预测得是否正确；
3. 只把预测错误的部分写回去。

这与传统 Attention 的逻辑完全不同。

传统 Attention 更像查数据库；KDA 更像在实时训练一个 Key 到 Value 的映射模型。

---

1. 最简单的线性记忆

先考虑一个状态矩阵：

S_t\in\mathbb{R}^{d_k\times d_v}

它可以被理解为一个从 Key 空间到 Value 空间的映射。

当第 (t) 个 Token 到来时，最朴素的写入方式是：

S_t=S_{t-1}+k_tv_t^\top

读取时使用 Query：

o_t=S_t^\top q_t

这套方法的优点是，历史 Token 不需要逐条保存。

无论上下文有多长，历史信息都会被压缩进固定尺寸的状态矩阵 (S_t)。

但这种简单累加很快会出现问题。

假设模型先后看到了两条信息：

项目状态：开发中
项目状态：已延期

如果两个“项目状态”拥有非常相似的 Key，简单累加会把“开发中”和“已延期”都写进同一个方向。

最后模型读出的可能不是最新状态，而是两者混合后的结果。

也就是说，普通线性注意力会不断增加记忆，却不知道如何修改记忆。

Delta Rule 解决的正是这个问题。

---

三、Delta Rule 最重要的不是写入，而是覆盖错误记忆

在写入新的 Value 之前，Delta Rule 会先让当前状态做一次预测：

\hat v_t=S_{t-1}^\top k_t

这一步的意思是：

根据现在的记忆，(k_t) 应该对应什么 Value？

然后计算预测误差：

e_t=v_t-\hat v_t

最后写入的不是完整的 (v_t)，而是误差：

S_t=S_{t-1}+\beta_tk_te_t^\top

展开后得到：

S_t = S_{t-1} + \beta_tk_t \left( v_t-S_{t-1}^\top k_t \right)^\top

进一步整理：

S_t = \left(I-\beta_tk_tk_t^\top\right)S_{t-1} + \beta_tk_tv_t^\top

这条公式初看很复杂，但实际只做了两件事。

第一步：删除当前 Key 方向上的旧答案

\left(I-\beta_tk_tk_t^\top\right)S_{t-1}

其中 (k_tk_t^\top) 可以看成沿着当前 Key 方向形成的投影。

这一项相当于告诉模型：

先把和当前 Key 相关的旧映射削弱。

第二步：写入新的 Key-Value 关系

\beta_tk_tv_t^\top

然后再把新的正确答案写入状态。

因此，Delta Rule 的本质并不是“记住更多”，而是：

根据预测误差，有选择地修正记忆。

如果当前记忆已经能够正确预测 (v_t)，那么误差接近 0，本次更新就会很小。

如果当前记忆完全错误，模型才会进行较大的修改。

这和机器学习中的梯度下降非常相似。

实际上，完全可以把状态矩阵 (S_t) 看成一个在推理过程中持续执行在线学习的小模型。

这也是 KDA 最值得掌握的第一层思想：

Transformer 不一定只能通过显式 KV Cache 保存历史，也可以在前向计算过程中不断训练一个临时记忆模型。

---

四、KDA 的细粒度门控，相当于给不同记忆设置不同保质期

Delta Rule 能够纠错，但还没有回答另一个问题：

一条信息应该保留多久？

自然语言中的信息并不具有相同的有效期。

例如：

用户姓名：长期有效
当前文件：中期有效
上一条命令输出：短期有效
刚才代码中的行号：可能只在下一步有效

如果所有信息都用相同速度衰减，模型就会面临两种极端：

• 遗忘太快，长期信息留不住；
• 遗忘太慢，短期噪声清不掉。

Gated DeltaNet 为状态增加了遗忘门：

S_t = \alpha_t \left(I-\beta_tk_tk_t^\top\right)S_{t-1} + \beta_tk_tv_t^\top

其中 (\alpha_t) 决定旧状态保留多少。

但一个标量门控意味着整个 Attention Head 中的所有特征都使用相同的遗忘速度。

KDA 将它进一步细化为向量：

\boldsymbol{\alpha}_t\in[0,1]^{d_k}

状态更新变成：

S_t = \left(I-\beta_tk_tk_t^\top\right) \operatorname{Diag}(\boldsymbol{\alpha}_t) S_{t-1} + \beta_tk_tv_t^\top

这里的关键变化不是公式多了一个对角矩阵，而是：

每个记忆通道都可以拥有自己的时间尺度。

某些维度可以长期保存主题和身份信息，某些维度可以快速跟踪最近动作，还有一些维度专门用于清除局部噪声。

这很像现代计算机系统中的多级缓存：

• 有些数据进入长期存储；
• 有些数据进入工作内存；
• 有些数据只存在于临时寄存器；
• 不同数据具有不同的淘汰策略。

因此，KDA 的门控并不是简单的“开或关”。

它更像一套由模型自己学习的记忆生命周期管理系统。

---

五、为什么 KDA 不需要像普通 Attention 那样显式保存位置

传统 Attention 本身并不知道 Token 的顺序。

如果不加入位置编码，模型看到：

A 在 B 前面

和：

B 在 A 前面

可能缺乏区分顺序的依据。

因此 Transformer 通常需要 RoPE 等位置编码。

KDA 的情况有所不同。

一条信息从第 (j) 个位置传播到第 (t) 个位置，需要连续经过中间所有状态转移：

A_tA_{t-1}\cdots A_{j+1}

其中：

A_i= \left(I-\beta_ik_ik_i^\top\right) \operatorname{Diag}(\boldsymbol{\alpha}_i)

距离越远，信息经历的衰减、覆盖和修正次数越多。

因此，KDA 天然包含三种信号：

• 信息出现的先后顺序；
• 信息距离当前 Token 的远近；
• 中间内容对这条记忆造成的影响。

它不是像 RoPE 那样直接给 Token 加上一个旋转角度，而是通过状态传播过程，让位置影响自然进入记忆。

可以把两者区别理解为：

• RoPE：显式告诉模型两个 Token 相距多远；
• KDA：让信息在传播过程中真实经历这段距离。

这也是为什么混合架构中的部分 MLA 层可以不再承担全部位置建模任务。

---

六、真正让 KDA 跑起来的不是公式，而是 WY 表示法

到这里，KDA 在数学上已经很漂亮。

但一个模型公式成立，并不意味着它在 GPU 上一定高效。

KDA 状态更新具有递归依赖：

S_t=A_tS_{t-1}+B_t

计算 (S_t) 之前，必须先获得 (S_{t-1})。

这意味着，如果严格按照公式逐 Token 执行，整个过程依然是串行的。

而 GPU 最不擅长的，恰好就是大量细碎、连续依赖的小型计算。

GPU 更喜欢的是：

• 大规模矩阵乘法；
• 规则的数据排列；
• 大批量并行任务；
• 可以交给 Tensor Core 的 GEMM。

所以线性复杂度并不自动等于高速度。

一个 (O(L)) 的算法，如果每一步都需要启动小 Kernel、读取状态、等待同步，最终完全可能跑不过经过高度优化的 (O(L^2)) Attention。

WY 表示法的价值，就是把递归公式重新翻译成 GPU 喜欢的语言。

---

1. 先把序列拆成 Chunk

假设将序列划分成长度为 (C) 的多个块：

[1,C],\quad[C+1,2C],\quad\ldots

执行方式由逐 Token 递归变成：

Chunk 之间传递状态，Chunk 内部批量并行。

也就是常说的：

\text{块间递归}+\text{块内并行}

Chunk 之间仍然有顺序关系，但一个 Chunk 内部的多个低秩更新可以被合并。

---

2. 把大量秩一更新压成矩阵运算

KDA 中频繁出现：

I-\beta_tk_tk_t^\top

其中 (k_tk_t^\top) 是秩一矩阵。

连续多个 Token 会形成大量类似变换的乘积。

WY 表示法能够把一系列低秩更新重新写成类似：

P=D-KW^\top

原本需要逐 Token 执行的操作，可以被整理成几个大矩阵之间的乘法。

于是状态更新可以从：

读取一个 Token
更新一次状态
等待完成
读取下一个 Token
再次更新

变成：

收集一个 Chunk
构造若干矩阵
执行大规模 GEMM
一次完成 Chunk 内的大量计算

这才真正利用了 GPU 的并行能力。

所以 WY 表示法并没有改变 KDA 学习什么，它改变的是 KDA 如何执行。

一句话概括：

Delta Rule 决定模型怎样记忆，WY 表示法决定这套记忆机制能不能高效运行。

这是很多大模型论文中最容易被忽略的部分。

一个架构最终能否落地，往往并不取决于公式是否优雅，而取决于公式能否被改写成：

• 少量大矩阵运算；
• 低通信开销；
• 规则的内存访问；
• 适合混合精度；
• 适合 Tensor Core。

---

七、为什么 Kimi 没有彻底抛弃传统 Attention

既然 KDA 可以压缩历史，为什么还要保留 MLA？

原因很简单：

压缩一定意味着信息损失。

KDA 把大量历史 Token 压进固定大小的状态矩阵。

无论门控和更新机制多么先进，固定维度的状态都不可能无损保存无限多条独立信息。

当大量相似 Key 被写入时，状态仍可能发生：

• 记忆碰撞；
• 旧信息覆盖；
• 精确字符串丢失；
• 远距离细节衰减；
• 多个相似实体相互干扰。

传统 Attention 虽然成本高，却拥有一种 KDA 很难完全替代的能力：

Query 可以直接访问某一个具体历史 Token。

因此 Kimi 采用的是分层混合，而不是非此即彼。

一种典型的组合方式是：

3\text{ 层 KDA}+1\text{ 层 MLA}

这套结构中的职责非常清晰。

KDA 负责：

• 大规模压缩历史；
• 保存近因和长期状态；
• 降低长上下文成本；
• 让大部分层不再依赖完整 KV Cache。

MLA 负责：

• 精确内容寻址；
• 恢复被压缩后的细节；
• 直接访问全局 Token；
• 处理需要精确复制和匹配的任务。

这就像一套计算机存储系统：

• KDA 类似经过压缩的高速工作内存；
• MLA 类似可以精确检索的长期存储索引。

真正成熟的架构通常不是只使用一种机制，而是让不同机制负责自己擅长的问题。

---

八、AttnRes 解决的不是上下文长度，而是“层越深，信息越乱”

KDA 解决的是 Token 序列方向的问题。

但模型变深后，还会出现另一类信息拥堵。

传统 Transformer 的残差结构近似为：

x_{l+1}=x_l+F_l(x_l)

随着层数增加，所有历史层的信息不断被累加进同一个残差流。

这种结构的优点是容易训练，梯度也更容易传播。

但它存在一个隐含问题：

后面的层只能接收已经混合完成的结果，无法重新选择某个早期层的表示。

可以把传统残差流想象成一个不断开会的会议室。

第 1 层说了一句话，第 2 层在上面补充，第 3 层继续补充。到了第 80 层，所有人的内容已经混成一大段会议纪要。

第 80 层无法直接说：

我现在只想重新听第 7 层和第 23 层的意见。

AttnRes 做的事情，就是让深层网络获得这种能力。

它把前面不同层的输出看成一组可检索的表示：

h_1,h_2,\ldots,h_{l-1}

当前层通过类似 Attention 的权重，选择自己需要的历史层：

h_l=\sum_{i<l}\alpha_{i\rightarrow l}h_i

其中：

\alpha_{i\rightarrow l} = \operatorname{Softmax} \left( q_l^\top k_i \right)

这相当于把“模型深度”也变成一个可检索空间。

传统残差是：

所有历史层默认相加。

AttnRes 是：

当前层主动判断，哪些历史层更重要。

这带来了一个非常有意思的对称关系：

• Attention 在 Token 维度选择信息；
• AttnRes 在网络深度维度选择信息。

所以 KDA 和 AttnRes 解决的是两个完全不同的方向：

\text{KDA：横向管理时间和上下文}

\text{AttnRes：纵向管理层级和表征}

这也是 K3 所谓重新设计 Transformer 扩展方式的核心之一。

模型变强，不一定只能增加层数，还可以提高不同层之间的信息利用效率。

---

九、2.8T 参数真正代表什么：容量很大，不代表每次全部工作

K3 的另一个核心是超稀疏 MoE。

MoE 最容易产生的误解是：

2.8T 参数就意味着每生成一个 Token 都要计算 2.8T 参数。

实际上，MoE 的设计恰恰是为了避免这件事。

K3 拥有大量专家，但每个 Token 只会被路由到少数专家。

可以把它想象成一家拥有数百个专业部门的公司。

当一个财务问题到来时，不需要所有部门同时参与，只需要调用：

• 财务专家；
• 表格专家；
• 合规专家；
• 少量共享专家。

因此 MoE 追求的是：

\text{总容量很大}

同时：

\text{单次激活规模可控}

这就是总参数量与激活参数量必须分开理解的原因。

---

1. MoE 节省的是计算，不一定节省显存

即使每个 Token 只激活少量专家，全部专家的权重通常仍然需要被部署到设备或集群中。

因此 MoE 面临三种不同成本：

计算成本

每次只计算少数专家，明显低于同规模 Dense 模型。

权重存储成本

大量专家权重仍然需要占据显存或内存。

通信成本

Token 需要被发送到专家所在的 GPU，完成计算后再把结果返回。

而第三项经常是实际部署中最麻烦的问题。

---

2. MoE 真正的瓶颈往往是 All-to-All 通信

假设不同专家部署在不同 GPU 上。

Router 为某个 Token 选择专家后，系统必须完成：

1. 将 Token 表示发送到目标 GPU；
2. 在目标专家上执行计算；
3. 将结果发送回来；
4. 按照路由权重重新合并。

如果一个批次中的 Token 被分散到大量专家，就会产生密集的跨卡通信。

因此，多张 GPU 能不能高效运行 MoE，不只取决于总显存够不够，还取决于：

• GPU 间带宽；
• 网络拓扑；
• All-to-All 实现；
• 专家放置策略；
• Token 路由是否均匀；
• 是否存在热点专家。

这也解释了为什么：

8 张 GPU 可以加载模型，不等于 8 张 GPU 就能提供理想的生产吞吐。

能够运行，至少包含四个不同层次：

1. 权重能够加载；
2. 前向计算可以完成；
3. 输出正确性可以验证；
4. 并发、吞吐、延迟达到生产要求。

前两项成立，不代表后两项也成立。

---

十、Stable LatentMoE 为什么要把专家计算放进更窄的空间

普通 MoE 中，Token 的完整隐藏状态会被发送到各个专家。

隐藏维度越大，跨 GPU 传输的数据量越大。

Stable LatentMoE 的一个关键思路，是将完整隐藏空间和专家处理空间分离。

可以理解为：

\text{完整隐藏状态} \rightarrow \text{压缩到 Latent 空间} \rightarrow \text{专家计算} \rightarrow \text{映射回完整空间}

这样一来，专家之间传输和计算的数据宽度可以更小。

它带来的价值不只是减少算力，还包括：

• 降低专家通信量；
• 降低专家权重访存；
• 提高专家数量可扩展性；
• 缓解超稀疏 MoE 的部署压力。

但专家越多、激活越稀疏，路由越容易不稳定。

例如，大量 Token 可能集中选择少数热门专家，导致：

• 某些 GPU 过载；
• 部分专家长期空闲；
• 通信拥堵；
• 吞吐下降；
• 专家专业化失败。

因此 MoE 系统还必须配套：

• 负载均衡；
• 路由约束；
• 激活值控制；
• 数值稳定机制；
• 专家容量管理。

K3 的价值不在于简单地把专家数量增加到 896，而在于试图让极高稀疏度仍然保持可训练、可路由和可执行。

---

十一、MXFP4 和 MXFP8：低精度不是后期压缩，而是训练阶段的共同设计

当模型达到万亿参数级别时，只靠稀疏激活仍然不够。

权重体积、显存带宽和通信量依然极其庞大。

这也是 MXFP4、MXFP8 和量化感知训练需要出现的原因。

可以粗略理解为：

• MXFP4：使用更低精度表示部分模型权重；
• MXFP8：使用相对更高精度处理部分激活或计算；
• 量化感知训练：在训练过程中让模型提前适应低精度误差。

很多人把量化理解成模型训练完成后的“压缩包”。

实际上，超大模型中的低精度设计更像建筑阶段就确定的材料标准。

如果先用高精度训练出模型，再粗暴压到 4 bit，可能出现：

• 权重分布被破坏；
• 离群值误差被放大；
• 专家路由发生偏移；
• 长序列状态误差不断累积；
• 输出质量明显下降。

量化感知训练的意义是：

模型在训练时就知道未来要在低精度环境中运行，并主动学会适应量化噪声。

这体现了 K3 非常典型的系统设计思想：

模型结构、训练精度、Kernel 和部署硬件不能分开设计。

真正能够大规模运行的模型，从来不是论文公式完成之后，再交给工程团队想办法部署。

它必须从一开始就考虑：

• 参数如何存储；
• 激活如何表示；
• 状态使用什么精度；
• 哪些运算保留高精度；
• 哪些矩阵可以交给低精度 Tensor Core；
• 误差会不会沿长序列持续累积。

---

十二、K3 最容易被低估的部分，其实是 Agent Harness

即使模型可以处理百万 Token，也不代表它就能连续完成数小时的工程任务。

这是理解 Agent 时最容易出现的误区：

上下文足够长，Agent 就不会失忆。

实际上，一个长程任务的状态远远不止聊天记录。

例如一个代码 Agent 正在开发系统，它的真实状态可能包括：

• 已经修改的文件；
• 当前 Git 分支；
• 安装过的依赖；
• 启动中的服务；
• 数据库结构；
• 编译缓存；
• 环境变量；
• 运行失败的日志；
• 已完成的测试；
• 尚未完成的任务计划。

这些信息并不全部存在于模型上下文中。

因此一个真正的 Agent 状态应该写成：

\text{Agent State} = \text{Model Context} + \text{Environment State}

模型上下文负责保存：

• 任务目标；
• 推理历史；
• 工具返回结果；
• 当前计划；
• 关键决策。

环境状态负责保存：

• 文件；
• 进程；
• 数据；
• 软件依赖；
• 工作目录；
• 服务和网络状态。

只保留前者，Agent 可能还记得自己要做什么，却发现文件和运行环境已经丢失。

只保留后者，环境虽然还在，模型却不知道之前为什么这样修改。

---

十三、为什么长程 Agent 必须有可恢复沙箱

当 Agent 只执行一次查询时，普通工具调用就够了。

但当 Agent 连续工作数小时，它一定会犯错。

例如：

• 删除错误文件；
• 安装冲突依赖；
• 修改错误配置；
• 启动失控进程；
• 执行危险命令；
• 把原本能运行的项目改坏。

如果系统没有检查点和恢复能力，一次错误就可能让整个长程任务前功尽弃。

因此真正的长程 Agent Harness 必须支持类似操作系统的能力：

Pause / Resume

模型思考或等待推理结果时，环境可以暂停，减少闲置资源。

Snapshot

在关键步骤保存文件系统和运行环境状态。

Rollback

当后续尝试失败时，回到最近的可靠状态。

Fork

复制当前环境，让评估程序在副本中运行测试，不污染原始工作空间。

Checkpoint

将长任务切分成多个可恢复阶段，而不是一次性赌完整条轨迹成功。

这时我们会发现，Agent 已经不再只是“大模型加几个 API”。

它实际上正在变成一个新的计算系统：

• 模型负责决策；
• Harness 负责编排；
• 工具负责行动；
• 沙箱负责隔离；
• Snapshot 负责恢复；
• 评估器负责判断结果是否正确。

K3 的长程能力不能只归因于模型参数。

没有相匹配的 Harness，即使拿到相同权重，真实任务表现也可能出现明显差异。

---

十四、把 K3 的所有组件放在一起，逻辑就清楚了

K3 并不是把一堆新技术简单堆在一起。

每个组件都在解决不同维度的信息爆炸问题。

维度	问题	对应机制
序列长度	历史 Token 太多	KDA
精确检索	压缩状态可能丢细节	MLA
网络深度	历史层输出被混合	AttnRes
参数容量	Dense 模型计算过高	Stable LatentMoE
权重体积	万亿参数难以存储和传输	MXFP4、MXFP8
任务时长	Agent 容易中断和失忆	长程训练与 Harness
环境连续性	工具执行会改变外部世界	Sandbox、Snapshot、Checkpoint

从这个角度看，K3 的架构主线可以被概括成四个词：

\text{压缩、选择、稀疏、恢复}

KDA 压缩序列历史。

AttnRes 选择历史层表示。

MoE 稀疏激活专家参数。

Harness 恢复长程任务状态。

这四个机制背后的思想高度一致：

不让所有信息、所有参数和所有计算无差别地参与，而是在每一步决定什么值得保留，什么应该调用，什么可以遗忘。

---

十五、K3 对企业做 Agent 的真正启示

企业通常很难直接训练一个 2.8T 模型，但 K3 的很多思想并不要求拥有万亿参数。

对于企业 Agent 平台，最值得借鉴的是下面几件事。

1. 不要把长上下文当成无限内存

上下文越长，噪声也越多。

企业 Agent 应当区分：

• 当前任务工作记忆；
• 历史对话；
• 长期用户记忆；
• 外部知识库；
• 文件和环境状态。

不是所有信息都应该直接塞进 Prompt。

2. 建立分层信息检索

可以参考 KDA 与 MLA 的组合思路：

• 高频、近期信息放在短期状态；
• 精确资料交给 RAG 和文件检索；
• 长期偏好进入持久化记忆；
• 环境变化通过工具实时读取。

3. Harness 比 Prompt 更重要

复杂 Agent 的稳定性主要取决于：

• 工具接口是否清晰；
• 状态是否结构化；
• 是否有超时和重试；
• 是否有任务检查点；
• 是否能判断工具执行成功；
• 是否支持失败恢复。

一个超长系统提示词无法替代这些工程能力。

4. 能执行不等于能交付

Agent 输出了一段代码，不代表任务完成。

真正的完成条件应该来自外部验证：

• 测试是否通过；
• 文件是否生成；
• 服务是否启动；
• 数据是否正确写入；
• 页面是否能够访问；
• 业务规则是否满足。

这也是长程 Agent 必须拥有评估器和验证闭环的原因。

---

十六、关于 K3 官方案例，需要区分三个证据层级

对于芯片设计、编译器构建、科研复现和长时间自主工作等案例，需要区分：

1. 官方技术报告或演示；
2. 第三方基准测试；
3. 社区独立端到端复现。

这三个层级不能混为一谈。

评价此类复杂案例时，应把官方演示、第三方基准与社区独立复现分开看待，避免把不同证据层级混为一谈。

同样，8 张 MI355X 能够完成模型加载和正确性验证，不等于已经证明该配置可以达到理想的企业生产吞吐。

具体的并发能力、Token 吞吐、延迟、功耗和长期运行稳定性，需要以实际部署测试为准。

---

写在最后

过去几年，大模型的发展经常被概括成一句话：

参数越大，能力越强。

Kimi K3 展示了另一种更值得关注的方向。

模型未来的竞争不只是比谁拥有更多参数，而是比谁更会管理参数、记忆和计算。

它需要知道：

• 哪些历史信息值得保留；
• 哪些旧映射应该被修正；
• 哪些中间层值得重新读取；
• 哪些专家应该被激活；
• 哪些计算可以使用低精度；
• 哪些任务状态必须被持久化；
• 哪些失败需要回滚并重新尝试。

因此，K3 最有价值的地方并不是 2.8T 这个数字。

它真正表达的是：

大模型正在从一个被动执行矩阵乘法的网络，逐渐变成一个能够主动分配记忆、路由能力、控制精度并管理任务状态的计算系统。

当模型开始学习如何管理自己的计算，扩展模型的方式也就不再只有“继续堆参数”这一条路。

这可能才是 Kimi K3 真正值得研究的地方。