Code Mode 真的有收益吗:687 次调用、两个模型跑出来的答案

不估字节数,真的执行。四组对照实验、687 次模型调用、两个模型,量出 Code Mode 省的是什么、省不动的是什么,以及我自己踩进去的三个实验设计坑。

上一篇我用一段脚本量了 Code Mode 能省多少字节,得出”省 92%“。写完我才意识到那个实验回避了唯一重要的问题:

省完之后,模型还干得对吗?

字节数实验里没有模型。它证明的是”把 JSON Schema 换成 TypeScript 签名字符更短”——这件事用肉眼也能看出来。真正要回答的是:把工具编排从上下文窗口搬进解释器,任务正确率会怎么变。

这篇用四组对照实验回答。总计 687 次模型调用,两个模型(本机 Qwen2.5-7B 和 Sonnet),全部脚本和原始 JSON 都在文末。

先把结论摆在前面,因为其中两条跟我开跑前的预期相反:

结论证据档位
Code Mode 的省 token 收益是真的且跨模型稳定:同样 12 道任务,多轮 tool loop 比 Code Mode 多烧 4.8× 的 prompt token(两个模型都是这个量级)亲手测,p 值见正文
Code Mode 的正确率收益大部分是弱模型效应:7B 上 25% → 100% 碾压,Sonnet 上 83.3% → 100%,差异不显著(p=1.0)亲手测
把 schema 换成 TS 签名省 60% token、没测出精度损失——但这是天花板效应,不是等价性证明亲手测,但检验功效不足
progressive disclosure 掉了 7.5 分,统计上说不清(p=0.25),而且掉分里混进了”两轮交互”这个额外变量亲手测,明确标注不显著
输出侧折叠:“留取回入口”这条规则能把 0% 救到 66.7%——这是全文最干净的一个因果亲手测

名词速查

词一句话解释
Code Mode让模型写一段代码调用若干工具、在沙箱里执行,只有最终结果回到上下文
Tool loop传统做法:模型每轮发一个工具调用,结果塞回上下文,再发下一个
Progressive disclosure按需加载:先给工具目录,用到哪个才读它的完整定义
Response folding把工具返回在进上下文前压成摘要,原始内容另存可按 ID 取回
McNemar 检验配对二分类的显著性检验。只看”A 对 B 错”和”A 错 B 对”这两格的数量差,适合同一批任务跑两种方法
Wilson 区间小样本比例的置信区间算法。n=12 时比常见的正态近似可靠

实验台

  • 本机模型:Qwen2.5-7B-Instruct-Q4_K_M,llama.cpp build b9630,Metal 后端,M5 Pro / 24GB。
  • 对照模型:claude -p --model sonnet,禁用全部工具与 MCP(--strict-mcp-config --mcp-config '{"mcpServers":{}}' --allowed-tools ""),当纯文本补全端点用——编排必须来自我测的协议,不能来自 Claude Code 自己的 agent loop。
  • 解码:temperature=0, top_k=1, seed=1234。
  • 工具目录:40 个工具 / 8 个虚构 MCP server,故意塞进易混对(list_directory vs search_in_files、create_draft vs send_email)。

一个一开始就该做的检查:三轮重复跑出来的结果 bit 级完全一致,非确定性配对数 = 0。

repeats=3, non-deterministic (arm,task) pairs=0

所以后文不会出现”三轮稳定复现”这种说法——贪心解码 + 固定 seed + 空闲服务器下,重复跑证明的只是确定性,它不提供任何稳健性信息。真正的不确定性全在任务抽样上,要靠配对检验和置信区间,不是靠多跑几轮。这是我这次最该记住的一条。

实验 A:输入侧——40 个工具怎么摆进上下文

五个 arm,同样 40 道单步选工具任务,判对的标准是”选对工具且填齐必填参数”:

