铃阅时讯
❌

普通视图

从多模态大模型中「拆」出音频向量模型

2026年3月12日 15:03

原创 Jina AI 2026-03-12 15:03 新加坡

把任意多模态大模型变成小型音频向量模型

Google 最近发了 Gemini Embedding 2,他们第一个原生多模态向量模型。文本、图像、视频、音频、文档,全部映射到同一个 3072 维向量空间。这是 Omni Embedding(全模态向量模型)的大趋势:一个架构吃下所有模态,从 jina-embeddings-v4 到 Omni-Embed-Nemotron 再到 Omni-5,大家都在往这个方向收敛。

去年 EMNLP BoF 上我讲过:Omni 模型是 2026 年 Dense Retrieval 的关键方向之一。
去年 EMNLP BoF 上我讲过:Omni 模型是 2026 年 Dense Retrieval 的胜负手。

真正引起我们注意的是音频。大多数人听到多模态 Embedding 首先想到的是图像,顶多再加个视频。音频是被遗忘的模态:数据难采、标注难做、做的人少。

过去一段时间,我们 Jina AI 团队恰好在啃这块硬骨头:如何在 1.2B 规模内做出高性能的音频向量模型?这也是我们通向全模态愿景的关键一步。

趁着 Gemini Embedding 2 发布的节点,把我们一路上踩的坑和学到的东西分享给大家。

音频向量是什么

音频向量就是把一段音频压成一个定长向量。输入原始波形,模型输出一个稠密向量(通常 768 到 3072 维),编码了这段声音的语义内容。语义相似的两段音频,向量也相近;一段音频和它的文本描述,在共享向量空间中距离很短。这是 Omni Embedding 拼图里的一块:一旦音频能和文本、图像映射到同一个向量空间,跨模态检索就打通了。

2022 年以来的主流方案是 Contrastive Language-Audio Pretraining(CLAP),本质上就是把 CLIP 搬到音频域。思路很直接:一个音频编码器,一个文本编码器,中间用对比学习拉近配对的音频-文本、推远不配对的。LAION-CLAP 在这个基础上用 630K 对数据加 Feature Fusion 做了放大。当前最强变体(Elizalde et al., 2023)在 4.6M 对数据上训练,音频编码器横跨 22 种音频任务,配合自回归解码器,250M 参数量在 AudioCaps 上做到 42.0 cvR@5。

CLAP 的问题在哪?它从零开始学习音频和文本之间的对齐。这意味着你需要海量的配对数据去建立跨模态桥梁,460 万数据对不是白烧的。

我们走了一条完全不同的路:把已经听懂音频的多模态 LLM,直接改造成 Embedding 模型。 桥梁已经在预训练中建好了,我们要做的只是把它从生成模型重塑为向量模型。

模型架构

先说输入输出。输入是原始音频波形,从 WAV/MP3/FLAC 解码后重采样到 16kHz 单声道。音频编码器先转成 128-bin log-mel 频谱图,再处理成特征 token 序列,大约每秒 150 个 token。一段 10 秒音频约 1500 token。最大输入 30 秒,更长的需要切片。输出是单个稠密向量,维度在 896 到 3584 之间,取决于 LLM backbone 的规模。

起点是 Qwen2.5-Omni,一个原生音频理解的多模态 LLM。三个组件:

  • 音频编码器(约 0.6-0.8B 参数):把波形转成特征向量,中间有一个约 4.5M 参数的线性投影层。这个投影层虽小,却至关重要,它是音频特征空间到 LLM 表示空间的桥梁,负责把音频编码器输出的特征维度对齐到 LLM 的输入维度。

  • LLM backbone(0.5-7B 参数):每个 Transformer 层约 0.2B 参数,同时处理音频特征和文本 token。

  • 池化层:对最后一层 hidden state 做 mean pooling,输出最终向量。

两个模态共享同一个 LLM backbone。这不是我们做的对齐,是 Qwen2.5-Omni 在预训练时就建立的。音频特征和文本 token 经过同一堆 Transformer 层处理,在表示空间里天然就有一定程度的对齐。我们要做的是把这种隐式对齐显式化为一个向量模型。

架构对比
架构对比

左边是标准做法,端到端微调整个 MLLM(3-7B 参数)。右边是我们的模块化组合做法,把预训练音频编码器接到一个更小的 LLM backbone 上。共享 backbone 同时处理音频特征和文本 token,在同一个向量空间中生成 Embedding。

训练目标是 InfoNCE 对比损失。两个模态各自独立编码,双向计算 loss 后取平均:

deftraining_step(audio_batch, text_batch):
    audio_embeds = model.encode_audio(audio_batch)  # [B, D]
    text_embeds = model.encode_text(text_batch)      # [B, D]
    audio_embeds = F.normalize(audio_embeds, dim=-1)
    text_embeds = F.normalize(text_embeds, dim=-1)
    sim = audio_embeds @ text_embeds.T / temperature  # [B, B]
    labels = torch.arange(len(sim), device=sim.device)
    loss = (F.cross_entropy(sim, labels) +
            F.cross_entropy(sim.T, labels)) / 2
return loss

训练数据

五个音频-文本配对数据集,共 181K 样本:

数据集

样本量

说明

AudioSetStrong

108K

时序标注事件,GPT 生成字幕(AudioSet 子集)

FSD50K

41K

人工标注声音事件,200 类

Clotho

19K

音频字幕,详细描述

UrbanSound8K

9K

城市声音分类

MACS

4K

城市声学场景

CLAP 用了完整 AudioSet(200 万+音频)加上其他来源,总计 460 万对。我们只用了 AudioSetStrong 约 10 万条,数据量差了 25 倍。

为什么能少这么多?因为 CLAP 需要从零建立跨模态对齐,460 万对数据大部分精力花在教模型"什么声音对应什么文字"。而我们的起点是一个已经听懂音频的 MLLM,跨模态的桥已经造好了,训练只需要把这座桥从"生成"重新校准到"向量检索"。这是一个 fine-grained calibration,不是 from-scratch alignment。

defload_sample(audio_path, caption):
    waveform, sr = torchaudio.load(audio_path)
    waveform = torchaudio.transforms.Resample(sr, 16000)(waveform)
    audio_inputs = processor.feature_extractor(
        waveform, sampling_rate=16000, return_tensors="pt"
    )
    text_inputs = processor.tokenizer(caption, padding=True, return_tensors="pt")
return audio_inputs, text_inputs

四条路,三条半死胡同

我们的目标很明确:参数量压到 1.2B 以下,性能超过 CLAP。我们试了四种做法,前三种各有各的问题,在第四种拿到了结果,但过程本身比结果更有价值。

路径一:全模型微调

Qwen2.5-Omni-7B 直接在音频-文本对上做对比学习微调,结果不出意外地好:AudioCaps T2A cvR@5 = 63.2,Clotho T2A = 39.2。这个分数远超 CLAP 的 42.0,证明了思路本身是对的。但 7B 参数量摆在那里,推理成本和延迟都不现实。这条路的价值是给后面所有实验画了一条上限。

值得对比的是其他团队的类似尝试:Tevatron 2.0 也做全模型微调,但只用 AudioCaps 一个数据集,AudioCaps 上拿了 61.2,Clotho 上暴跌到 11.9。单数据集训练在分布内表现好看,出了分布立刻垮掉,这是向量模型老生常谈的问题了。还有 ColQwen-Omni,在视觉文档任务上微调、零音频数据,纯靠跨模态迁移拿到了 37.4。逼近 CLAP 但没超过。零数据能做到这一步,本身也说明 MLLM 的跨模态对齐的能力。

路径二:层剪枝

既然 7B 太大,能不能直接砍层?每个 Transformer 层约 0.2B 参数,从 28 层砍到 10 层就剩 3.5B,砍到 5 层剩 2.3B。

随 Transformer 层数减少的性能变化。
随 Transformer 层数减少的性能变化。

AudioCaps(红线)从 20 层的 63.2 降到 5 层的 56.0 cvR@5。所有配置仍然高于 CLAP baseline(虚线)。但即使砍到 5 层(2.3B 参数),离 1B 目标差了一倍多。

层数

参数量

AudioCaps T2A cvR@5

Clotho T2A cvR@5

20

5.8B

63.2

39.2

10

3.5B

58.2

36.5

5

2.3B

56.0

36.0

性能下降是平滑的,说明信息在各层间分布比较均匀,没有哪几层是可以无痛摘掉的。

另外一个有意思的观察是 Batch size(32、64、128)几乎没有影响最终性能。大 batch 在训练初期有优势,但后期可能过拟合负样本分布,batch 128 在 2K 步时 Clotho NDCG 打到 31.3,到 10K 步反而掉到 29.3。这说明在数据量有限的情况下,大 batch 带来的 hard negative 数量优势敌不过分布偏移的风险。

层剪枝的根本限制是:音频编码器本身就有 0.6-0.8B,加上投影层和 Embedding 层的固定开销,即使 LLM backbone 砍到零,模型也至少 1B 起步。此路不通。

路径三:纯文本模态迁移

这个思路更激进:完全不用任何音频-文本配对数据,只用纯文本 NLI 数据集(MultiNLI、SNLI、FEVER、SciFact)做微调。逻辑是这样的,MLLM 预训练时已经建立了音频和文本的对齐,那我只训练文本侧的向量质量,音频侧应该能搭上便车。

在完整 7B 上,这个赌注居然赢了:AudioCaps 46.1,超过了 CLAP 的 42.0。零音频训练数据,纯靠文本 NLI 就能做出一个比 CLAP 更好的音频向量模型,这本身就很说明问题,MLLM 预训练建立的跨模态对齐做得很深,不是表面功夫。

但在剪枝后的 10 层模型上,同样的做法直接塌了:cvR@5 = 5.9,几乎等于随机。

这里的 insight 很重要:跨模态对齐不是一个集中存储在某几层的对齐模块,而是分布在整个网络的每一层中。28 层的完整网络里,每一层都参与了音频和文本表示的渐进对齐。你砍掉大部分层,对齐就碎了。文本侧靠 NLI 数据还能补回来,但音频侧没有任何数据兜底,直接归零。

这条路教会我们的是:模态迁移的可行性和模型压缩的可行性是矛盾的。你不能同时既要又要。

路径四:模块组合

前三条路的共同问题是都从同一个 7B 模型出发往小了做。路径四我们换了一个思路:不从大模型上减,从小组件上加。 从一个模型里摘出音频编码器,从另一个模型里拿一个小 LLM backbone,拼在一起,甚至可以跨模型家族拼装。

为什么这也能行呢? 因为 Qwen2.5-Omni 的训练分了三阶段:1. 冻结 LLM,只训练音频/视觉编码器的投影层;2. 全参数解冻联合训练;3. 扩展到 32K 上下文。

关键在于第一阶段,音频编码器学会了如何把波形转成 LLM 能读懂的 token。这种说 LLM 语言的能力是通用的,不绑定某一个特定的 LLM。所以我们大胆假设:一个在第一阶段训练好的音频编码器,应该能直接插到任何 Qwen 系列的小 LLM 上。

我们测试了四种组合:

配置

音频编码器

LLM

参数量

M1

Qwen3-Omni(0.6B,stage-1 之前)

Qwen2.5-0.5B

1.1B

M2

Qwen3-Omni(0.6B,stage-1 之前)

Qwen2.5-3B

3.6B

M3

Qwen2.5-Omni-3B(0.8B,stage-3 之后)

Qwen2.5-3B

3.8B

M4

Qwen2.5-Omni-3B(完整)

完整 3B

3.8B

实现细节上有个坑,Qwen3-Omni 用的是 Qwen3OmniMoePreTrainedModel,standalone Qwen3 用的是 Qwen3ForCausalLM,两者的模型壳子不一样。我们的做法是初始化一个维度匹配的 Omni 模型壳子,然后把权重拷贝到对应位置。

各配置在 AudioCaps 和 Clotho T2A cvR@5 上的表现
各配置在 AudioCaps 和 Clotho T2A cvR@5 上的表现

用 stage-3 之后对齐更好的音频编码器效果更好(M3 vs M2:AudioCaps +4.2)。LLM 预训练的 stage 2-3 对 Embedding 质量影响不大(M3 vs M4 在误差范围内)。

结果里有三个发现:

第一,M1(1.1B)在 AudioCaps 上就打到了 49.7,超过 CLAP 的 42.0 整整 18%。 我们目标达成:参数量 1.1B,低于 1.2B 的目标线,性能大幅领先 CLAP,并且只用了 CLAP 1/25 的训练数据。

第二,音频编码器的对齐质量决定上限。 M3 用的是第三阶段之后完整训练过的音频编码器,M2 用的是 stage-1 之前的初始版本,两者 LLM backbone 相同(Qwen2.5-3B),但 M3 在 AudioCaps 上比 M2 高了 4.2 个点。这说明音频编码器在多阶段训练中获得的对齐精度直接传导到了最终的 Embedding 质量。

第三,LLM 的 stage 2-3 训练对 Embedding 质量几乎没有影响。 M3(拼装的 LLM)和 M4(原装完整 3B)的性能在误差范围内。这也意味着 LLM backbone 在 stage 2-3 学到的那些能力:更好的指令跟随、更长的上下文处理,对向量化任务没有贡献。向量模型需要的是表示能力,不是生成能力。

评测

音频 Embedding 的评测本质上就是看检索质量:给一段文本 query,能不能找到对的音频?

难点在于对的定义因数据集而异。

AudioCaps 的描述很具象("一个男人说话,然后门关上了"),这种描述和声学特征是一一对应的,模型只要记住声学 pattern 就能得分。

而 Clotho 的描述更抽象("安静的氛围中远处有隆隆声")。这需要模型理解场景级别的语义,而不只是频谱特征。一个只记住表面声学特征的模型在 AudioCaps 上跑分好看,到 Clotho 上就原形毕露。我们最看重的是跨描述风格的泛化能力,这才能反映模型真正理解了什么。

CV-Recall@5(cvR@5):对每个文本 query,看 top-5 结果中是否命中正确音频。二值打分,所有 query 取平均。这是 MTEB 音频检索的标准 metric。

defevaluate_cvr_at_k(model, dataset, k=5):
    audio_embeds = model.encode_audio(dataset.audio_clips)
    text_embeds = model.encode_text(dataset.text_queries)
    sim = F.normalize(audio_embeds) @ F.normalize(text_embeds).T
    hits = 0
for i in range(len(dataset.text_queries)):
        top_k = sim[:, i].argsort(descending=True)[:k]
if dataset.ground_truth[i] in top_k:
            hits += 1
return hits / len(dataset.text_queries)

三个评测集均来自 MTEB:AudioCaps(视频衍生,人工字幕)、AudioSetStrong(时序标注,GPT 描述)、Clotho(多样化,抽象字幕)。CLAP 用了完整 AudioSet(200 万+),我们只用了 AudioSetStrong 约 10 万条,这在一定程度上解释了 CLAP 在该 benchmark 上的优势。

所有配置在 AudioCaps、AudioSetStrong、Clotho T2A 检索上的横向对比
所有配置在 AudioCaps、AudioSetStrong、Clotho T2A 检索上的横向对比

红色虚线为 CLAP baseline。模块组合方案(绿色)以远远更小的模型尺寸取得了有强竞争力的结果。全量微调的 7B 模型(深蓝)是性能上限。

应用场景

传统的音频检索里,输入文字找音效当然是最直接的场景。但更值得关注的是音频 Embedding 在 Agentic 系统中的角色。当语音成为 Agent 的主要输入方式时,第一步往往是 ASR 转文字再处理。但 ASR 有延迟、会丢失语气语调信息、还依赖转写质量。如果 Agent 能直接对语音输入做向量化,根据语义相似度分发到正确的工具或子 Agent,就跳过了 ASR 这个瓶颈。不是所有语音输入都需要逐字转写,很多时候你只需要知道"这段话的意图是什么"。

工业场景里的声音事件分类也是一个被低估的方向。设备异响检测、安防系统、智能家居,这些场景需要的不是转写,而是"这个声音像什么",这正是 Embeddings 的强项。

更远一步看,当 Omni Embedding 做成了,文本、图像、音频、视频都在一个向量空间里,Agent 就获得了一个统一的感知接口。不管输入是什么模态,都转成向量后统一检索、比较、推理。这是多模态 Agent 能真正 scale 的前提。

而这一切有个硬性前提:模型要够小,能在端侧跑。 语音交互容不下云端传输带来的延迟损耗,而且语音数据的隐私敏感度远高于文本。所以高性能的小模型不是加分项,而是入场券。这也是我们把目标定在 1.2B 以下的原因。

结论

预训练 MLLM 是做新模态 Embedding 最大的杠杆。 它一次性提供了跨模态对齐、强文本编码器和能力不错的音频编码器。

模块化组合是目前最有前景的方向。 从不同模型、不同训练阶段里拆出组件自由拼装,我们在音频向量任务上验证了可行性。实验结果也指向了一个清晰优先级:音频编码器的对齐质量是第一位的(stage-3 vs pre-stage-1 差了 4.2 个点),LLM backbone 的生成能力对向量化任务没有贡献(stage 2-3 训练前后没有差异)。这也意味着构建向量模型时,选组件的优先级是:编码器对齐 > LLM 的表示能力 > LLM 的其他能力。

跨模态迁移和模型压缩不能既要又要。 文本模态迁移在完整 7B 上漂亮地跑通了(46.1 vs CLAP 42.0),但在 10 层剪枝模型上直接归零(5.9)。对齐分布在整个网络中,压缩就碎。

AudioCaps 领跑不代表问题解决了。 我们模型在 AudioCaps 上大幅领先 CLAP,但在更依赖抽象语义的 Clotho 榜单上只是持平。暴露了模型的场景级语义理解不够。只看 AudioCaps 你会觉得模型已经很好了;加上 Clotho 就知道还差得远。

这项工作是我们迈向 Omni Embedding(全模态向量模型)的关键一步,模块化组合让我们找到了无需大规模烧数据即可开启新模态的方法,但 Clotho 的结果提醒我们:光靠复用预训练组件还不够,数据质量和多样性仍然是底层硬约束。

接下来我们会探索 MoE 架构把激活参数压到 500M 以下,尝试模块组合和模态迁移的深度结合,引入 WavCaps、MusicCaps 和语音数据集做数据扩充,重点补上抽象描述的短板。

我们开源社区见!https://github.com/jina-ai/audio-embedding-kickstarter

阅读原文

跳转微信打开

CLI is All Agents Need — *nix Agent 设计宝典

2026年3月12日 11:55

原创 yan5xu 2026-03-12 11:55 北京

oi! 这真的是我觉得最好的 agent 架构啊啊啊啊啊,真的不要来看看吗!!!

Why a single run(command) outperforms sprawling tool catalogs

当所有人在为 Agent 设计复杂的函数调用框架时,我发现:一个 run(command="...") 就够了。

本文由 AI Agent 协作完成,但每一个设计决策、每一次生产踩坑、以及把它们提炼成原则的思考过程,都是本人完成的。

为什么是 *nix

Unix 在 50 年前做了一个设计决策:一切皆文本流。 程序之间不交换复杂的二进制结构,不共享内存对象——它们通过文本管道沟通。小工具各司其职,通过 | 组合成强大的工作流。程序用 --help 描述自己,用 exit code 报告成败,用 stderr 传递错误上下文。

LLM 在 50 年后做了一个几乎相同的决策:一切皆 token。 它只理解文本,只输出文本。它的"思考"是文本,它的"行动"是文本,它从世界获得的反馈也必须是文本。

这两个决策跨越半个世纪,从完全不同的出发点,收敛到了同一个接口模型。Unix 为人类终端操作者设计的文本系统——cat、grep、pipe、exit code、man page——对 LLM 来说不是"也能用",而是天然适配。LLM 在工具使用这件事上,本质就是一个终端操作者,只不过它比任何人类都快,而且它的训练数据里有大量 shell 命令与 CLI 用例。

这就是 *nix Agent 的核心哲学:不发明新的工具接口,把 Unix 已经验证了 50 年的设计直接交给 LLM。

为什么只有一个 run

单工具假说

主流 Agent 框架给 LLM 一堆独立工具:

tools: [search_web, read_file, write_file, run_code, send_email, ...]

LLM 每次调用前要做工具选择——用哪个?参数怎么填?工具越多,选择越难,准确率越低。认知负荷花在了"选工具"上,而不是"解决问题"上。

我的做法:一个 run(command="..."),所有能力通过 CLI 命令暴露。

run(command="cat notes.md")
run(command="cat log.txt | grep ERROR | wc -l")
run(command="see screenshot.png")
run(command="memory search 'deployment issue'")
run(command="clip sandbox bash 'python3 analyze.py'")

LLM 仍然需要选择"用什么命令",但这和"从 15 个不同 schema 的工具中选一个"是完全不同的认知任务。命令选择是在一个统一的 namespace 里做字符串组合——而函数选择是在多个不相关的 API 间做模式切换。

LLM 的 CLI 母语

为什么 CLI 命令比结构化函数调用更适合 LLM?

因为 LLM 的训练数据里,CLI 是最密集的工具使用范式。GitHub 上数十亿行代码充满了:

# README 里的安装指南
pip install -r requirements.txt && python main.py
# CI/CD 里的构建脚本
make build && make test && make deploy
# Stack Overflow 里的解决方案
cat /var/log/syslog | grep "Out of memory" | tail -20

我不需要教 LLM 如何使用 CLI——它已经会了。这种熟悉度是概率性的、模型相关的,但在主流模型上经验证非常可靠。

对比两种方式完成同一个任务:

任务:读取日志文件,找出错误行数
函数调用方式(3 次 tool call):
  1. read_file(path="/var/log/app.log") → 返回完整文件
  2. search_text(text=<entire file>, pattern="ERROR") → 返回匹配行
  3. count_lines(text=<matched lines>) → 返回数字
