进阶 pydantic.dev 2026-11-20 05:57:40 · 11 阅读

第13章 Code Mode 与工具调用之争:基于 5276 次运行的基准测试

现在每个和我聊过的人对 code mode 都有自己的看法。我的想法源于 Prime Intellect 的 Prime Agent——一个围绕持久 REPL 构建的 coding harness——以及 Alex Zhang 的 speculative programmatic tool calling 设想,它(特点之一)能在模型还在流式输出代码时就开始执行工具调用。Cloudflare 有自己的方案,Anthropic 也有。我们自己做过几个,从 MCP code execution 到 Pydantic Monty。Coding agent 领域也在朝同一方向走:OpenCode 2 现在默认通过 Code Mode 发送 MCP 工具,Pi 也内置了 codemode 工具。这套方案的说辞通常是这样:别再让模型一个一个地调用你的工具了,让它写个小程序来调用,一切都会更便宜、更快、更好。

我信这套说法。但我见过的几乎所有数据都来自拥有几百个工具或超大 payload 的 agent,而现实中的很多 agent 其实很朴素:几条 CRUD 工具加一个待办的任务。所以我正是围绕这一点做了一个 benchmark。五个小型 Pydantic AI 应用,全部是单项操作工具,三类工作:日常请求、长流程多步任务,以及五个可以从 5 项调节到 200 项的任务。八个模型,code mode 开和关,在一个内部 benchmark 上跑了 5,276 次评分运行。

简短结论:任务越长,优势越大。而且优势会变得很大。

TL;DR

在长任务上,code mode 大约把成本和耗时砍半。八个模型整体:成本 -58%,耗时 -51%,成功率 +16.0 个百分点。不开 code mode 时 288 次运行有 67 次失败;开了之后只有 21 次。

它能扩展。对 gpt-6.1-sol 来说,不开 code mode 时每多 100 项,每次运行要多花 30 到 79 秒和 $0.04 到 $0.07。开了之后:五个任务里有四个只增加 4 到 9 秒,其中三个成本增加不到一美分。在 200 项时,code mode 便宜 47% 到 75%。

不开它会损失正确性。从 5 项到 200 项,不开 code mode 的成功率从 92-100% 掉到 62-79%。开了 code mode,200 项时仍是 92-100%。

关键不在往返次数。模型本来就会批量调用:有一个响应携带了 200 个工具调用。在 200 项时,八个模型的平均模型请求数只下降 1% 到 22%;deepseek-v4.1-flash 单独看降幅大得多。code mode 真正削减的是每次请求里装了什么。

小任务要交税。在 5 项时,五个任务里有三个 code mode 反而更贵(+21% 到 +38%)。在 50 个日常任务上总体便宜 16%,但成功率基本持平(+1.6 个百分点,属于噪声)。

它是沙箱化的,而且留下追踪痕迹。在 Pydantic AI Harness 中,模型的代码跑在 Monty 里——Monty 默认不接触宿主机,且默认在执行满 30 秒或堆内存达到 256 MiB 时终止任何代码片段。用 Pydantic Logfire 追踪 agent 时,代码发起的每一次工具调用都会显示为独立的 span。

开启 code mode 后,每多 100 项对 gpt-6.1-sol 有多快多便宜:

Task Faster Cheaper

cart 7x 8x

calendar 9x 25x+

chat 5x 2.4x

kanban 20x 11x

inventory 2.2x 2.2x

我的理解是:模型写一个循环远比亲自充当循环要强,而且任务越长,这个差距越大。

循环,以及它为什么疼

在普通的 tool calling agent 里,模型挑一个工具,输出一段 JSON,停下,等 harness 执行完,读结果,再挑一次。模型处在每一步的中间,成本不断叠加:工具定义挤占上下文,每个中间结果都流经模型,而且通常的说法是,每次工具调用都是一轮新的模型请求,要把不断膨胀的整个上下文重新发送一遍。

Code mode 把它倒过来了。工具变成沙箱里的函数,模型写一个程序去循环和分支地调用它们,只有结果返回来。在 Pydantic AI Harness 里,这个沙箱是 Monty——我们用 Rust 写的 Python 解释器——而模型看到的只是一个 run_code 工具。

