Lin Ting

Interested in NLP, IR, RecSys, and ML E2E model implementation.

[yibie @yibie]

推荐这篇文章，Mem0 团队对 Agent Wiki 这个新兴品类做了一次全景综述。今年 4 月 Karpathy 在一个 Gist 里提出 LLM Wiki 模式之后，Cognition、Factory、LangChain、Garry Tan 四家各自独立实现了同一套架构。文章最值得读的是最后一部分——把 Wiki（语料知识）和 Memory（用户记忆）做了一次清晰切割：wiki 告诉你语料里有什么，memory 告诉你这个人是谁、做过什么决定。

!Article cover https://t.co/i1JubsHz6N

Agent Wiki 的现状

2026 年 4 月，Andrej Karpathy 发了一个 GitHub Gist，描述了一种他称之为 LLM Wiki 的模式。

此后几个月里，四个不同的团队在没有任何协调的情况下发布了同一个想法：Cognition 做了 DeepWiki，Factory 做了 AutoWiki，LangChain 开源了 OpenWiki，Garry Tan 开源了 GBrain。不同公司、不同用户、同一种架构。

一个 LLM 读取一批源材料，把它们编译成一套持续维护的 markdown 页面，并在源材料变化时更新这些页面。然后 agent 读取页面，而不是每次提问都从原始材料重新推导一切。

这种模式已经成了一个品类，基于它构建的系统越来越被简单地称为 agent wiki。这篇文章讲它到底是什么、每个团队构建了什么、它在哪里出问题，以及它反复被误解的那一件事。

核心理念：在写入时编译，不在查询时编译

先说问题，因为这个模式是直接冲着问题来的。

给模型提供知识体系的默认方式是检索。你上传文档，切块、做 embedding，查询时取出相关 chunk 然后回答。这能用，但有一个结构性的缺陷：什么都不会积累。每个问题都从原始 chunk 开始，模型一遍又一遍地重新推导出同样的理解，关于一个代码库的第十个问题并不比第一个更便宜或者更深入。

LLM Wiki 颠倒了"合成"发生的时刻。不是在查询时从原始碎片拼出知识，而是由一个 LLM 在写入时一次性把知识组装成持久的页面，然后维护它们。当有新源材料到达，模型读取它，更新受影响的实体页面，修订摘要，把与已有内容的矛盾标出来。

RAG 在每次提问时重新推导知识。Wiki 推导一次然后保持最新。两者都是合理的做法；区别在于你在什么时候支付合成成本，以及结果是否存活下来。

架构：始终是三层

原始来源是不可变的：文章、论文、仓库、数据。模型读取它们，永远不编辑它们。

Wiki 是 LLM 生成的 markdown，模型完全拥有：摘要、实体页面、概念页面、交叉引用。

Schema 是一个配置文件（CLAUDE.md、AGENTS.md 或类似的东西），告诉模型 wiki 怎么组织、跑什么工作流。这才是让它成为一个有纪律的维护者、而不是一个带文件访问权限的聊天机器人的东西。

三条操作运行在上面：写入一个来源，把它归档到它影响的所有页面；查询 wiki（以及可选地把好的回答归档成新页面，这样探索也会积累）；扫描，一次周期性遍历，寻找矛盾、过时的声明和孤儿页面。

它为什么管用：瓶颈从来不是写作

人类 wiki 会腐烂，原因很具体。最难的部分从来不是读源材料或拥有洞察。最难的是记录管理：更新交叉引用、保持摘要最新、把一份新文档和四十个已有页面对齐。这项工作是无限的、不体面的，也是繁忙团队最先放掉的事。于是 wiki 衰减，人们不再信任它，它就死了。

这恰恰是语言模型不介意的工作。它不会无聊、不会忘记更新一条交叉引用、可以一次触及十五个文件。LLM Wiki 之所以能运转，是因为它消除了维护成本——就是这项成本杀死了之前所有的 wiki。