CLI 方式(1 次 tool call):
  run(command="cat /var/log/app.log | grep ERROR | wc -l")
  → "42"

一次调用替代三次。不是因为做了特殊优化——而是 Unix 管道天然支持组合。

让管道和链式执行成为可能

光有一个 run 不够。如果 run 只能执行单条命令,LLM 还是要多次调用才能完成组合任务。所以我在命令路由层实现了一个链式解析器(parseChain),支持四种 Unix 操作符:

|   管道:前一个命令的 stdout 作为后一个的 stdin
&&  与链:前一个成功才执行后一个
||  或链:前一个失败才执行后一个
;   顺序:无论前一个成败都执行后一个

有了这个机制,LLM 的每一次 tool call 都可以是一个完整的工作流:

# 一次 tool call:下载 → 查看
curl -sL $URL -o data.csv && cat data.csv | head 5
# 一次 tool call:读文件 → 过滤 → 排序 → 取前 10
cat access.log | grep "500" | sort | head 10
# 一次 tool call:尝试 A,失败则尝试 B
cat config.yaml || echo "config not found, using defaults"

N 个命令 × 4 种操作符,组合空间急剧扩大。而在 LLM 看来,这只是一个字符串——它已经从训练数据里学会了怎么写。

命令行就是 LLM 的母语工具接口。

启发式设计:让 CLI 引导 Agent 顺滑工作

单工具 + CLI 解决了"用什么"的问题,但 Agent 还需要知道 "怎么用"。它没有搜索引擎,没有同事可以问。我通过三个递进的设计手段,让 CLI 自身成为 Agent 的导航系统。

手段一:渐进式 --help 自发现

一个设计良好的 CLI 工具,用户不需要读文档就能上手——因为 --help 告诉了一切。我把同样的理念用在 Agent 身上,并且做成了渐进式披露:Agent 不需要一次加载所有文档,而是按需逐层深入。

第零层:Tool Description → 命令列表注入

run 工具的 description 在每次对话开始时动态生成,列出当前所有已注册命令的一行摘要:

Available commands:
  cat    — Read a text file. For images use 'see'. For binary use 'cat -b'.
  see    — View an image (auto-attaches to vision)
  ls     — List files in current topic
  write  — Write file. Usage: write <path> [content] or stdin
  grep   — Filter lines matching a pattern (supports -i, -v, -c)
  memory — Search or manage memory
  clip   — Operate external environments (sandboxes, services)
  ...

Agent 从第一轮就知道有哪些能力,但不需要知道每个命令的所有参数——那会浪费上下文。

注: 命令列表全量注入 vs 按需发现,随着命令增多这里存在上下文预算的权衡。目前还在探索更优的平衡方式,欢迎讨论。

第一层:command(无参数)→ 命令用法

Agent 对某个命令感兴趣时,直接调用它。没给参数?命令返回自己的用法:

→ run(command="memory")
[error] memory: usage: memory search|recent|store|facts|forget
→ run(command="clip")
  clip list                              — list available clips
  clip <name>                            — show clip details and commands
  clip <name> <command> [args...]         — invoke a command
  clip <name> pull <remote-path> [name]   — pull file from clip to local
  clip <name> push <local-path> <remote>  — push local file to clip

现在 Agent 知道 memory 有五个子命令,clip 可以 list/pull/push。只花了一次调用,没有多余信息。

第二层:command subcommand(缺参数)→ 具体参数

Agent 决定用 memory search,但不确定参数格式?继续深入:

→ run(command="memory search")
[error] memory: usage: memory search <query> [-t topic_id] [-k keyword]
→ run(command="clip sandbox")
  Clip: sandbox
  Commands:
    clip sandbox bash <script>
    clip sandbox read <path>
    clip sandbox write <path>
  File transfer:
    clip sandbox pull <remote-path> [local-name]
    clip sandbox push <local-path> <remote-path>

渐进式披露:概览(注入)→ 用法(探索)→ 参数(深入)。 Agent 按需探索,每一层只获取当前需要的信息量。

这和把所有文档塞进 system prompt 是完全不同的思路。system prompt 里塞 3000 字的工具文档,大部分信息在大部分时候都用不到——白白占用上下文预算。渐进式 help 让 Agent 自己决定什么时候需要更多信息。

这也对命令设计提出了要求:每个命令、每个子命令都必须有完整的 help 输出。 不仅是给人看的,更是给 Agent 看的。一条好的 help 能让 Agent 一步到位,一条缺失的 help 意味着一次盲猜。

手段二:Error Message 纠偏

Agent 不可能永远走对路。关键不是阻止它犯错,而是让每个错误都指向正确方向。

传统 CLI 的错误信息给人看——人可以 Google。Agent 不能 Google。所以我要求每个错误同时包含"出了什么问题"和"该怎么做":

传统 CLI:
  $ cat photo.png
  cat: binary file (standard output)
  → 人会 Google "how to view image in terminal"
我的设计:
  [error] cat: binary image file (182KB). Use: see photo.png
  → Agent 直接调用 see,一步修正

更多例子:

[error] unknown command: foo
Available: cat, ls, see, write, grep, memory, clip, ...
→ Agent 立刻知道有哪些命令
[error] not an image file: data.csv (use cat to read text files)
→ Agent 从 see 切换到 cat
[error] clip "sandbox" not found. Use 'clip list' to see available clips
→ Agent 知道先列出 clips

手段一(help)解决"我能做什么"。手段二(error)解决"做错了怎么办"。两者配合,Agent 的试错成本极低——通常 1-2 步就能找到正确路径。

真实案例:stderr 被丢弃的代价

有段时间,我的代码在调用外部沙箱时,如果 stdout 非空就丢弃 stderr。Agent 运行 pip install pymupdf,exit code 127。stderr 里有 bash: pip: command not found,但 Agent 看不到。它只知道"失败了",不知道"为什么"——于是盲猜了 10 种包管理器:

pip install         → 127  (不存在)
python3 -m pip      → 1    (模块不存在)
uv pip install      → 1    (用法错误)
pip3 install        → 127
sudo apt install    → 127
... 又试了 5 种 ...
uv run --with pymupdf python3 script.py → 0 ✓  (第 10 次)

修复后 stderr 永远可见,Agent 第一次就看到 "pip: command not found",立刻换方向。

stderr 是 Agent 最需要的信息,恰恰在命令失败的时候。永远不要丢弃它。

手段三:Output Format 持续反馈

前两个手段解决了 Agent 的"发现"和"纠错"。第三个让 Agent 在持续执行过程中越来越懂系统。

我在每个 tool result 末尾追加一致的元数据:

file1.txt
file2.txt
dir1/
[exit:0 | 12ms]

LLM 从中提取两个信号:

退出码(Unix 约定,LLM 已掌握):

  • exit:0

     — 成功

  • exit:1

     — 一般错误

  • exit:127

     — 命令不存在

耗时(成本感知):

  • 12ms

     — 廉价操作,可以放心多调

  • 3.2s

     — 中等成本

  • 45s

     — 昂贵操作,需要谨慎

Agent 在对话中看到几十次 [exit:N | Xs] 后,内化了这个模式。它开始预判——看到 exit:1 就知道检查错误,看到耗时很长就减少调用。

一致的输出格式让 Agent 越用越聪明。不一致让每次都像第一次。

三个手段的递进关系:

--help       →  "我能做什么?"       →  主动发现
Error Msg    →  "做错了怎么办?"     →  被动纠偏
Output Fmt   →  "做得怎么样?"       →  持续学习

双层架构:把启发式设计落地的工程

上面讲了 CLI 如何在语义层面引导 Agent。但要真正落地,还需要解决一个工程问题:CLI 执行的原始输出,和 LLM 需要看到的结果,往往不是一回事。

LLM 的两个硬约束

约束 A:上下文窗口有限且昂贵。 每个 token 消耗金钱、注意力、推理速度。一个 10MB 文件全文塞进上下文,不仅浪费,还会把之前的对话挤出窗口——Agent "失忆"。

约束 B:LLM 只能处理文本。 二进制数据经过 tokenizer 产生高熵无意义的 token。它不仅浪费上下文,还会扰乱周围有效 token 的注意力,导致推理质量下降。

这两个约束决定了:命令的原始输出不能直接扔给 LLM——需要一个呈现层做加工。但加工不能影响命令的执行逻辑——否则管道会坏。所以需要分层。

执行层 vs 呈现层

┌─────────────────────────────────┐
│  Layer 2: LLM 呈现层             │  ← 为 LLM 认知约束设计
│  二进制拦截 | 截断+溢出 | 元数据    │
├─────────────────────────────────┤
│  Layer 1: Unix 执行层             │  ← 纯 Unix 语义
│  命令路由 | pipe | chain | exit   │
└─────────────────────────────────┘

当 cat bigfile.txt | grep error | head 10 执行时:

Layer 1 内部:
  cat 输出 → [500KB 原始文本] → grep 输入
  grep 输出 → [匹配的行] → head 输入
  head 输出 → [前 10 行]

如果在 Layer 1 截断 cat 的输出 → grep 只搜到前 200 行,结果不完整。如果在 Layer 1 加 [exit:0] → 它作为文本流入 grep,变成搜索内容。

所以 Layer 1 必须保持原始、无损、无元数据。加工只在 Layer 2 发生——管道链执行完毕,最终结果准备返回给 LLM 时。

Layer 1 服务于 Unix 语义。Layer 2 服务于 LLM 认知。分层不是设计偏好,是逻辑必然。

Layer 2 的四个机制

机制 A:二进制守卫(应对约束 B)

在返回给 LLM 之前,检查内容是否为文本:

检测到 null byte → 二进制
UTF-8 校验失败 → 二进制
控制字符比例 > 10% → 二进制
如果是图片:[error] binary image (182KB). Use: see photo.png
如果是其他:[error] binary file (1.2MB). Use: cat -b file.bin

LLM 永远不会收到它无法处理的数据。

机制 B:溢出模式(应对约束 A)

输出 > 200 行 或 > 50KB?
  → 截断到前 200 行(rune-safe,不切断 UTF-8)
  → 完整输出写入 /tmp/cmd-output/cmd-{n}.txt
  → 返回给 LLM:
    [前 200 行内容]
    --- output truncated (5000 lines, 245.3KB) ---
    Full output: /tmp/cmd-output/cmd-3.txt
    Explore: cat /tmp/cmd-output/cmd-3.txt | grep <pattern>
             cat /tmp/cmd-output/cmd-3.txt | tail 100
    [exit:0 | 1.2s]

关键洞察:LLM 已经知道如何用 grep、head、tail 导航文件。溢出模式把"大数据探索"转化为 LLM 已掌握的技能。

机制 C:元数据脚注

actual output here
[exit:0 | 1.2s]

退出码 + 耗时,追加在 Layer 2 的最后一行。给 Agent 判断成败和感知成本的依据,同时不污染 Layer 1 的管道数据。

机制 D:stderr 附加

命令失败且有 stderr 时:
  output + "\n[stderr] " + stderr
确保 Agent 能看到错误原因,不会盲目重试。

实现:agent-clip 核心代码

以下为简化的伪代码,突出架构骨架。完整实现见源码仓库。

单工具定义

// LLM 只看到一个工具:run(command, stdin?)
// 所有命令及帮助文本列在 description 里
func RunToolDef(commands map[string]string) ToolDef {
    desc := "Execute commands via run(command=\"...\").\n"
    desc += "Supports chaining: cmd1 && cmd2, cmd1 | cmd2.\n\n"
    for name, help := range commands {
        desc += "  " + name + " — " + help + "\n"
    }
    return ToolDef{
        Name: "run",
        Description: desc,
        Parameters: { command: string, stdin?: string },
    }
}

Layer 1:命令路由与管道

// Exec 解析命令链,执行管道,返回原始输出 + 退出码
// 这里是纯 Unix 语义——没有截断,没有元数据,没有二进制检测
func (r *Registry) Exec(command, stdin string) (string, int) {
    segments := parseChain(command)  // 按 &&, ||, |, ; 分割
    for i, seg := range segments {
        if prevOp == OpAnd && lastExitCode != 0 { continue }
        if prevOp == OpOr && lastExitCode == 0  { continue }
        if prevOp == OpPipe { stdin = lastOutput }
        lastOutput, lastExitCode = r.execSingle(seg, stdin)
    }
    return lastOutput, lastExitCode
}
func (r *Registry) execSingle(command, stdin string) (string, int) {
    name, args := tokenize(command)
    handler, ok := r.handlers[name]
    if !ok {
        return "[error] unknown command: " + name + "\nAvailable: ...", 127
    }
    output, err := handler(args, stdin)
    if err != nil {
        return "[error] " + name + ": " + err.Error(), 1
    }
    return output, 0
}

Layer 2:LLM 呈现层

// execToolCall 把 Layer 1 的原始结果加工成 LLM 能理解的格式
// 所有的截断、溢出、元数据包装都在这里发生
func execToolCall(registry *Registry, tc ToolCall) string {
    command, stdin := parseToolCallArgs(tc)
    // Layer 1: 纯执行
    start := time.Now()
    rawOutput, exitCode := registry.Exec(command, stdin)
    duration := time.Since(start)
    metadata := fmt.Sprintf("[exit:%d | %s]", exitCode, duration)
    // 失败时直接返回(execSingle 已加 [error] 前缀 + stderr)
    if exitCode != 0 {
        return rawOutput + "\n" + metadata
    }
    // 截断检查(仅超限时才持久化到 /tmp)
    result := rawOutput
    if tooLarge(rawOutput) {
        truncated := first200LinesRuneSafe(rawOutput)
        file := persistToTmp(rawOutput)
        result = truncated + "\n--- truncated ---\nFull output: " + file
    }
    return result + "\n" + metadata
}

二进制守卫

func fsCat(args []string, stdin string) (string, error) {
    data := readFile(path)
    // 二进制守卫:拦截 LLM 无法处理的数据,引导到正确命令
    if !base64Flag && isBinary(data) {
        if isImage(path) {
            return error("binary image (%s). Use: see %s", size, path)
        }
        return error("binary file (%s). Use: cat -b %s", size, path)
    }
    return string(data), nil
}
func isBinary(data []byte) bool {
    sample := data[:min(8192, len(data))]
    if containsNull(sample)       { return true }  // null byte = 一定是二进制
    if !utf8.Valid(sample)        { return true }  // 非法 UTF-8 = 大概率二进制
    if controlRatio(sample) > 0.1 { return true }  // 控制字符太多
    return false
}

Vision 自动挂载

// Agent 不需要显式请求"看图"——see 返回的 URL 被自动挂载到 vision 通道
func extractImagesFromResult(result string) []ImageData {
    urls := findImageURLs(result)  // 匹配 pinix-data://...png
    for _, url := range urls {
        data := readFile(urlToPath(url))
        images = append(images, ImageData{
            Base64:   base64Encode(data),
            MimeType: detectMIME(url),
        })
    }
    return images  // 附加到下一轮 LLM 调用的 vision 内容
}

Agentic Loop

func RunLoop(config, context, registry, output) {
    // 不设硬性迭代上限。LLM 不调用工具时循环自然结束。
    // 如果 Agent 还在调工具,说明它认为任务没完成——
    // 我通过前面的启发式设计(help / error / output format)
    // 让它更快到达终点,而不是粗暴截断它的执行。
    //
    // 实际安全边界由外部机制保障:沙箱隔离、API 预算、用户取消。
    for {
        response := callLLM(context)
        if response.hasToolCalls() {
            for _, tc := range response.toolCalls {
                result := execToolCall(registry, tc)      // Layer 2 包装
                images := extractImagesFromResult(result)  // vision 挂载
                context.append(toolResult(result, images))
            }
            continue
        }
        // LLM 没有调用工具 = 任务完成
        return response.content
    }
}

经验教训:来自生产的故事

故事 1:一张 PNG 引发的 20 轮崩溃

用户上传了一张架构图。Agent 用 cat 读取,收到 182KB 的 PNG 原始字节。LLM 的 tokenizer 把这些字节变成数千个无意义的 token,塞进上下文。LLM 完全无法理解,开始反复尝试不同的读取方式——每次都返回同样的乱码。20 轮后进程被强制终止。

根因:cat 没有二进制检测,Layer 2 没有拦截。修复:isBinary() 守卫 + 错误引导 Use: see photo.png。教训: Tool result 是 Agent 的眼睛。返回垃圾 = Agent 失明。

故事 2:沉默的 stderr 与 10 次盲猜

Agent 需要读取一个 PDF。它尝试 pip install pymupdf,exit code 127。但 stderr(bash: pip: command not found)被代码丢弃了——因为有一小段 stdout,代码逻辑是"有 stdout 就忽略 stderr"。

Agent 只看到"失败了",不知道"为什么"。接下来是漫长的试错:

pip install         → 127  (不存在)
python3 -m pip      → 1    (模块不存在)
uv pip install      → 1    (用法错误)
pip3 install        → 127
sudo apt install    → 127
... 又试了 5 种 ...
uv run --with pymupdf python3 script.py → 0 ✓

10 次调用,每次 ~5 秒推理。如果第一次 stderr 可见,1 次就够了。

根因:InvokeClip 在有 stdout 时静默丢弃 stderr。修复: 失败时永远附加 stderr。教训: stderr 是 Agent 最需要的信息,恰恰在命令失败的时候。

故事 3:溢出模式的价值

Agent 分析一个 5000 行的日志文件。没有截断时,5000 行全文(~200KB)塞进上下文,LLM 的注意力被淹没,回答质量骤降,还把之前的对话挤出了上下文窗口。

加了溢出模式后:

[前 200 行日志内容]
--- output truncated (5000 lines, 198.5KB) ---
Full output: /tmp/cmd-output/cmd-3.txt
Explore: cat /tmp/cmd-output/cmd-3.txt | grep <pattern>
         cat /tmp/cmd-output/cmd-3.txt | tail 100
[exit:0 | 45ms]

Agent 看到前 200 行,了解了文件结构,然后用 grep 精准定位——总共 3 次调用,上下文占用不到 2KB。

教训: 给 Agent 一个"地图"比给它"全部领土"有效得多。

边界与局限

CLI 不是银弹。以下场景中,typed API 可能是更好的选择:

  • 强类型交互

    :数据库查询、GraphQL API 等需要结构化输入输出的场景,schema 验证比字符串解析更可靠。

  • 高安全要求

    :CLI 的字符串拼接天然带有注入风险。在不可信输入场景中,typed parameters 比命令字符串更安全。agent-clip 通过沙箱隔离来缓解这个问题。

  • 多模态原生

    :纯音视频处理等需要二进制流的场景,CLI 的文本管道是瓶颈。

此外,"不设迭代上限"不意味着没有安全边界。实际安全由外部机制保障:

  • 沙箱隔离

    :命令在 BoxLite 容器内执行,无法逃逸

  • API 预算

    :LLM 调用有账户级别的费用上限

  • 用户取消

    :前端提供取消按钮,后端支持 graceful shutdown

把 Unix 哲学交给执行层,把 LLM 的认知约束交给呈现层,用 help、error message 和 output format 构建三个递进的启发式导航手段。

CLI is all agents need.

以上所有设计在 agent-clip 中均有完整实现。核心代码对应关系:

  • 单工具命令路由 → internal/tools.go

  • 管道与链式执行 → internal/chain.go

  • 双层 agentic loop → internal/loop.go

  • 文件系统与二进制守卫 → internal/fs.go

  • 外部环境调用与 stderr 处理 → internal/clip.go

  • 浏览器自动化与 vision 挂载 → internal/browser.go

  • 语义记忆与向量搜索 → internal/memory.go

Built with Go. Powered by Unix. Designed for LLMs.

阅读原文

跳转微信打开

作品集的「转化率+X%」,面试官信吗?

2026年3月11日 08:20

原创 邹咿ZoeYZ 2026-03-11 08:20 广东

作品集常见问题

我发现大部分UX/交互作品集都会在项目末尾加上数据验证。然而10个里面,9个都缺乏说服力。

例如:会员页改版让转化率提升3%。

这种数据验证,不但没有让我对这位设计师的能力产生认可,反而是增添了疑虑。

即便这个作品集整体还不错,能进入面试环节,我也会仔细盘问这数字是怎么来的。

数据验证确实是个好东西,但是很多设计师在毫无数据分析经验的情况下,就胡乱编造数据。结果炫技不成,反而给人留下“不诚实”的印象,就糟糕了。

其实也不怪设计师们,因为数据分析这东西,确实没太多适合设计师学的途径。不论是大学的设计专业还是市场上的设计培训班,都极少有针对设计师的数据分析课。

设计师想要提升数据分析能力,推荐来我们的《数据分析训练营》,已经第5期了,每期都大获好评。不论是零基础还是有点儿经验的,都表示受益匪浅,并且立马就能用起来。

接下来,我就分析一下,为什么会员转化率提升3%这个数据验证缺乏说服力。

1. 价值过高显得不真实

转化率提升3%没什么奇怪的,但让会员转化率提升3%,就有点惊人了。

要知道,连知乎这种平台,一年都能卖4亿会员费。假设一个设计师能把知乎的会员转化率提升3%,那就意味着,这名设计师凭一己之力帮企业多赚了1200万!

这就好比一个年入千万的高富帅/白富美说看上你了,理智一点的人都会想:“这是不是遇到诈骗了?”

2. 缺少严谨性声明

假设这个产品的一年的会员费只有100万,会员转化率上涨3%也不过多赚了3万块钱,这么看就很正常了。

但要确定这个数据是设计的功劳,是不是得排除营销的影响?好歹得说一句,数据测量期间没有任何营销活动的变动。

对方也知道这可能是一句谎言,但加上这么一句声明,至少说明设计师知道怎样的数据才算是严谨的,并且愿意为数据的严谨性负责。

3. 缺少方案关联性

