Deep Research · Agent Architecture

Jev 集成到智能体:速度、成本与最佳实践

TypeSafe AI 的 System One 决策模型如何被接进 Agent 循环,社区已经跑出哪些可复用的集成模式,以及那些被厂商宣传掩盖的数量级落差与硬失败案例。

研究日期 2026-09-22 对象 Jev 1.13 / jev-1.13.0 发布 2026-09-15 证据等级 一手文档 + 第三方实测 零外部依赖单文件

01 核心论断

先给结论。以下九条中,第 4、8 条是对主流宣传最直接的校正,也是本报告最有决策价值的部分。

论断 1 · Jev 替换的不是规划器,是 Agent 循环里的"判断点"

它不写代码、不聊天、不生成工具调用字符串。它占据的是循环里那些高频、原子、可枚举的岔路口:下一步调哪个工具、点哪个元素、这个请求该路由给谁、这段输出合不合规。把这些岔路口从"生成 + 解析"换成"一次前向、并行打分",是全部收益的来源。

论断 2 · 速度收益的真实落点不是"模型更快",是"少等了"

三处结构性省时:① 一次请求并行评估 N 个问题(官方称加问题几乎不增加响应时间);② 不需要等输入完整——语音浏览器在用户还没说完时就执行 go back;③ 消除了解析失败重试与格式校验的返工。

论断 3 · 成本结构翻转为"输入侧主导",且随判断密度放大

$0.042/MTok 输入 + 输出免费。传统 LLM 输出单价约为输入的 5 倍,而 Agent 的每一轮决策都要为"解释答案"付输出费。判断越密集、上下文越大,优势越明显——因为省掉的是最贵的那一半。

论断 4 · 端到端提速远小于模型层提速(最重要的一条校正)

官方宣称 20–200× 快、40–400× 便宜(帕累托前沿口径:193.6× / 444.6×)。第三方实测(Every)落在 25× 快、580× 便宜。而社区最优的端到端实测——browser-use 创始人亲自接线的那个 demo——只有 25% 提速(9.45s → 7.09s)。

原因很直白:Agent 循环里模型推理往往不是瓶颈。Jev 决策总共只占全流程 3.72s / 7.07s(53%),其余是浏览器渲染、等待与执行。先把决策算成多少倍,再问它在你的端到端里占多少比例。

论断 5 · 社区已沉淀出四类可复用集成模式

① 动态动作空间(工具/元素选择)② 投机扇出 + 置信度门控 ③ 校验器 / 裁判 / 模型路由 ④ 上下文与记忆管理。前三类有正面实证,第四类出现了明确的失败数据——见论断 8。

论断 6 · 价值在分工,不在替代:快不等于深

开发者 Hassan 的下棋对照是最好的注脚:Jev 每步约 0.3s / <$0.0001,GLM5.3 每步约 5.8s / $0.008——但 29 步后是 GLM5.3 将死了对手。正确姿势是让 Jev 管"快速且明确"的判断,把需要深推的交给推理模型。

论断 7 · 官方自述的 9 项失败模式,比能力清单更能定义边界

不数数、不算数、不比日期、怕多层间接推理、怕大状态里的无关细节、不生成文本。这份"锯齿清单"实质上是一份使用说明书:凡是算术、计数与多层推理,必须留在代码里。

论断 8 · 唯一有硬失败数据的场景是上下文压缩:Jev 只能判断它能看见的东西