这是 50 个任务之一,原话是:"can you get rid of everything in my cart that costs more than $50 a piece? it's getting out of hand"。购物车里有 122 行,list 工具每页最多返回 50 条,remove 工具一次只接受一个 id。有 22 行需要删除。不开 code mode,就是三页的 listing 加 22 次 remove,每一步都由模型来决策。开了 code mode,是这样的:

import asyncio

items, offset = [], 0 while offset is not None: page = await list_items(offset=offset, limit=50) items += page["items"] offset = page["next_offset"]

pricey = [i for i in items if i["unit_price"] > 50] await asyncio.gather(*(remove_item(item_id=i["id"]) for i in pricey)) len(pricey)

模型从没读过那 100 条便宜的商品。它不需要记住自己已经删了哪些 id。"> 50" 这个比较由 Python 完成,而不是由一个语言模型眯着眼睛看浮点数。

带护栏的 code mode

那段程序是模型写的代码,总得有什么东西来运行它。这个东西允许代码碰什么,是 code mode 里最重要的设计决策。

Prime Agent 选择了开放。它的模型唯一的工具是一个持久 IPython kernel,harness 的其余部分——包括子 agent——都以函数的形式活在这个 kernel 里。IPython kernel 是一个完整的 Python 进程:除非周围有什么限制它,代码可以 import 任何库、读写文件、开网络连接。对于你自己机器上的编程助手,这正是你想要的。但我不太敢把它放进 web 服务器,让每个用户的 prompt 来驱动它。

Pydantic AI Harness 选择了相反的方向。CodeMode 在 Monty 里运行模型的程序——我们用 Rust 写的 Python 解释器——它从零开始,只添加你明确允许的东西:

默认不接触宿主机。沙箱代码一开始无权访问宿主机的文件、环境变量和时钟,也没有网络。如果 agent 需要一个目录、一个环境变量或当前时间,你按请求逐次授权。这个 benchmark 授权了内置的 OSAccess handler:内存文件系统与环境,以及宿主机时钟。

你的工具是唯一的出口。程序只能通过你注册的函数加上你授权的 OS 访问来触及外部世界,每次工具调用都经由 Pydantic AI 到达你的真实工具。它能做这些允许的事,仅此而已。

硬性上限。默认情况下,每个 run_code 片段有 30 秒执行时间和 256 MiB 堆内存(详情),这正是防止失控循环的机制。

启动快。每个 Monty 会话运行在本地 worker 进程里,从运行中的进程池里启动一个新沙箱不到一毫秒,所以这些护栏不会给每个片段增加一次容器启动。

于是你得到了带护栏的 code mode。这个 benchmark 里所有 code mode 运行都跑在 Monty 里。

代码即图

Samuel 为此写过一整篇文章,《The code is the graph》,如果你在做 agent,应该读一读。他的论点是:图数据库式的流程库把控制流重建得很糟糕:"if 是分支。for 是循环。函数调用是一条边",而 asyncio.gather 是一次扇出加一次汇合。或者用他评价一个五行例子的话说:"扇出、汇合、分支。这就是一张图,它同时也是一个 Python 函数。"

上面那个程序正是如此。这是它编码出的图:

这段程序是我为配图写的,但模型在 benchmark 里运行时,面对从未见过的任务,也会自发写出同样的形状(在一次 cart 运行中,gpt-6.1-sol 把它拆到了三次 run_code 调用里)。没有人预先画过那张图。这正是让我相信 code mode 代表 agent 未来方向的地方:模型不只是在更便宜地调用你的工具,它是在现场设计工作流。

但这是一篇带 benchmark 的博客文章,所以让我们来验证一下这些说法到底是不是真的。

Benchmark

这个 benchmark 是刻意做得很简单的。五个微型 Pydantic AI 应用:购物车、日历、聊天室、kanban 看板和库存系统。每个应用只有单项 CRUD 工具(list、get、create、update、delete),列表带分页。没有 shell,没有文件系统,没有批量接口。如果 agent 要改 200 条数据,它就得发 200 次调用,或者写个循环。