这个想法比工具古老得多。Vannevar Bush 在 1945 年描述了 Memex：一个经过筛选的个人文档存储，文档之间有联想路径。Bush 没有解决的问题是：谁来维护这些路径。八十年后的答案是：模型。

这个名字从哪里来

Karpathy 的 Gist 值得直接读一下，因为它比大多数摘要更精确。他对于普通文档工作流的抱怨是："LLM 在每个问题上都从零开始重新发现知识。没有积累。"他的替代方案是编译而不是检索，这样"知识被编译一次然后保持当前，而不是在每次查询时重新推导"，产出的东西他称之为"一个持久的、会积累的造物"。

关键的是，你不需要写它。"你永远不（或很少）自己写 wiki，LLM 编写和维护它全部。"他自己的设置是一边是 agent，另一边是 Obsidian，看着页面实时更新："Obsidian 是 IDE；LLM 是程序员；wiki 是代码库。"

这个 Gist 在规模问题上也很具体，这是最值得传承的细节。不使用 embedding 的、以索引为先的方法"在中等规模下效果出奇地好（约 100 份源材料，约几百个页面），避免了基于 embedding 的 RAG 基础设施的需要。"超过这个规模，他建议添加搜索，特别是 qmd，描述为"一个针对 markdown 文件的本地搜索引擎，带有混合 BM25/向量搜索和 LLM 重排序。"

这读起来更像一个范围规则，而不是对检索的替代。在语料很小的时候跳过检索基础设施，等它变大再加回来。编译时合成和查询时合成坐落在一条光谱上，你最终落在哪里主要取决于你有多少材料。

工程问题是：这个模式在超越个人规模之后长什么样——过去几个月回答的就是这个问题。

实验室们真正构建了什么

这里开始，模式不再是一个想法，而是工程。各实现之间的差异才是最有用的部分。

Cognition：DeepWiki，作为公共基础设施的 wiki

Cognition 把这个模式指向了 GitHub 上的每一个公开仓库。在任何公开仓库的 URL 里把 https://t.co/3xHlU1nQfD 换成 https://t.co/4TUmh9gCPF，你就得到了一个生成的、可导航的代码库 wiki：架构概览、文件索引、依赖图和搜索，带回到源代码的链接。

两件事值得注意。规模是真实的：超过 5 万个顶级公开仓库已经被索引了，从 MCP 到 LangChain。而且 wiki 不是产品的终点——它是 agent 的检索基础设施。Devin 用 wiki 来在代码库中定位相关上下文，所以 DeepWiki 是让 Devin 的代码搜索更扎实的编译层。

Factory：AutoWiki，作为构建产物的文档

Factory 用 CI 的语言来框定同一个模式，他们的框定是这个品类里最锋利的一句话：文档应该是一个构建产物，而不是一个副项目。它从源代码构建，围绕代码库实际工作方式组织，在仓库变化时刷新。

生成方法是四家里工程化程度最明确的。AutoWiki 运行两轮分析：一轮对 README、包清单、CI 配置和入口点做结构性扫描，然后一轮对路由、API 端点、服务类、数据库 schema 和 feature flag 做更深的语义扫描。工作被拆分到专门的 agent 上，每个 agent 只负责仓库的一个方面，刚好有足够的上下文产出一页好的内容。这是对上下文问题的直接解决——单 agent 做文档生成在规模上平庸的原因就在这里。

时效性被当成基础设施而不是纪律来处理：/wiki 按需重新生成，/install-wiki 写一条 CI 工作流，在每次推送到默认分支时刷新 wiki。对 GitHub 仓库来说，它同步到仓库自己的 wiki tab 里。

LangChain：OpenWiki——从代码跃向一切

LangChain 开源了 OpenWiki，一个为代码库编写和维护 agent 文档的 CLI 工具，然后把它扩展为 OpenWiki Brains，有两种模式：Code Brain，原始的仓库用例；以及 Personal Brain，从你自己连接的数据源构建 wiki。

第二种模式是那个重要的跃迁。Personal Brain 从 Gmail、Notion、Git 仓库、X、Hacker News 和网页搜索读取数据，把它们合成为一个本地 markdown wiki，agent 去查询它。品类从"给我的仓库写文档"跳到了"编译我的整个工作生活"。