假设前面的2点都做到了,但这方案的哪个部分,导致了如此漂亮的数据上涨呢?

假设改的地方是「连续包月」,那应该用「连续包月」的转化率来验证,才更能看出效果。

假设改的地方是权益展示,那应该用各项权益的点击率来验证,才更能看出效果。

总而言之,具体改了哪里,就应该看哪里的数据。

如果不管三七二十一,全部只看总数据,就感觉没有那么可信。

设计师的数据思维

其实真正懂数据的设计师,一定是拿到需求的时候,就开始分析数据了。然后在设计方案的过程中,会围绕着如何提升这些数据进行思考。

如果拿到需求的时候不看数据,反而等方案完成了再突然来个数据验证,是很不现实的。

因为设计师最有理由申请数据权限的时机,就是刚接到需求的那一刻。反倒是把方案交付完成后,设计师不知道方案何时上线,手上又有别的需求要忙,申请数据权限没那么方便了。

所以设计师做数据分析,跟产品经理、市场营销等业务岗位,是完全不一样的。包括如何获取数据、如何整理数据、如何分析出设计策略、如何验证方案……都是不同的。

设计师想要提升数据分析能力,推荐来参加我们即将开始的训练营。除了紧贴设计师实际工作需要的理论课程外,还有真实产品的项目带练及1对1作业点评,帮你在2周内成为有数据思维的设计师。

新用户(消费累计<10)可以领取150元的优惠券(扫码后,课程标题下方)。如果不能使用,可以先下单后微信zoeyz0001改价后付款。

阅读原文

跳转微信打开

pinix 东半球第一个专门为 agent 设计的 os

2026年3月10日 22:52

言午 北京

epiral 2.0 来啦,不过重点不是 epiral(🦞),这次是 pinix,大概是东半球第一个专门为 agent 设计的 os hhh

春节在迭代epiral 的时候,撞上一个问题:Agent 只靠 IM 交互,很多场景都有点难受。

比如 todo。让 Agent 管理很顺——它自己调命令,增删改查,清清楚楚。但我自己想看一眼今天的任务呢?纯靠对话去问,怎么都不如一个列表界面来得直接。

于是想通了一件事,Agent 需要命令行,人需要界面,但它们操作的是同一个东西。所以 Agent 时代的 app 就该同时有两个入口。

所以就有了 pinix。上面的应用叫 clip。每个 clip 长这样:底层是一组命令脚本(或者二进制 cli),Agent 直接调;上层是一个 web 页面,人直接用。同一份数据,两种交互方式。

然后有意思的来了:Agent 本身也是一个 clip。

就是你们在用的龙虾——对话、记忆、工具调用、浏览器控制——我把它整个做成了 pinix 上的一个应用。它不是系统的主人,它是系统上跑的一个 app,跟 todo、跟沙盒平级。Agent 通过命令跟其他 clip 交互,装一个新 clip,Agent 就自动多一个新能力。

看图就懂了👇

四个画面,同一个 pinix 节点:

左一:Agent clip——刚帮我批量更新 todo 状态,调的是 clip todo task-update,返回结构化结果自动整理成表格

左二:todo clip——同一批任务,我直接在看板上看,按项目分组,拖拽排优先级。Agent 改的数据,这边实时看到

左三:Clip Dock(桌面端)——所有 clip 的入口,哪些在线一目了然

右一:todo clip 的 iOS 端——同一个 web 页面,手机上直接用

UI 选了 web,跨平台就不用做了——桌面套 WebView,iOS 套 WKWebView,一个下午两端全通。每个 clip 跑在独立微型虚拟机里,安全也是顺手的事。

跳转微信打开

苹果的圆角好规整,但大多APP设计不来

2026年3月10日 08:20

原创 邹咿ZoeYZ 2026-03-10 08:20 广东

原因是…

之前看过一个设计规则,就是两个圆角套在一起时,大圆角的半径等于小圆角的半径加上二者的间距。这样就能保证两层圆角之间的距离严丝合缝地保持统一。

而苹果手机更新到 iOS 26 后,圆角感觉都挺符合这个原则的。

我一边感叹苹果设计师的严谨态度,一边在 iOS 26 的官方Figma组件库上测量圆角尺寸,然后惊讶地发现……

其实并没有那么严丝合缝!

例如下图这些双层圆角,表面看起来很贴合,但实际算一下尺寸,都差了几个数字,不完全严谨。

对了,上图的尺寸标注,是我自己做的一套Figma组件,用起来非常方便。如果你需要,文章末尾可以免费领取。

那好吧,反正绝大多数用户没有像素眼,只要看起来大致规整,数字上并不需要那么完美。

如果把UI设计搞成数学题,那就没必要了。苹果能做出这个效果,已经很好了。

要知道绝大多数产品,包括App、网页、PC端软件等……连苹果这种看似规整的圆角都做不到。

为什么大家不能跟苹果学学这种规整的双层圆角设计呢?

其实我以前还真的尝试过,但很快就发现了难点。

对齐圆角的设计难点

1. 容易导致容器圆角太大

iOS 18 因为不需要考虑圆角对齐的问题,当时的弹窗圆角不是很大。大部分移动端APP弹窗的圆角,也差不多就是这个尺寸。

但是 iOS 26 为了对齐圆角,必须把外层容器的圆角做得很大。

2. 大圆角容器要搭配大边距

容器的圆角大了,边距也要大一些,否则看起来就很奇怪。例如下图,iOS 26 加大圆角的同时,也把间距从16和19加到了22。 

内边距大了,就会挤占内容空间,降低屏效。

3. 文字边距与按钮边距的矛盾

仔细看 iOS 26 的弹窗就会发现,文字边距和按钮边距是不同的。

如果改成统一边距,向下图这样,要么会感觉要么文字太贴边了,要么感觉按钮距离边缘太远了。

为了让文字和按钮看起来更舒适,只能搞2套内边距。这对设计师和开发来说,都更麻烦了。

4. 有些组件的圆角尺寸不能随便改

iOS 26 的设置页,图标没有跟外层卡片对齐圆角。如果要对齐,需要把图标改成圆形,但那样会导致视觉上更拥挤,而且识别度下降。

按钮用大圆角没问题,但文本框也用大圆角就有点奇怪了,除非是搜索框。

iOS 26 有很多大圆角输入框,但这种操作系统本身也没有很多输入框组件,所以问题不大。

但是对于表单较多的产品,例如B端设计规范,就很少见到哪家的输入框用大圆角的。

有多少设计会对齐圆角吗?

我们来投个票吧:

圆角设计的基本规则?

其实很多大厂的设计系统,也没有在圆角尺寸上做特别定义。

但整体有2点原则:

1. 同级别元素的圆角尽量统一

例如菜单容器和弹窗容器,都是容器层级,圆角就可以统一。再比如开关和按钮,都在容器内容,属于统一层级,圆角就可以统一。

2. 圆角尺寸要符合用户预期

例如按钮或标签通常是大圆角,输入框通常是小圆角或者无圆角的。同一个图标,在不同地方的圆角应该是符合等比放大原则。

如果你有更具体的设计心得,欢迎留言分享~

Figma尺寸标注组件

点击左下角体验进阶头像后,回复:尺寸标注。

阅读原文

跳转微信打开

深度避坑:Ontology本体论的10个常见误区,很多人都踩过

2026年3月9日 20:01

原创 风叔 2026-03-09 20:01 上海

本文聚焦Ontology最易被误解的10个关键点,用通俗的解析和示例,帮你厘清认知、避开陷阱,真正理解Ontology的核心价值与适用逻辑

随着AI、数据治理的兴起,Palantir Ontology(本体)逐渐成为前沿科技领域的热门概念,被广泛应用于供应链、金融、医疗等多个行业。但热度背后,无论是从业者还是学习者,对Ontology的认知普遍存在偏差——把它和知识图谱、数据库混为一谈,认为所有场景都能套用,忽略其核心逻辑与边界。

本文将跳出“正确的废话”,聚焦Ontology最易被误解的10个关键点,用通俗的解析和示例,帮你厘清认知、避开陷阱,真正理解Ontology的核心价值与适用逻辑,阅读时长约5分钟。

误区1:Ontology = 知识图谱

误区点破:最常见的认知偏差,认为Ontology和知识图谱是一回事,甚至有人直接将两者等同称呼,混淆其核心目标。

正确认知:两者均涉及“语义关联”,但核心目标、侧重点完全不同。知识图谱侧重“关联关系的展示与查询”,核心是“连接”;而Ontology是一套“标准化的语义体系”,核心是“定义规则、统一认知”,知识图谱可基于Ontology构建,但Ontology的价值远不止于关联。

示例:还是以供应链为例,知识图谱会展示“供应商→供货→货物→存储→仓库”的关联路径,方便查询某供应商的所有供货品类;而供应链Ontology会先定义“供应商”“货物”“仓库”的对象类型、属性规则(如供应商的供货合格率范围)、跨对象约束(如冷藏货物需存入冷藏仓库),知识图谱的关联的前提,是Ontology定义的标准化语义。

避坑提示:需关联查询、可视化展示,优先选知识图谱;需统一语义、规范规则、支撑智能决策,则需要Ontology。

误区2:所有业务场景,都适合用Ontology

误区点破:盲目跟风,认为只要涉及数据、涉及对象,就需要搭建Ontology,忽略其适用边界,导致资源浪费。

正确认知:Ontology的核心价值是“打破信息孤岛、统一语义、规范规则”,仅适用于“多系统、多角色、多对象交互”的复杂场景;单一系统、简单流程(无多对象关联、无规则约束),完全不需要搭建Ontology。

示例:适合用Ontology的场景——大型企业的全域供应链,涉及采购、仓储、生产、物流、销售多系统,供应商、货物、订单、产品、产线多对象交互,需统一语义、规范规则。不适合Ontology的场景——小型仓库的单一库存管理,仅需记录货物库存,无多系统交互、无复杂规则约束,用简单的Excel或库存管理工具即可,搭建Ontology纯属多余。

避坑提示:判断是否适用,核心看“是否有语义混乱、多系统与多对象互通需求、复杂规则约束、复杂决策输出”。

误区3:函数不仅能计算,还能执行动作

误区点破:混淆Ontology中“函数”与“动作类型”的边界,认为函数既能做计算,也能触发对象状态变化、执行具体操作。

正确认知:Ontology中,函数的核心是“无状态、无副作用的计算”,仅负责输入参数→输出结果,不改变任何对象的属性值、不执行任何操作。执行动作、改变对象状态,是“动作类型”的核心功能,与函数完全独立。

示例:函数“库存周转率计算”,输入货物当前库存、近30天出库总量,输出周转率结果,整个过程不改变库存数据、不触发任何入库/出库操作。而动作类型“货物出库”,执行后会减少货物库存、增加仓库空闲面积,属于“执行操作、产生副作用”,与函数无关。

避坑提示:记住核心区别——函数只计算不执行,动作类型只执行不单纯计算,两者不可混淆使用。

误区4:Ontology的数据,必须写回原始数据源

误区点破:认为“数据写回”是Ontology的必选项,只要搭建Ontology,就必须将其数据反向写入ERP、WMS等原始系统,否则就是不完整的。

正确认知:数据写回是“可选功能”,而非“必选项”,核心取决于业务需求。Ontology的核心是“语义化描述与规则约束”,若仅需基于Ontology做分析、决策、预警,无需改变原始系统数据,则无需写回。仅当需要实现“Ontology-数据源”数据闭环、同步更新原始系统时,才需要配置写回。

示例:若仅用Ontology中的AI模型做需求预测(输出未来30天货物需求总量),用于制定采购计划,无需改变ERP系统中的历史数据、当前库存数据,则无需写回。若需将Ontology中“货物入库”的库存更新数据,同步到WMS系统,确保两者数据一致,才需要配置数据写回。

避坑提示:无需盲目追求“数据写回”,根据业务需求判断——需同步原始系统则需要配置,仅做分析决策则无需配置。

误区5:Ontology = 数据库

误区点破:认为Ontology是“特殊的数据库”,核心作用是“存储数据”,甚至用数据库的逻辑去设计Ontology。

正确认知:Ontology不负责存储数据,其核心是“定义语义规则和业务规则”;数据库/数据仓库的核心是“存储、管理数据”,两者是“规则与数据”的关系。Ontology规范数据的语义与规则,数据存储在数据库中,Ontology读取数据库中的数据进行校验、分析。

示例:WMS仓库管理系统(数据库)存储货物库存、入库时间等原始数据;供应链Ontology不存储这些数据,而是定义“库存数据的规则”(如冷藏货物库存需关联温湿度数据)、“货物的属性规范”(如规格型号的格式),读取WMS中的数据进行规则校验,确保数据合规。

避坑提示:搭建Ontology时,重点设计语义规则,而非考虑“如何存储数据”,数据存储由数据库/数据仓库负责。

误区6:Ontology和OLAP,功能重叠可替代

误区点破:混淆Ontology与OLAP(联机分析处理)的功能,认为两者都能做数据分析,可相互替代。

正确认知:两者的核心目标完全不同,无替代关系,反而可协同使用。OLAP的核心是“多维度数据分析”(如按时间、区域分析库存变化),侧重“数据的统计与分析”。Ontology的核心是“语义标准化与规则约束”,侧重“数据的合规性与语义一致性”,可为OLAP提供“干净、规范、语义统一的数据”,提升分析准确性。此外,随着AI大模型的兴起,Ontology还是实现精准ChatBI的重要手段,良好的语义规则有利于AI大模型进行跨表查询。

示例:OLAP可分析“近6个月各区域的货物出库量、库存周转率”;但OLAP无法判断“出库数据是否合规”(如是否存在库存不足仍出库的情况),而Ontology可通过跨对象规则(库存≤0时无法出库)校验数据合规性,确保OLAP分析的是“正确、合规的数据”,两者协同发挥作用。

避坑提示:需要多维度数据分析,用OLAP;需要规范数据语义、校验数据合规、通过自然语言快速查询数据,用Ontology。两者结合效果最佳,不可相互替代。

误区7:Ontology需要穷尽所有对象和属性

误区点破:搭建Ontology时,盲目追求“全面性”,试图定义领域内所有的对象、所有的属性,导致Ontology过于复杂、难以维护,反而失去核心价值。

正确认知:Ontology的核心是“定义核心必要的语义与规则”,无需穷尽所有对象和属性,只需覆盖“核心业务场景、核心对象、核心属性”即可;过度冗余的对象和属性,会增加维护成本、降低执行效率。

示例:搭建供应链Ontology时,核心对象是“供应商、货物、仓库、产品、采购订单”,核心属性是供应商的供货合格率、货物的库存数量、仓库的仓储类型、产品的良率、产线的产能等等;无需定义“供应商的员工人数”“货物的生产车间”等与核心业务无关的属性,避免冗余。

避坑提示:搭建Ontology的原则是“核心优先、精简高效”,冗余的对象和属性,不如不定义。

误区8:动作类型 = 工作流

误区点破:将“动作类型”与“工作流”等同,认为单个动作就是工作流,或工作流就是多个动作的简单叠加。

正确认知:动作类型是“单个操作”(如货物入库、供应商审核),是工作流的“组成单元”;工作流是“多个动作类型、规则、链接关系的标准化串联”,明确动作的执行顺序、触发条件,是“完整的流程”,而非单个动作或简单叠加。

示例:动作类型“货物入库”是单个操作;而工作流“采购入库流程”,是将“创建采购订单→供应商发货→货物质检→货物入库→流程归档”多个动作类型,按顺序串联,明确“质检合格才可入库”的触发条件,属于完整的流程,包含多个动作类型。

避坑提示:单个操作是动作类型,多个动作按规则串联的完整流程,才是工作流,不可混淆两者的“单元与整体”关系。

误区9:预警规则越多,Ontology越智能

误区点破:认为预警规则的数量,决定了Ontology的智能程度,盲目添加大量预警规则,导致过度预警、无效预警,反而增加业务负担。

正确认知:Ontology的智能性,取决于预警规则的“精准度”,而非“数量”。预警规则需贴合核心业务风险,聚焦“关键异常、高风险场景”,过多的无效规则,会导致相关角色被冗余预警干扰,忽略真正的风险。

示例:供应链Ontology中,核心预警规则是“库存不足预警”“仓库温湿度异常预警”“供应商交货延迟预警”,这3个规则覆盖核心风险;若添加“货物规格型号格式预警”“供应商注册地址变更预警”等无关紧要的规则,会导致仓储管理员、采购经理被大量无效预警干扰,反而降低工作效率。

避坑提示:预警规则的核心是“精准防风险”,而非“数量多”,冗余预警不如无预警。

误区10:推理规则可以凭空推导,无需依托现有知识

误区点破:认为Ontology的推理规则,可脱离现有数据、现有规则,凭空推导出新的知识,过度夸大推理规则的作用。

正确认知:推理规则的核心是“从已知推未知”,所有推理都必须依托“现有明确的知识”——包括对象属性、链接关系、现有规则,无法凭空推导;脱离现有知识的推理,本质是无效推理,会导致结果失真。

供应链示例:推理规则“若供应商供货合格率<90%,且连续3个月延迟率≥3%,则存在合作风险”,其推理依托的是“供货合格率”“延迟率”这两个已知属性,以及“连续3个月超标”的已知规则;若凭空推导“某供应商存在合作风险”,无任何已知属性和规则支撑,该推理就是无效的。

避坑提示:设计推理规则时,必须明确“依托的现有知识”,杜绝凭空推导,否则会导致决策失误。

最终总结:避开误区,读懂Ontology的核心价值

梳理以上10个误区,不难发现:所有误解的本质,要么是“混淆了Ontology与相似概念(知识图谱、数据库、OLAP)的边界”,要么是“误解了Ontology的适用场景、核心功能(函数、动作类型、推理规则)”,要么是“过度追求全面性、数量,忽略了精简高效的原则”。

其实,Ontology的核心从来不是“复杂的概念堆砌”,也不是“万能的工具”,而是一套“标准化的语义体系+规则约束框架”,其价值在于:解决语义混乱、打破信息孤岛、规范业务流程、支撑智能决策,且仅在复杂多系统、多对象交互的场景中,才能发挥最大作用。

下篇文章,风叔将对Palantir的整个产品体系进行拆解

跳转微信打开

从向量里逆向出原始文本和模型来源

2026年3月9日 16:26

原创 Jina AI 2026-03-09 16:26 新加坡

不就是一堆浮点数嘛,能看出什么?87% 识别出模型,81% 还原文本。

🔬 在线 Demo: embedding-inversion-demo.jina.ai

📊 技术报告: jina.ai/news/embedding-fingerprints 

📊 技术报告: jina.ai/news/embedding-inversion 

📄 论文: arxiv.org/abs/2602.11047 

💻 代码: github.com/jina-ai/embedding-fingerprints

用户把文本发到我们的 API,我们返回一串浮点数。没有标签,没有水印,没有任何元数据告诉你它从哪来、用的什么模型。大多数人看到这串数字,反应都是"不就是一堆浮点数嘛,能看出什么?"

过去两周,我们做了两项研究,发现能看出的东西远比想象中多:

  1. 模型溯源:我们训练了一个仅有 80 万参数的小模型。光看一串浮点数,就能判断出这是哪个模型生成的,准确率高达 87%,覆盖 68 个模型和任务组合。

  2. 文本逆向:我们用掩码扩散模型,直接从向量中反推出原始文本。Token 级还原准确率达到了 81%。

也就是说,向量不仅携带语义,还带着生成它的模型的基因,以及原始文本的大量信息残留。

demo: https://embedding-inversion-demo.jina.ai/

向量溯源:这串数字是谁生成的?

当有人给你一个 1024 维的向量,你能判断它是 BGE-M3 生成的,还是 jina-embeddings-v3,还是 Qwen3-Embedding 吗?

再往前走一步: 同一个模型,你能分辨推理时用的是 retrieval 指令还是 classification 指令吗?

直觉上这似乎不可能。向量就是一堆数字,模型之间的差别应该体现在语义空间的几何结构上,而不是数值本身的分布细节。但实验结果直接推翻了这个直觉。

不同模型产生的浮点数,在统计上有非常显著的差异。值域范围、各小数位数字出现的频率、维度间的相关模式...... 这些特征拼在一起,构成了模型独特的数字指纹。这有点像笔迹鉴定,同一段话让不同人抄写,内容一样,但笔画的力度、倾斜和连笔方式都会无意间暴露书写者的身份。

把浮点数当文本来读

这个方法最反直觉的地方在于输入表示。我们没有把向量当成一堆浮点数,而是把每个数字转成了字符串,像处理文本一样,逐个字符拆开喂给模型。

如下图所示,-0.1234 会变成 token 序列 [CLS] - 0 . 1 2 3 4,维度之间用 [SEP] 隔开。整个词汇表极简,只有 15 个 Token:数字 0 到 9、负号、小数点、几个特殊分隔符。

位级别分词(Digit-level Tokenization)
位级别分词(Digit-level Tokenization)

为什么不使用更直观的量化分桶(Binning):把数据范围划分为 256 个区间(bin),一个维度对应一个 Token,这样 1024 维的向量只需 1024 个 Token 就能表达完。

因为量化需要预设边界,而不同模型的数值分布天差地别:有的集中在 0 附近,有的铺满整个 [-1, 1] 区间,同一个模型不同维度的分布也完全不同。任何固定的分桶方案,都会在某些模型上造成严重的分辨率损失,掩盖掉最关键的特征。

所以我们选了最“无假设”的方案:位级别分词(Digit-level Tokenization)。虽然这会让一个 1024 维向量膨胀成 7700 个 Token 的长序列,但它原样呈现了数字的每一位,保留了所有的统计痕迹,不预设规律,让模型自己去学习其中的统计特征。

比如某些模型在特定位上出现数字 7 的频率更高,或者某些维度的排列模式更独特。这些看似无意义的微观特征,恰恰构成了模型的数字指纹。