这里没有哪一步是难的。难的是把一个简单步骤正确地重复几百次,顺序不能乱,计数不能丢——这正是我想隔离出来的部分:长跨度上的迭代。代码即图。让你的 agent 去写那张图。

在这些应用之上是三层工作:

日常:50 个测试,每个应用 10 个。单个修改、批量修改、带分支的规则、查找和求和。不开 code mode,一次运行大约 13 次工具调用。

长跨度:12 个跨 60 到 500 条记录的多步任务,每个应用两个,另有两个跨应用。"Alex is leaving the team. go through Alex's open tasks (not done) in order of id: if it's urgent or high priority, give it to whoever has the fewest open points at that moment..." 每次运行约 68 次工具调用。

规模伸缩:每个应用一个任务,同一条规则分别在 N = 5、20、50、100 和 200 项上执行。"I have a pile of meeting invites I never answered. for each one: accept it if it's on a weekday and ends by 5pm, decline it if it's on a weekend or ends after 5pm." 在 N = 200 时,不开 code mode 的运行平均 168 次工具调用。

每个应用是一个 Pydantic AI agent。开启 code mode 时,它获得 Pydantic AI Harness 的 CodeMode 能力(eager execution),可以在模型还没写完 run_code 调用之前就开始执行完整的语句。关闭 code mode 时,同一个 agent 直接调用同样的工具。所有东西都固定在同一个 commit 上,code mode 只靠一个设置开关,所以两组之间的唯一差异就是 code mode 本身。Prompt 都按真人打字的方式写,每次运行由确定性 oracle 评分:应用的最终状态必须与预期状态完全一致(金额误差在一美分以内),回复必须包含正确的数字。没有 LLM 评审。

下面所有对比都是 code mode 开与关的比较。

任务越长,差距越大

先看规模伸缩层,因为它是整个 benchmark 里最干净的实验:同一个应用、同一条规则、同一个 prompt,唯一变化的是规则要处理多少项。这是 gpt-6.1-sol 在全部五个任务上的表现,上面是耗时,下面是成本:

不开 code mode,两条线都随每一项攀升。这就是 tool calling 的本质:每一项都是模型必须写出的调用,每个结果都是它必须读回的东西。对 gpt-6.1-sol,每多 100 项增加 30 到 79 秒和 $0.04 到 $0.07。

开了 code mode,五条线里有四条接近水平。关闭一个 200 卡片的 sprint,不开 code mode 用了 166.6 秒,开了只用 26.6 秒。每多 100 张卡片,不开 code mode 增加 79 秒,开了只增加 4 秒。

每多 100 项对 gpt-6.1-sol 的成本,按任务:

Task Code mode off Code mode on

cart +66 s, +$0.065 +9 s, +$0.008

calendar +54 s, +$0.068 +6 s, +$0.002

chat +30 s, +$0.039 +6 s, +$0.016

kanban +79 s, +$0.067 +4 s, +$0.006

inventory +63 s, +$0.061 +29 s, +$0.028

Inventory 是例外,而且这个例外是合理的:delivery 数据以 N 行列表的形式直接贴进了 prompt,所以无论开不开 code mode,模型都得全部读一遍。

看全部八个模型,code mode 从哪里开始划算:

在 5 项时,五个任务里有三个 code mode 更贵,贵 21% 到 38%。它的指引说明会附在每一次请求上,而五次调用折叠进一个循环的收益太小。到 50 项时,五个任务里有四个更便宜了;到 200 项时,每个任务节省 47% 到 75% 的成本和 42% 到 67% 的耗时。

不过看下面那块面板:即使在 200 项,模型请求数平均也几乎没动,只降了 1% 到 22%。下面细说。

然后是正确性:

不开 code mode,成功率随 N 增长而下滑:从 5 项时的 92-100% 跌到 200 项时的 62-79%。开了 code mode,终点是 92-100%。汇总所有规模:不开 code mode 是 600 次中 518 次正确,开了是 600 次中 577 次。每个规模的样本都不大(每组 24 次运行),25 个差距里只有 5 个独自显著,但五个任务方向一致:在 200 项时,code mode 在每一个任务上都领先。