有一个设计细节值得注意，因为每个团队都汇聚到了这一点：输出不是面向人类的散文。它是面向 LLM 上下文优化的结构化 markdown，有标题、交叉引用和摘要，设计目标是让 agent 能快速找到相关上下文。wiki 是为真正会读它的那个读者写的，那个读者是一个模型。

GBrain：个人规模的、开源版本

Garry Tan 的 GBrain 把同样的形态应用到了个人知识库而不是代码库：Git 仓库里的 markdown、一个 schema 文件、一个自动维护的实体交叉链接图。它是模式"底层非常简单"的最清晰证明。不需要向量数据库、不需要服务，只是一个模型维护、人类能读的文件集合。

技术矩阵

按列往下读，收敛本身就是信号。四个团队、四种语料、一种架构：Git 里的 markdown、一个模型遵守的 schema 文件、在写入时合成、在变化时刷新、面向 agent 阅读而写的页面。当解决不同问题的独立团队落在同一个形态上时，这个形态通常是正确的。

差异在于时效性，这是成熟度的信号。Factory 把过时当成构建问题，在 CI 里解决。其他所有家都是按需刷新，这意味着它们的 wiki 的当前程度等于上一次有人记得运行命令的时间。

它的边界

这个模式确实好，所以需要诚实地说明它的局限。

规模。Karpathy 自己就说了：不用 embedding 的、以索引为先的方法是中等规模的技术，大约一百份源材料。超过几百页之后，你就回到了搜索引擎，这也是他自己的 Gist 推荐混合 BM25 和向量搜索的原因。

保真度。在写入时编译意味着，一个早期摘要可能悄悄丢失源材料中的某个细节，而后面的每一次回答都会继承这个丢失。针对原始 chunk 的检索没有这个失败模式。你是在用重新推导的成本换取压缩风险。

过期。一页编译过的内容只在最后一次刷新前是真的。这就是为什么 Factory 的 CI 框架比它最初看起来更重要：一个过时的 wiki 比没有 wiki 更糟，因为它用一种看起来权威的格式自信地犯错。

编译成本。你需要真金白银地付 token 来构建你可能永远不会查询的页面，并重新扫描那些什么也没变的页面。

Wiki 不是 Memory

有一点需要仔细画出来，因为这个领域的词汇表目前还很松散。

这些系统越来越被描述为 memory。LangChain 把 OpenWiki 称为 AI agent 的 wiki memory 层，围绕这个模式的普遍说法是"这就是你怎么给 agent memory"。这个词承载了太多分量，它盖住了两件相当不同的事。

一根术语下面有两条轴。

语料知识是 wiki 做的事：编译一组文档、或一个仓库、或你的 Gmail 归档说了什么。它回答的是"这份材料里包含什么"。

用户和体验记忆是另一条轴：一个具体的人偏好什么、他们上周做了什么决定、他们团队已经拒绝过哪种方案、一个 agent 昨天在另一个 app 里尝试了什么、结果如何。它按身份划定范围，不是按语料。它从交互中积累，不是从写入中积累。它需要处理矛盾、过期、来源追溯和按用户的删除。

wiki 在第一件事上极其出色，并且不试图做第二件事。把你的 Gmail 编译成页面，告诉 agent 你的 Gmail 里有什么。它不会告诉 agent 你在上周二的一次谈话里改了主意、关于那个供应商的决定，或者某种建议方案已经失败过一次了。

第二条轴是像 Mem0 这样的专用 memory 层要做的事：memory 标记到 user_id，跨会话、跨 app、跨 agent 跟随一个人，当事实变化时原地更新，而不是永远追加。这两者是互补的。错误不在于选择了 wiki。错误在于认为因为你编译了一份语料，你就解决了 memory 问题。

收获