fast-jev-compaction 的会话回放(issue #26):16 段真实 Claude Code 会话、256 个工具结果,没有一个保留分数达到默认的 0.5 阈值;240 个被删除或截断,字符数减少 87.7%。而一个"一律不保留"的假评分器减少 88.5%——两者几乎无差别。

根因不是模型笨,是喂不进去:为了塞进 64k 状态上限,插件把工具结果写成 ok, 4213 chars (omitted) 的占位符,Jev 看不见那 4213 个字符里有没有关键报错。这是一条通用律。

论断 9 · 闭源不可自托管是最大工程风险,但护城河不是架构而是校准

"跳过自回归、单次前向打分"这一层已被开源复现(fast-browser-use 本地 79ms、Nimble 一致率 90.12% vs Jev 93.21%、基座 66.36%)。Jev 真正难以复制的是 RLCD 训练出的校准概率,以及真·并行多问题采样器——那才是置信度门控能成立的前提。

02 范式判定:Jev 是什么,不是什么

名字取自卡尼曼《思考,快与慢》的"系统一",以及杰文斯悖论——智能成本每降一个数量级,就会解锁数量级更多的场景。

2.1 一句话定义

Jev 接收一段非结构化 state(字符串 / JSON 对象 / 文本数组)和一组类型化问题,在一次请求中并行评估全部问题,返回类型安全的答案 + 概率分布 + 置信度。官方把它称作"前沿智能的函数调用":非结构化状态进,带概率的类型化决策出。

2.2 三种原语

原语回答什么返回字段典型场景(社区实跑过的)
Choice从已定义选项中选一个choice、probabilities、confidence工单路由、意图识别、点哪个 DOM 元素、调哪个工具(上限 255 项)
Score在有序量表上处于哪一级score、legend、probabilities、confidence严重度、客户挫败感、滚动幅度、简历各维度打分(2–10 级)
Noul这个命题为真吗noul(0–1 概率,无独立 confidence)是否请求退款、是否破坏性操作、用户这句话说完了吗

原语设计上刻意保持"一个知识丰富的人几秒钟内能做的直觉判断"。需要多因素权衡的问题,官方明确要求拆成多个原子问题、再用代码加权组合。

2.3 它不是什么

不是 LLM 的替代品

不写散文、不聊天、不写代码、不生成工具调用字符串、不做数学、不可靠地数数。官方"生成"一项被直接列为失败模式之一。

不是"零幻觉"的正确率保证

零幻觉的准确含义是类型安全:schema 匹配是数学保证,不可能返回 schema 外的答案。但格式良好的错误答案依然是错的——只是此时你有校准概率告诉你它有多确定。

2.4 关键规格(生产必读)

规格数值工程含义
端点POST https://api.typesafe.ai/v1/systemone仅文本输入,不支持图像 / 音频 / 视频
模型别名jev-latest(稳定)/ jev-preview生产须 pin 版本 jev-1.13.0;别名会移动,调好的置信度阈值会悄悄失效
上下文单请求 64k tokens;state + 最长单问题 32k决定了"能看见多少",是论断 8 失败的根因
延迟端到端 70–500ms(官方美西实测)社区实测 p50 ≈ 178–300ms
价格输入 $0.042 / MTok;输出 $0第三方网关见 §11 价格表,最低 $0.0105
限流250,000 tokens/秒;1,200 请求/分钟early access 期间动态调整,超限 429 + SDK 自动退避
Choice 基数最多 255 个选项更高基数走"先独立打分、再显式选择"两阶段
语言英语最优,CJK 可用但不对等中文场景须自行实测并善用 confidence 路由
定制不支持微调 / LoRA,全账户共享权重只能通过 state 与 instructions 定制
数据不用客户数据训练;企业可谈 ZDR未向中国大陆地区开放

来源:docs.typesafe.ai/models(2026-09-17 复核)、CSDN 技术整理(2026-09-20)、llm24 聚合(2026-09-18)。

图 1 · Agent 循环中的快慢分工:Jev 插在哪里
System 2 · 慢思考(前沿 LLM,秒到百秒级) 职责:目标分解 · 多步规划 · 代码与文本生成 · 需要深推的难题 目标 / 计划 生成代码 / 文本 唯一的文字出口 难例升级处理 低置信度时接手 结果核验 / 收尾 System 1 · 快判断(Jev,70–500ms,一次请求 N 个问题并行) 职责:工具/元素选择 · 意图路由 · 打分排序 · 完成度与破坏性判定 · 输出合规校验 下一步调哪个工具 Choice · 动态动作空间 说完了吗 / 危险吗 Noul · 部分输入即可判 严重度 / 优先级 Score · 阈值分支 输出合不合规 裁判 / 越狱检测 路由 难度判 派判断 回结果 代码层(你自己的策略):阈值 · 权重 · 组合 · 回退 置信度门控:高 → 自动执行;中 → 请求确认;低 → 转人工 / 升级大模型
读图要点:Jev 从不独占循环,它只替换循环里可枚举的岔路口。文字出口始终留在 System 2,最终策略与阈值始终留在代码层——这是所有社区实践中共同的结构。

03 机制:为什么快,为什么便宜

三条机制,每条都能推出一个具体的工程动作。理解机制而不是背倍数,才能判断自己的场景吃不吃得到这份收益。

3.1 机制一:跳过自回归,一次前向并行出全部答案

传统 LLM 即便只需要输出一个 "A",也要为解释答案逐 token 生成;Jev 直接对隐状态打分,单 token logits 完成决策,并用 KV-Cache 广播把多个候选 / 多个问题的评估并行化为一次批处理前向。复杂度从 O(tokens × layers) 的解码循环降到 O(1) 的 logits 投影。

可推出的工程动作

把问题堆到一次请求里。官方原话:"问一个你可能不需要的问题,成本接近于零。"社区实践走得更远——语音浏览器一次发 9–11 个问题,浏览器 agent 把 operation 与 target 两个头塞进同一个请求。这是唯一没有副收益递减的优化。

3.2 机制二:问题之间彼此独立,不产生上下文腐化

同一次请求中的所有问题针对同一个 state 并行、独立评估:增删问题不影响其他问题的结果,不存在 context-rot。这与"把所有条件写进一个大 prompt 让模型在思维链里权衡"形成鲜明对比——后者的问题会互相污染。

可推出的工程动作

原子化提问,在代码里组合。不要问"给这个创业 pitch 打分",而是分别问市场规模、技术可行性、差异化,再用自己的公式合成。优先级变化时改代码里的系数,而不是重写 prompt——这把"调优"从玄学变成了可版本控制的算术。

3.3 机制三:RLCD 把概率训练成"认知诚实"的信号

第三条后训练路线。RLHF 优化"人类偏好的文本"(会奖励谄媚与听起来自信的幻觉),RLVR 优化"可验证的正确性",RLCD 优化决策 + 校准概率:被赋予 0.8 概率的结果,应在约 80% 的情况下发生。

为什么这是自动化的入场券:一个 95% 准确率但不说自己何时落在那 5% 里的模型,无法被自动化。LLM 即使被要求输出置信度,也往往过度自信且不一致。

可推出的工程动作

把置信度当成第二决策轴,按后果设阈值。查余额 0.6 就够(最坏是用户多听一遍);批准转账要 >0.85,否则请用户确认。阈值不是全局常数,是按动作的风险分级的函数。

图 2 · 串行决策 vs 并行决策:一次 Agent 循环的等待结构
上:传统 LLM 串行(每个判断一次往返 + 解析重试) 下:Jev 并行(N 个问题一次往返,无解析环节) t t 判断 1 · 生成 解析 判断 2 · 生成 解析 判断 3 · 生成 解析 判断 4 · 生成 累计等待 = 4× 生成 + 3× 解析 + 可能的重试返工 ✕ 问题越多,等待线性增长;✕ 前序判断错了,后续全错;✕ 必须等输入完整 一次请求:判断 1 · 2 · 3 · 4 并行 端到端 70–500ms(社区 p50 ≈ 178–300ms) 代码 阈值分支 直接动作 ✓ 加问题几乎不增加响应时间;✓ 问题互不干扰;✓ 可对部分输入提前决策 ✓ 类型安全:不可能返回 schema 外的值,无解析失败重试 ⚠ 但:端到端耗时里模型只占一部分——见 §9 的数量级校准
读图要点:并行的收益是"等待从线性变常数"。但要注意这张图只比较决策环节本身;Agent 的端到端时间里还有渲染、网络、执行、等待——它们不会因为换了决策模型而消失。

3.4 RLCD 的另一面:为什么"校准"比"准确"更值钱

官方评测(Workflow Evals)的方法值得单独说:假设存在一个用代码表达的正确计算图,把任务分解为程序化规则 + 若干独立原子问题,由 GPT-6 Astra 与 Claude Fable 5.1(均开最高思考档)对每题作答取平均作为参照标签。

结论有两条:① 每个模型用工作流方式都比用大 prompt 更准确、更便宜、更快——"结构总是更好";② Jev 位于帕累托前沿,在相近智能水平下速度 / 成本领先约两个数量级。

官方自己也标注了偏差("Nuance"小节,值得称道):193.6× / 444.6× 属于真实世界收益的偏高端;工作流由其模型能力团队编写;参照答案取两家平均可能低估 Jev 与 DeepSeek;速度 / 成本声明无法证明没有补贴。

04 四种集成模式与决策树

官方给出 4 个 pattern,社区实践把它们落到了四类场景。这张表把官方意图与社区实测并排列出——右侧"实证状态"列是本节的价值所在。

模式官方定义社区落地形态代表项目实证状态
① 动态动作空间
≈ Speculative Fan-Out
一次请求发多个问题(含投机性的),由代码事后决定哪些相关 把"可选动作"枚举成编号候选集,Jev 一次请求同时选 操作 与 目标,代码校验后执行 browser-use/jev-ultrafast
APUS-AI-Lab/fast-browser-use
正向 端到端 −25%,浏览器协议调用 −90.7%
② 投机扇出 + 置信度门控
Fan-Out + Confidence Routing
置信度作第二决策轴:高 → 自动执行;中 → 确认;低 → 转人工 对部分输入持续采样,一次请求问 intent / target / 完成度 / 破坏性,代码按阈值决定 act / wait / ignore / confirm moritzkremb/jev-voice-browser
Gradium 语音智能体
正向 34/34 集成用例通过,p50 ≈ 300ms
③ 校验器 / 裁判 / 模型路由
≈ Composite Scoring
拆成独立维度打分,用代码控制的权重组合 给 LLM 的 prompt / 推理轨迹 / 输出做打分、裁判、越狱检测;按难度路由到快模型或推理模型 fx 安全分类器
Elvis Saravia 自定义验证器
Hassan 下棋路由测试
正向但有限 快 ≠ 深,深推任务仍须大模型
④ 上下文 / 记忆管理
社区自创,官方未推荐
— 对每条 tool_use / tool_result 逐项问"还需要保留吗",按阈值删除或截断 tamaratran/fast-jev-compaction 失败 256 条无一达阈值,与"全删"基线无差别
图 3 · 决策树:这个判断点该不该交给 Jev
这个判断点需要 Jev 吗? Agent 循环中的一次岔路决策 Q1 · 输出是自由文本吗?(写代码 / 聊天 / 长篇解释) 否 是 不接 Jev 交给生成式模型 Q2 · 答案空间可枚举吗?(N ≤ 255 的离散选项 / 有序等级 / 是非) 是 否 Q3 · 判断所需的全部证据,能被塞进 state 吗? (≤ 32k tokens,且不会被占位符省略成 ok, 4213 chars (omitted)) 能 不能 → 必败 不接 Jev 它看不见的东西判断不了 Q4 · 涉及算术 / 计数 / 日期比较 / 多层间接推理吗? (官方 jaggedness 清单的前四项) 否 是 拆开接 算术与比较留在代码里 Q5 · 这个判断每秒 / 每会话会发生多少次? 高频(≥ 每秒级或每会话数十次)→ 收益最大 高频 低频 接:收益最大 接但收益有限
读图要点:Q3 是最容易被忽略、也最致命的一关——fast-jev-compaction 正是倒在这里。Q4 不是"不接",是"拆开接":让 Jev 判语义,让代码算数。

05 模式一:动态动作空间(工具 / 元素选择)

这是目前证据最扎实、也最能代表"Jev 该被怎么用"的一类。两个项目几乎同时独立做出同样的设计,而且都完整公开了原始测量文件。

5.1 机制:把"可选动作"变成编号候选集

传统 Agent 让模型生成一个动作(选择器、坐标、JSON)。Jev 路线反过来——先由 Harness 扫描当前状态,把真实存在且可交互的候选整理成编号表,再让模型从编号里选。

[1] button    Change ticket type · Round trip
[2] combobox  Where from?        · San Francisco
[3] combobox  Where to?          · empty
[4] textbox   Departure          · empty
...

关键在 jev-ultrafast 的"投机目标头"设计:一次请求同时问 operation(CLICK / TYPE_TEXT / SELECT / SCROLL / WAIT / DONE / BLOCKED)和三个投机性的 target 头(click_target / type_text_target / select_target)。如果操作是 CLICK,就只有 click_target 能执行——两个决策,一次网络往返。每个 target 头只包含与之兼容的元素,从机制上杜绝了"点错类型的元素"。

这个设计的三重收益(可迁移到任何工具调用场景)

  • 结构性消除幻觉:模型从不写选择器、坐标、shell 命令或可执行 JS——它只选编号。类型安全是数学保证,不是经验比率。
  • 动作与生成解耦:只有 TYPE_TEXT 才唤醒小模型生成文字,其余 99% 决策不产生任何文本生成成本。
  • 状态是原子快照:一次浏览器调用读完可见控件、名称、值与文本,并保留真实 DOM 节点引用;执行前重新校验新鲜度与遮挡。

5.2 实证 A:browser-use/jev-ultrafast(MIT,2026-09-16)

由 browser-use 创始人 Gregor Zunic 亲自接线。任务:在 Google Flights 上搜苏黎世 → 伦敦单程机票,含真实文本生成与加载等待。

7,073 ms
端到端任务耗时(1× 原速录制)
17 → 178 ms
决策请求数 · 单次中位延迟
1,092 → 101
浏览器协议调用数(−90.7%)
$0.0038
全流程 Jev 输入成本(90,558 tokens)

更值得看的是对照实验:六次交替运行、相同模型与设置,两版均 3/3 通过。中位任务时间 9.450s → 7.092s(−25%),中位浏览器协议调用 1,092 → 101。

但请注意这几个数字的分母

  • 决策总耗时 3,720ms,占全流程 7,073ms 的 53%——也就是说另外 47% 是浏览器工作、加载等待与陈旧决策重试,换模型动不了。
  • 计时从首次页面观察之后开始,不含初始导航与浏览器启动(Hacker News 上被直接质疑:"那部分不就是最耗时的吗")。
  • 三对配对样本太少(双侧符号检验 p = 0.25),仓库自己声明"这不是通用可靠性基准"。
  • 任务只做到搜索结果出现,不是完成订票;DONE 从来不是成功的独立证据。

来源:仓库 docs/flights-measurement.json、docs/full-speed-measurement.json、docs/performance.md(2026-09-17)。同政策还跑出 Wikipedia 任务 2.798s、本地酒店搜索筛选 1.896s。

5.3 实证 B:APUS-AI-Lab/fast-browser-use(MIT,2026-09-19)

没有 API key、也不能接受数据出境场景下的答案:把它搬到本地。APUS 基于公开文档反推出"跳过自回归解码、隐状态直接打分"的核心逻辑,用 Qwen3.5-9B 复现了单 token logits 决策 + KV-Cache 广播 + 并发批量评估。

场景任务Qwen3.5-9BQwen3.5-35B-A3B说明
Wikipedia 导航(搜到 Python 条目)4.055 s4.944 s仅 4 个离散单 token 评分步骤
Workspace 设置表单(填表 / 下拉 / 开关)2.488 s3.360 s—
本地阅览室导航0.808 s1.049 s—
Python.org 导航(到 About)1.789 s2.120 s—
Example.com → IANA Info1.263 s1.535 s—

测量环境:NVIDIA RTX PRO 6000 Blackwell(96GB VRAM,Linux),PyTorch 2.14.0 + Flash Linear Attention,100% 本地推理。单次决策 79ms,与 Jev 官方 70–500ms 区间对齐。在 M2 Pro 消费级笔记本上跑同样的维基百科任务,中位耗时约 18s——无 GPU 也能用,只是慢一档。全程零云端调用、零 API 费用、数据不出本机。

本地化带来的三个额外性质

  • 成本归零且不再受限流约束:没有 1,200 req/min 的天花板,也没有 250k tokens/s 的共享配额。
  • 数据不出本机:对政企 / 金融场景是硬需求,也是闭源 API 结构性给不了的。
  • 可作为 Agent Skill 挂进宿主:npx skills add APUS-AI-Lab/fast-browser-use --skill fast-browser-use -a claude-code -a codex -g -y,然后在 Claude Code 里 /fast-browser-use <目标>——这就是 System 1 / System 2 分工的最直观形态。

06 模式二:投机扇出 + 置信度门控

语音场景把 Jev 的能力边界推到了最有趣的地方——它可以在用户还没说完的时候就行动。

6.1 打破"等一句话结束"的串行假设

传统语音智能体的链路是:等一句话说完 → ASR 定稿 → LLM 推理 → 执行。Gradium 团队的测试把中间那一步换成了"对每个部分转写持续判断",于是链路变成:部分转写 → Jev 判断 → 若已足够明确则提前触发工具调用。

moritzkremb/jev-voice-browser 把这个思路做成了完整实现,而且工程细节非常值得抄:

一次请求问 9–11 个问题(全部并行)

问题 ID类型作用
intentChoice导航 / 搜索 / 点击 / 输入 / 滚动 / 后退 / 标签页 / 确认 / 取消 / none——每个选项都带 {what, not_for, examples}
targetChoice页面上所有元素编号 + none
siteChoicegoogle / wikipedia / youtube / github / … 用于选 URL 模板
completeNoul用户说完这句话了吗——这才是"提前执行"的开关
is_commandNoul用户是在跟浏览器说话吗(闲聊时 ≈ 0.02,直接忽略)
destructiveNoul会不会提交 / 购买 / 删除 / 发送
is_correctionNoul用户是否在否定上一个动作("不是这个,另一个")
scroll_amountScore一点点 / 一页 / 到底
text_span / url_spanChoice由正则代码抽出的候选片段,Jev 只负责选一个,代码原样复制

策略层:阈值不是常数,是按风险分级的门控表

0. is_correction ≥ 0.6 且无新指令  → 撤销上一个动作
1. is_command    < 0.5             → 忽略
2. intent.confidence < 0.55        → 等待
3. complete < 0.6 且未静音 900ms    → 等待
4. 自由文本类意图额外静音 600ms      → 防止 "search for alan" 截断
5. 目标需 confidence ≥ 0.45 且 top-p ≥ 0.35,否则弹编号浮层让人选(无模型调用)
6. destructive ≥ 0.5               → 必须口头 "confirm"
≈ 300 ms
Jev p50 延迟(avg 330ms,首请求 ~700ms 含 TLS)
≈ 300 ms
最后一个词 → 做出决策(含 200ms 防抖)
$0.0002
单次决策成本
34/34
真实 API 集成用例通过率

来源:仓库 README 与 test/integration/(2026-09-21)。整个 16 条语音命令的 demo 花费约 $0.01。

这里有三个可以立刻抄走的设计

  • 记忆放在 state 里,不放在模型里。Jev 请求之间无记忆,所以项目把 previous_page 与最近 3 个动作(说了什么 / 做了什么 / 结果如何)编码进 state——这才让"回到刚才的结果""不是这个,另一个"可解析。
  • 文本生成由代码拥有,Jev 只做选择。搜索词、URL 由正则抽成候选 span,Jev 选一个,代码原样复制。绝不让它生成。
  • 低置信度时不问模型,问人。目标不确定时弹编号浮层、用户说个数字即可——这一次消歧不花任何模型调用。

6.2 官方的置信度门控范式(可直接套用)

action = response.answers["intent"]

if action.confidence < 0.6:
    route_to_support_agent(account_id)          # 通用地板
elif action.choice == "check_balance":
    show_balance(account_id)                    # 低风险:0.6 够用
elif action.choice == "approve_transfer":
    if action.confidence > 0.85:
        approve_transfer(account_id)            # 高风险 + 高置信:自动执行
    else:
        ask_user_to_confirm(...)                # 高风险 + 中置信:先确认
else:
    route_to_support_agent(account_id)

来源:docs.typesafe.ai/patterns/confidence-routing(语音银行示例)。要点:先设一个通用地板(0.6)兜住"模型真的不确定",再按后果严重性给每类动作单独设阈值。

6.3 复合评分:把权重留在代码里

官方的简历筛选示例展示了"原子打分 + 代码加权"的形态——四个维度各自 Score,归一化到 0–1 后按不同岗位套不同权重:

py      = answers["python_depth"].score   / 4
lead    = answers["team_leadership"].score / 4
arch    = answers["system_design"].score  / 4
general = answers["generalist"].score     / 4

ic_score = 0.40*py + 0.10*lead + 0.40*arch + 0.10*general   # 高级 IC
em_score = 0.15*py + 0.40*lead + 0.20*arch + 0.25*general   # 工程经理

同一批打分,换权重就是换岗位标准——不需要重跑模型,也不需要改 prompt。这是"判断原子化"最实际的回报:优先级调整从重写提示词变成了改一行系数。

07 模式三:校验器、裁判与模型路由

"Verify Everything"——用便宜的判断去给昂贵的输出把关。这一类在社区里花样最多,也最容易高估收益。

7.1 三类玩法

① 输出合规裁判

把 LLM 的 prompt / 推理轨迹 / 输出交给 Jev 打分:是否越狱、是否跑题、是否自相矛盾、是否真的完成了宣称的任务。

② 完成度复核

开发者 Elvis Saravia 把 Jev 接进自己的 Agent 框架,构建自定义验证器——在 Agent 宣称任务完成之后再检查一遍,成本足够低到可以每次都跑。

③ 难度路由

先让 Jev 判断请求难度:简单任务走快模型,难题升级给推理模型。这是最贴近"成本优化"本意的用法。

7.2 实测数据

场景对照结果证据强度
fx 自动模式安全分类器
Vercel 工程师 Pranit
原方案 GPT-5.6 Luna 快 518 倍,且准确性更高 单一案例 · 厂商转述
商业邮件分类
BryoAI 技术总监 Nikhil Mudholkar
Gemini Gemini 准确率略胜,但价格是 Jev 的 10–20 倍 单一案例 · 厂商转述
缺陷检出(12 段文本,6 段植入缺陷)
Every · Mike Taylor 独立测试
Claude Fable 5.1(高推理档) Jev 中位 0.35s vs 8.83s(≈25×);成本约低 580×;但 6/7 vs 7/7 受控实验 · 样本小
下棋(每步决策)
开发者 Hassan
GLM5.3 Jev 0.3s / <$0.0001;GLM5.3 5.8s / $0.008;但 GLM5.3 在 29 步内将死 单一案例 · 结论明确

"快不等于深"——这是本节最重要的一条

Hassan 的下棋测试同时给出了速度与智能两个维度的读数:Jev 每步快约 19 倍、便宜约 80 倍,但棋力明显不如 GLM5.3。Every 的缺陷检出同向印证:快 25 倍、便宜 580 倍,代价是漏掉一个缺陷(一段"教一个共享日历"的用词不当,Fable 三档推理都抓到了,Jev 三次都漏)。

结论:Jev 适合做"早期预警系统"和"高频闸门",不适合做最终判官。Every 的测试者原话:现在宜先当预警,而不是生产判官——样本规模还不足以支撑生产结论。

7.3 一个被低估的用法:给 Agent 轨迹做可观测性审查

官方四个公开工作流里有一个是 Agent 轨迹可观测性审查。这恰好对应真实痛点:Agent 跑了几百步之后,你无法人工回看每一条轨迹。而 Jev 的输入侧定价让"全量审查"在经济上第一次成立——审查 1 万条轨迹、每条 20 个原子判断,输入按 4k tokens 计,成本约 10000 × 4000 / 1e6 × 0.042 ≈ $1.68。

这是纯建模估算,不是实测值。它的意义在于说明数量级:同样的全量审查用前沿 LLM 做,成本会高两个数量级,因而根本不会被做。这就是杰文斯悖论在 Agent 工程里的具体形态——便宜到某个阈值以下,原本"不值得做"的事变得值得做。

08 模式四(反面):上下文压缩为什么失败了

这一章专门留给一个失败的案例。它比任何成功案例都更能说明边界在哪,而且失败原因是可以推广的通用律。

8.1 它原本想解决什么

普通上下文压缩让模型把前面的对话重写成短摘要,痛点是:文件路径、精确报错、限制条件、已经试过的失败方案,都可能在改写时消失。fast-jev-compaction 换了个思路——不写摘要,只做选择题:把每个 tool_use 与对应的 tool_result 配成一组,让 Jev 分别回答两个问题:这个调用还要保留吗?它的结果还要原样保留吗?

默认阈值 0.5,最近 6 条消息与第一条消息默认不动。演示里压缩几乎瞬时完成,保留下来的内容一字不改——这是它最吸引人的地方。

8.2 回放测试的打击

GitHub issue #26 给出了一组真实会话回放:2 个项目、16 段 Claude Code 会话,在上下文达到 12 万 token 时触发压缩,共让 Jev 评估 256 个非固定工具调用。

图 4 · 上下文压缩:Jev 评分器 vs "一律不保留"基线
字符数减少幅度(16 段真实会话回放,256 个工具结果) 0% 25% 50% 75% 100% 87.7% fast-jev-compaction 240 / 256 条被删除或截断 88.5% "一律不保留"假评分器 不需要任何模型 差距 0.8 个百分点 —— 花了一整个模型,效果与无条件全删无法区分 刻度换算:y = 200 + 百分比 × 7.2px。87.7% → 宽 631px;88.5% → 宽 637px 数据:GitHub issue #26 真实会话回放(样本仅来自 1 位用户、2 个项目,且会话多为中文)
读图要点:两根条几乎等长。这不是模型能力问题,是输入问题——Jev 被喂的是 ok, 4213 chars (omitted) 这样的占位符,它看得见工具名、入参与长度,却看不见那 4213 个字符里有没有关键报错。

8.3 根因:Jev 只能判断它能看见的东西

一条通用律

64k 上下文上限 + "必须把所有待判对象塞进一次请求"的设计,共同造成一个后果:为了并行,你必须压缩;为了压缩,你丢失了判断所必需的证据。任何"让 Jev 逐条评判大体积数据"的设计都会撞上这堵墙。规避方式只有两种:① 把判断所需的关键片段显式提取进 state;② 改成分批,但那就放弃了并行优势。

8.4 更有分量的批评:压缩不是筛选

Theo(t3.gg)看过演示后写了措辞很重的长评,核心区分是:整理任务状态 ≠ 逐条过滤工具记录。六条意见里五条直接关系到使用效果,其中两条尤其值得记:

另有开发者给出更激进的对比:Jev 删掉了 98.7% 的上下文,但在复杂会话里丢了 7 个关键测试与边界事实中的 6 个。Agent 忘掉之前为什么失败,很容易重新走一遍老路(Theo 称之为 stupid loops)。

那这条路是不是就废了?不是——但定位要改

作者 Tamara Tran 回应了"它只是在删 tool results"的批评:Anthropic 自己的 context editing 同样会清理旧工具结果,区别在于 Jev 想做得更有选择性。这个回应成立,但没有回答"看不见正文"与"触发缓存重写"两个实现问题。

可执行的定位:把它当成摘要前的预清理——先删高置信度噪音,压不动或判断不稳时回退到内置摘要。若要用于长时间编码任务,至少补三层保护:① 让 Jev 看见工具结果的关键片段;② 默认固定失败记录、编辑操作与不可重跑的输出;③ 用任务成功率与缓存成本评估效果,而不是只看压缩率。

09 速度与成本全景校准

本章回答"到底能快多少、省多少"。结论是:倍数取决于你把测量边界画在哪里——从 1.33× 到 518× 都有人报,而且都是诚实的数字。

图 5 · 提速倍数全景(对数刻度):测量边界决定你看到多少倍
同一件事,五种口径(x 轴为对数刻度) 1× 10× 100× 1000× 换算:v 倍 → 条宽 = log₁₀(v) / 3 × 720 px 1.33× 端到端:browser-use 9.45s → 7.09s 社区实测 · 端到端口径 19.3× 每步决策:下棋对照 0.3s vs 5.8s(棋力更弱) 社区实测 · 单次调用 25× 缺陷检出:Every 独立测试 0.35s vs 8.83s 第三方实测 · 单次调用 193.6× 帕累托前沿:官方评测 厂商自评,偏高端 厂商自评 · 工作流口径 518× 安全分类器:Vercel fx 对比 GPT-5.6 Luna 厂商转述 · 单一案例 只有最上面那条是"端到端"口径 —— 其余全部只测决策环节本身
读图要点:五个数字都不假,只是分母不同。做预算时请只用第一行那种口径:先量出决策环节在你的端到端里占多少比例(browser-use 实测是 53%),再把模型层倍数乘以这个占比,才是真实可得的提速。

9.1 成本:为什么是"输入侧主导"

传统 LLM 的输出单价约为输入的 5 倍,而 Agent 的每一轮决策都要为"把答案写出来"付输出费——哪怕最终只需要一个枚举值。Jev 的输出是 logits 投影,不是 token 序列,因而输出免费。

图 6 · 单次 Agent 决策的成本解剖(假设 4k 输入 / 300 输出 tokens)
每 1,000 次决策的成本构成 $0 $5.4 $10.8 $16.2 $18 换算:每 $1 = 40px。Jev 输入 $0.168 → 6.7px;LLM 输入 $12.00 → 480px;LLM 输出 $4.50 → 180px $0.168 输入 $0.168 · 输出 $0 Jev 1.13 $0.042 / MTok $16.50 输入 $12.00 输出 $4.50 前沿 LLM $3 / $15 每 MTok 成本比 ≈ 98× 其中 71× 来自输入单价差,剩余来自"输出免费"。若 LLM 需要更长解释性输出(如 1,500 tokens),比值升至约 205×
读图要点:绿色那条细到几乎看不见——这就是重点。输出免费带来的收益随"要解释多少"增长:决策任务越简单、LLM 却写得越长,Jev 的相对优势越大。这是纯建模估算,非实测值;实测对照见 §7.2 表格(Every 的 580×、BryoAI 的 10–20×)。

9.2 一个可以直接套用的估算式

# Jev:只算输入
jev_cost   = (state_tokens + Σ question_tokens) / 1e6 × 0.042

# LLM:输入 + 输出(输出单价通常 ≈ 输入的 5 倍)
llm_cost   = in_tokens / 1e6 × P_in  +  out_tokens / 1e6 × P_out

# 真实可得的端到端收益 —— 别忘了这一项
real_gain  = 1 + (model_layer_speedup − 1) × decision_share_of_end_to_end

decision_share 是你必须自己测的那个数。browser-use 实测为 53%(3,720ms / 7,073ms)——所以即便模型层快 25 倍,端到端也只能拿到 −25%。在测量之前,任何"10 倍提速"的承诺都是无意义的。

9.3 便宜到某个阈值以下,会解锁原本不做的事

这是杰文斯悖论在 Agent 工程里的具体形态,也是 Jev 命名由来。三个已经在社区出现的例子:

反过来说:如果你的场景每秒只做几次判断、且判断本身不是瓶颈,那么这份"便宜"换不来任何结构性变化——你只是省了一点钱。

10 失败模式与适用边界

TypeSafe 单独维护了一页 jaggedness(锯齿)说明,列出 jev-1.13 的九项已知弱点,最后复核日期 2026-09-17。厂商主动公开失败模式这件事本身就值得称道——而且这份清单实质上是一份使用说明书。

图 7 · 九项已知失败模式与规避动作
失败模式(官方自述) 规避动作(官方建议 / 社区实践) 1 · 字面理解(答你写的,不是你想的) 把条件写死;给每个选项补上 criteria 与反例 2 · 数学与算术(不是计算器) 算术一律留在代码里 3 · 计数不可靠(字符 / 词频 / 长清单) 它识别"答案的形状"而非清点;误差随规模增长 4 · 日期与时间比较 抽取成分,在代码里比较 5 · 多层间接推理(多跳) 减少跳数;直接指向相关 state 6 · 塞满无关细节的大 state 先过滤,只发该问题需要的部分 7 · 对抗性内容 写精确 prompt,部署前测边界用例 8 · 指令与准则自相矛盾 对齐 criteria 与 instruction;恒等式用代码强制 9 · 生成文本 改用生成式模型 共同点:凡是"算"与"数"的部分都留给代码,Jev 只负责语义判断
读图要点:第 3 项尤其值得注意——官方明确写"模型识别答案的形状而非清点,误差随被计对象的规模增长"。这意味着任何"数一下有几个"的提问都是错的,哪怕看起来很自然。

10.1 反模式清单

层级反模式症状修正
战略 拿 Jev 当"更便宜的通用 LLM" 要求它写代码、聊天、做总结,然后抱怨它不行 它根本不做这些。生成环节必须走生成式模型
用压缩率衡量收益 上下文少了 87%,但任务成功率掉了 改用任务成功率 + 缓存成本双指标评估
工程 让 Jev 评判它看不见的内容 占位符 ok, 4213 chars (omitted);结果与"全删"基线无差别 把判断必需的关键片段显式提取进 state
一个巨型问题代替多个原子问题 多因素权衡时概率失真,且无法调权重 拆成原子 Score / Noul,在代码里加权
用 jev-latest 别名上生产 某天阈值悄悄失效 pin 到 jev-1.13.0,并把响应的 model 字段记入日志
治理 把敏感数据发给闭源 API 而不做评估 数据出境;无自托管路径;未向中国大陆开放 企业谈 ZDR;或走 fast-browser-use 本地路线
相信"零幻觉"等于"不会错" 格式正确的错误答案照样通过 记住:类型安全是数学保证,正确性不是。依赖置信度门控

11 开源生态地图与本地化路线

Jev 本身完全闭源——无权重、无自托管、官方从未承诺开源。但社区在一周内就把这条路铺开了。

图 8 · 生态分层:从闭源 API 到纯本地复现
层 1 · 闭源托管 API(官方) Jev 1.13 · $0.042/MTok 输入,输出免费 · 70–500ms · 250k tok/s,1,200 req/min typesafe.ai 直连 OpenRouter Vercel AI Gateway OpenCode Zen(免费) ZenMUX / Nano-GPT 等 8 个渠道 层 2 · 集成层(开源,把 Jev 接进 Agent) 这一层才是"最佳实践"的载体:动作空间设计、扇出问题集、阈值策略、回退路径都在这里 jev-ultrafast(MIT) jev-voice-browser fast-jev-compaction system-one-adapter-python 官方出品 层 3 · 开源复现(把机制搬到本地) 核心是"单 token logits + KV-Cache 广播 + 语法约束",可完全离线;但缺 RLCD 校准训练 fast-browser-use(MIT) Nimble(Apache 2.0) jevlike(MIT) APUS-OpenJev-v1(HF) 护城河判定: 架构层已可被复现(Nimble 与参考标签一致率 90.12% vs Jev 93.21% vs 基座 Qwen3.5-9B 66.36%) 真正难复制的是 RLCD 校准出的可信概率,以及真·并行多问题采样器——那才是置信度门控能成立的前提
读图要点:层 2 是值得投入的地方(工程可复用、与模型解耦),层 3 是数据合规场景的退路。层 1 的风险是单点与不可自托管。

11.1 项目速查表

项目许可首发做什么关键数据
browser-use/jev-ultrafastMIT09-16 动态索引动作空间的浏览器 agent;operation + 投机 target 头共用一次请求 7.07s 完成任务;1,092→101 协议调用;端到端 −25%
APUS-AI-Lab/fast-browser-useMIT09-19 本地复现:Qwen3.5-9B 单 token logits,可挂为 Agent Skill 决策 79ms(RTX PRO 6000);Wikipedia 4.055s;M2 Pro 约 18s;零 API 费用
moritzkremb/jev-voice-browser—09-17 语音控浏览器:部分转写即决策,9–11 问题并行 + 阈值策略层 p50 ≈ 300ms;$0.0002/次;34/34 集成用例
tamaratran/fast-jev-compaction—09-18 前后 Claude Code 插件:逐条给 tool_use / tool_result 打保留分 失败:256 条无一达 0.5 阈值;−87.7% vs 基线 −88.5%
bespokelabsai/nimbleApache 2.009 月中 Qwen3.5-9B LoRA 适配器 + 训练数据与方法全开源;对比式数据构造 一致率 66.36% → 90.12%(Jev 93.21%)
vinnylarouge/jevlikeMIT09-16 独立起始模型:同输入形状,一次前向出 N 个概率;也用于游戏控制器 8 选项任务比小型自回归解码器快约 100×;无 RLCD
typesafe-ai/system-one-adapter-python—官方 TypeSafeClient 的 drop-in 替换,底层走 OpenAI / Anthropic,把 LLM 包成 System One 结构化输出 用途:自己跑 A/B 对比,量化 Jev 与 LLM 的成本 / 速度 / 智能差
apus-ailab/APUS-OpenJev-v1HF09-20 9B / 4B 参数规模的开源复现权重 团队称可更小参数复现 Jev 性能

11.2 接入渠道与价格(2026-09-18 前后)

渠道模型名输入 $/MTok输出 $/MTok备注
TypeSafe 官方jev-1.13.00.0420最完整:Playground / SDK / Skill,$5 试用额度;需排队
OpenCode Zenjev-1.13-free00零密钥零额度;/models 里选带 free 的即可
Surplus Intelligencejev-1.130.01050P2P 渠道
Qubax AIJEV 1.130.01580P2P 渠道
OpenRouter / Nano-GPT / ZenMUXtypesafe/jev-1.130.0420OpenAI 兼容通道;OpenRouter 标 32K context
Vercel AI Gatewaytypesafe-ai/jev0.040可经 AI SDK 的 experimental_evaluate 调用
AIHubMixjev-1.130.04620—

来源:llm24.net / llmpricing.dev 聚合(2026-09-18~20)。价格会随渠道调整;生产前请以官方文档与账单为准。

最省事的零成本上手路径

① 想先看效果:OpenCode 里 /models 选 jev-1.13-free,零密钥。② 想在自己的代码里试:官方 npx skills add typesafe-ai/skills --skill typesafe-ai,然后在 Claude Code 里说 "use the TypeSafe skill"。③ 想做严谨对比:装 system-one-adapter-python,同一份问题集分别走 Jev 与 LLM,自己测——厂商的倍数永远不如你自己的对照实验可信。

12 落地检查清单

把前十一章压缩成可勾选的动作。按"先测量、后接入"排序——跳过第 1 步直接接入,是本项目观察到的最主要失败方式。

12.1 接入前(必做)

  • 量出 decision_share。在你的 Agent 端到端耗时里,决策环节占百分之多少?参考值:browser-use 实测 53%。低于 20% 的话,换决策模型带来的端到端收益会被稀释到几乎不可见。
  • 列出现有判断点,按"可枚举 / 高频 / 低风险"排序。只把同时满足这三条的交给 Jev。
  • 确认证据可见性。判断所需的全部内容能否塞进 32k 的 state?会不会被占位符省略?——这是 §8 失败案例的直接教训。
  • 先跑一次 A/B。用 system-one-adapter-python,同一份问题集分别走 Jev 与你现在用的 LLM,测准确率 / 延迟 / 成本三项。不要采信任何未经你自己复现的倍数。

12.2 接入时(设计要点)

  • 把问题堆到一次请求里。投机性的问题也一起发——加问题几乎不增加响应时间,事后由代码决定哪些相关。
  • 原子化提问,代码里组合。一个知识丰富的人几秒内能做完的直觉判断 = 一个问题。多因素权衡拆成多个 Score 再加权。
  • 答案空间要包含 none / other 兜底。Choice 上限 255,超过走"先打分、再显式选择"两阶段。
  • 阈值按后果分级,不是全局常数。先设 0.6 地板兜住"真的不确定",再给高风险动作单独设 >0.85。
  • 算术、计数、日期比较全部留在代码里。官方 jaggedness 前四项。
  • 记忆放 state,不放模型。Jev 请求间无状态,把"上一页 / 最近 3 个动作 / 结果"显式编码进去。
  • 文本生成仍归代码。候选片段由代码(正则 / 模板)抽出,Jev 只选一个,代码原样复制。
  • pin 版本号(jev-1.13.0 而非 jev-latest),并把响应的 model 字段记入日志。

12.3 接入后(护栏)

  • 必须有回退路径。fast-jev-compaction 做对了一件事:Jev 请求失败、返回格式不对、或压缩幅度不够时,回退到内置摘要。任何 Jev 调用都不能是单点。
  • 低置信度时问人,不要问模型。语音浏览器的做法:目标不确定就弹编号浮层,用户说个数字即可——这一次消歧零成本。
  • 评估指标换掉。不要看"压缩率""调用次数",看任务成功率 + 缓存写入成本 + 端到端 P95 延迟。
  • 监控版本漂移。别名会移动;调好的阈值会悄悄失效。
  • 数据合规先谈清楚。闭源、无自托管、未向中国大陆开放;企业需谈 ZDR,或走本地复现路线。

12.4 成熟度阶梯

阶段形态典型收益判断依据
L0 未接入所有判断都由 LLM 生成 + 解析—有解析失败重试、有格式校验代码
L1 单点替换一个高频分类点换成 Jev该环节降本 10–100×,端到端几乎无感已跑通 A/B,有回退
L2 动作空间枚举候选 + 一次请求选操作与目标协议调用数 −90%;端到端可感知(实测 −25%)候选集由 Harness 生成,模型不写选择器
L3 扇出 + 门控N 问题并行 + 按风险的阈值策略层可对部分输入提前决策;消歧成本趋零置信度已进入你的策略分支
L4 全链路分工System 1 / System 2 各自负责明确边界,含校验器与路由解锁原本不做的事(全量轨迹审查、实时闭环)你能量出 decision_share 并按它做预算

13 结论与参考来源

13.1 判断(以下为观点,不是共识)

① Jev 真正的产品不是"更快的模型",是"可被代码依赖的判断接口"

放弃字符串生成换来四样东西:类型安全、校准概率、真·并行多问题、毫秒级延迟。前两样让"自动化"这件事第一次在工程上成立——一个不说自己何时不确定的模型,无论多准都无法无人值守地跑。

② 但它不是 Agent 的万能加速器,端到端收益有硬上限

社区最优实测是 −25%,不是 −96%。先用 decision_share 做预算,再决定是否接入。那些 100× 以上的数字都只在"决策环节"这个口径内成立。

③ 最值得抄的不是模型调用,是 Harness 设计

两个浏览器项目独立做出了同一套东西:候选集由 Harness 扫描生成、模型只选不写、执行前重新校验新鲜度与遮挡、结果必须独立验证。这套工程与模型解耦——即使明天换成别家的决策模型,它依然有效。

④ 边界由"它看得见什么"决定,而不是由"它有多聪明"决定

上下文压缩的失败不是能力问题,是输入问题。这条律可以推广到所有"用 Jev 逐条评判大体积数据"的设计。

13.2 参考来源(按证据类型分组)

一手官方文档

开源项目(含原始测量文件)

第三方实测与评测

中文报道与访谈(二手,用于线索发现与交叉印证)

本报告未能亲自调用的验证边界

本次研究未持有 TypeSafe / OpenRouter / Vercel 的 API key,未亲手调用 Jev API。所有延迟、成本与准确率数字均标注了来源与性质(厂商自评 / 第三方实测 / 社区实测 / 建模估算),建模值已在正文显式区分。Jev 发布于 2026-09-15,本研究距发布仅 7 天——样本量与时间跨度均不足以支撑长期生产结论。