最弱的模型把它体现得最明显。在 200 项时,gpt-6-luna 不开 code mode 的 15 次运行 0 次正确,其中 7 次它根本什么都没改。它只是解释了为什么做不到:

I found 200 cards labelled sprint-42, but I haven't changed them yet: the board tools require updating each card individually, and the card list is too large to safely process in a single operation here.

开了 code mode,同一个模型 15 次对了 8 次。失败不是崩溃、超时或上下文溢出:不开 code mode 的运行里一次这些情况都没有。这是一个模型看着 200 次调用,拒绝去做。

有些模型开了 code mode 后从未失误。在全部五个任务上,muse-spark-1.3-contributor、muse-wonder-1.0-contributor 和 deepseek-v4.1-flash 的 225 次 code mode 运行全部正确,而不开时是 225 次中 202 次。

Model Correct runs, off → on Wall time at 200 items

muse-spark-1.3-contributor 65 → 75 of 75 -28% to -50%

muse-wonder-1.0-contributor 75 → 75 of 75 -41% to -61%

deepseek-v4.1-flash 62 → 75 of 75 -58% to -87%

muse-spark-1.3-contributor 十次失败里有八次是同一个毛病:它正确地完成了聊天分诊,然后没被要求地在 #support 里又发了一条总结消息。按评分标准,这些运行算错。忽略那条消息的话,它不开 code mode 的 15 次 chat 运行对了 14 次。开了 code mode,它一次也没多发。

200 项的单个任务

近距离看其中一次运行:gpt-6.1-sol 处理 200 个邀请,两种模式都被判为正确。

不开 code mode,它做了 205 次工具调用,装进 7 个响应里,最多的一个装了 43 次。批量做得已经不错了。问题在于每次请求带着什么:到目前为止的整个对话,包括每个工具结果。到最后,它读了 183,723 个输入 token,写出 4,430 个输出 token 来拼出那 205 次调用和最终回答,花了两分钟。

开了 code mode,它写了 5 个片段,日历执行了 215 次调用,模型读了 34,461 个 token,写出 573 个。耗时降了 76%,成本降了 84%。请求从 8 个变成 6 个。

模型本来就会批量

我一开始假设"删除 22 项"意味着不开 code mode 就要 22 个往返。并不是。现代模型会发出并行工具调用,而且发得很多。在长跨度层,单个响应里调用最多的,gpt-6.1-sol 装了 77 次,两个 Claude 模型各装了 119 次。在 200 项时,claude-haiku-5-5 把全部 200 次调用装进了一个响应。

所以往返次数并没有像宣传里说的那样下降,至少对批量最强的模型没有。长跨度层的模型请求数降了 22%,但这取决于模型。GPT 系请求少了三分之一(-33%),Claude 系反而变多:claude-haiku-5-5 是 +24%,claude-sonnet-5-5 是 +26%。不开 code mode 它们一次倾泻一大波;开了之后每次运行写大约五段短片段,读完一个结果再写下一段。它们仍然省了 67% 和 70% 的成本。批量最弱的模型反而获益最大:muse-spark-1.3-contributor、muse-wonder-1.0-contributor 和 deepseek-v4.1-flash 单个响应最多装 25 到 50 次调用,不开 code mode 每次运行发 13 到 22 个请求,开了降了 27% 到 52%(muse-spark-1.3-contributor 的降幅在噪声范围内)。

这正是我要对"每次工具调用都要多花一轮模型请求"这个常见说法提出质疑的地方。对当前模型上的独立调用,这基本不成立。真正还需要一轮请求的,是依赖性的步骤:你没列出邀请所在的那一页,就没法回复它。code mode 移除的,是每一轮里随工作量增长的那部分:模型必须写出的调用,和必须读回的结果。

例外是 deepseek-v4.1-flash。它也会批量,单个响应最多 80 次调用,但在 200 项不开 code mode 时,它每次运行平均发 64 个请求(最多 171 个),读了 280 万输入 token。开了 code mode:11 个请求和 86,000 token。不开 code mode 处理 200 个邀请每次要 1,070 秒,开了只要 138 秒。它跑在我们没控制负载的单台 vLLM 服务器上,所以秒数仅供参考;请求和 token 数与服务器无关。