LLM Wiki 是一个真实的模式，背后有一个真实的洞见：知识应该被编译一次然后维护，而不是在每次提问时重新推导。而杀死人类 wiki 的维护工作，恰恰是模型免费完成的劳动。四个团队在几个月里交付了同一套架构，这是它正确的最强证据。

从这里带走三件事。当语料稳定且被反复阅读时，把你的文档编译成维护中的页面。当它超越个人规模时，添加真正的检索——原始提案也这样建议。以及，保持"编译语料"和"记住用户"的区别，因为 wiki 给你第一件，给不了第二件。那已经很值了，但那不是同一件事。

https://t.co/iZatEoDhq7
#AgentWiki #上下文工程 #AgentMemory

[Songlin Yang @SonglinYang4]

hybrid linear attn is scalable!!

[徐伦 @Jolyne_AI]

加州大学开放课程《大语言模型的强化学习》，用“理论 + 实战”的方式，把 AI 训练的关键技术从零到一讲透，帮你系统建立从强化学习到 LLM 训练的完整框架。

课程内容覆盖全面，配套资源齐全：讲座幻灯片、完整视频、实践练习一应俱全，学完就能上手做。

课程地址：https://t.co/W0l8b4f7Pi

你将学到：

- 深度强化学习核心：MDP、策略梯度、A3C、PPO 等关键算法
- 大语言模型基础：NLP、语言建模、RNN 等入门与脉络
- RLHF 全流程拆解：基于人类反馈的训练方法与落地思路
- 可验证奖励强化学习：面向更安全、更可靠的训练范式
- 动手实践：Jupyter 代码示例 + 课后作业，边学边练

课程由 UCLA 数学系助理教授主讲，YouTube 提供全套视频，内容扎实，适合想把“RL + LLM 训练”真正学明白的人。

[徐伦 @Jolyne_AI]

想系统学数学，教材、视频、题库遍地都是；真正靠谱的优质资源却零散难寻，光筛选就能耗掉大把时间。

我在 GitHub 上挖到一份很省心的清单：Awesome Math——把高质量数学资源按学科体系整理好的一站式索引，已拿下 14k+ stars。

它覆盖代数、几何、分析、概率统计、数论等 30+ 领域，把入口统一收拢；形式也齐全：视频课、电子教材、练习工具都有，甚至还能找到 MIT、哈佛等名校学生的课程笔记。

GitHub：https://t.co/vEo6jaNILw

资源经过筛选并持续更新；如果你打算自学数学，这份清单值得直接收藏。

[0xNullPath @luyanfcp]

国内的线性代数教学实在是太烂了，尤其再配上同济的烂书。印象中读书的时候完全是看3b1b的视频再加上Linear Algebra Done Right 这本书学会的。

[徐伦 @Jolyne_AI]

GitHub 开源 CUDA 系统教程：LeetCUDA（从入门到进阶，一站打通）

200+ 个循序渐进的 CUDA Kernel 实战题，配套 HGEMM 库性能可达 cuBLAS 的 98%～100%。另有 100+ 篇高性能计算技术博客，专讲关键技巧与优化方法，帮你从“能写”进阶到“写得又快又稳”。

GitHub： https://t.co/7NPsVWuRf1

面向初学者精心设计，结合 PyTorch 梳理清晰路线：写对 → 写快 → 逼近库级性能。

适合系统掌握 CUDA 的开发者，也适合作为大模型推理优化的 AI 工程师参考与进阶路径。

[Abhimanyu Shekhawat @abshekha]

https://t.co/qhUI7YlSmk
Link to the Talk.

[黄赟 @huangyun_122]

前两天，有水友告诉我，他的3人小队接 GEO 项目已经稳稳躺过月入 6位数，没想到姚老板这，把全套底层资料开源了

[Dwarkesh Patel @dwarkesh_sp]

What does the next training paradigm look like?

0:00:00 – The big research bet the labs are making
0:02:12 – Grindability is just as important as verifiability
0:06:10 – Will RLVR alone generalize?
0:08:41 – Getting the learning back to the weights
0:15:22 – Dreaming
0:17:23 – What 2027 looks like

