Jev AI 设计模式:投机扇出、Noul 预筛与伴随 Noul
Jev 的一个请求里可以同时问很多问题,所有问题都对着同一份 state 并行、彼此独立地评估,一次返回全部答案。就是这个设计,撑起了一整类架构模式——TypeSafe 官方文档里明确写了六种。它们不是 prompt 技巧,而是关于请求怎么组织、分支逻辑放在哪里的决定。六种模式的收尾方式完全一致:Jev 给概率,你的代码做决定。
下面按官方示例把六种模式走一遍,阈值、代码结构、实测返回值全部照抄文档(2026-11-09 读取),最后给出批量的实测数据和上线前该算的那笔账。
六种模式一览
| 模式 | 作用 | 换来什么 |
|---|---|---|
| 投机扇出 | 一次问全,包括只对部分输入有意义的问题 | 省钱、变快 |
| 先用 Noul 预筛 | 一个便宜的 yes/no 问题挡住昂贵的下一步 | 省钱、变快 |
| 伴随 Noul | 再加一问:到底有没有选项适用 | 可靠 |
| 按置信度路由 | 没定下来的 Score 答案交给人 | 可靠、安全 |
| 按概率路由 | 风险越高的动作,概率门槛越高 | 可靠、安全 |
| 复合打分 | 多个原子分数,在你的代码里加权合成 | 省钱、可靠、快 |
共同前提是:一个只回答单一窄问题的模型,比一个被你要求同时思考六件事的模型值钱。所以判断被拆开,而组合——权重、阈值、分支——留在代码里,因为代码你能 review。
模式一:投机扇出
官方示例是工单分诊。你需要工单分类;如果是 Bug 报告,还要严重度和有没有复现步骤;如果是账务问题,还想知道对方有没有要求退款;而情绪分无论哪类都有用。
朴素做法是两次调用:先分类,再追问。Jev 的做法是把五个问题——分类 choice、Bug 严重度 score、可复现 noul、要求退款 noul、情绪 score——塞进同一个请求,再由代码丢掉不适用的答案。文档把这类问题叫投机的(speculative),理由说得很直白:多问几个通常几乎不影响响应时间,所以问一些可能用不上的问题几乎不要钱。
分支就是普通 Python:
category = response.answers["category"]
bug_severity = response.answers["bug_severity"]
bug_repro = response.answers["has_reproducible_steps"]
refund = response.answers["refund_requested"]
frustration = response.answers["frustration"]
if category.choice == "bug_report":
if bug_severity.score > 1.5 and bug_repro.noul > 0.6:
escalate_to_engineering(ticket_id, severity="high")
else:
add_to_bug_backlog(ticket_id)
elif category.choice == "billing":
if refund.noul > 0.7:
route_to_billing_with_flag(ticket_id, refund_likely=True)
else:
route_to_billing(ticket_id)
elif category.choice == "feature_request":
log_feature_request(ticket_id)
if frustration.score > 1.5:
flag_for_priority_response(ticket_id)
两个细节值得注意。整棵决策树——三条分支加上那个无条件执行的情绪标记——都来自一次调用。另外 frustration 完全在分支结构之外,这才是模式的真正收益:当每个问题都是独立对着 state 评估时,一个问题可以同时服务多条代码路径,而你不需要事前决定这件事。
模式二:先用 Noul 预筛
扇出是默认选择,例外只有一个:当下一步要付出第一个问题不需要的代价时。文档点名了三种情况——更大的 state(客户档案、完整会话、得先抓的附件)、更慢的模型(下一步是一次 LLM 调用)、或者一个人。只有这时,预筛才划算。
官方的例子是共享收件箱:订单咨询、newsletter、付款回执、道谢、还有「顺便说一声」全混在一起。完整分诊要先抓发件人的账户和订单历史,再问好几个问题。预筛只问一件靠消息本身就能定的事:发件人在等回复吗? 同时在 false 的 criteria 里列清楚哪些属于「没什么可回的」。
五条消息的实测值把价值说得很清楚:
| 消息 | expects_reply |
|---|---|
| “I ordered a standing desk two weeks ago and the tracking hasn’t updated… I’m moving on the 30th and need it before then.” | 0.98 |
| “Just so you know, the desk arrived with one of the cross-bar screws missing. I had a spare so it’s built now.” | 0.44 |
| “Thanks, the desk arrived yesterday and it’s great.” | 0.10 |
| “20% off every desk and chair until Sunday. Unsubscribe | View in browser” | 0.02 |
| “Your payment of $129.00 was successful… replies to this address are not monitored.” | 0.02 |
两个阈值把这一列切成三种结果,中间那种才是重点:高于 0.7 算 yes,低于 0.3 算 no,落在中间的不许被四舍五入,单独走一条路。那条 0.44 的「螺丝少了」消息,是一个真人写的、提到了问题但没提要求——直接归档等于丢掉一个客户信号,直接分诊等于白抓一次档案。它应该进人工快速过目队列。
预筛这次调用在文档的实测响应里是 input_tokens: 414、output_tokens: 21。只有 0.98 那条触发了完整分诊请求(input_tokens: 803、output_tokens: 84);在那条请求里,repeat_contact 这个靠抓来的客户档案回答的问题,有历史联系记录时是 0.99,没记录时只有 0.05。同一条消息、不同 state、不同答案——这正说明抓取必须发生在预筛之后,而不是塞进预筛里。
模式三:伴随 Noul
choice 永远会选一个选项。问「这条消息关于我们三条产品线中的哪一条」,一条哪条都不沾的消息照样会得到答案,甚至可能概率很高——模型只是在回答你问的问题,挑最接近的那个。
文档示例里,一封关于台灯的消息被归到 desk_pro,概率 0.96、confidence 0.94。这个答案里没有任何东西告诉你「其实不属于我们的产品」:三个选项里台灯离桌子最近,而分布还对这个错误的问题很有信心。
修法是在同一个请求里加第二个问题:一个问「到底有没有选项适用」的 Noul。这条消息的实测值是 0.02。四条消息并排看:
| 消息 | Choice | 最高概率 | 伴随 Noul |
|---|---|---|---|
| “The motor on my standing desk has started making a grinding noise… the 140 cm one” | desk_pro | 1.00 | 0.98 |
| “The chair arrived but the monitor arm didn’t. Can you check where the arm is?” | monitor_arm | 1.00 | 0.99 |
| “My desk lamp stopped working after two weeks…” | desk_pro | 0.96 | 0.02 |
| “I’m a recruiter working with several furniture retailers and wondered if your head of operations is open to a quick call” | desk_pro | 0.81 | 0.02 |
先读 Noul。低于 0.3,Choice 的答案就是噪音,消息进公共收件箱,别去看它选了什么。高于 0.7,只说明「确实是我们产品」,还得看 probabilities[choice] 是否也够硬(文档代码里是 > 0.7)才直送产品团队;否则由通用客服决定,把 Choice 的首选当建议一并带过去。
文档还明确否掉了一个看起来更省事的替代方案:在 Choice 里加一个 other: "Something else"。other 会和真实选项抢概率,一条半沾产品半沾别的的消息会把概率劈成两半,两个数字都没法指导代码;换成带具体 true/false criteria 的独立 Noul,TypeSafe 自己的测试里通常效果更好。
box 有同款毛病——它永远返回图像里的一个位置——所以文档给了同一个药方:配一个「photo 里有咖啡杯吗」的 Noul,代码才知道这个框到底是不是杯子。(Box 需要 Jev 1.14。)
模式四:按置信度路由
到这里答案本身是定下来的,但决定有代价。score 答案给你一个刻度上的位置,外加一个 0 到 1 的 confidence,表示概率离最可能那一级有多远。
官方示例是 Bug 报告分诊:五级严重度,外观问题进 backlog,功能坏了进本迭代,核心任务做不了直接叫 on-call 工程师。有一份报告——「Notes gone after the update, or maybe deleted」——返回 score 3.19、confidence 0.34,因为概率劈在第 4 级(0.59,更新弄丢了笔记)和第 1 级(0.14,用户自己删了)之间。单看 3.19,半夜会把人叫起来;而这件事可能根本不存在。所以先看 confidence:
severity = response.answers["severity"]
if severity.confidence < 0.5:
send_to_triage(report_id)
elif severity.score < 1.5:
add_to_backlog(report_id)
elif severity.score < 2.5:
add_to_sprint(report_id)
else:
message_on_call(report_id)
四份报告的实测结果是:设置页错别字 0.0 / confidence 1.0 → backlog;PDF 导出超过 50 页失败、拆分文档能过 2.0 / 1.0 → 本迭代;所有客户结账都 500 的 3.36 / 0.7 → 叫 on-call;那份含糊的笔记报告 3.19 / 0.34 → 人工分诊。闸门只在四份里挡住一份,好的闸门本来就该这样。
文档还标了一个坑:Score 的 confidence 把落在相邻级上的概率当作几乎没分散,所以一个卡在两相邻级之间的答案可以顺利通过 confidence 检查,却栽在你自己设的那道级间阈值上。当决定取决于某一侧时,把那侧所有级的概率加起来:probabilities[3] + probabilities[4] >= 0.3 就是一条「用户真有可能被卡住」的判据,完全不关心模型自不自信。
模式五:按概率路由
同一套思路用在 choice 上,只是换了个数。每个 Jev 答案都带概率,于是对代码能采取的每个动作,你单独决定「意图要有多确定才动手」——风险越高的动作,门槛越高。
官方示例是语音银行。任何意图低于 0.7,说明这句话没把意图说清,转人工。check_balance 到 0.7 就够,显示错余额页是可恢复的。但 approve_transfer 分成两段:0.7 到 0.9 先问用户澄清,高于 0.9 才打开转账流程等确认。
这个示例下面那句话,是整份文档里做产品最该记住的:阈值只决定跑哪条流程,没有一条会动钱。明确的转账请求只是打开一张写着金额和收款人的确认页,真正转账要等用户确认。这是故意的,因为一句犹豫的话也可能意图明确——用 jev-1.14.0 测,「Um, the transfer thing… yeah, go ahead I guess.」在 approve_transfer 上拿了 0.99。概率回答的是「用户要哪个动作」,它没有、也不可能回答「用户核对过详情了没有」。只有你的界面能定这件事。
文档也顺手回答了那个显然的问题:这里为什么不用 confidence?选项固定的 Choice,confidence 是由最高概率算出来的,再加一道阈值不提供独立信息——而 probabilities[choice] 读起来就是风险本身。一条「只在 0.9 以上动手」的规则,用大白话说就是「选错的概率低于 10% 才动手」。
模式六:复合打分
排序是单问题判断崩掉的地方,因为「这个候选人有多好」本来就不是一个判断。复合打分把它拆成互相独立的维度,每个维度一个 score 问题,再由代码加权合成。
官方示例给工程岗筛简历,一个请求里同时打四个分——Python 深度、带队能力、系统设计、泛化广度。每个分先归一化到 0–1(五级 rubric 就除以 4),然后按两个岗位各加权一次:
py = response.answers["python_depth"].score / 4
lead = response.answers["team_leadership"].score / 4
arch = response.answers["system_design"].score / 4
general = response.answers["generalist"].score / 4
# Senior IC
ic_score = (0.40 * py) + (0.10 * lead) + (0.40 * arch) + (0.10 * general)
# Engineering Manager
em_score = (0.15 * py) + (0.40 * lead) + (0.20 * arch) + (0.25 * general)
文档强调的好处不是「更准」,而是可见:当排在前面的候选人不符合预期时,你改的是一个系数,不是一段 prompt,而且你能说清是哪个维度把人推上去的。这跟入门文档里那条「原子问题」原则是同一个道理——不要问「给这个创业 pitch 打个分」,而是分开问市场规模、技术可行性、差异化,再用你自己的公式合成。
批量到底会不会改变答案
按理不会,官方也真去量了。parallel-questions 食谱拿 GDPR 的维基百科条目(53,777 字符,固定修订号 1363040264),问 13 个问题——8 个 Noul、2 个 Choice、3 个 Score——两种方式各跑 5 遍:13 个一起发,和 13 次各问一个,比较每遍之间的标准差。
结论:批量没有引入有意义的噪声。13 个答案里有 7 个在两种方式的 5 次重复中完全一致,标准差正好 0.0;其余的波动在两种方式下都不超过 0.015。
变的是成本和耗时。文档在每条请求里都占大头,拆成 13 次就是付 13 遍、跑 13 个来回,合并成一次只付一遍。那一轮里合并版便宜 12.2 倍、快 11.8 倍,答案没变;文档还补了一句:文档越大,省下的越接近整整 N 倍。
上线前该算的那笔账
官方价是每十亿输入 token $42,即每百万 $0.042,输出 token 免费。真实用量看 usage.input_tokens,别猜——不过本文引用的实测响应已经够给一套预筛方案定价:
| 请求 | input_tokens | 按 $0.042/Mtok 的单价 | 1,000 次 |
|---|---|---|---|
| Noul 预筛,只带消息(文档实测值) | 414 | $0.0000174 | $0.0174 |
| 带客户档案的完整分诊(文档实测值) | 803 | $0.0000337 | $0.0337 |
| 塞满默认 64k 单请求上下文的请求 | 65,536 | $0.00275 | $2.75 |
这张表就是预筛的经济学,压缩成两行:预筛每千条消息花不到两分钱,把 80% 的流量从分诊路径上分走,省下的远超预筛本身的成本。而只要待在默认 64k 单请求限制以内,费用比你原本打算调的那次 LLM 便宜三个数量级。
两个上限决定了上面这些形状:整条请求 64k、单个问题 32k;发 TypeSafe-Danger-Zone-Long-Context: true 头之后两者都升到 262k。文档说得很直白——长上下文更慢、更不准,所以按需打开,不要当默认值。
怎么选
- 没有要挡的步骤、只有一份 state → 投机扇出。全问,不适用的忽略。
- 下一步要更大的 state、更慢的模型、或者一个人 → 先用 Noul 预筛,三种出口,不是两种。
- 任何「这些选项都不适用」真实存在的
choice→ 伴随 Noul,并且先读 Noul 再读 Choice。 - 走错路很贵的
score→ 先看 confidence,再按分数路由;卡边界时把那一侧的概率加总。 - 会触发有后果的动作的
choice→ 卡probabilities[choice],一个动作一道门槛,不可逆的那一步留在确认之后。 - 排序 → 复合打分,原子分数,权重写在代码里。
六种模式守的是同一条纪律:Jev 回答,代码决定,每个阈值都是有人能 review 的具名常量。最后这点比模式名字重要得多——文档自己也说,TypeSafe 集成里最该由人来 review 的就是问题和那些阈值常量,所以它们应该集中放在一个地方,好找。
阈值要自己验。 文档反复提醒一句容易被跳过的话:阈值取决于你的领域,以及模型在你数据上的表现。从保守值起步,拿有标注的样本去量,再调。本文出现的 0.7 / 0.3 / 0.5 是官方示例的起点,不是通用常数。
常见问题
这些模式在 Jev 1.13 上能用吗? Choice、Score、Noul 在 1.13 和 1.14 上都有;box 需要 1.14。除了 Box 那条注记,本文所有内容用 1.13 的原语都能表达。
六种模式能混在一个系统里吗? 能,官方示例就是混着用的:共享收件箱先用 Noul 预筛,接着发的分诊请求本身是一个扇出,它的答案再按概率路由。每种模式只关于一个步骤,不是系统级二选一。
扇出里的两个问题会不会互相矛盾? 不会「矛盾」——每个问题都是独立对着同一份 state 评估的,各自的答案就是它自己那个问题在这份 state 上的答案。优先级由你在代码里定义,这也正是分支必须放在代码里的原因。