长跨度任务:更便宜、更快、更常做对

长跨度层最接近真实的 agent 工作:十几步、相互作用的规则、几百条要保持清晰的记录。"supplier price update plus some housekeeping, in this order: 1. raise the unit cost of every fastener and every electrical product by 6%..."

每个模型的 code mode 正确率都至少持平或更高,而且模型越弱,提升越大:gpt-6-luna 从 14% 到 58%,claude-haiku-5-5 从 64% 到 94%,deepseek-v4.1-flash 从 81% 到 100%。gpt-6.1-sol 和 claude-sonnet-5-5 也到了 100%,muse-wonder-1.0-contributor 两种模式都没失误。

而且它做到了这些的同时,每个模型的成本和耗时都在下降,每个区间都不含零:

每次运行的金额和秒数:

Model Cost per run Wall time

gpt-6.1-sol $0.074 → $0.033 (-55%) 75.0 → 28.2 s (-62%)

gpt-6-luna $0.0029 → $0.0021 (-30%) 48.5 → 38.2 s (-21%)

gpt-6-astra $0.365 → $0.149 (-59%) 72.8 → 28.4 s (-61%)

claude-haiku-5-5 $0.0127 → $0.0042 (-67%) 55.2 → 23.0 s (-58%)

claude-sonnet-5-5 $0.176 → $0.053 (-70%) 56.7 → 21.6 s (-62%)

muse-spark-1.3-contributor $0.245 → $0.110 (-55%) 137.0 → 84.1 s (-39%)

muse-wonder-1.0-contributor $0.470 → $0.207 (-56%) 57.8 → 29.1 s (-50%)

deepseek-v4.1-flash $0.027 → $0.0072 (-73%) 311.9 → 136.4 s (-56%)

all models -58% -51%

不开 code mode 的失败和我日常任务里看到的是同一类,只是更多:对几百条记录的算术和记账。在 supplier-price 测试里,不开 code mode 的 24 次运行 16 次失败,开了只有 1 次。其中六次运行来自三个不同模型,报告的库存价值都是 $1,671,683.13。正确答案是 $1,671,682.13,而它们自己的最终状态恰好就是那个数。修改都对,回复里的求和错了。每一个给出数值的 code mode 运行给出的都是 $1,671,682.13。

统计长跨度层的所有失败,不开 code mode:52 次最终状态错误,11 次状态对但回复错,4 次什么都没改(全是 gpt-6-luna)。开了 code mode:16、5 和 0。

Token 去哪了

Token 的图景解释了成本:

八个模型的输出 token 降了 66%,从 gpt-6-luna 的 -43% 到 claude-sonnet-5-5 的 -80%。输出是最慢、最贵的部分,模型正是用它来写出每一次调用和每个中间值。输入 token 也降了 53%,因为堆积在上下文里的结果变少了。

短任务上,输入端反而上升。Code mode 的指引(run_code 怎么用、沙箱里有什么)给每次请求增加约 2,600 字符,这是按请求支付的固定费用,无论任务多小。日常任务上输入涨了 29%,输出降了 37%。规模伸缩层的 5 项时总 token 涨了 65% 到 114%。这笔固定费用是税的大头,而在长工作上它被节省额吞没了。

日常任务:更便宜,正确率差不多

50 个日常测试都很短:每次四五个请求、十几次工具调用。这是我入手的地方,也是 code mode 论据最安静的地方。

Model (4 reps, 3,200 runs) Success Cost per run

gpt-6.1-sol 96% → 98% (noise) -9%

gpt-6-luna 66% → 85% +19%

gpt-6-astra 94% → 98% -7% (noise)

claude-haiku-5-5 96% → 96% (noise) -40%

claude-sonnet-5-5 97% → 95% (noise) -38%

muse-spark-1.3-contributor 98% → 92% (worse) -13%

muse-wonder-1.0-contributor 98% → 94% (noise) -8% (noise)

deepseek-v4.1-flash 96% → 95% (noise) -34%

all models +1.6 pts (noise) -16%