Also on YouTube, pod feed, and Substack.

[Avi Chawla @_avichawla]

A tricky LLM interview question:

You're serving a reasoning model on vLLM, and it keeps running out of GPU memory on long traces.

So you add KV cache compression and evict 90% of the cached tokens.

VRAM usage stays as is and GPU still runs out of memory.

Why?

(answer below)

Evicting 90% of the KV cache can free almost none of the memory it was using.

This sounds counterintuitive, but it follows directly from how production servers store the cache today.

The KV cache grows with every token a model generates. Each token appends its key and value vectors across every layer, and nothing is freed while generation continues.

This is the dominant memory cost for reasoning models.

If a 32K-token CoT caches ~32K tokens of KV vectors, a Qwen3-32B with 4-bit weights will run out-of-memory around 24K tokens on a 24GB GPU.

One obvious solution is to keep the important tokens and drop the rest, since attention is sparse enough to allow it.

But this does not solve the memory problem yet.

The reason is paged attention, which is the memory manager behind vLLM and most production servers.

Under the hood, it splits GPU memory into fixed physical blocks, each one holds the KV for about 16 tokens.

This block returns to the allocator only when every slot inside it is empty.

Since the eviction logic selects tokens by importance, and such tokens are scattered across blocks...

...so despite eviction, almost every block is left with at least some survivor tokens.

For instance, if the logic evicts 14k of 16k tokens across 1,000 blocks, most likely every block will still have a token.

This means the allocator frees almost nothing.

Placing the new tokens into those freed slots is not ideal because it breaks the cache's layout.

Say token 16,001 arrives, and it's placed in the slot the 40th token used to hold. The cache now reads position 38, then 16,001, then 41, so the cache is no longer in token order.

Attention can still compute the right answer from that, but only if every slot now carries a separate note recording which position it actually holds.

This introduces another bookkeeping cost that an in-order layout inherently avoids.

So the cache is logically 90% smaller and still physically the same size. Many compression results miss this because they measure on pre-allocated contiguous tensors rather than a paged server.

There's another problem.

Eviction methods pick which tokens to keep by looking at the attention scores themselves (as expected).

But fast attention kernels used in production, like FlashAttention, never save those scores.

They compute attention in small pieces and throw the full score grid away as they go, which is also why they're fast.

So the exact signal eviction methods need isn't available in memory. The workaround is to fall back to eager attention and build the full matrix, which gives up the speed FlashAttention was there to provide.

NVIDIA published a method called TriAttention to solve both these problems.

It never needs attention scores. Instead, it scores tokens from the geometry of the model's key and query vectors before RoPE is applied, where those vectors sit in stable clusters.

For the memory problem, it runs a compaction pass every 128 decoded tokens.

The surviving tokens slide forward to close the holes eviction creates, so whole blocks empty out and return to the allocator while the cache stays in token order.

On long reasoning traces, the approach matches full-attention accuracy while decoding 2.5x faster and using 10.7x less KV memory.

KV cache compression is a big infrastructure problem. The number that decides whether it works is the count of freed blocks, not the count of evicted tokens.

You can find the NVIDIA write-up here: https://t.co/ZwXv7VezVu

I wrote a first-principles breakdown of how the KV cache works. It walks through why the model stores keys and values at all, why the cache grows with every token, and a comparison of LLM generation speed with and without KV caching.

Read it below.

[Ornith @ornith_]

Aloha! 🌺 Meet Ornith-1.0, a family of open-source LLMs specialized for agentic coding.

Ornith-1.0 spans the full parameter sizes including 9B Dense, 31B Dense, 35B MoE, and 397B MoE. It achieves state-of-the-art performance among open-source models of comparable size on coding benchmarks including:
✅Terminal-Bench 2.1(77.5)
✅SWE-Bench(82.4 on verified, 62.2 on pro, 78.9 on Multilingual)
✅NL2Repo(48.2)
✅SWE Atlas(41.2 on QnA, 42.6 RF, 39.1 TW)
✅ClawEval(77.1)