arm上下文里放什么
full_schema全部 40 份 JSON Schema(传统 MCP)
full_ts全部 40 份 TypeScript 签名
progressive只给 40 行文件名,模型挑一个,第二轮才给它那一份签名
prog_desc文件名 + 每个工具一句描述,第二轮同上
prog_desc_srv同上,再按 server 分组
arm                acc        95% Wilson CI   prompt_tok  vs schema
full_schema      97.5% [ 87.1%,  99.6%]          5011      1.00x
full_ts          97.5% [ 87.1%,  99.6%]          1995      0.40x
progressive      90.0% [ 76.9%,  96.0%]           523      0.10x
prog_desc        92.5% [ 80.1%,  97.4%]           892      0.18x
prog_desc_srv    87.5% [ 73.9%,  94.5%]           956      0.19x

paired McNemar exact vs full_schema (n=40):
  full_ts        schema-only-right=0  arm-only-right=0  p=1.000
  progressive    schema-only-right=3  arm-only-right=0  p=0.500
  prog_desc      schema-only-right=2  arm-only-right=0  p=1.000
  prog_desc_srv  schema-only-right=4  arm-only-right=0  p=0.250

能说的:换成 TS 签名,prompt token 掉到 40%,97.5% → 97.5%。

不能说的:不能说”TS 签名零精度损失”。两个 arm 都是 97.5%,McNemar 的两格都是 0——这不叫”没有差异”,叫这个检验在这里完全没有功效。任务太简单,天花板效应把分辨率吃光了。Wilson 区间宽到 [87.1%, 99.6%],意思是真实水平落在 87% 还是 99% 我都分不出来。正确的说法只能是:在这个难度下没测出差异。

progressive 掉的 7.5 分也一样,p=0.25。方向一致(四个 arm 全部只输不赢,没有一个 arm 在 full_schema 错的题上做对),但 n=40 撑不起显著性。

还有一个我自己埋的坑:progressive 系列同时改了两件事——信息量变少且交互结构从一轮变两轮。证据是 prog_desc 保留了全部 40 条描述(选工具需要的信息一点没少),却仍比 full_schema 低 5 分。所以”progressive disclosure 的代价”这个归因是脏的,掉的分里有一部分是两轮结构本身造成的,我这次没把它拆干净。

有一道题五个 arm 全错,值得单独看:

tasks every arm failed: 1
 - "Call off the Friday retro and let everyone know."

模型一律选 send_message 而不是 cancel_event。这是我出题出歪了(“let everyone know”把它往发消息上带),属于任务瑕疵,不是格式效应——这种题应该在定标时就剔掉。

实验 C:真正的 Code Mode——写代码,而且真的执行

实验 A 其实根本没在测 Code Mode。给 TS 签名只是换了个表示层,模型干的事还是”吐一个工具调用”。Code Mode 的主张是让模型写一段编排多个工具的程序,所以忠实的实验必须:给 API 文档 → 模型写代码 → 真的跑 → 和多轮 tool loop 在同一道多步任务上比。

于是做了 12 道必须跨工具组合的任务,比如:

在”severity=critical 且 status=firing”的事件里,哪个服务最多?报出该服务名和它当前的健康状态。

两个 arm 打同一套真实可执行的后端:

  • tool_loop:每轮一个 JSON 工具调用,结果塞回对话,最多 10 轮。
  • code_mode:写一段 Python,在受限命名空间里 exec,只有 stdout 回来。
tool_loop            25.0% [  8.9%,  53.2%]  prompt_tok=  6605  turns=4.1
code_mode            83.3% [ 55.2%,  95.3%]  prompt_tok=   378  turns=1.0
code_mode+repair    100.0% [ 75.7%, 100.0%]  prompt_tok=   581  attempts=1.33

McNemar tool_loop vs code_mode:        loop-only=0 code-only=7 p=0.0312
McNemar tool_loop vs code_mode+repair: loop-only=0 code-only=9 p=0.0078

这是全文唯一统计显著的正确率结论,而且是零反例:没有任何一道题是 tool loop 做对而 Code Mode 做错的。

失败长什么样,比数字更有说服力。同一道题:

# tool_loop:列出 16 条之后,开始一个个服务去问健康状态
{"tool": "list_incidents", "args": {"severity":"critical","status":"firing"}}
{"tool": "get_service_health", "args": {"service": "inventory"}}
{"tool": "get_service_health", "args": {"service": "payments"}}
{"tool": "get_service_health", "args": {"service": "search"}}
{"tool": "get_service_health", "args": {"service": "auth"}}
{"answer": "inventory degraded"}        # 错,正确答案是 checkout
# code_mode:同一道题、同一个模型
from collections import Counter
critical_firing_incidents = [inc for inc in list_incidents(severity='critical', status='firing') if inc['service']]
service_counts = Counter([inc['service'] for inc in critical_firing_incidents])
most_common_service = service_counts.most_common(1)[0][0]
print(most_common_service, get_service_health(most_common_service)['status'])
# checkout degraded —— 对

Counter.most_common 不会看岔,模型的眼睛会。掉的那一分不在”理解任务”,在”在上下文里数数”。

我在这一组里修掉的两个自造 bug

第一版 code_mode 只有 50%,我差点就那么发了。看了失败样本才发现六次失败里有四次是我的沙箱太严:

c05  WRONG  [ImportError: __import__ not found]   # 模型写了 from collections import defaultdict
c11  WRONG  [ImportError: __import__ not found]   # from statistics import mean

真实的 Code Mode 沙箱当然允许 import collections——拦它是在用我的偏执给模型记过。放开标准库(仍然禁 os/sys/网络,这是能力围栏不是语法围栏)之后,83.3%。

第二个 bug 方向相反,是我不公平地苛待了 tool_loop:工具返回我截断在 12,000 字符,而完整事件列表是 18,518 字节——tool loop 一直在用被我截断的数据答题。改成 60,000 后重跑,它的分数没变(还是 25%),但这是修完才知道的,修之前我没资格报这个数。

剩下两次失败是模型真实的错:把 search_logs 返回的字符串 id 当 dict 用;写了 statistics.mean 却没 import。给一次错误回传后两道都自己改对了——这正是真实 Code Mode 的工作方式(沙箱把 traceback 还给模型),所以 code_mode+repair 这个 arm 才是对应生产形态的那个。

实验 D:换成强模型,结论还成立吗

实验 C 有个要命的歧义:tool_loop 只有 25%,那 83% vs 25% 到底在测”Code Mode 有收益”,还是在测”7B 做不了多轮编排”?

这个必须用强模型做控制。同样 12 道题、同样两个协议,换 Sonnet:

            acc        95% Wilson CI    prompt_tok   turns   wall
tool_loop   83.3% [ 55.2%,  95.3%]        191,289     2.5    496s
code_mode  100.0% [ 75.7%, 100.0%]         39,857     1.0    171s

McNemar: loop-only=0 code-only=2 p=1.0000
prompt_token 比值 loop/code = 4.80

结论确实要改写。换成 Sonnet 后,正确率差距基本消失(p=1.0,不显著)——7B 上那个 25% → 100% 的碾压,大部分是模型能力差距,不是 Code Mode 的功劳。Sonnet 的 tool loop 能稳稳地数完 16 条记录再回答。

但另一半结论站住了,而且跨模型稳定:token 成本差 4.8×。中间结果反复流经上下文这件事,再强的模型也免不掉——它是协议决定的,不是能力决定的。

两个必须说清的软处:

  • tool_loop 那两次失败里,有一次是 300 秒超时(基础设施),不是答错。按答错算只有 1 次,真实是 11/12。把超时算成模型错误会夸大 Code Mode。
  • prompt_tok 里含 Claude Code 自己约 36k 的系统前言(每次调用都付),所以这列只能 arm 之间互相比,不能跟本机那组数字比。

实验 B:输出侧折叠——以及我第一版里的作弊

输出侧我第一版写了个折叠器,手工导出 counts_by_severity / counts_by_status / top_firing_critical,然后拿”有多少 critical""哪个 firing 的 duration 最大”去问它。