八个模型整体,code mode 便宜 16%,快 11%,正确率大致持平。平均值掩盖了一个分化。大多数模型不开 code mode 就已经有 94% 到 98% 的正确率,开了也保持在那里。gpt-6-luna 是例外,它的大部分提升在问答题上。第一批里有十二个测试要求给出一个数字("what's my cart total going to be if dairy is 10% off?"),gpt-6-luna 不开 code mode 对了 38%,开了对了 88%。不开 code mode,模型要在脑子里把 30 到 120 行加总,结果算错,或者读完三页中的两页就停了,或者干脆拒绝:"I can't reliably calculate the total from this many cart lines."。反方向的是 muse-spark-1.3-contributor,它开 code mode 后正确率下降,而且每次失误都把应用留在了错误的状态。

按任务类型拆分可以看到税落在哪:

聚合(对多行的提问)是 code mode 的高光时刻:正确率 90% 到 98%,便宜 27%,快 26%。然后是对照组:五个只需单次操作的测试("change the sourdough to 2 please")。这里 code mode 贵了 8%,慢了 16%,因为模型为指引付了钱,还写了个程序只为发一次调用。批量修改也更便宜,但正确率更低(95% 到 90%),Muse 系模型贡献了大部分降幅。Categories 每类只有 5 到 10 个测试,样本太少算不出区间,那些柱子只看方向。

Code mode 付出代价的地方

诚实的清单,因为代价是存在的:

小任务。在 5 项时,五个规模伸缩任务里有三个 code mode 更贵;到 20 项时三个更便宜、一个持平。Chat 分诊 crossover 来得最晚:在 5 和 20 条消息时更贵,从 100 条起才变便宜。区分退款请求和其他消息需要阅读文本,所以开了 code mode 消息仍然要经过模型。

写出带 bug 代码的小模型。gpt-6-luna 在日常任务上贵了 19%,每次运行有 0.56 个失败的 run_code 片段,每次失败都是又一个往返。但按正确运行均摊它仍然更便宜:$0.00121 对 $0.00130。在 inventory 规模伸缩任务上,它开 code mode 的成本增长比不开更快,同时正确率从 3/15 提高到 9/15。

把数据打印回来的模型。muse-spark-1.3-contributor 的 code mode 运行把大量数据打印进了对话,所以 200 项时它的 token 只降了 5% 到 64%。muse-wonder-1.0-contributor 和 deepseek-v4.1-flash 则降了 57% 到 99%。

重试可能重复写入。一段中途失败被重跑的片段,前半部分可能执行两次。gpt-6-luna 在长跨度层的失败里有三次重复创建了相同的记录。

它仍然可能出错。日常任务上,muse-spark-1.3-contributor 开 code mode 正确率 92%,不开是 98%,这是唯一一个区间显著的下降。它的大部分失误是把应用留在错误状态的批量修改。规模伸缩层有两个格子朝反方向走,都在噪声范围内。在 N = 20 的日历邀请上(92% → 83%),gpt-6-luna 留下了未处理的邀请,claude-haiku-5-5 数错了自己做过的事。在 N = 5 的 inventory 上(100% → 92%),claude-haiku-5-5 两次漏掉了回复中要求的数字。

所以当数据量或任务规模超出普通 tool calling 能从容处理的范围后,code mode 才开始体现价值。在这些应用上,对大多数任务来说,这个临界点在 20 到 50 项之间。

那为什么它是未来?

因为这条曲线是真实的,而且方向只有一个。Code mode 收固定费用:每次请求几千字符的指引。Tool calling 按项收费:每次调用都要写出,每个结果都要读回,每个运行总额都要记在模型脑子里。单次修改上,固定费用输。几十项之后,它开始赢;到 200 项时,已经不是接近,而是碾压。我预计 agent 任务会越来越长。我没有测量过这一点,但如果真是这样,越来越多的任务会落到曲线正确的一边。

权衡是真实的,值得认真对待:

你在运行 LLM 生成的代码。是的,这正是为什么沙箱和模型一样重要。生成的代码只能触及你交给它的东西,并且受时间和内存限制。你的工具就是你交给它的东西,它们以你的应用的权限运行,所以仍然需要自己的验证和授权。Samuel 那篇 Monty 文章解释了我们为什么从零构建一个解释器,而不是去锁死一个完整的 Python。