Post-trained on top of gemma4 and qwen3.5, Ornith-1.0 employs a novel self-improving training strategy in which reinforcement learning is used to generate not only solution rollouts, but also the task-specific scaffolds that drive those rollouts. By jointly optimizing the scaffold and the resulting solution, the model generate higher-quality solutions in agentic coding.😎

All models are released under the MIT license, enabling full commercial and research use.

📖Tech Blog: https://t.co/qT9N2HYWFn
🤗Huggingface: https://t.co/PRrwqjeBtM

[陈成 @chenchengpro]

给 LLM Agent 堆越花哨的"记忆"架构，效果不一定越好。一篇新论文实测了 12 个记忆系统，没有通用赢家。

它把 Agent 记忆当成数据库来拆——表示与存储、抽取、检索与路由、维护四个模块，拉来 Mem0、Letta、Zep、Cognee、MemOS、MemTree、A-MEM、LightMem 等 12 个系统，外加 Long Context 和 Embedding RAG 两个基线，跑 5 类负载、11 个数据集。

几个反直觉的点：

1）在数据库操作类任务 DB-Bench 上，裸的 Long Context（48.20 EM）和最朴素的 MemoChat 反而赢过一众精致记忆系统。强记忆看的是它对主导瓶颈的对齐程度，而不是用了多花哨的表示。

2）检索的关键是怎么组织证据供后续重建，而不是把最相关那条排第一。证据拉远时图/层级结构碾压扁平：A-MEM Recall@10 达 85.9，而 Embedding RAG 的 Answer-F1 从 37.1 断崖跌到 7.4。

3）成本由"维护范围"而非"结构本身"决定，局部维护远胜全局重组。LongBench 上 LightMem 稳在 17.3 秒，而做全局协调的 Mem0/MemoChat/MemoryOS/A-MEM 飙到 374~552 秒，20~30 倍延迟差。

4）别急着压缩：保留原文胜过摘要，压一压 Substring-EM 就从 26.0 掉到 10.7；抽取要保上下文（MemOS Fast 25.5 EM vs Fine 2.5）；维护要保守整合，激进的延迟刷新反而把分数拉低。

还有个普遍毛病叫"过去的幻觉"：事实更新后系统照样返回旧值。所以论文标题才会问，我们真的准备好迎接 Agent 原生的记忆系统了吗。

https://t.co/T6hYrIp9Xg

[Aixin Sun @AixinSG]

We are pleased to invite submissions to SIGIR-AP 2026, the 4th ACM SIGIR Conference on Information Retrieval in the Asia Pacific, which will be held in Singapore, 13–15 December 2026. The conference will be organized in a hybrid format, supporting both in-person and remote participation. #SIGIRAP2026 #InformationRetrieval #RecommenderSystems #LLM #GenerativeAI #Search #NLP #MachineLearning

[Lin Ting @LinTing_SG]

@ai_super_niko 这不是遗传算吗？

[Niko爱学习 @ai_super_niko]

Google DeepMind 刚刚发布了一篇长达 44 页 的论文，介绍了一种能够循环重写自身代码的 AI 系统。整个流程为：
采样（sample）→ 变异（mutate）→ 运行（run）→ 评分（score）→ 保留最佳（keep the best）→ 重复（repeat）研究人员将这个系统应用于一个自 1969 年 以来一直悬而未决的数学问题，成功打破了 Strassen 算法 的纪录。随后，这个相同的循环还被用于加速 Gemini 背后的训练内核，让模型能够优化自己的训练过程。
不过针对不同的开发需求和背景，你真的需要 loop 吗？

[Phoenix Yin @Phoenixyin13]

我认为这是ICML 2026里的上乘工作。

传统 Transformer 的 Attention 机制，本质上是点对点匹配，把输入切成一堆 token，即离散点，然后算 Query 和 Key 的相似度，再加权 Value。

这在 NLP、图像上很管用，但对连续函数、场，比如物理模拟中的 PDE 偏微分方程、3D 几何、流体、材料力学等来说，就有严重的问题：