模型架构

分类器本身是个 4 层 Transformer,128 维,4 个注意力头,总共约 80 万参数 。用 RoPE 做位置编码,SwiGLU 做 FFN,RMSNorm 归一化。CLS token 池化后投影到 68 个输出类别。

模型架构图
模型架构图,比 GPT-2 小 150 倍,但对 15 token 词汇表的分类任务完全够用。

80 万参数是什么概念?比 GPT-2 小两个数量级。但这个任务词汇表只有 15 个 token,分类目标是 68 个类别,瓶颈不在模型大小,而是如何从 7700 个 token 的长序列里提取出能区分 68 个类别的统计特征。

训练数据方面,我们准备了一万条多语言文本,分别送入 25 个以上的模型,配合不同 task prefix 编码,产生 68 个类别。每类 7000 条训练样本,3000 条验证样本。

这 68 个类别不只是 68 个模型。其中包含了同一个模型搭配不同 instruction prompt 的组合,比如 jina-embeddings-v5-text-small 配 retrieval 指令和配 classification 指令算两个不同类别。如果分类器能区分它们,说明仅仅换一个 instruction prompt,就足以在输出数值上留下可检测的痕迹。

在这些类别中,最难的分组是 1024 维度,包含 32 类模型,分类器无法通过序列长度投机取巧,必须纯粹依赖数值模式。

维度

类别数

示例模型

384

8

BGE-small, E5-small, MiniLM, GTE-small

512

2

BGE-small-zh

768

24

BGE-base, E5-base, jina-embeddings-v5-text-nano, Nomic, INSTRUCTOR, LaBSE

1024

32

BGE-M3, E5-large, jina-embeddings-v3, jina-embeddings-v5-text-small, Qwen3-0.6B, Snowflake, mxbai

1536

2

GTE-Qwen2-1.5B

68 类分类,87% 准确率

我们在 A100 上跑了 14 个 Epoch,处理了大约 430 亿个 Token。

14 个 epoch 的训练和验证曲线
14 个 epoch 的训练和验证曲线

最终,训练准确率达到了 87.3%,验证准确率为 86.0%。两条曲线贴得很近,说明模型真的学到了真实的数值规律,而不是在死记硬背训练集。

87% 准确率,随机猜的话是 1.5%。比瞎猜好 59 倍。

68 类验证集混淆矩阵,每类 3000 样本,共 204000 样本。对角线越亮说明分类越准确。
68 类验证集混淆矩阵,每类 3000 样本,共 20.4 万样本。对角线越亮说明分类越准确。

观察这 20.4 万个样本的混淆矩阵,能看到几个有趣的现象:GTE-large、LaBSE、Paraphrase MiniLM 等模型被 100% 准确识别。跨系列的区分(如 BGE vs Jina)非常容易,模型底层的架构和训练方法留下的指纹最深。最难分辨的是同一个基础模型搭配不同的任务前缀。

最让人意外的是,同一个模型、完全相同的权重,仅仅是推理时换了一个 instruction prompt,输出的数值分布就会产生可检测的差异。jina-embeddings-v5-text-small在 5 个不同 task prefix 之间达到了 92% 的区分准确率。任务适配(Task adaptation)不只是在语义空间里挪了个位置,它实际上改变了数值的统计分布。

这件事有非常直接的用途。接手了一个向量数据库但不知道当初用的什么模型?取出一条向量送进分类器就能识别。怀疑某个 API 声称用的是 model A 但实际偷偷换成了 model B?向量指纹可以验证。向量模型的提供商悄悄升级了版本?指纹同样会暴露这个变化。

从向量逆向文本

如果识别模型来源只是让人意外,那接下来的事就有点狠了:从向量里逆向出原始文本。

给你一个 1024 维的向量,还原出生成它的那段文本。

这不是全新的问题。2023 年 Morris 等人做的 Vec2Text 用 T5 编解码器(Encoder-Decoder)在 32 token 的序列上做到了 92% 的精确匹配(Exact Match)。但那个方法有个根本限制:它需要反复调用目标模型的 API 进行迭代修正,动辄 20 多轮,推理成本直接翻了一个数量级。

我们的目标更激进: 只看向量本身,不碰目标模型,一次性把文本还原出来。

用掩码扩散逆向出文本

我们将这个问题重新定义为一个条件掩码扩散(Conditional Masked Diffusion)问题。

从一个全 [MASK] 的序列开始,模型在每一步同时预测所有位置的 token,逐步替换成真实词汇。整个过程只需要 8 步。不是从左到右一个个生成,而是所有位置并行去噪。

步骤 8/8  [MASK] [MASK] [MASK] [MASK] [MASK]
步骤 6/8  [MASK] quick [MASK] [MASK] [MASK]
步骤 3/8  The   quick brown [MASK] jumps
步骤 1/8  The   quick brown fox   jumps

去噪过程: 从全掩码出发,每一步同时预测所有位置,8 步内完成还原。

我们通过自适应层归一化(Adaptive Layer Normalization,AdaLN) 将目标向量注入到 Transformer 的每一层。向量先经过一个投影层,然后在每一层生成缩放(Scale)和位移(Shift)参数,用来调制层归一化的输出。时间步也通过同样的机制注入。两个信号相加,模型同时知道"当前去噪到了哪一步"和"目标向量长什么样"。

Embedding Inversion 架构图

条件掩码扩散语言模型的架构。上半部分是训练流程: 输入文本经 embedding encoder 编码后,通过 MLP 投影注入 Transformer。下半部分是去噪过程: 从全掩码序列出发,逐步还原。

这个设计一举解决了 Vec2Text 的两个问题。第一,推理时完全不需要接触原始模型,向量是唯一的输入。第二,所有位置并行预测,避免了自回归从左到右的误差累积。而且 AdaLN 的条件注入方式天然不挑编码器:不管目标向量来自什么模型、什么维度,过一遍投影 MLP 就能注入同一个 Transformer。

底座模型我们选用了 22 层、3.8 亿参数的多语言 BERT。在冻结预训练权重后,我们只训练投影层、AdaLN 模块和输出层,实际训练参数量约 1.9 亿。训练数据是 mC4 的 200 万条多语言样本,统一截断到 32 个 token。

# 训练核心伪代码
for text, embedding in dataloader:
    t = uniform(0, 1)              # 随机采样时间步
    masked = random_mask(text, t)   # 按比例随机掩码
    cond = mlp_project(embedding)   # 投影 embedding
    logits = model(masked, t, cond) # 条件预测
    loss = cross_entropy(logits[masked_pos], text[masked_pos])

训练流程: 随机掩码 + 条件去噪。噪声调度用 log-linear schedule,集中在后期掩码,前期保留结构。

81% 的 Token 级还原准确率

我们分别在三个主流模型上进行了实测,还原率都很惊人。

编码器

Token 还原率

向量维度

Qwen3-Embedding-0.6B

81.3%

1024

EmbeddingGemma-300m

78.8%

768

jina-embeddings-v3

76.0%

1024

三个编码器上的 token 还原准确率,使用顺序贪心解码(Sequential Greedy Decoding),序列长度 32 token。每个编码器单独训练。

训练曲线

四个编码器配置的训练准确率曲线。所有模型在 50K 步后趋于收敛。

为了看清这个数字的含金量,我们设定了一个基准对照组:让一个普通的语言模型在完全不看向量的情况下盲猜文本。它能写出非常流畅的句子(BLEU 分数很高),但 Token 准确率只有 2.1%。随机 token 更惨,0.02%。

"能说人话"和"说对的话"是两回事。 模型必须从向量中真正提取语义信息,才能在最低的编码器上也做到 76% 的还原。

在解码策略上,我们测试了五种方案。表现最好的是欧拉 + 重掩码(Euler + Remasking):模型每一步去噪后,都会自我检视一遍,把置信度最低的 5% 重新掩码,交给下一步去修正。相当于把 Vec2Text 的外部修正循环内化到了扩散过程里。

实验证明 5% 是一个最优平衡点,比例太多丢掉正确的预测,太低则修正力度不够。

解码策略

jina-v3

Qwen3

Gemma

顺序贪心(Sequential Greedy)

0.715

0.585

0.621

欧拉采样(Euler Sampling)

0.667

0.556

0.604

欧拉 + 重掩码(Euler + Remasking)

0.665

0.584

0.595

两阶段(Two-Stage)

0.667

0.591

0.605

不同解码策略在 10 种语言上的平均余弦相似度。需要注意,这里衡量的是还原文本与原始文本的向量相似度,而非 Token 级准确率。两个指标下的最优策略不完全一致。综合来看,Sequential Greedy 在大多数编码器上表现得最为稳健,是目前最可靠的还原主力。

一个 1024 维的 float32 向量只有 4KB。但这 4KB 足以让一个扩散模型还原出 32 个 token 中超过 80% 的内容。

向量并非不可逆

在很多人的认知中,向量是一道天然的脱敏屏障:文本转化为高维坐标后,原始信息便不可回溯。很多系统也都宣称:“我们只存向量,不存原文,所以用户隐私是绝对安全的。”

这两项研究动摇的正是这个假设。向量不是不可逆的哈希,而是一个有损但信息密度极高的压缩表示。模型的身份、原始文本的内容,都编码在里面,提取的门槛也在不断降低。

指纹研究(Fingerprint)证明了每个模型编码语义的数值风格各不相同,区分度高到一个 80 万参数的小模型就能认出 68 个来源。逆向研究(Inversion)则证明了这些数字里编码的原始信息,足够扩散模型还原出 80% 以上的内容。两个工作串联起来,先用指纹分类器锁定编码器,再用对应的逆向模型还原文本,就构成了一条完整的攻击链路。

对模型开发者来说,这些发现迫使我们直面一个此前被忽视的问题:向量模型的安全边界到底在哪里?过去我们把精力都投在提升语义检索性能上,但从来没认真想过这些向量在安全性上到底暴露了多少。

我们是否该在训练中引入某种信息瓶颈?在保留检索能力的同时,降低向量的可逆性,或者至少让模型的数值指纹不再那么容易被识破?

当然,硬币有另一面。在 API 提供商可以悄悄换模型的世界里,能从数值本身验证模型来源,本身就是一种有价值的审计能力。

两个项目的代码和在线 demo 均已开源:

🔬 在线 Demo: embedding-inversion-demo.jina.ai

💻 代码仓库: github.com/jina-ai/embedding-fingerprints

阅读原文

跳转微信打开

Notion 年度最大更新来了!Custom Agent 首发万字解析

2026年3月9日 14:59

原创 二一的笔记 2026-03-09 14:59 福建

Notion 系统迎来质变时刻

前言


1 月份我就拿到了 Notion 最新功能的 Beta 权限,到现在已有十几个 Notion 全自动工作流被我创建,我的工作效率以一种前所未有的速度在提高,过去的笔记积累终于迎来了质变,我是如此欣喜,因此必须写下这篇文章,向各位分享这份快乐。

这个 Notion 的最新功能名叫 Custom Agent,它正是我在上一篇文章(Notion Agent 完整解析)的末尾所预告的,本年度 Notion 最为重磅的新功能。

它可以让你雇佣一批 7×24 小时持续运转的虚拟员工,然后不知疲倦地替你干活。这意味着,你的工作产出将有机会在「睡后」以十倍甚至百倍计算。

这篇文章又是长到不行,建议准备至少半小时的阅读时间。

我会在前半部分介绍 Custom Agent 的定义和用法,后半部分再介绍我的实践经验,以及它暂时存在的一些负面体验。

另外在正式开始前,介绍一下我专门为Notion AI 搭建的网站,我会在这里长期分享我关于 Notion AI 的各种经验和模板,内容还在更新中,欢迎访问 ⬇️

21notion.ai

具体定义

什么是 Custom Agent


Notion 早已不是单纯的笔记软件,你可以把它看作是一间「数字办公室」。

它有前台(目录导航)、有工位(Page)、有档案室(Database)、有标准流程(Template)、有传送带(Automation)、有内部顾问(AI)、有外包团队(第三方工具联动)。

作为办公室的头头,你在 Notion 里不只是记笔记,更是在安排信息的流动、组织人的协作,最终促成任务的推进和经验的积累。

然而如果你不编辑,任务就会停滞,你不执行,再强的 AI 都在等你开口,这间功能完备的办公室的员工其实只有你一个人,你是所有信息流动的入口和出口,是所有决策的发起和执行。

你可能已经用过 Notion AI,问它一个问题它能给你答案,让它编辑页面或者数据库,它也能立刻完成。但这些操作有一个共同前提:你得打开 Notion 告诉它需要做什么,然后它才会动。

Custom Agent 打破的就是这个前提,你给它设置一套规则,它就会自己一直跑下去,不需要你盯着,也不需要你开口。

这意味着你的产出系数可以从 1 变成 5 甚至是 100,因为每个 Agent 都可以看作是一个自带大脑的虚拟员工。

在我雇佣和培训的十几个虚拟员工里,流程最复杂的一个能在我写完文章后,自动完成从内容优化、SEO 处理、多语言翻译再到跨平台发布的整套自动化流程,一共 11 个复杂步骤,全部由一个 Agent 在一次执行中跑完。

这个案例我会在后半部分具体介绍,但你现在只需要知道一件事:Custom Agent 的上限真的非常非常高。

如何创建 Custom Agent

首先你需要订阅 Notion 的商业版会员,然后点击左上角的新建代理按钮

接下来就会弹出下图所示的设置界面,你需要在这里定义这个虚拟员工的技能和权限:

就像员工入职培训一样,「触发器」是它的上班时间,「指令」是它的工作内容手册,「模型」则是它的脑子,越聪明的脑子处理复杂任务的效果越好,但需要支付的「Token 工资」也就越高。

另外「工具」和「访问权限」则是给这个员工配备的电脑和门禁卡。配置好之后,这个虚拟员工就可以在你划定的范围内自行活动。

值得一提的是,Custom Agent 的活动范围并不局限在 Notion 内部。它可以通过 MCP 和 Notion Worker 连接外部服务、调用第三方 API,具体怎么用我会在后面的案例六和案例七中详细展开。

对于没有编程背景的普通用户来说,Notion 的 Custom Agent 是目前我用过的最直观、最易上手、也最容易发挥实际价值的智能代理方案,远比最近大热的 OpenClaw 更值得推荐。

如果有人不同意这个观点,那么你可以认为他或许了解 OpenClaw,但一定不了解现在的 Notion。

一些案例


接下来我将用七个从简单到复杂的真实场景,帮你建立起对 Custom Agent 能力边界的完整认知。你会看到,单个能力本身可能并不惊艳,但当它们开始互相组合,这个工具就开始变得不一样了。

一、早晨简报

每天早上打开 Notion,你想知道的无非是今天该做什么、哪些事情还悬着、有没有什么需要特别注意的。这些信息散落在不同的数据库页面里里,你需要自己跳转、筛选、汇总,才能拼出一幅完整的图。

所以我创建的第一个 Custom Agent 就是早晨简报,我为它设置了一个定时触发器,每天早上 9 点 Agent 会自动读取我的多个核心数据库,筛选汇总所有我需要关注的信息,然后按照预定格式将整理好的简报写入指定数据库,并向我发送通知。

但早晨简报真正让我觉得有意思的地方,不是它能把信息汇总到一起,而是它会做判断。

它会根据截止日期和前后关系排出建议顺序,逾期的任务会被单独标记,排期撞车了也会主动提醒。这些事情我自己翻数据库当然也能发现,但往往要等到出了问题才会意识到,而 Agent 每天早上都会替我检查一遍。

在这个场景里,「触发器」决定什么时候干,「指令」决定干什么。把这两件事组合起来,你就能延伸出各种自动化场景:

  • • 每天自动生成剪藏数据库的摘要

  • • 每周自动汇总项目进度

  • • 每月自动整理订阅工具的支出与使用情况

当然,单看每天早上的工作量,手动操作也不过 10 分钟,但早晨简报真正节省的不是这 10 分钟,而是每天早上那段最宝贵的注意力。

你只需要打开简报看结果,然后把精力留给真正重要的事。

二、任务跟进

我的 FLO.W 模板的任务数据库有一个字段叫「下一步做什么」,目的是让我在看到这个任务的时候,不需要思考和迟疑,就能立刻知道自己下一步需要做什么。

要想写好这个字段是需要耗费一定的脑力 Token 的,但现在有了 Custom Agent 后,这个字段就可以让 AI 来填写。

首先设置一个触发器:当数据库页面被编辑时

然后给这个 Agent 设置执行规则:读取当前页面的所有内容,包括标题、正文、状态、排期、关联笔记、关联项目、前后置任务等内容,然后进行综合评估,并在「下一步做什么」这个字段里写入 3 条可快速执行的行动建议。

和案例一不同的是,这个 Agent 不按时间表上班,而是在你工作的过程中实时响应,并且不是一边写一边改,而是在你停止页面编辑的三分钟之后自动执行。

下图就是这个 Agent 的思考过程和执行结果

其实这个能力还可以泛化到更多场景,只要你的数据库里有一个字段是「需要人读完内容才能填的」,Agent 就能帮你填。

很多数据库字段之所以一直空着,不是因为你不知道它重要,而是因为填写它需要先阅读页面内容再做判断,这个过程复杂麻烦,久而久之你就放弃了,然后这个字段就会变成一个漂亮但长期失效的设计。

现在 Agent 可以把「读完再填」这一步变成自动动作,页面一更新,它就把该补的字段补上,把该整理的结构整理好。你写下会议记录、咨询记录、剪藏全文等原始信息,Agent 就帮你把它加工成可检索、可统计、可触发下一步动作的数据库字段信息。

这样一来,你的 Notion 数据库就能自己维护自己了,你只管往里面丢原始信息,剩下的交给 Agent 处理。

三、处理邮件

我的邮箱每天都会收到各种通知,包括支付平台的交易确认、SaaS 工具的报告、Newsletter 订阅等等。这些邮件里藏着各种有用的信息,都需要等我一封封打开、阅读、手动摘录。

但现在这个流程完全不需要我参与了,只需要利用「邮件触发器」来激活这个自动化邮件处理流程。当我收到新邮件后, Notion Agent 会自动读取邮件全文,提取我预设的关键信息,然后写入对应的数据库。

我第一个跑通的场景是 Stripe 订单自动入库,当我的网站上有模板售出后,Stripe 都会自动给我发一份订单邮件:

这个时候我的 Agent 就会自动读取邮件里的订单信息,然后把用户信息、付款方案、付款金额等信息写入 Notion 里的 Stripe 订单数据库,然后我就可以在 Notion 中实时看到我的 Stripe 的订单动态了。

同样的逻辑,我还用来处理邮件订阅的 Newsletter。

收到邮件后,Agent 自动触发并读取邮件全文,然后根据我预设的规则生成一段核心摘要,这样一来就算我订阅的是英文邮件,也可以第一时间判断有没有继续阅读下去的必要了。

我觉得再适当做一些补充和优化,完全替代 Readwise Reader 也不是不可能。

你的收件箱里也许没有 Stripe 邮件,但你大概率有各种发票、招聘邮件、学校通知、报销通知或客户反馈,只要信息的来源是固定的、格式是相对稳定的,Agent 就能可靠地完成信息提取和入库。

然后,当邮件能被自动读取、提炼、写入数据库,这些信息就可以被追踪、被统计,甚至触发后续的自动化动作。

或者我们再偷懒一点,你完全可以让 Custom Agent 每天早上读取前一天的所有邮件,然后生成一份邮件简报给你。只要设定好你关注的信息类型,哪怕一天收到 100 封邮件也不需要你再亲自阅读了。

四、智能客服

案例三的 Agent 是一个尽职的记录员,邮件来了它可以帮你写入和归档,但最终还是需要你本人去阅读和处理后续的流程。但如果 Agent 不仅能读懂这封邮件,还能直接回复呢?那它干的就是智能客服的活了。

正好我希望的这些功能 Notion 都支持,Custom Agent 不仅可以读邮件,还可以回复邮件。

基于这个能力我就可以构建这样一个流程:

  1. 1. 持续监控邮箱

  2. 2. 接收到用户咨询邮件时触发 Agent

  3. 3. 读取邮件里的用户问题

  4. 4. 根据问题检索 Notion 知识库

  5. 5. 根据知识库和预设规则生成回答

  6. 6. 调用 Gmail 将答案回信给用户

  7. 7. 如果用户有追问,则重复上述过程

以下就是一次真实的智能客服案例,用户来信咨询问我,如果购买了 FLO.W 模板的「基础版」后,能否付费升级为「进阶版」,而 Agent 给出的回答完美符合我的预期,不仅回答了用户问题,还用上了恰当的话术去促单。

这件事在 Custom Agent 出现之前是做不到的,因为用户邮件的格式五花八门,问题也千奇百怪,你没法用 if-else 规则去穷举所有情况,但大语言模型可以。

不过 Agent 的回复质量不仅取决于 AI 模型的能力,更取决于你的 Notion 知识库的质量,如果知识库组织清晰、覆盖了常见问题,Agent 的回复就会准确且有帮助;如果知识库稀疏或混乱,它就会给出模糊甚至错误的答案。

所以要想做好邮件智能客服得有一个前置条件,你需要先花时间维护一份结构化的知识库,这件事其实比搭建 Custom Agent 本身更为困难。

邮件这个入口一旦被 Agent 接管,整个收件箱就变成了一条自动运转的业务管线——识别、分类、响应,全都不用你亲自动手。

例如,它可以在回信之前先做一层智能分流,识别这是售前咨询、售后问题、退款请求还是合作邀约;也可以把邮件当作一条「线索」来处理,提取客户信息,然后自动安排日程、给负责人发提醒。

甚至还能做风险兜底,当检测到可能触发合规的关键词时,直接升级为人工接管,避免 AI 误判造成事态升级。