调试更难了。也是的。一段失败的程序会把中间值藏在沙箱里,而且如 gpt-6-luna 所示,重跑的片段可能重复写入。你确实得开始读代码,而不只是 JSON。好消息是,程序的调用仍然经过 Pydantic AI 到达你的真实工具,所以只要用 Logfire 或任何 OpenTelemetry 后端追踪 agent,每个 run_code 调用是一个 span,它内部的每次工具调用在下面各有一个 span。

你可能根本不需要它。没错,我们的小 N 结果也支持这一点。答案是用少一点的 code mode,而不是完全不用。Pydantic AI 的 CodeMode 接受工具选择器,你可以只把那些要被循环处理的工具放进沙箱,其余的保持普通工具调用。

Code mode 也是模型正在前进的方向:写代码看起来是它们进步最快的技能。我猜这是因为代码可校验,因此容易用于训练。无论如何,给模型一门编程语言来驱动你的工具,正好发挥了它进步最快的那项长处。

它还必须能安全运行。上面的每一个结果都来自沙箱中的 code mode:它能触及这些应用的工具、一个内存文件系统和环境、时钟,仅此而已:没有宿主文件,没有网络。这正是我们为 Monty 设计的场景。

下一步是同一个想法再上一级。在 dynamic workflows 里,沙箱中的函数不再是工具而是子 agent,模型写的程序就是编排。Samuel 的那张图,由模型在运行时写出,节点是 agent。这就是我说的未来。

试试看

在你自己的 Pydantic AI agent 里,code mode 是 Pydantic AI Harness 的一个能力:

uv add "pydantic-ai-harness[codemode]" "pydantic-ai-slim[openai]" export OPENAI_API_KEY="your-api-key"

然后给 agent 它的工具:

from pydantic_ai import Agent from pydantic_ai_harness import CodeMode

CART = { 1: {'name': 'Espresso machine', 'unit_price': 249.00}, 2: {'name': 'Oat milk', 'unit_price': 3.49}, 3: {'name': 'Cast iron pan', 'unit_price': 64.95}, }

agent = Agent( 'openai:gpt-6.1-sol', instructions='You help the user manage their shopping cart. Prices are in US dollars.', capabilities=[CodeMode()], )

@agent.tool_plain def list_items(offset: int = 0, limit: int = 20) -> dict: """List cart items in id order, one page at a time.""" ids = sorted(CART)[offset : offset + limit] next_offset = offset + limit if offset + limit < len(CART) else None return {'items': [{'id': i, CART[i]} for i in ids], 'next_offset': next_offset}

@agent.tool_plain def remove_item(item_id: int) -> str: """Remove one item from the cart.""" return f'removed {CART.pop(item_id)["name"]}'

result = agent.run_sync( 'can you get rid of everything in my cart that costs more than $50 a piece?' ) print(result.output)

模型只看到一个工具 run_code,并在其内部以异步函数的形式调用 list_items 和 remove_item。这些代码跑在 Monty 里,所以那两个函数就是它唯一能触及的东西。Benchmark 是以 eager=True 运行的。Code mode 文档涵盖了 eager 与 speculative 执行、工具选择、资源限制等内容。

那 speculation 呢?

Pydantic AI Harness 的 CodeMode 还有 speculative 执行:也就是本文开头提到的 speculative programmatic tool calling,它会在模型还在写 run_code 调用时,就开始调用你声明为可提前执行的工具。这些应用的工具都没有做此类声明,所以 speculation 没有东西可以提前启动。在第一批日常任务里,它与普通 code mode 的区别只在更长的指引,结果也体现出来了:成功率 +7.7 个百分点(普通是 +10.3),成本 +4%(普通是 -2%)。后面的批次就跳过它了。这不算对 speculation 的测试,所以我不据此下结论。

感谢阅读!

致谢

Samuel Colvin,为了那个关于图的论点,以及推动我去寻找更大的差异。

Maverick(@maverick-jackson),他的 code mode 研究确立了这个 benchmark 沿用的 A/B 方法。

Ruben,指出了我的成功率图表第一版里 "more correct" 指反了方向。

评论 (0)