折叠器偷看了考题。 真实 gateway 折叠的时候并不知道下一个问题是什么。

重写成问题无关的折叠规则:逐字段看统计特征——低基数的留直方图、数值的留 min/max/mean、平均长度超过 200 字节的长文本字段直接丢并记账。这套规则换任何工具返回都能跑,它不认识我的题目。

同时补上第一版缺的另一半:原来的摘要里写着 retrieve_with: fetch_record(id),但模型根本没有任何能调的取回工具——“buried 类必全错”是我构造出来的,不是测出来的。所以加了第三个 arm,真给它 get_record / search_logs。

arm           class          acc   prompt_tok  fetches
raw           surfaced      0.0%        76737        0
raw           aggregate     0.0%        76748        0
raw           buried        0.0%        76754        0
folded        surfaced    100.0%         1016        0
folded        aggregate    33.3%         1027        0
folded        buried        0.0%         1033        0
folded_tools  surfaced    100.0%         1114        0
folded_tools  aggregate    33.3%         1125        0
folded_tools  buried       66.7%         2334        3

raw 这一行必须特别说明:它 0/9,连”这里有多少条记录”都答错(答 1119,实际 120)。 76.7k token 丢给一个 7B 模型,测的是长上下文退化,不是折叠的对照基线。所以这组里任何”folded 赢 raw”的解读都是错的,我不会那么写——raw 这一列的唯一作用是标出这台机器上 7B 的长上下文地板在哪。

能站住的是另外两条,都不依赖 raw:

  1. 问题无关的折叠器在聚合题上只有 33.3%。 它留的是边际直方图(severity 各多少、status 各多少),而”既是 critical 又是 firing”要的是联合计数——边际推不出联合。这是折叠的结构性失真,不是模型笨。
  2. “留取回入口”这条规则,把 buried 从 0% 抬到 66.7%。 唯一的变量就是给了它真能调的取回工具,而且它自己主动用了(fetches=3,三道题各取一次)。

第 2 条是全文最干净的一个因果。还有一个细节值得记:folded arm 答 buried 题时,不是说”我看不见”,而是编了几个 ID 出来(答 INC-1000,INC-1007,正确是 INC-1007,INC-1042,INC-1091)。折叠丢掉证据之后,模型不会报警,它会流畅地瞎编。

还有一道有意思的错:folded_tools 在 q3a 正确取回了 3 条记录,然后把”3”数成了”2”。取回路径通了,数数还是会错——这又是实验 C 那个毛病:数数这件事就不该交给模型,该交给 len()。

本质:省 token 和防出错,是同一个动作的两个侧面

把四组实验串起来,底下是同一条约束:上下文窗口既是成本,也是精度瓶颈——同一份中间数据放在那里,既要付钱,又会被看错。

  • 数据库里这叫谓词下推:能在存储层过滤就别搬到计算层。
  • Code Mode 下推的是编排:筛选、排序、计数这些机械步骤交给解释器。实验 C/D 量到的 4.8× token 差,和 7B 上那些”目测挑了 inventory”的错,是同一件事的两个后果。
  • Response folding 下推的是裁剪:哪些字段进不去模型,由 gateway 决定。它省 token 的同时也在丢证据——所以必须配取回入口,这正是实验 B 量到的 0% → 66.7%。

一个反事实能检验这条主线:如果上下文不要钱、而且模型在十万 token 里数数永不出错,这两个模式都没有存在理由。实验 B 的 raw 那一行(0/9,连记录条数都数错)正好说明第二个条件现在差得有多远。

怎么用:三张边界卡

我在造 Agent,任务需要跨工具组合 → 上 Code Mode,这是本文证据最硬的一条(p=0.0078,零反例)。但要明白你买的主要是 token 和延迟:4.8× 的 prompt token 差跨模型稳定;正确率的好处在强模型上会缩水到不显著。沙箱要允许标准库,要把 traceback 回传给模型——code_mode+repair 和 code_mode 差 16.7 个百分点,就这一个设计决定。