另外,邮件只是这个智能客服的入口之一,它的本质是「接收问题 → 触发 Agent → 检索知识库 → 生成回答」,因此如果你在做产品、带课程、或者是在管理一个团队,只要你有「高频、且有标准答案」的问答场景,这个模式都能用。

因为 Custom Agent 除了可以定时触发或被动触发,还支持主动触发,也就是直接打开这个代理,然后和它对话,提交你的问题,它就会按照预设的流程和规则去生成符合知识库的回答。

因此某种程度上你也可以把 Custom Agent 当成类似 Claude Skill 一样的东西去使用。

五、选题助手

很多创作者都会搭建自己的选题库,我也不例外,刷到一个观点,突然觉得这个可以写,于是随手丢进选题库里,起名叫《聊聊 XXX》,然后就没有然后了,90% 的选题都会被我搁置。

因为所有的选题都存在以下三个问题:

  1. 1. 我有没有积累过相关材料?

  2. 2. 这个选题的核心切入点是啥?

  3. 3. 第一段怎么写?

于是选题库会变成一个「灵感墓地」,条目越来越多,真正能写出来的越来越少,积重难返,然后越来越不想打开。

所以我做了一个 Custom Agent 叫选题助手,当我的「选题数据库」有新页面被创建时,这个 Agent 就会被触发,然后自动完成以下两件事:

  1. 1. 素材检索

  2. 2. 大纲生成

比如我现在随便起个无厘头的选题叫做《我是怎么浪费时间的》

然后这个 Agent 就会自动启动,第一件事是检索,它会拿着这个选题,在我的整个 Notion 系统里翻箱倒柜。

我本来只是随手一试,结果它竟然从我的剪藏库里翻出了一篇 TED 演讲笔记,讲的是拖延的心理学机制,然后又从读书笔记里找到了《原子习惯》里关于打破坏习惯的方法论,甚至还挖出了一篇我早就忘了的 Newsletter 剪藏,里面有个博主分享自己如何在细节上过度投入而忽略大方向的经历,最后还有一篇反思效率文化的长文,讨论「觉得自己在浪费时间」本身就是一种被建构的焦虑。

一个随手起的无厘头选题,居然在我的系统里找到了五条完整的素材线索,而且每一条都能独立撑起一个段落。

第二件事是搭架子,它会基于检索到的材料,自动生成一份脚本大纲,开场怎么引,主体分几个要点,每个要点用哪条素材支撑,结尾怎么收,全部帮你排好。比如这个选题它就给出了四个递进的要点,从「浪费时间不等于懒惰」到「我们对浪费时间的定义可能本身就有问题」,最后落在具体可执行的改变方法上。

灵感的生成速度永远快于整理和组织的速度,你能在 10 秒钟内产生一个想法,但要把它变成可发布的内容,往往要付出半天、甚至更长的时间,并且绝大部分的时间都花在了「整理素材」这件事上,这种机械、枯燥的工作最让人倦怠和拖延。

而 Agent 接管了检索和搭架子之后,最爽的一点是,你每次新建一个选题,它都会自动去翻你的旧笔记找素材,然后搭好一份大纲等着你。你平时随手记下的东西越多,选题助手能调用的材料就越丰富。

你也许会说,素材检索这事哪个 AI 不能做?但 Notion Custom Agent 是全自动的、无人值守的,你只管写灵感,剩下的全部交给 AI 自己干。

多么美妙的正循环,哈哈!

六、推特助手

在处理日常任务或项目的时候,我经常会蹦出一些碎片化的思考,这个时候我就会打开 X 平台,然后在输入框里撰写一条帖子并发出去。

但这时候就难免会遭遇注意力切换的问题,经常一打开 X 就会被上面的信息流吸引,然后就忘了自己上一秒想干什么,或者本来就转瞬即逝的灵感思路就会被破坏。

问题的解法也很简单,既然切换场景会导致注意力丧失,那么我不要切换场景不就好了?

所以我创建了一个 X 内容管理数据库,每当我有什么想法要分享,我就在这个数据库里新建页面然后写下要分享的内容即可。

而且写完帖子后我不需要手动复制粘贴到 X,我只需要在看板中把页面从「待办」拖到「进行中」的分组里,也就是把 Status 改成 Ready,那么 Notion Custom Agent 就会帮我把页面里的内容发送到 X 平台上。

这一整套流程具体可以分为这几个步骤:

  1. 1. Agent 持续监控这个数据库

  2. 2. 当 Status 被设置为 Ready 就触发

  3. 3. 读取页面的 Body 字段或者正文内容

  4. 4. 使用 Notion Worker 将内容通过 X 的 API 发布出去

前三个步骤我们已经很熟悉了,但第四步的 Worker 又是什么,它有什么作用?

Notion Worker 你可以理解为一种自定义代码工具,它让 Agent 拥有了「走出 Notion」的能力。如果说 MCP 更像是标准化的插头,那么 Worker 就是你自己焊的电路板,后者更灵活但也相对更麻烦一些。

没有 Worker 的时候,Custom Agent 只能操作 Notion 生态内部的信息,以及 Notion 官方已经接入的少数第三方服务(比如 Stripe、Github 或者 Cursor)。超出这个范围的话,Agent  的手就够不着了。

但有了 Worker 之后,你可以自己写一段代码然后部署到 Notion 的服务器上,让 Agent 通过这段代码去调用外部平台的 API。比如在这个案例里,我用 AI 写了一个叫 postToX 的 Worker,它可以调用 X 平台的官方付费 API,然后把我在 Notion 里写的内容直接发布到我的 X 账号上。

实际跑通之后,整个体验就变成了:想到什么就写进数据库,拖一下状态,帖子就发出去了。从头到尾不需要打开 X,注意力始终留在 Notion 里。也就是说,Notion Worker 让这个虚拟员工学会了「出差」。

它可以带着你的指令走出 Notion 这间办公室,去任何有 API 的地方办事。今天是发推文,明天可以是往 Github 推消息、从数据平台拉报表、调用 AI 接口做图片处理,甚至是把 Notion 里的数据同步到你的财务系统里。

只要你能写出(或者让 AI 帮你写出)对应的 Worker,Agent 的能力边界就可以一直往外扩。

七、博客助手

上一个案例展示了 Worker 怎么让 Agent 走出 Notion,但那只是一个单步操作:读取内容,发到 X 然后结束,接下来这个案例要做的事情复杂得多。

我的网站是用 Next.js + Vercel 搭建的,文章以 MDX 格式存放在 GitHub 仓库里。以前我得在代码编辑器里(例如 Cursor)对着赤裸的 Markdown 写长文,虽然不是不行,但阅读效果实在太辣眼睛了。

所以我为什么不直接用 Notion 撰写和发布呢?

现在我创建了一个博客发布 Agent,配合一个叫 publishBlogPost 的 Worker,我只需要在 Notion 里写完文章,然后把状态从「撰写中」改为「待发布」

Agent 就会自动完成以下 11 个步骤:

  1. 1. 检测文章状态是否被改为「待发布」

  2. 2. Agent 自动唤醒,读取页面全文内容

  3. 3. 扫描其他已发布的文章,找出内容相关页面

  4. 4. 在正文中为合适的关键词插入站内互链

  5. 5. 按照 SEO 策略优化标题和正文关键词布局

  6. 6. 文末生成与文章匹配的个性化 CTA

  7. 7. 将文章按照策略翻译成英文和繁体中文

  8. 8. 调用 API 将三语文章推送到 Github

  9. 9. Vercel 检测到新提交后自动触发部署

  10. 10. 将三篇文章的发布链接回填到数据库

  11. 11. 数据库文章的状态更新为「已发布」

如果你仔细看这 11 步,会发现它其实把前面几个案例里用到的能力全部串了起来:数据库读写(案例一二三)、内容理解和生成(案例四五)、状态触发与调用外部 API(案例六),只不过这一次它们不是单独工作,而是在一条流水线上依次协作,中间没有任何人工介入。

在没有这个 Agent 之前,我写完文章只是完成了相对愉快的那部分,接下来我还得继续检查 SEO 关键词、监督 AI 完成翻译工作、然后命令 AI 把文章推送到 Github 再等待 Vercel 的部署,然后把发布链接回填到数据库。

最消耗人的是写完文章后那种创作状态已经结束了,但你还得硬撑着做一个小时的机械劳动。但现在我在 Notion 里写完文章,把状态拖到「待发布」,然后去泡杯咖啡,等我回来的时候,三语文章已经上线了,发布链接已经回填到数据库里,状态也自动变成了「已发布」。

我的工作在「写完」那一刻就结束了,但产出一直延续到了「三语文章上线」。

不是每个人都有博客,但「写完之后还要做一串重复的事才算真正完成」这个痛点是通用的。做课程的人可能是:写完课件 → 生成讲义 → 上传平台 → 更新课程目录;做产品文档的人可能是:写完文档 → 多语言翻译 → 推到文档站 → 通知相关同事;哪怕只是做周报,也可能是:汇总本周数据 → 生成报告 → 发给领导 → 归档到项目文档。

只要你的流程里有这种「后半段」,它就是 Agent 可以替你接管的部分。

回头来看这七个案例,从最简单的定时简报到最复杂的跨平台发布流水线,Custom Agent 的能力边界其实不在于某个单一功能有多强,而在于这些能力可以自由组合。单个触发器、单次数据库读写并不稀奇,但当它们串联起来,你搭出来的就是一套完整的自动化系统。

但光是「能力可以组合」这一点,跟市面上其他自动化工具也没什么本质区别。真正让我兴奋的是,过去那些积累终于能被用起来了。

我在 Notion 里记了八年的笔记,整理了上百个数据库,写了几十篇文章和视频脚本,剪藏了数不清的链接。这些东西过去就是静静躺在那里,偶尔被我翻出来看一眼,大部分时候连我自己都忘了它们的存在。它们是沉没成本,是你曾经花了时间但不确定什么时候能用上的积累。

但 Custom Agent 让这些沉睡的积累突然变成了可以被自动调用的资源。选题助手会翻我的旧笔记找素材,早晨简报会汇总散落在各处的任务数据,智能客服会检索我亲手写的知识库来回复用户。

每一个 Agent 都在消费我过去的积累,而我每一次新的记录又在为所有 Agent 提供更多燃料。这才是我觉得 Notion Custom Agent 真正厉害的地方:它长在你现有的系统里面,你过去积累得越多,它能干的事就越多。

你过去在 Notion 里花的每一分钟,都在变得更值钱。

一些经验

聊完了几个案例,接下来分享一些我在实践过程中总结出的经验,有些是关于架构设计的,有些是关于心态调整的,但它们的共同点是,如果我早一点知道,可以减少浪费许多的时间和积分。

一、邮件路由模式

当你拥有的 Agent 越来越多,一个问题就会开始浮现:每个 Agent 都需要一个触发器,而每次触发都会不同程度地消耗 Credits。

假设你有三个邮件 Agent 分别处理订单、客服和 Newsletter,每收到一封邮件,三个 Agent 同时被唤醒、各自解析,最后只有一个真正对口,另外两个白忙一场。我的解决方案是只用一个 Agent 做入口,负责识别和分流。

首先,如果你订阅了 Notion AI,那么 Notion 官方推出的 Mail 应用可以用 AI 给你收到的邮件打标签,这一步是不需要消耗 Custom Agent 的 Credits 的。

然后回到 Custom Agent,将邮箱的触发器改为「当标签已应用于邮件」

那么当邮件进来时,只有符合我需求的邮件才会被分别打上 Stripe 订单、OpenWidget、Newsletter 等标签,在这之后邮箱 Agent 才会被唤醒,然后再按照不同的标签去触发不同的子场景文档,如下图所示:

每个子场景的具体执行规则,都写在独立的子页面里,然后主指令通过 @ 的方式引用这些子页面,Agent 只有在命中对应路由时才会去加载那份子页面的内容。这意味着处理 Stripe 订单时,Agent 不会读取 Newsletter 归档的规则,每次执行只加载必要的上下文,既省 Credit 又减少干扰。

这个分流的思路在上一篇文章(Notion Agent 完全解读)就有介绍,在 Custom Agent 里同样适用。场景路由让不该醒的 Agent 别醒,邮件标签在 Agent 启动之前就把垃圾邮件挡掉了,指令拆成子页面按需加载而不是一股脑全塞进去。

所以每次建新 Agent 之前,除了想「它要干嘛」,也值得想想它什么时候不该被叫醒。

二、先有问题再找答案

在刚用上 Custom Agent 的时候,我的第一直觉是过去沉积的那些笔记和任务有救了。这些内容我自己都快忘了,但总觉得它们有价值,只是缺一个契机去重新激活。

于是我立刻做了两个 Agent,一个叫「随机任务」,每天随机捞一条旧任务,然后给我一份重启建议;另一个叫「随机笔记」,每天随机捞一条旧笔记,问我「这个想法你现在怎么看」,试图帮我重新审视过去的思考。

想法很美好,但跑了一段时间后我发现,这两个 Agent 的推送信息我几乎都不看,或者看完后也没有什么下一步的动作,因为每次都觉得阅读的负担太大。后来我把这两个 Agent 和前文案例五的选题助手放在一起对比,才想明白问题出在哪。

选题助手同样也是在翻找旧数据,不论是从几个月前的剪藏资料库、还是从去年的读书笔记里找,但它之所以让我觉得有用,是因为我刚刚创建了一个新选题,这个选题就是一个天然的目标过滤器,然后 Agent 带着「这个选题需要什么」的问题去检索,找回来的东西自然是相关的、或者我感兴趣的。

而随机任务和随机笔记没有这个过滤器,它们的触发器是定时机制,不是你当下的任何需求,因此没有预设目标的问题检索只会带回一堆与你此刻无关的信息,最终变成噪音。

所以问题不在于数据是新的还是旧的,而在于 Agent 动手的那一刻,有没有一个明确的「当下需求」在驱动它。

这意味着你应该把触发器设计成「当下事件」,例如一封新邮件到了、一个新选题被创建了、一个任务状态变了、一天开始了需要看简报。在这些事件的驱动下,旧数据作为被调用的资源自然会发挥价值。但如果没有事件驱动,单纯让 Agent 去主动推送历史信息,你大概率只会觉得它们很烦。

三、建好只是开始

建一个 Agent 可能一句话十分钟就搞定了,真正费劲的是后面那段漫长的养成期。这个过程很像带一个新员工,入职第一天你并不能指望它什么都做好。

因此, 第一版指令千万别追求完美,只写最核心的步骤,让它先跑起来就行,跑完再看看哪里不对,因为你总会漏掉一些自己没想到的边界情况。

并且就算它成功跑起来了,我也建议你经常性地复盘和反思,去验证 Agent 的执行结果,去认真评估这个 Agent 存在的必要性,如果觉得它可有可无,那就不要犹豫将它删掉,否则时间一长你就会对一堆 Agent 的推送通知感到麻木,到最后什么是有用的、什么是噪音,你自己都分不清了。

如果有必要的话,还可以给这个 Agent 专门创建一个记忆页面,让它每次执行前先读一遍、执行完再把关键信息写回去,相当于拿 Notion 页面充当它的外部记忆。内容不用写得好看,真实准确就行。这样你才能在一次次的小调整里,慢慢把一个粗糙的 Agent 磨成真正靠谱的虚拟员工。

不少缺点

聊了那么多用法和优点,接下来也该诚实聊聊这个新功能目前还存在的一些不足。

一、积分压力

首先是积分制带来的心理压力比我预想的大,因为 Notion 的 Custom Agent 是按积分计费的,并且暂定的价格是 1000 Credits/10$,当前在测试阶段免除积分费用,5 月 4 号后就要开始正式收费了,真的贵到我边用边骂。

当然下图的 5 万积分不是正常情况,排除掉测试用例,我一个月下来的实际开销应该得在 3 万积分左右,但也要 300 美元,这已经能同时订阅 ChatGPT Pro + Claude Max 5X 了,我觉得光这一点就能把你刚才阅读本文的所有热情浇灭。

更让我觉得可惜的是,Notion 目前没有提供 BYOK(Bring Your Own Key)选项,你不能接入自己的 API Key 来降低成本。

但好消息是,现在还在测试阶段,一切都还有转机。

Notion 显然也知道这样的积分消耗根本无法拓展市场,所以很快就加入了国产模型 MiniMax 2.5,这也是 Notion 第一次有国产模型的加入,虽然智能程度有所下降,但积分消耗至少能降低三分之二,用来执行简单的定时循环任务也足够了。

并且 Notion CEO 表示还会有更多的可选模型加入,值得期待一下。

二、边界与稳定性

成本之外,能力边界也是一个绕不开的限制。 Worker 确实让 Agent 可以派一个外勤去「出差」,但它出差的方式有点像是被关在一个只有 Wi-Fi 的酒店房间里,只能通过公网 HTTP 请求和外面通信,不能碰你的内网资源,也不能调用本地服务。

而且 Worker 是按需执行的,干完活就走,没办法保持长连接,所以如果你想让 Notion Agent 操作本地文件、调用本地跑着的模型、或者和局域网里的设备打交道,这些需求暂时都还做不到。

Worker 更像是一扇刚打开的窗户,你能看到外面的风景,但想自由地走得更远还需要再给它一些时间。

还有个问题是是页面权限的稳定性, 因为它不是「出了错你能看到」的那种显性问题。 我偶尔遇到过几次这样的情况是,Agent 被赋予的页面访问权限莫名其妙地丢了,表面上工作流还好好地挂在那里,实际上它已经因为权限问题停摆了很久,而我根本没收到任何提示,这种「静默失败」比直接报错恐怖得多,虽然遇到的频率并不高,但一旦出现还是挺麻烦的。

三、通用性

以上这些都还是技术层面可以迭代的,最核心的问题在于,Custom Agent 的价值,和你在 Notion 里扎根的深度几乎是一比一绑定的。

前面那七个案例之所以能跑通,之所以让我这么兴奋,是因为我在 Notion 里记录了八年,有上百个数据库、无数条笔记和结构化信息供 Agent 调用。但如果你不是 Notion 用户,或者你的 Notion 里只有零零散散的几页东西,那 Custom Agent 对你来说意义就没有那么大。

它所有的感知、思考和行动都以你的 Notion 工作区为圆心,离开这个圆心它的价值就会迅速下降。相比之下,Claude Code 或者 OpenClaw 不挑场地,你的本地文件系统、任意第三方 API、任何开发环境都是它们的工作台,灵活性和可覆盖的范围确实要宽得多。

所以如果你问我「要不要入坑 Notion Custom Agent」,我的回答是:先问问自己在不在 Notion 里。 如果你已经在这里并且积累够深,它能帮你把过去的积累全部激活;但如果你还没进来,那现阶段可能有比它更通用的选择。

不过话说回来,如果你看到了这篇文章的这个位置,你大概率已经是 Notion 用户了吧。

写在最后


写到这里我唯一确定的一件事是,Custom Agent 真正带来的变化,发生在你和系统的关系上。

以前很多整理和记录需要你不断推动才会往前走,现在你只要把规则讲清楚,系统就会自己继续运转。你多年积累的笔记、字段、文档,会在你不盯着的时间里被读取、被调用、被转化成下一步的行动与产出。

我也不想把它写成一件轻松的事。积分带来的焦虑、Worker 的限制、权限偶发的静默失效、生态绑定的硬边界,都是真实存在的麻烦。有些问题短期内可能不会消失,但我仍然愿意继续用下去,因为方向足够明确,收益也足够具体。

因此如果你想开始,建议从一个最小的场景入手。做一个早晨简报,或做一个自动补字段的小工具,让它先跑起来。你会很快体验到那种醒来发现事情已经被处理过的感觉。

等你尝到第一口甜头,后面的流程自然会一点点长出来。


本文中提到的所有 Agent 案例,都运行在我所搭建的 Notion 系统 FLO.W 思流之上。它不只是一套 Notion 模板,更是一个专为 AI 时代设计的操作系统。

👉 了解详情与购买:21notion.com

阅读原文

跳转微信打开

DeepSeek DualPath 论文详细解读

2026年3月6日 20:01

原创 AI闲谈 2026-03-06 20:01 北京

没等来 DeepSeek V4,等来了 DualPath,虽然没有非常多算法上的创新,依然是个非常不错的工程实践。依照惯例,这里我们对 DeepSeek 的这篇文章进行重点介绍。

一、引言

没等来 DeepSeek V4,却先等来了 DualPath。虽然它在算法层面并没有带来特别显著的创新,但从工程实践的角度看,依然是一项非常值得关注的工作。业内已经有不少关于 DualPath 的介绍,不过按照笔者的一贯习惯,对于这类具有较强启发性的技术方案,还是希望进行一次较为系统的解读。

对应的论文:[2602.21548] DualPath: Breaking the Storage Bandwidth Bottleneck in Agentic LLM Inference

DeepSeek 的相关文章可以参考:

其他相关文章可以参考:

    二、摘要

    多轮、Agentic LLM Inference 的性能越来越受 KV-Cache 存储 I/O 主导,而非算力主导。在主流 PD 分离架构中,从外部 Storage 加载海量 KV-Cache 会产生根本性失衡:Prefill Engine 的 Storage NIC 带宽饱和,而 Decoding Engine 的 Storage NIC 却处于闲置状态。这种不对称性严重制约了系统整体吞吐量。

    为此,DeepSeek 提出 DualPath Inference 系统,通过引入双路径 KV-Cache 加载机制突破上述瓶颈。在传统 Storage-to-Prefill 路径之外,额外实现了 Storage-to-Decoding 路径,将 KV-Cache 加载到 Decoding Engine 后,通过后端计算网络的 RDMA 技术高效传输到 Prefill Engine。该系统融合了两大创新:

    • 优化数据路径:该路径天然可以规避网络拥塞,且不对延迟敏感的模型 Forward 通信产生干扰。

    • 全局调度器:动态平衡 Prefill Engine 和 Decoding Engine 的负载分配。

    基于三种模型在真实 Agentic 工作负载下的评估表明,DualPath 在自研的推理系统中将 Offline Batch Inference 吞吐提升 1.87x;在满足 SLO 的前提下,Online Serving 吞吐平均提升高达 1.96x。

    三、背景

    3.1 标准 DGX Superpod 集群

    3.1.1 DGX H100 System

    如下图所示为一个 DGX H100 System(具体可以参考 Introduction to the NVIDIA DGX H100 System [2]),其包含:

    • 8 个 H100 GPU,每个 GPU 900 GB/s NVLink 带宽。

    • 总共 900*8=7.2TB/s NVSwitch 带宽,80*8=640GB HBM3 显存。

    • 8 个 400 Gbps 的 ConnectX-7计算网卡,提供 8*400 Gbps 带宽(4 x OSFP ports)。

    • 2 个 400 Gbps 的 ConnectX-7存储网卡,提供 2*400 Gbps 带宽(Slot 1 和 2)。

    • 1 个 100 Gbps Ethernet NIC(前端网络,Slot 3)。

    3.1.2 SuperPod SU

    如下图 Figure 2 所示为构建 DGX-SuperPod-H100 的基本单元,称作 SuperPod SU(Scalable Unit):

    • 每个 SU 中包含 8 个 Compute Rack,每个 Rack 40 KW。

    • 每个 Compute Rack 包含 4 个 DGX H100 System,以及 3 个 PDU(Power Distribute Unit),也就是每个 Compute Rack 32 个 H100 GPU,则一个 SU 有 256 个 H100 GPU。

    3.1.3 Management Rack

    在 H100 对应的 DGX SuperPod 中,NVIDIA 提供了 Management Rack。如下图 Figure 3 所示为一个示例(针对不同的规模相应的配置会有所改变),其包含:

    • 后端计算网络:

      • 32 个 LeafCompute Switch,使用 QM9700,每个可以提供 64 个 400Gbps 的 Port。理论上有 32*(64/2)=1024 个 400Gbps Port 可以连接节点上的 ConnectX-7 网卡,剩下的 1024 个 Port 正好连接 16 个 Spine Compute Switch,实现 1024 GPU 的无阻塞(Non-Blocking)网络。

      • 16 个 Spine Compute Switch,同样使用 QM9700。正好连接 32 个 Leaf Compute Switch 的一半 Port。

    • High-Performance 存储网络:

      • 8 个 Leaf Storage Switch,同样使用 QM9700,连接存储网络的网卡和 Spine Switch。

      • 4 个 Spine Storage Switch,同样使用 QM9700,连接存储网络的 Leaf Switch。

    • 前端网络:

      • 6 个 SN4600c In-Band Leaf Switch。

      • 2 个 SN4600c In-Band Spine Switch。

    • 管理网络:

      • 8 个 SN2201 Out-of-Band Leaf Switch。

    3.1.4 DGX SuperPod 127-node

    如下图 Figure 5 所示为一个 127 节点的 DGX SuperPod 对应的计算网络,对应 4 个 SU,以及一个上述的 Management Rack。理论上上述的 Management Rack 正好可以连接 4 个 SU 的 128 个 Noe,但是 Leaf Switch 有一部分连接了 UFM(Unified Fabric Manager),所以实际上只有 127 个节点(NVIDIA 在最新的交换机中优化了这个部分,不会再出现少一个节点的情况)。

    如下图 Figure 6 所示为其对应的 High-Performance 存储网络,也可以看出,计算网络和存储网络是独立的网络平面,互不联通。

    如下图 Figure 8 所示为前端网络,也是独立的网络平面:

    3.2 DeepSeek H800 集群

    DeepSeek 在 [2505.09343] Insights into DeepSeek-V3: Scaling Challenges and Reflections on Hardware for AI Architectures [3] 中也介绍过其 H800 集群的网络拓扑,如下图 Figure 2 所示,其与标准 DGX H100 有所不同,其不是 2 个 High-Performance 存储网卡,每个节点只有一个 400 Gbps 的存储网卡。(PS:其并没有介绍是否还有独立的前端网卡,还是 Storage NIC 就是东西向网络,而计算网卡是南北向网络。)

    3.3 当前系统的问题

    当前 Agentic 应用场景快速发展,输入序列长度急剧增加,KV-Cache 的加载成为主要瓶颈。

    • 如下图 Figure 1 左侧所示,Prefill 节点使用 Storage NIC 加载 KV-Cache 的利用率达到 100%,而 GPU 的利用率只有 40%。与此同时,Decode 节点的 Storage NIC 利用率极低。

    • 如下图 Figure 1 右图所示,通过利用 Decoding 节点的 Storage NIC + 后端计算网络 NIC 作为 KV-Cache 加载的第二路径,可以更加充分的提升 Prefill 节点的利用率。

    四、方案

    4.1 方案概览

    DualPath 依赖两种广泛认可的技术:

    • PD 分离:Prefill 和 Decoding 分开部署,以获得更高的效率。

    • Layerwise Prefill:按层加载 KV Cache,可以和计算 Overlap,提升 GPU 利用率。 

    DualPath 系统包含以下几个关键组件:

    • Inference Engine:每个 Engine 管理一个 GPU,其中 Prefill Engine 简称 PE,Decoding Engine 简称 DE。

    • Traffic Manager:采用以计算网卡为中心(CNIC-centric)的流量管理方案,以防止 KV-Cache 的后端流量干扰模型 Inference 的正常通信。每个 Engine 包含一个 Traffic Manager,用于:

      • CPU DRAM 和 GPU HBM 之间的数据拷贝(H2D 和 D2H)。

      • PE 和 DE 之间的 KV-Cache 传输。

      • 经由 Storage NIC 读写 Storage 中的 KV-Cache。

    • Request Scheduler:中心调度器,负责:

      • 接收 Client 端 Request 并将其分发给各个 Engine。

      • 在两条数据加载路径之间进行动态的流量分配。

    4.1.1 DualPath 加载

    DualPath 的核心创新是在 “Storage-to-Prefill” 的路径外,额外引入一条 “Storage-to-Decoding” 的路径。允许 KV-Cache 先加载到 DE 中,然后通过高带宽的计算网络(经 RDMA)传输给 PE。通过在两条路径之间动态分配负载,能够聚合所有 Engine(包括原本闲置的 DE 侧的 Storage NIC)的存储带宽资源,进而将 Storage I/O 从单一资源瓶颈转变为一个全局池化且可调度的资源。具体数据流程如下所示,为了实现 DualPath 加载,会在每个 PE 和 DE 预留少量的 DRAM 作为缓冲区,称为 PE Buffer 和 DE Buffer:

    • Prefill PE 读路径(Figure 4a):

      • 命中的 KV-Cache 从持久化 Storage 中经存储网卡(SNIC)读取到 PE Buffer 中(1 和 2)。

      • 该过程会逐层进行并充分的 Overlap。

        • 以 Layerwise 的方式将 KV-Cache 逐层加载到 GPU HBM 中(3 和 4)。

        • 逐层加载后的 KV-Cache 可以立即启动计算。

        • 计算后的命中 KV-Cache 和未命中 KV-Cache 会经计算网卡(CNIC)传输到 DE Buffer 中(5、6 和 7)。

    • Prefill DE 读路径(Figure 4b):

      • 命中的 KV-Cache 从持久化 Storage 中经存储网卡(SNIC)读取到DE Buffer 中(1 和 2)。

      • 该过程会逐层进行并充分的 Overlap。

        • PE 以 Layerwise 方式经计算网卡(CNIC)从对端 DE Buffer 中拉取命中的 KV-Cache(3、4 和 5)。

        • 逐层加载后的 KV-Cache 可以立即启动计算。

        • 某一层计算完之后只需将未命中的 KV-Cache 传输给 DE Buffer,然后与 DE Buffer 中命中的 KV-Cache 合并。

    • Decoding 阶段:

      • 在 DE Buffer 中拼凑齐完整的 Prompt KV-Cache后(包括网络传输来的和新生产的),Decoding 阶段便正式开始。

      • DE 首先在自己的 HBM 中分配所需显存,执行 H2D 传输,并在开始模型 Decoding 之前主动释放 CPU DRAM,避免浪费。(PS:增加 DE Buffer 会额外引入一次 H2D 操作,实际上可以使用 RDMA 直接写入 HBM,但是考虑到 Agentic 场景中 TTFT 耗时占比很大,DE Buffer 能够有效缩短 KV-Cache 在 HBM 中的占用周期)

      • 在 Decoding 阶段,每当积攒够一个完整的 Block(通常 64 个 Token),系统立即将它们持久化写入 Storage。

    • 不同的数据块布局:系统采用两种不同的内存布局类型:

      • Full Block:存储全部层的数据,对于所有的 Storage 存储操作,均使用 Full Block 以提升吞吐。

      • Layer Block:存储单层的数据,当 PE/DE 数据在 HBM 和 CPU DRAM 中逐层流式搬运时,均使用 Layer Block。

    4.1.2 Bottleneck-Free 分析

    作者通过数学形式论证,在绝大多数合理的 P/D 比例配置下,该系统可以跑满 SNIC 的带宽,而不会引入任何 CNIC 或 DRAM 方面的新瓶颈。

    假设:各节点的 PCIe 拓扑结构优良,调度实现负载均衡,计算网络不拥塞,且整个系统的存储读带宽被 100% 使用。

    参数定义:

    • 设 P 和 D 为 Prefill 节点和 Decoding 节点的数量。

    • 每个节点包含 g 张 GPU(并配有带宽为 B 的 CNIC),节点 CNIC 总带宽为 B x g。

    • 每个节点 SNIC 总带宽为 B x s,这里 s 可以理解为折算系数(1 个 200Gbps SNIC,则 s=0.5,2 个 400 Gbps SNIC,则 s=2),由节点内所有 Engine 共享。

    • M 为单个节点的 DRAM 带宽。

    每个 PE-DE 对流量:

    • PE 读路径:流量为 Tp = Bs/(Dg2)。

      • 共有 Pxg 个 PE,Dxg 个 DE;也就是有 Pxg 个发送端,Dxg 个接收端。

      • 全集群可能的 “PE-DE Pair” 为 (Pxg) x (Dxg) = PDg2。

      • Prefill 节点全集群拉取 KV-Cache 的带宽为 PxBxs。

      • 在极端均衡的情况下,可以得出每个 PE-DE 对的流量为:Tp = PxBxs / (PDg2) = Bs/(Dg2)。

    • DE 读路径:流量为 Tc = Bs/(Pg2)。

      • Decoding 节点全集群拉取 KV-Cache 的带宽为 DxBxs。

      • 在极端均衡的情况下,可以得出每个 PE-DE 对的流量为:Tp = DxBxs / (PDg2) = Bs/(Pg2)。

    PE 侧的 CNIC 带宽分析:由于存在不会跨交换机的回环流量 (Loopback traffic,即 H2D/D2H),PCIe 侧的总流量始终大于等于交换机侧的流量。因此只需要计算 PCIe 的压力即可。

    • 读操作包括 PE 路径中的 (3 和 5),如下图 Figure 4 中绿框,所有对的总流量为:2 x Tp x Dg = 2Bs/g <= B。实际中 2s < g 通常都成立,因此读方向没有瓶颈。

    • 写操作包含 PE 路径中的 (4) 和 DE 路径中的 (5),如下图 Figure 4 中蓝框,所有对的总流量为:(Tp + Tc) x Dg = Bs/g x (1 + D/P) <= B。因此可以得出 P/D >= s/(g-s)。

    DE 侧的 CNIC 带宽分析:

    • 读操作包括 PE 路径中的 (8) 和 DE 路径中的 (3 和 6),如下图 Figure 4 中绿框,所有对的总流量为:(Tp + 2 x Tc) x Pg = s/g x (P/D + 2) x B <= B。因此可以得出 P/D <= (g-2s)/s。

    • 写操作包括 PE 路径中的 (7 和 9) 和 DE 路径中的 (7),如下图 Figure 4 中蓝框,所有对的总流量为:(2 x Tp + Tc) x Pg <= B。因此可以得出 P/D <= (g-s)/2s。

    DRAM 压力分析:DRAM 是半双工的,读写相加,PE 侧压力极低;对于 DE 侧,要求压力不超过 M,得出条件:P/D <= (M/(Bs) - 3)/2。

    总的来说,合并并简化上述不等式,可以得出系统安全的配比为:

    s/(g-s) <= P/D <= min{(g-2s)/s, (g–s)/2s, (M/(Bs) - 3)/2}

    例如:

    • DeepSeek H800 系统:g=8,s=1,M≈500GB/s,B≈50GB/s,得出 1/7 <= P/D <= 7/2。

    • NVIDIA DGX H100 系统:g=8,s=2,M≈500GB/s,B≈50GB/s,得出 1/3 <= P/D <= 1。

    4.1.3 实践挑战

    DualPath 在理论上可以利用 Decoding 节点闲置的 I/O 来缓解 Prefill 节点的压力,但想要实现会面临 3 个工程挑战:

    • 细粒度数据传输:Layerwise 方式可以克服 HBM 容量瓶颈,但会将 Full Block 的 KV-Cache 拆分成很多 Layer Block 的细粒度 KV-Cache。这些碎片化的 KV-Cache 在 Storage、DRAM、HBM 之间高频传输,要求系统不能有明显的调度开销,并且能无缝的与计算 Overlap。

    • 流量隔离:DualPath 生成了远比单机 Inference 复杂的内部 KV-Cache 传输网络流。非常容易干扰模型并行 Inference 中极度看重时延的集合通信操作(如 All2All 和 AllReduce)。如果因为传输 KV-Cache 导致通道拥塞,整个 Forward 的卡顿将是致命的。挑战在于“在压榨出所有空闲 I/O 带宽的同时,不允许对模型的正常通信性能造成任何负面影响”。

    • 动态负载均衡:系统中存在两条 KV-Cache 的读路径,系统必须对每个新到来的请求在线决策“该走哪条路”。Traffic Manager 必须在极短的时间窗内,实时综合多个瞬态因子来权衡:包括 SNIC 的队列深度、GPU 上的计算负载,以及 Request 负载特征等。

    4.2 以 CNIC 为中心的 Traffic Manager

    LLM Inference 系统中广泛采用先进的数据传输技术(比如使用 GPU 上的 Copy Engine 和 GPUDirect Storage)实现 Storage、DRAM 和 HBM 之间的高效搬运。然而这些机制存在一个严重的缺陷,严重干扰模型 Forward 期间对时延敏感的集合通信操作(如 All2All 和 AllReduce),主要有 2 个原因:

    • 这些数据传输技术往往运行在独立的数据路径上,这些路径与计算网络没有共享同一套 QoS 控制机制。

    • 现有的 GPU 不支持 PCIe 层级的 QoS,导致很难保护 Model Forward 通信不受其他 PCIe 流量的干扰。

    此外,集合通信往往以亚毫秒级的极快突发形式出现,试图依靠纯软件维度的流量整形器去在这些高优且转瞬即逝的通信窗口之间,精确穿插低优先级的 I/O 读写操作,在工程上是不切实际。

    为了解决这一问题,作者提出:以 CNIC 为中心的数据传输方案——所有进出 GPU 的数据流向,包括 GPU 与通节点的 H2D/D2H,都必须强制经由这块 GPU 绑定的 CNIC,并依靠 GPUDirect RDMA 数据链路完成。通过将所有异构流量强行收拢并暴露在计算网络上,可以充分利用计算网络底层的原生 QoS 硬件能力,来实施绝对严格的流量隔离与分级管制。

    4.2.1 流量隔离

    对于基于 IB 的网络,可以利用虚拟信道(Virtual Lanes, VL)技术实现流量类别间的硬隔离。(PS:DeepSeek 在 3FS 中也提到,利用 IB 的 Service Level(SL)技术,在节点之间建立连接时为其分配不同的 SL 值,并将 SL 映射到 IB 物理队列 VL,使用 VL 可以确保不同通道中的流量不会相互干扰。)

    • 所有与模型 Inference 相关的 Forward 通信流量都被全部调度到专有的 High-Priority VL 中。

    • 所有其他流量,包括 DualPath 的跨节点 KV-Cache 传输,全部被映射到一条隔离的 Low-Priority VL。

    • 为基于该通信框架内的 Switch 和 NIC 的 VL 仲裁器配置极端的加权轮询参数策略,为 High-Priority VL 预留大约 99% 的带宽,仅把剩余的带宽留给 Low-Priority VL,以防止 KV-Cache 传输彻底饿死断连。这种配置可以保证模型 Forward 的通信流量免受 KV-Cache 传输的干扰,同时又给 KV-Cache 传输利用计算网络中的闲置带宽提供机会。

    尽管上述方案基于 IB 网络,但该隔离设计原则上能够平滑的迁移到其他网络互联技术中。例如,在 RoCE 中,DualPath 可以基于 Traffic Class 控制器并结合 DSCP 组合实现。

    4.2.2 CNIC 辅助的 KV-Cache 拷贝

    目前常见的两种 GPU 数据传输流派包括:从底层 Storage 直接传输到 HBM 的 GPUDirect Storage,以及传统基于 CUDA Copy Engine 的方式。这两种方式无法实现 KV-Cache 传输的 I/O 操作与模型 Forward 中的集合通信操作互相隔离,会导致模型 Forward 性能退化。

    为了解决这一痛点,实现了 CNIC 辅助的 H2D/D2H 数据路径。

    • 对于 KV-Cache 加载:

      • 首先从 Storage 后端中读取 KV-Cache 到 DRAM。

      • 然后向目标 GPU 对应的 CNIC 下达 RDMA 写请求,以便进行本地的 H2D 拷贝。

    • 对于新生成的 KV-Cache 的存储:

      • 首先交由对应的 CNIC 写入 DRAM 中缓存。

      • 然后通过 SNIC 写入 Storage 后端。

    这种设计可以将 CNIC 作为所有 GPU PCIe 流量的中心 QoS 调度器,使其 VL 仲裁器能够优先处理 Inference 通信流量,并利用空闲的 PCIe 带宽执行 KV-Cache 传输。

    作者观察到,在处理大量小数据 Block 时,CNIC 辅助的 H2D 和 D2H 传输性能优于 CUDA Copy Engine。测试数据表明,通过 cudaMemcpyAsync 提交的单次复制操作会产生约 5-7 μs 的延迟开销,由于 CUDA Driver 是闭源的,无法进一步分析该开销的构成。相比之下,提交单个 RDMA 写入请求仅需在用户空间对 NIC Register 执行少量的 mmio 写入操作,耗时仅 1μs。此外,通过 doorbell batching 技术,可以显著分担 RDMA 工作提交开销。

    4.3 自适应请求调度器

    理论分析证实 DualPath 读取不会产生绝对瓶颈,但在实际运行中,负载不均仍会大幅降低硬件利用率。在这种情况下,需要同时兼顾 NIC 流量和 GPU 利用率之间的平衡。为此,将调度分为两个层次:

    • 跨 Engine 调度:负责将 Request 精确分配给一对目标节点(PE,DE),并为每个 Request 判定具体的 KV-Cache 读取路径(PE 或 DE)。

    • Engine 内调度:负责 Engine 内 Request 如何处理。

    4.3.1 跨 Engine 调度

    为了减轻调度器的压力,将 Engine 分为不同的组,只有组内编号 Rank 0 的 Engine(也称为 Leader Engine)与调度器交互。一个组内所有 Engine 要么都是 PE,要么都是 DE,且确保同一个节点上的所有 Engine 都属于同一个组。

    组内的所有 Engine 会定期、同步主动拉取任务。在拉取新的 Request 时,每个 Engine 同时上报 3 个关键状态指标:

    • seqe:已分配给该 Engine 但还未完成的 Request 数量。

    • toke:上述 seqe 个 Request 包含的总 Token 数量。

    • read_qn(e):Engine e 所在节点 n(e) 当前磁盘读取队列长度。

    因为 GPU 负载、磁盘读负载以及网络负载压力与 Token 数量密切相关,因此使用 Token 数量(toke)作为平衡所有 Engine 的代理指标。

    PE 调度:所有抵达调度器的 Request 都首先进入全局等待队列,并严格按照 FIFO(先进先出)原则调度。当一个 PE 组发起一个拉取请求时,启动调度算法。如下图 Figure 5 所示,定义两个阈值:短读取队列 α,未完成 Token 上限 β。所有 Engine 被分为 3 类(如下图 Algorithm 1 中红框):

    • 第一类(过载 Engine):toke > β,排队处理的 Token 超标。

    • 第二类(理想 Engine):未超标,且 read_qn(e) <= α,toke <= β。

    • 第三类(磁盘受压 Engine):节点的磁盘读取队列较长,read_qn(e) > α,toke <= β。

    系统绝对不会将新的 Request 发送给过载 Engine,此外让第二类的调度优先级高于第三类——因为第二类节点 SNIC 此刻没有磁盘排队任务,如果不安排新的 Request,将导致 SNIC 处于低利用率。当选中类别后,会将 Request 调度到类别中 toke 最小的 PE,然后会更新当前 PE 的 toke(如下图 Algorithm 1 蓝框);接着处理下一个 Request。直到队列为空或者第二、三类别都满为止(如下图 Algorithm 1 绿框)。

    DE 调度 - 阶段 1:跨组全局调度:与 PE 强制全局 FIFO 不同,DE 的调度分为两级,且不保证绝对的全局 FIFO。存在一个全局等待池,以及每个 DE 组的私有队列池。新 Request 先落到全局池。当一个 DE 组来拉取任务时,会针对性清空全局等待池,并将任务直接发给当下总 toke 最小的 DE 组。

    DE 调度 - 阶段 2:组内处理:

    • 首先计算本组所有 DE Engine 的 HBM 余量,随后从私有队列池头部开始遍历,以计算假设不存在 HBM 碎片时可调度的 Request 数量。这些 Request 构成集合 R,作为可以调度的上界。然后计算一个“危险界线”——高 Token 阈值 Z:

    • 然后从私有队列池的头部开始调度 Request,将其调度到剩余 HBM 满足该 Request 需求的 DE Engine。具体来说,将 DE 分为两种类型,并优先将 Request 调度到(2)中 seqe 最小的 DE,从而平衡 Request 数量;只有(2)为空,才会在(1)中挑选 toke 最小的 DE,以避免 HBM 用满触发抢占风险。

      • (1):高 Token DE,如果接收该 Request,则 toke + len(r) > Z。

      • (2):剩余 DE,即使接收 Request,依然满足 toke + len(r) <= Z。

    KV-Cache 读任务调度:为一个 Request 选好 PE 和 DE 后,调度器最后只需选择较短读队列长度的路径读取 KV-Cache 即可。理论上,将 Request 拆分成两部分,从 PE 和 DE 两个路径同时读取会更好,不过本文中并没有实现,当做未来的工作。

    4.3.2 Engine 内调度

    Engine 内的细粒度调度只发生在 PE 节点,因为 DE 总是把所有 Request 放入一个 Forward Batch,不需要过度调度。如下图 Figure 6 展示了 Engine 内调度方式,常见模型在 Attention 层都会采用 DP 方式,尤其是 MLA 模型:

    • Dense 模型或粗粒度 MoE 模型可能会采用 Attention TP + FFN TP 方式。

    • 细粒度 MoE 模型(MHA/GQA)可以考虑 Attention TP + FFN EP 或 Attention DP + FFN EP。

    • 细粒度 MoE 模型(MLA)模型一般采用 Attention DP + FFN EP,MLA 不适合 TP,甚至可以考虑 CP。

    在这种情况下,每个 GPU 处理不同的 Request,可能导致 GPU 之间出现工作负载不均,而又必须在 Attention 阶段后同步并进入 FFN 阶段,从而导致 GPU 互相等待产生的 Bubble。因此,需要确保各 GPU 具有相似的 Attention 执行时间,以最大程度减少等待 Bubble。

    层时间预估:采用 FIFO 打包策略确定 Forward 中包含的 Request 数量。Forward Batch 中的每个 Request 都有一对(cached, bsz)参数描述,其中:

    • cached 表示已经具备 KV-Cache 的 Token 数量。

    • bsz 表示当前 Batch 中需要计算 KV-Cache 的 Token 数量。

    基于这些参数对,计算 Attention 层的理论总计算量并估算其执行时间。理论计算量和实际计算时间的关系取决于硬件和并行配置,可通过预先的性能分析进行拟合。

    算法:只要预测的 Attention 层执行时间不超过预设上限(称作计算配额),就持续按照 FIFO 顺序添加 Request。如果某个 Request 超过此限制,则对 bsz 进行二分搜索以找到更小的 bsz’,使其适配剩余的计算配额,并对该 Request 执行 Chunked-Prefill 处理。

    五、评估

    5.1 实现 & 配置

    代码实现:DualPath 的实现结合了 DeepSeek 之前开源的 FlashMLA、DeepGEMM、DeepEP 以及 3FS,大概涉及 5K 行代码修改。

    硬件配置:前面介绍的 DeepSeek H800 集群,SNIC 连接 3FS。

    模型:

    • MoE 模型:DeepSeek V3.2 660B,表示为 DS 660B;缩小版的 DS 27B;

    • Dense 模型:Qwen2.5 32B。

    数据集:3 个 Agent Trace 数据集,每个包含 500 个轨迹,统计信息如下图 Table 2 所示。

    基线:实验对比了 3 个基线。

    • SGL(MC):SGLang + HiCache、Mooncake、3FS。

    • Basic:未修改的内部 Inference 框架。

    • Oracle:基于 DualPath,绕过所有的磁盘读取, H2D/D2H 传输, 以及 PD 间的 KV-Cache 传输。相当于 I/O 开销为 0 的理想情况。

    PD 比例和并行度:DS 660B 采用 2P4D;Qwen 32B 采用 1P2D;DS 27B 采用 1P1D。DS 模型采用 Attention DP + FFN EP;Qwen 模型仅在 DualPath 中采用 DP,SGL(MC) 中采用 TP=8。

    Metric:对于 Offline Batch Inference 场景, 测量整个任务的作业完成时间 (JCT)。对于 Online Serving 场景,测量首个 Token 时延(TTFT),第二个 Token 时间(TTST),以及每输出 Token 时间(TPOT)。

    5.2 Offline Inference 场景

    可变 Agent Batch Size & 最大 Agent 长度(MAL):DualPath 在更大的 Batch Size,更长的 MAL 是可以获得更大的收益。如下图所示,在 DS 660B 上,DualPath 相较于 Basic 可以实现高达 1.87x 的提升,并且性能接近理论上限 Oracle,表面 KV-Cache 的传输几乎可以被隐藏。

    可变的 Append 长度& 生成长度:DualPath 在可变的 Append 长度以及生成长度下都有明显优势,并且 DualPath 和 Oracle 很接近。如下图 Figure 9 所示,随着 Append 长度增加,Basic 方案逐渐趋近于 DualPath,表面系统瓶颈在 GPU 计算。相比 Basic 方案,DualPath 在不同的 Append 比例下实现了 1.82x-1.99x 的加速。

    可变的 P/D 比例:在所有比例下, DualPath 都比 Basic 表现出显著的性能收益。如下图 Figure 8 所示,DualPath 在所有配置中平均实现 1.64x 加速(最高 2.46x)。Basic 版本的 1P1D 和 1P2D 性能接近;DualPath 的 1P1D 和 2P1D 性能接近;DualPath 2P1D 和 DualPath 1P2D 也类似。主要是各组系统具有等效的可用存储带宽,从而证实在 Agent 场景中存储带宽是主导系统性能的关键瓶颈。

    5.3 Online Serving 场景

    方法论:评估系统在不同 Agent 每秒到达率(APS)的时延特性。Agent 根据泊松过程以指定速率到达,每个 Agent 在到达时从第 0 轮开始重放直至其最后一轮。实验中,SLO 目标为 TTFT <= 4s,TPOT <= 50ms。实验终止条件为满足以下任何一种情况:TTFT > 4s 或系统到达稳态(150s 滑动窗口内的 TTFT 波动相较于 30min 前低于 5%)。

    如下图 Figure 10 所示,DualPath 比 Basic 方案获得更高的 APS 容量(DS 27B 提升 1.67x,DS 660B 提升 2.25x)。DualPath 的 TTST 指标与 Basic 相当,而 TPOT 数据表面 DualPath 相较于 Basic 方案未引入额外的 Decoding 开销。SGL(MC) 出现异常偏低的 TTST,可能源于实现问题,导致前两个 Token 几乎同时到达客户端。对于 DS 27B,呈现出与 DS 660B 相似的趋势。但 Basic 与 DualPath 方案的 TPOT 均显著高于 Oracle,表明在小规模模型场景中 P-D 传输机制的开销相当大,不容忽略。

    两种模型的平均 JCT 如下图 Figure 11 所示。如下图 Figure 12(左)所示,在不同 APS 配置下 DualPath 能保持稳定的 TTFT 耗时,而 Basic 方案因存储带宽不足导致队列等待时间急剧增长。

    5.4 消融实验

    5.4.1 负载均衡

    DualPath 的调度算法改善了 SNIC 和 Attention 层计算时间的负载均衡。

    • 对于 SNIC:如下图 Figure 13 所示,调度算法将负载均衡程度(Max/Avg 比例)从 1.53 改善到 1.18。

    • 对于 Attention 层计算:如下图 Figure 14 所示,DualPath 在任务的前 5% 期间将 Max/Avg 比例维持在低于 1.06,减少了 GPU Bubble。

    5.4.2 大规模可扩展性

    使用 1152 GPU 进行 Offline 和 Online 实验以展示大规模可扩展性。如下图 Table 3 和 Figure 15 所示:

    • Offline 采用 2P4D(2K Agent),扩展后 48P96D(48K Agent),JCT 相当。

    • Online 也是 2P4D,扩展后 44P88D,实现了 22x 的吞吐量(0.4 APS vs 0.8 APS),同时保持相似的时延。

    六、参考链接

    1. https://arxiv.org/abs/2602.21548

    2. https://docs.nvidia.com/dgx/dgxh100-user-guide/introduction-to-dgxh100.html

    3. https://arxiv.org/abs/2505.09343

    阅读原文

    跳转微信打开

    来,你说场景,我帮你设计如何用 Agent 工作

    2026年3月6日 12:43

    原创 yan5xu 2026-03-06 12:43 北京

    这是一套方法论——用它来找出你每天在哪儿当管道、从哪里下刀,以及 Agent 如何把你从这些事里解放出来。

    TL;DR:这篇文章分享我自己摸索出来的一套方法论——用它来找出你每天在哪儿当管道、从哪里下刀,以及 Agent 如何把你从这些事里解放出来。看完你可以自己拆自己的工作;如果不想自己分析,评论区告诉我你做什么的,我来帮你描绘有了 Agent 之后的一天。

    正文是方法论,想自己学的往下看。懒得分析的,直接评论区告诉我你的工作场景就行。


    任何工作都是同一个闭环:调研 → 决策 → 规划 → 执行 → 反馈 → 复盘。

    不管你是做运营、做自媒体、做项目管理还是做财务,把工作拆开往这六步里放,一定放得进去。

    每一步有它的核心问题:

    • 调研:事实从哪来?数据、信息、现状——你得先知道发生了什么,才能做下一步。

    • 决策:判断依据是什么?这件事值不值得做、怎么分类、优先级怎么排——这是人真正在发挥作用的地方。

    • 规划:下一步怎么走?把决策结果转成可执行的任务和格式。

    • 执行:怎么改变现实?发消息、写数据、调接口、推结果——让事情真正发生。

    • 反馈:做成了吗?验证执行结果,确认到位。

    • 复盘:经验固化成什么?这次做完学到了什么,能不能变成下次自动跑的规则。

    少任何一环就不完整——只有调研没有执行是研究报告,只有执行没有反馈是瞎干,没有复盘就永远原地踏步。

    这个框架有什么用?它让你一眼看清,你每天的时间到底花在了哪一步。更重要的是,那一步,你到底在做判断,还是在做搬运。


    这很关键,因为六步里每一步,都已经有了对应的工具。

    工具意味着可编程——CLI 命令、API 调用、浏览器自动化,本质上都是可以被程序调用的接口。这是员工:接收指令、执行、不需要思考。

    但光有员工不够。还需要两件事:

    经理——理解你的意图,制定计划,决定下一步调哪个工具、怎么调。LLM 就是这个角色。它能读懂你说的话,把工具一步步驱动下去。

    章程——把经理的判断固化成文字,让员工照着重复跑。这是代码和脚本的作用:写一次,执行无数次,零边际成本。没有章程,每次都要经理临时指挥,跑一次就停。

    层级对应说明
    🧠 经理LLM理解意图,制定 SOP,决定下一步干什么
    📋 章程代码和脚本写一次,执行无数次,零边际成本
    💪 员工工具和设备按 SOP 执行,不思考,只执行

    三层接通,临界点就出现了:当六步里的每一步都有了工具,LLM 就能把整条链路串起来,从头到尾自主跑完整个闭环。 不再是「帮你完成某个步骤」,而是整个任务自主执行。这就是 Agent——你的电脑,24 小时开机的数字同事。

    三层没接通,LLM 再聪明,也是被关在小黑屋里的经理——看不见外面,也改变不了任何事。


    所以设计一个 Agent,本质上就是做一件事:把六步里每一步的工具填具体。

    步骤方向具体化的意思
    调研自动拉取数据你用的是哪个后台?有没有 API?用什么工具抓?
    决策把判断变成规则你的分类标准是什么?边界情况怎么处理?
    规划格式和模板结果要输出成什么格式?发到哪里?
    执行程序替手操作调哪个接口?操控哪个页面?跑哪条命令?
    反馈自动验证结果怎么确认执行到位?出错怎么报警?
    复盘纠正写回规则这次的判断偏差,怎么变成下次的自动处理?

    这张表填完,就是你这个场景的 Agent 配置文件——Claude Code 读它,知道自己有什么工具、该怎么跑。表没填完,Agent 就跑不完整。

    你可以拿这张表,去拆自己的工作——看看六步里,有几步是你在当搬运工,有几步已经有工具可以接管。填满的那一天,就是你的 Agent 上线的那一天。


    填表的时候,从哪里下手?

    目标很简单:先让自己真实体验到用 Agent 的爽感。 有了这个感受,才会有动力把剩下的步骤也接进来。

    方法是识别意愿瓶颈——那个每天让你心里发堵、让你拖延的步骤。不一定耗时最长,但它卡在最前面,让你迟迟不想启动。

    比如做运营的,每天第一件事是登后台导数据。登后台、找菜单、点导出——也许只要 3 分钟,但它每天都在前面堵着。

    先把这一步接进 Agent。第一个早上打开电脑,数据已经在那里了——这一刻,你会真实感受到用 Agent 是什么感觉。不是「效率提升了」,是「这件事消失了」。

    有了这个感受,你自然会想:还有哪步也可以消失掉?然后一步步往下改。调研自动跑、执行自动发、反馈自动收——最后留下来的,只有真正需要你判断的那几个时刻。你是阀门,不是管道。

    下面两个案例,一个从意愿瓶颈下手,一个从耗时最长的步骤下手。同样的框架,不同的切入点。


    如果你想直接上手,我做了一个开源工具 Rewire——你描述工作场景,它帮你把这张表格自动填具体:追问细节、搜工具、给出能直接跑的方案。下面两个案例就是用它跑出来的。


    案例一 · 运营 · 用户反馈分类

    之前:每天从后台导出反馈 Excel,逐条阅读、打标签、整理成分组表格发飞书群。50-80 条,2-3 小时。六步里,真正需要判断的只有「这条反馈是 Bug 还是需求」这一步决策,其余全是纯人肉搬运。最烦的是一开始那步——登后台、找菜单、等下载,还没开始做正事就已经没了心气。

    怎么改造的:Claude Code 用 bb-browser 操控你本地浏览器——复用已有的登录态,不需要额外配密码——直接打开后台,找到导出按钮,点击,30 秒下载完成。然后用 Python 读 Excel,按你预先写好的规则分类:「崩溃」「报错」「闪退」归 Bug,「希望」「建议」「能不能」归需求,「怎么用」「在哪里」归咨询。90% 直接分好。剩下拿不准的,弹出来问你,你回一句,它继续。最后用 curl 调飞书 Webhook 把结果推进群。

    改造后:早上到工位,打开飞书,反馈已经分好类发在群里了。你的待办只有 5-8 条标了"不确定"的,点开扫一眼,3 分钟搞定。剩下的时间去看最近反馈里有没有反复出现的模式——比如上周 12 条都提到"支付超时"。这才是运营该做的事。

    2-3 小时 → 5 分钟。


    案例二 · 自媒体 · 选题调研

    之前:每天刷小红书、抖音、微博、知乎,来回切四个 App,3-4 小时。95% 是噪音,刷着刷着就走神了。真正产生价值的判断可能只有 15 分钟,剩下的时间在做人脑搜索引擎。

    怎么改造的:Claude Code 调 RSSHub 拉取你关注的对标账号最近 24 小时更新,同时跑 MediaCrawler(44.9k stars,支持小红书/抖音/微博/知乎多平台)用关键词搜一轮最新热门内容。两分钟抓到约 200 条,再按领域相关性、互动数据、时效性过滤,剩 15 条候选。每条附上来源、核心数据、建议角度。你选完方向,它展开评论区分析,给你一份大纲草稿,同时把今天的候选和最终选择写入 Notion 选题库。

    改造后:泡咖啡的时间里四个平台已经过了一遍。你端着咖啡回来,15 条候选摆在屏幕上,每条带数据和角度建议。5 分钟选方向,开始写。下午不用刷平台了。

    每天省下的不只是 3 小时,是 3 小时的注意力损耗。


    完整方案在 GitHub 的 examples/ 目录。


    评论区告诉我你是做什么的——你的岗位、你每天最费劲的那块。我来帮你描绘那个画面:有了 Agent 之后,你的早上会怎么开始,哪些事情机器在跑,你在做什么。

    阅读原文

    跳转微信打开

    OpenClaw 登顶 GitHub 榜首,Web 3.0* 已经到来

    2026年3月5日 00:39

    原创 yan5xu 2026-03-05 00:39 北京

    多年以后,人们回望 2026 年,会猛然发现:当一个名叫 OpenClaw 的开源项目,以 258,000 个 GitHub Stars 碾过 Vercel 的 Next.js 登顶历史总榜第一的那个瞬间,正是整个 Web 世界从 2.0 转向 3.0* 的分水岭。

    但此刻,绝大多数人还没意识到这件事意味着什么。

    Next.js 代表的是什么?云端渲染、中心化分发、平台即服务——Web 2.0 前端基础设施二十年来的绝对王者。而 OpenClaw 呢?一个完全跑在你本地硬盘上的个人 AI Agent 中枢。它的核心配置文件——决定 Agent 性格的 SOUL.md、存储记忆的 MEMORY.md、规划任务的 HEARTBEAT.md——全部是几 KB 的纯文本。没有云端微服务,没有花里胡哨的控制台,你用记事本就能打开并重塑你 AI 助手的灵魂。

    王座从一个云端框架,转移到一个本地 Agent 架构。这不是开源社区内部的排名游戏,这是整个 Web 世界的主导权正在换手。

    不妨问自己一个问题:如果今天有一股不可抗力,强行卸载了你手机里的微信、飞书和 Gmail,你还能不能正常地联络同事、找出昨天确定的会议纪要,甚至仅仅是证明你在这个世界上留下的社交痕迹?

    大概率绝对不能。

    你的社交图谱被锁在腾讯的数据库底层;你的工作上下文被切碎,散落在十几个 SaaS 工具的云端抽屉里;你的消费偏好被各大平台的推荐算法暗箱藏匿,打包卖给广告主。我们每天产生数以 GB 计的数据,但几乎从来没有真正“拥有”过哪怕 1 KB 属于自己的数字记忆。

    我们看起来在自由地使用互联网,实际上更像是在超级平台的地盘上卑微地租住。交出隐私当租金,随时防备地主涨价、改规则、甚至扫地出门。

    而这套运行了近二十年、看似坚不可摧的“租住秩序”,现在终于在底层物理架构的剧烈冲撞下,出现了不可逆转的结构性崩塌。OpenClaw 的登顶,正是地表上露出的第一道裂缝。

    §0 引子:系统架构的主导权正在发生位移

    历史的每一次伟大演进,在它发生的前夜,都会在系统最底层的角落里亮起微弱的信号灯。如果你把过去六个月发生在底层技术栈的几个切片叠在一起看,一幅极其清晰的图像会突然在你面前浮现。

    现象一:普通人拥有超级 Personal AI 的巨大机会

    回到开场的那个结论,为什么一个配置局域网和 Docker 极其繁琐的开源项目,能让全球开发者趋之若鹜?

    因为这不只是一种对中心化 SaaS 平台出事的被动防守,更是一个极其诱人的机会:它让普通人第一次有可能在本地跑起一个极度强大的 Personal AI。

    “在 OpenClaw 的架构中,用户的配置文件、记忆数据库(基于 SQLite)全部以纯文本的 Markdown 形式保存在本地。这是一种冷酷的权力宣示:系统的大脑完全向你敞开。” —— 摘自知乎开发者社区对 OpenClaw 架构的解析

    这种级别的私人助理,要真正发挥威力,必须深度掌握你极度隐私的个人上下文。这里的隐私,不是指你的银行卡密码,而是你在这个世界上真实存在的颗粒度——你写周报时固定的排版强迫症、你对某个客户的隐性反感、甚至你每次出差一定要住带大窗户酒店的怪癖。只有掌握了这些,它才是“你的”Agent,才能替你做出符合你心意的决策。

    你敢把这些代表你灵魂的数据交给一个随时可能修改隐私条款的贪婪平台吗?显然不敢。所以,这种强大的 Personal AI 注定了它只能存在于本地硬盘。哪怕它现在还很粗糙,极客们也宁可把它握在自己手里。

    现象二:Web 不再只为人类服务,互联网接口开始转向

    2026 年初,Chrome 悄然发布了一份由 Google 与 Microsoft 联手向 W3C 推进的 WebMCP(Web Model Context Protocol)标准草案。紧接着,网络基建巨头 Cloudflare 推出了面向 AI Agent 的 HTTP Header——只要 Agent 发送一个 Accept: text/markdown 的请求头,Cloudflare 就会把原本花里胡哨的网页,瞬间扒掉广告、CSS 和冗余的导航,只吐出干干净净的 Markdown 文本供机器阅读。

    这意味着什么?这意味着网站不再仅仅是为了“留住人类的眼球、展示华丽的广告”而设计。互联网正在主动抛弃过去那一套逻辑,Web 不再只为人类服务,它正在转向,同时为 Agent 提供最高速度、最强可靠性的结构化接口。

    现象三:资本的冷酷投票,SaaS 的黄昏与 HALO 效应

    如果说极客的狂欢和标准草案还显得有些遥远,那么华尔街资金的疯狂出逃,则是最能刺痛神经的现实。2026 年初,被称为“SaaS-pocalypse(SaaS 末日)”的风暴席卷纳斯达克。Salesforce、Adobe、ServiceNow 等 SaaS 巨头的股价遭遇断崖式下挫。

    为什么会崩盘?因为 Agent 正在粉碎 SaaS 赖以生存的商业地基。SaaS 公司最核心的暴利模式是“不管你用不用,按人头强行收系统席位费(Seat)”。当 Agent 开始海量替代数据录入、客服和 IT 运维等人力岗位时,没人买席位了,它当然会崩。

    与此同时,高盛抛出了一个震动市场的理论:HALO(Heavy Assets, Low Obsolescence / 重资产,低过时风险)。资本正疯狂逃离那些靠“把用户关起来”盈利的轻资产软件股,转而拥抱能源、电力和底层算力基建。

    把这三个现象严丝合缝地扣在一起,结论已经震耳欲聋:互联网系统架构的主导权,正在发生一次史诗级的物理位移——从高高在上的“平台中心”,无可挽回地迁往无数个边缘的“个人 Agent”。

    Web 3.0* 论证全景思维导图

    本文把这个正在发生的新范式叫做 Web 3.0*。这里的星号是故意加上的,它极其重要。(顺便提一句,这与币圈大肆炒作、至今并未实质性发生的 Blockchain Web3 毫无关系)。我们现在讨论的这一套,不靠发币,不炒作空气,它只关心一个极其硬核的工程演进——当个人专属的 Agent 拿到了足够密集的全局上下文,并获得了不受平台限制的跨域执行能力,整个互联网的权力拓扑结构,将会怎样被彻底重排?

    §1 历史的轮回:谁创造了效率,谁就拥有主导权

    我们不妨回顾一下历史。要真正看懂这场颠覆,我们需要回到互联网最底层的物理定律去寻找答案。

    互联网从诞生至今,每一次代际的切换,表面上看是雅虎倒下、谷歌崛起,是 PC 时代的落幕、移动大厂的上桌。但本质上,每一次王权的更替,都在解答同一个母题:“在当时的物理和硬件约束下,谁能最有效率地解决问题?” 谁能提供最高的效率,算力和数据就会自然地向谁流动,谁就拥有那一代 Web 的主导权。

    §1.1 Web 1.0:信息可访问,能力不可执行(主导方:发布者)

    时钟拨回上世纪 90 年代。那是一个只要 56k 调制解调器拨号时发出刺耳的握手声,就能让网民心潮澎湃的年代。

    当时的物理现实极其严苛:服务器带宽昂贵,个人电脑性能孱弱。在那个年代,马云还在杭州街头挨家挨户推销“中国黄页”,试图把中国企业的资料翻译成英文放到网上,却常常被当成骗子。而“黄页”这两个字,恰恰是 Web 1.0 模式最精准的缩影。

    受限于当时的约束,互联网只能妥协成一种高度不对称的模式。站长在昂贵的服务器端搭建静态内容,用户在简陋的终端点开网页浏览。你上网不是去“创造”,你仅仅是去“访问”。

    “在 Web 1.0 时代,系统就像一个巨大的广播站,而我们每个人都只是握着收音机的听众。”

    这是 Web 1.0 的伟大之处——信息流动第一次打破了地理边界,让普通人拥有了俯瞰世界的可能。

    但这伟大的代价是:用户如同被锁在巨大图书馆里、被绑住双手的读者,几乎没有任何“行动能力”。你看见了屏幕上的数据,不代表你能把它带走。在这个时代,系统效率的果实归属于内容发布方(如早期的雅虎、新浪门户),他们是主导者。

    §1.2 Web 2.0:交互爆发,平台成为中枢(主导方:中心平台)

    到了 2005 年前后,AJAX 技术的成熟让网页局部刷新成为可能;同时,摩尔定律的狂飙让服务器算力变得廉价。物理约束一旦解除,Web 2.0 时代轰轰烈烈地开启了。

    Web 2.0 的本质,是用中心化的算力,解决人类在海量信息中“供需匹配”的效率难题。你需要打车,滴滴用算法把司机和你匹配;你需要沟通,微信把庞大的通讯录映射为实时的社交图谱。互联网从一个静态的图书馆,变成了一个高频交互的社会系统。

    这套被称为“数据飞轮”的机制极其伟大,但它也极其昂贵。昂贵的不只是大厂机房里的电费账单,更是十多亿用户被迫付出的代价:

    为了维持这种中心化的匹配效率,平台开始建立起高耸入云的围墙花园。更恶劣的是,平台利用这种数据隔离开始作恶。它们不仅把你的社交关系锁死在自己的系统里,还偷偷收集你在其他场景的隐私信息。比如,你在购物软件里刚搜了一双鞋,转头打开另一个资讯 App,满屏都是鞋的广告。你的隐私被暗箱打包,变成了平台在华尔街换取高估值的筹码。

    在这个时代,用户逐渐异化成了游走在各个 App 之间的“肉体 API”——你要把这段文本从微信的聊天记录里复制出来,切换应用粘贴到飞书的文档里,再转头去淘宝对比价格,最后人肉敲进公司的 ERP 系统。

    所以,Web 2.0 最大的历史功绩与最恶劣的历史罪名,其实根本就是同一件事:它用极高的效率把整个世界连接了起来,同时又用同一套机制把所有连接的定价权和果实,死死地集中在自己手里。

    §1.3 Web 3.0*:执行与编排回归本地(主导方:个人 Agent)

    天下大势,合久必分。正如我们前面提到的那个至关重要的转折——Web 不再只为人类服务。当互联网的接口开始向机器敞开大门,当 AI 拥有了理解复杂意图和逻辑推理的能力,数字世界的主导权终于开始向边缘的普通人回迁。

    如果说 Web 2.0 是“全人类的互联网”,那么 Web 3.0* 就是“人与 Agent 共同驱动的互联网”。它绝不是让你在手机里多安装一个套壳的聊天 App,它是整个互联网“执行位置”的历史性翻转。

    很多人对 Chatbot(聊天机器人)和 Agent(智能体)的区别缺乏体感。我们不妨用一个“规划北京出差”的场景来做个对比。

    如果你对一个纯粹的 Chatbot 说:“帮我规划下周去北京出差的行程。”它会像一个不知疲倦的打字机,一秒钟给你吐出一篇精美的攻略,甚至贴心地为你算出了预算。这叫“优雅的盲目生成”。但如果你真按这个去走,你大概率会崩溃:它根本不知道你的目标客户这周已经搬到了另一个区,它的预算也只是一个荒谬的统计学数字。Chatbot 只是在复刻一个看起来像答案的虚假文本。

    但如果你把任务交给一个真正的个人 Agent,情况完全不同。它会启动一个严密的 Think -> Act -> Observe(思考-行动-观察)循环。

    • 它会去调取你微信里和客户确认好的最新会议地址;

    • 它会去查看飞书日历上老板有没有强行加塞的视频会议;

    • 甚至它知道你曾在小红书上点赞过“酒店必须有大窗户”,从而在携程接口里自动加上这个过滤条件。

    看明白了吗?Agent 的本质不是“更聪明的聊天框”,它是“你和异构系统之间的专属中间执行层”。

    Web 代际演进路线图:从发布者到平台再到个人 Agent

    一旦这个强大的中间层稳固地扎根在你的本地设备上,传统的超级平台就从“你必须交出灵魂才能进入的主场”,被降维成了“用完即走、随时可替换的能力供应商”。互联网剥削了二十年的效率果实,终于要重新落回用户自己的口袋。

    但问题来了,这一切听起来很美好,为什么偏偏是在今天发生?这就不得不提到底层算力结构正在经历的一场隐秘而剧烈的化学反应。

    §2 深层因果:当廉价的“智能”点燃沉睡的“算力”

    我们不喊任何宏大的口号,只谈冷冰冰的因果物理。为什么打破平台坚冰的,偏偏是现在的 2026 年?

    在展开讨论之前,我们需要澄清科技行业一个最容易混为一谈的底层概念。如果不把它切开,所有的讨论都会沦为“手机电池那么小,怎么可能跑得动千亿大模型颠覆互联网”的无意义口水战。

    我们必须冷酷地把一直以来被统称为“算力”的系统能力,劈成截然不同的两半:一是执行命令的机器算力(Compute),二是理解意图的系统智能(Intelligence)。

    • 算力(Compute):

       这是执行一行 Python 脚本、查询本地 SQLite 数据库、调用 API 接口的“肌肉力量”。这种力量极其廉价,你手边的 Mac Mini,哪怕是一台三年前的旧手机,今天都能在端侧完美跑满。但它的致命弱点是“没有脑子”。

    • 智能(Intelligence):

       这是理解复杂意图、规划任务步骤、拆解并编写逻辑代码的“大脑”。过去,机器没有智能。这种智能完全依赖于人类,尤其是那些年薪百万的高级软件工程师。

    “过去,智能极其昂贵,而算力虽然廉价却需要智能去驱动。大厂垄断了人类工程师(智能),也就垄断了为你分配机器执行力(算力)的权力。”

    §2.1 智能的平民化:释放被垄断的算力

    过去,要让机器替你自动回复邮件、跨表格比对数据,你需要懂 Python,懂如何调用 API,懂各种乱七八糟的鉴权协议。因为这个极高的门槛,海量充沛的本地电脑算力一直处于沉睡状态。普通人只能被动地使用大厂封装好的罐头软件和平台。

    大厂们雇佣了最昂贵的人类大脑,提供着原始的“智能”,写成代码封装成平台和 SaaS。然后,他们要么按人头强行收你的席位费,要么通过更隐蔽的方式——榨取你的隐私和免费创作(UGC)——来让你为这套“智能”买单。

    但今天,大语言模型带来的最大颠覆,并不是它能写出多漂亮的诗,而是它把“智能”彻底廉价化、平民化了。正如 Notion 创始人 Ivan Zhao 所说,AI 带来了“无限的心智(Infinite minds)”。

    这就是 OpenClaw 为什么让整个极客圈感到震撼的根本原因。在这个框架里,大模型(廉价的智能)在后台疯狂“思考(Think)”,自动生成代码,去点燃本地极其廉价的工具(算力)。

    "智能点燃算力"因果链:LLM 如何激活本地算力并瓦解平台垄断

    大模型把普通人变成了高级工程师,从而彻底激活了原本被大厂垄断的本地算力。 当廉价的智能点燃了免费的算力,普通人就相当于拥有了一个不知疲倦的数字劳工。这种化学反应一旦发生,过去必须依赖大厂集中处理的任务,瞬间就能在你的本地笔记本上闭环。

    §2.2 复杂度的蒸发:当并发数降为 1

    很多人带着崇拜的目光仰视大厂,误以为 Web 2.0 的架构之所以极其复杂、需要年薪百万的架构师来设计,是因为它的业务逻辑深不可测。这是一场巨大的错觉。

    Web 2.0 那些令人窒息的复杂架构,本质上是为“服务百万并发”的商业模式买单,而不是为了完成你个人的任务。

    举个最日常的自动化任务例子:从收件箱里提取客户需求,并自动汇总到你的任务表里。

    如果由跑在你本地的 Agent 来做,这只不过是一个极低负载的本地后台脚本。读取本地缓存,写入本地数据库,几毫秒就能静悄悄地完成,完全不需要什么高深架构。

    但在 Web 2.0 时代,如果你把这个任务交给云端的自动化 SaaS 平台,当一百万个用户同时在周一早晨触发类似任务时,这就变成了工程学噩梦。为了对抗这个因为“集中处理”而产生的洪峰,大厂被迫堆砌了庞大的消息队列(如 Kafka)、昂贵的负载均衡器、微服务集群,以及烧脑的分布式事务锁。

    这整套动辄几万台服务器、几十亿电费的庞然大物,统统是在为“百万个你同时存在”时的系统生存危机买单。

    现在,把视线拉回 Web 3.0* 的 Agent 架构。当 Agent 在你的本地设备上,只全心全意服务你这一个人时,底层拓扑结构发生了地动山摇的翻转:

    • 并发数永远逼近绝对的 1

      ,你再也不需要任何硬件负载均衡器。

    • 单用户的任务流水线

      ,那些炫技般的高并发框架直接下岗。

    • 核心数据就安安静静存一份在本地 SQLite

      ,让人掉头发的分布式数据一致性难题、CAP 定理,直接从物理学意义上彻底消失。

    当计算回到边缘,那层压在头顶的巨大架构复杂度,其商业价值直接清零。

    §2.3 异构性从 Bug 变 Feature:物理引擎级的理解力

    在 Web 2.0 时代,系统最大的敌人叫“异构性”(Heterogeneity)。你的系统用 XML,他的系统用 GraphQL,没有统一的标准就无法对话。大厂对抗异构性的唯一解法是暴力强拆:“消灭差异,强制标准化”。平台制定霸道的统一 API,逼迫所有人遵守。

    而在 Web 3.0* 的 Agent 路线里,异构性不再是让人头疼的 Bug。因为“无限的心智”赋予了 Agent 强大的原生理解力。

    这就好比神作《塞尔达传说:旷野之息》里的物理引擎。在海拉鲁大陆,你不需要一个专门设定的“点火按钮”。你把木柴扔在地上,用金属剑用力劈砍燧石,火自然就烧起来了。这就是底层理解力带来的化学反应。

    Agent 面对千奇百怪的互联网接口也是一样。A 服务用 REST,B 服务用表单,没关系。只要你的服务是“自描述”的(比如提供了一份简单的 SKILL.md,或者像前文提到的 Cloudflare 那样吐出纯净的 Markdown),Agent 的大脑就能像看说明书一样,瞬间读懂并精准调用它。

    我们再也不需要低三下四地求着 SaaS 厂商的 PM 去排期开发一个集成插件。Agent 靠着自己的理解力,随时能用手里的木柴加燧石,生出一团火。

    §3 结构性张力:平台自杀悖论与围墙的倒塌

    Agent 要想真的聪明、真的懂你,天生就需要跨域的“全局上下文”。回到前面“规划北京出差”的例子,你的私人 Agent 必须能够同时去微信里抓会议地址,去飞书里对齐日程,甚至去小红书里翻你曾经点赞过的酒店。

    但这恰恰触碰了巨头们最敏感的逆鳞——数据。在 Web 2.0 的逻辑里,把你死死锁在围墙花园里,用你的数据训练他们自己的模型,再用流量卖广告,是他们生存的唯一命脉。

    当代表用户利益的 Agent,撞上死守垄断利益的平台,一场残酷的绞杀开始了。

    平台围墙花园 vs Agent 开放架构对比

    §3.1 平台的自杀悖论:为了护城河,干掉生态

    为了防止自己的数据被 AI 公司免费“白嫖”,平台开始陷入一种疯狂的自杀悖论:它们不惜亲手毁掉曾经为它们带来繁荣的第三方开发者生态。

    Reddit 的 API 危机是这场悖论最血腥的注脚。2023 年 6 月,Reddit 突然悍然调整 API 定价,给广受欢迎的第三方客户端 Apollo 开出了约 2000 万美元一年的荒谬账单。这直接逼死了这家用心做了多年的开发者。面对超过 8000 个子版块同时发起的“大停电”抗议,Reddit 的 CEO 不仅寸步不让,反而将抗议的版主嘲讽为“地主贵族”,强行镇压了社区。

    为什么这么硬气?因为只要护住这些语料库,Reddit 就能转头拿着它们与 Google 签下 6000 万美元的 AI 训练大单,并在华尔街敲响上市的钟声。这是踩在开发者尸体上的狂欢。

    “在绝对的垄断利益面前,十几年的开发者忠诚连个标点符号都不如。”

    平台自杀悖论时间线:巨头为保护数据垄断而毁掉第三方生态

    Twitter 的做法则更加暴戾,连一封官方邮件都没有,一夜之间关闭免费 API,让运营了十几年的第三方应用瞬间暴毙。在旧时代的既得利益者眼中,只要数据还在他们手里,你就永远是个待宰的羔羊。

    §3.2 强拆高墙:从 DMA 监管到中国市场的“绞肉机”

    面对高耸入云的围墙,破局的锤子从两个方向砸了下来。

    一个是自上而下的监管。欧盟的《数字市场法案》(DMA)明确要求被定义为“看门人”的巨头开放数据可携权,甚至强制 WhatsApp 允许第三方通信协议接入。

    但在中国这个超级 App 渗透极深、支付和社交高度耦合的独特市场里,诞生了另一种更野蛮、更硬核的暴力破局法。

    由于国内大厂之间有着长达十年的互封历史(回想一下曾经荒谬绝伦的“淘口令”乱码),这里的接口比世界上任何地方都封闭。于是,以字节跳动的“豆包手机”(其系统团队的前身正是那支对系统级交互有着极致追求的锤子/坚果团队)为代表的硬件厂商,给出了一种“掀桌子”的解法:GUI Agent。

    当微信或淘宝以安全为由拒绝提供 API 时,豆包手机底层的系统级 Agent 直接通过“读屏(视觉理解)+ 模拟点击”,像一个隐形的透明人一样,跨越 App 的边界强行完成任务。

    它不需要求着平台开放接口,它直接在操作系统层面,把那些不可一世的超级 App 降级成了一个个没有灵魂的被执行器。这正是中国市场特有的“绞肉机”生态:巨头建墙,监管拆墙,而端侧的 Agent 直接暴力翻墙。

    §3.3 SaaS 的降级:从“超级工作台”到“可插拔组件”

    在这场冲击中,企业级 SaaS 的角色将被彻底重塑。

    过去,SaaS 厂商最喜欢讲的故事叫“All-in-One”。他们希望你把所有的工作流都搬进他们的系统里,把你关在一个叫“超级工作台”的精美笼子里。

    但当 Agent 成为你的私人执行中枢后,你不再需要去适应 SaaS 复杂的交互界面。你需要 Salesforce 仅仅是因为它那里存着客户名单,你需要 Workday 仅仅是为了提一个假单。SaaS 被迫从“把用户死死关在里面的超级容器”,屈辱地降级退化成了 Agent 工作流里“可随意调用的底层组件”。

    §4 我们该做什么:不要等终局,先建护栏

    这场浩大的范式转移不会在一夜之间完成。“全自动驾驶”的 AI Agent 时代距离我们还有段距离,但在风暴来临前,有些事情你今天就必须开始做。

    §4.1 注意力经济的黄昏

    当帮你买票、挑酒店、对比商品参数的是一个冷酷的 Agent 时,Web 2.0 时代最依赖的“注意力广告”将彻底失效。

    Agent 没有荷尔蒙,不会因为弹出了一个美女广告就冲动消费,它只会冷酷地对比几十个接口的参数并锁单。这就意味着,未来商业的计费模式,将从“你骗了多少用户的眼球”,转向“你能否给 Agent 提供最精准、最便宜的结构化意图”。传统曝光广告的 ROI 正在面临结构性的雪崩。

    §4.2 个人与组织的新技能树

    如果非要给在这个时代感到焦虑的人,一个最不讲情面的生存建议,我会写成这样一句朴素的话:

    未来三到五年,无论个人还是组织,决定你生死存亡的核心竞争力,不再是你“拥有多少个花里胡哨的 SaaS 账号”,而是你“拥有多么强悍的跨域任务编排能力”。

    工具只会越来越泛滥,模型(智能)只会越来越廉价。真正拉开巨大鸿沟的,是谁能把杂乱无章的工具,用自己的 Agent 拼接成一条极度稳定、可复用的自动化流水线。

    §4.3 把这三条红线死死握在手里

    在享受 Agent 带来的狂暴效率复利之前,请务必先建立这三条不可妥协的护栏:

    • 权限最小化

      :绝不给 Agent 泛范围的通行证,只给最低必要权限。

    • 审计日志留存

      :它调用的每一个接口、做的每一次决策,必须有防篡改的本地追踪日志。

    • 一键撤销与迁移

      :你必须拥有物理级别的紧急制动按钮,不仅能一键切断它的行为,还能把所有配置和记忆完整导出。

    没有这三条护栏,所谓的高效 Agent,不过是挂在你脖子上的新核弹。

    §5 结语:不可逆的列车

    让我们回到最初的那个判断:这场正在发生的变革,核心是一次主导权的回归。

    它让互联网重新回到服务于“人”的轨道上,而不是让人去适应平台的规则。当沉睡在你本地设备的充沛算力被平民化的大模型唤醒,当冷冰冰的机器获得了物理引擎般的理解力,并发洪峰和异构壁垒就不再是困住你的高墙。

    不要再等那个“完美替代一切”的终局了。如果你今天就想拿到这张新世界的船票,不必好高骛远:把你每天重复的高频任务写成 Agent 能跑的自动化流程;把你最重要的核心数据,从平台的抽屉里抽出来,变成可以随时打包带走的本地文件。

    这就像是一列在暗夜中启动的列车,虽然我们还不知道终点站的具体名字,但它已经碾碎了 SaaS 报表的遮羞布,撞破了平台 API 筑起的高墙。这列火车,绝无可能倒回去了。

    附录:一些我还没完全想明白的事情

    写到这里,整个逻辑似乎已经闭环。但我必须诚实地暴露,在这个新范式的演进中,依然有几个让我感到极其棘手、尚未想明白的黑洞:

    1. 大众的隐私惰性

      :千万不要用极客的硬核精神去揣度所有人。历史反复证明,只要平台给予足够无脑的便利,绝大多数人会笑嘻嘻地按下那个绿色的“同意”按钮,双手奉上自己的数据主权。这种人性的重力,Agent 真的能对抗吗?

    2. 商业闭环的终极形态

      :如果 Agent 真的无情消灭了注意力广告,打穿了 SaaS 的人头席位费,那么那些开发出顶级 Agent 框架和高质量底层基础设施的团队,到底靠什么活下去?目前我依然没有看到一个能说服我的商业模式。

    3. 非结构化数据的治理深渊

      :没有了大厂几万人维护的数据清洗流水线,仅仅依靠 Agent 在本地处理我们日常产生的那堆杂乱无章的脏数据,体验会不会随时崩溃?

    这些未解的难题,可能不会推翻拓扑换轨的方向,但绝对会无情地拖拽着它到来的速度。

    阅读原文

    跳转微信打开

    ❌