1. 连续的东西被强行离散化成 token，忽略了全局函数结构。
2. 对分辨率敏感，换个采样率就容易崩
3. 计算是 O(n²)，n 很大时很贵。

所以，Functional Attention应运而生。

这次，FuncAttn 把函数本身当成第一公民，不再用 softmax 算点对点相似度，而是用 结构化的线性算子，来建模两个函数空间之间的函数对应关系。

它的灵感，来自几何处理里的 Functional Maps，把复杂 3D 形状对应问题变成简单线性算子，实为巧妙。

结果是更紧凑（k×k 算子，k << n）、分辨率不变，捕捉全局依赖更好、在 PDE 求解、3D 分割、回归等任务上达到或超过 SOTA，还在 OOD泛化上表现突出。

未来，Functional Attention对 AI 应用的实际用处很大，尤其在科学计算 + AI和需要处理连续、物理世界数据的场景中。

它会成为Neural Operator与科学 AI 领域的强力升级组件。

这篇论文，会让 AI 向擅长连续物理世界迈进一大步。对科研加速、工程模拟、具身 AI、BCI 等前沿应用极度有价值。

这正是我认知神经愿景的核心基础设施之一。

[Tianqi Chen @tqchenml]

We taught a brand-new mini-series this year at @SCSatCMU on Modern GPU Programming for ML Systems, as part of the ML Systems course, touching on fun questions like what data layout swizzling is, how to use 3D TMA, and state-of-the-art Blackwell programming. We released a curated online book based on the materials: https://t.co/5ZJg2lySNO check it out

[William Chen @solidwillity]

Inference engineering at its finest

[Xudong Han @Xudong07452910]

小米最近发表的这篇论文很适合所有在为 Agent 性能头疼、但不想每次都去换模型的工程师看，harness 工程值得你认真投入。

核心观点：LLM Agent 的性能，几乎有一半的决定权在那层「运行外壳」里，例如提示词、工具描述、记忆接入方式、控制流设计，而不只是底层模型的能力。HarnessX 把这层外壳变成了一个可以像乐高一样组合、并且能自动进化的系统。

具体来说：HarnessX 用「替换代数」定义运行外壳的基本构件，让 harness 的各个组件可以被系统化地替换和组合。然后用一个叫 AEGIS 的多 Agent 进化引擎，自动分析 Agent 运行轨迹，找出哪个组件拖了后腿，提出改进，在不碰底层模型的前提下迭代优化整个外壳系统。在 ALFWorld、GAIA、WebShop、tau³-Bench、SWE-bench Verified 五个基准测试上，平均提升 14.5%，最高单项提升 44.0%。

我觉得「不改模型、只改外壳，就能在五项 benchmark 平均提升 14.5%」这个数字本身最值得反复想。很多团队在用 Agent 时，遇到性能问题的第一反应是「模型不够强」；但 HarnessX 说的是：你可能还没有用完现有模型在正确外壳设计下的潜力。更重要的是：外壳是工程问题，是可以迭代、可以模块化、可以系统优化的，AEGIS 把这件事变成了一个可以跑起来的自动化流程。

以前我们关注 Agent 用什么模型，以后可能更要关注 Agent 的运行外壳设计得有多好，这一层可能才是真正决定 Agent 系统上限的地方。

https://t.co/skaWRB7izY

[Z.ai @Zai_org]

Introducing GLM-5.2: Frontier Intelligence, Open Weights

- Significant improvements in coding and agentic tasks
- Strong long-horizon capabilities with a 1M context window
- Two levels of reasoning effort: GLM-5.2 (max) pushes the limits, while GLM-5.2 (high) strikes a strong balance between performance and token efficiency
- MIT-licensed open weights
- Same API pricing as GLM-5.1

Tech Blog: https://t.co/LAsxUdN0JZ
Weights: https://t.co/g0A1C4UWx4
API: https://t.co/Kc3E22cbN7
Coding Plan: https://t.co/Nk8Y98HNhU
Chat: https://t.co/WCqWT0qCQb