我的瓶颈是工具太多,schema 装不下 → 换 TS 签名能省 60% token,我没测出精度损失——但请读成”这个难度下没测出”,而不是”等价”。上 progressive disclosure 前先知道它有两个代价:信息变少,以及多一轮交互(我这次没拆开,但 prog_desc 保留全部描述仍掉 5 分,说明第二项不是零)。

我的瓶颈是工具返回太大 → 折叠必须留取回入口,这条有 0% → 66.7% 的实测支撑。同时记住两件事:边际统计推不出联合统计(我的折叠器在聚合题上只有 33.3%);折叠丢掉证据后模型会瞎编而不是报警。

我这次踩进去的坑,比结论更值钱

四个坑,每个都差一点让我发出错的数字:

坑后果判据
沙箱禁了 import collectionscode_mode 被我按到 50%,真实是 83.3%失败样本里出现 harness 的错误类型(ImportError/截断),先怀疑自己
工具返回截断 12k < 数据 18.5ktool_loop 在用残缺数据答题截断阈值必须大于最大可能的工具返回
折叠器按考题设计输出侧的好成绩全是泄漏折叠规则必须能在不看问题的情况下写出来
用 76k 上下文的 7B 当基线0/9,测的是长上下文退化不是折叠基线自己先要能做对题,否则它不是基线

还有一个不算 bug 但更隐蔽的:我原本打算用”三轮重复”给结论加码。跑完发现非确定性配对数是 0,三轮完全一致——那三轮提供的信息量是零,加码是无效论证。小样本下该补的是任务数和配对检验,不是重复次数。

通俗总结

把这件事想象成让实习生去仓库盘点。

  • 传统 tool loop:你让他每次搬一箱到你办公室,你亲眼看一眼,再让他搬下一箱。箱子堆满办公室(上下文),而且箱子一多,你自己就数错了——实验里 7B 就是这么把 checkout 看成 inventory 的。
  • Code Mode:你给他一张清单,让他在仓库里点完,只回来报一个数。办公室干净,数也是算出来的不是看出来的。实测他要搬的箱子少了 4.8 倍。
  • 但是:换一个很厉害的实习生(Sonnet),他搬满一屋子也能数对。所以”不会数错”这个好处随着人变强而缩水,“少搬箱子”这个好处不会。
  • 折叠返回就是让他只报摘要不搬原件。好处是办公室彻底空了,风险是你问”那批货的批号是多少”时,摘要里没有——而他不会说”我不知道”,他会编一个批号给你。所以摘要上必须写明”原件在 3 号架,随时可取”,他才会跑回去查。实测这一条能把这类问题的正确率从 0 抬到 2/3。

一句能复述给同事的话:Code Mode 真正稳定的收益是省上下文(4.8×,换模型也不变);它”让模型少出错”的那部分,模型越强越不值钱。

下一步:我自己想补的两个实验

这篇撑不起来的地方,诚实列在这里:

  1. 把”信息变少”和”多一轮交互”拆开。 做一个 twostep_full arm:第一轮给完整 schema 让它选,第二轮再问参数——信息量不减,只加一轮。它和 full_schema 的差就是纯粹的两轮结构代价。这个实验大概 20 分钟。
  2. 把任务难度抬到天花板以下。 实验 A 的 97.5% 让所有检验失去功效。要测 TS 签名和 JSON Schema 是否真的等价,得先把任务做到 70-80% 的区间(加更多近义工具对、让参数更容易填错),否则再跑多少次都只能得到 “p=1.000”。

全部脚本和原始 JSON 在仓库的 notes/ctxmode-exp/:exp_a_full.py(输入侧五 arm)、exp_c.py / exp_c_repair.py(编排对照 + 错误回传)、exp_d.py(Sonnet 控制组)、exp_b2.py(输出侧折叠)、analyze.py(全部统计)。687 次调用的原始记录都在同目录的 .json 里,想重算哪个数字都可以。

参考来源