根据应用输入和输出格式中的证据选择模型。将相同任务通过 OpenRouter 运行，并比较评分准确率、计费成本和请求时间。在我们的 60 个合成任务上，GPT-6.1 Sol 在测试的契约和设置下，三次重复共通过 180/180 次试验。

TL;DR

  • 代码检查衡量正确性和输出合规性。

  • Sol 在我们的合成集上通过了 180/180 次试验；DeepSeek 的响应成本最低，通过 157/180。

  • 与公开排名的一致性较弱，Spearman 相关系数为 0.109。

  • 在你信任一个分数之前，检查每个任务运行了多少次、返回了多少答案，以及每笔账单是否经过验证。

先定义行为，再定义其检查。

第 1 步。编写答案可由脚本检查的任务

一个任务需要输入、预期答案和输出契约。对于发票，指定包含的行、舍入方式和可接受的货币后缀。

我们在最终运行之前编写了全部 40 个基线任务和 20 个困难任务。

类别示例检查
发票算术折扣后的未付行总额小数总额和舍入
日期和日程转换时间戳或列出匹配的日期精确时刻或日期列表
邮件提取将字段提取为 JSON键、类型和值
Python 函数针对隐藏输入实现一个函数在隔离运行时中的结果
输出约束在指定限制内生成文本长度、词汇和格式
退款决策在其边界处应用书面政策每个订单的决策

独立计算参考值。将提示调优用例与最终评估分开。退款用例测试书面决策，而不执行交易。

第 2 步。用代码评分，并检查评分器

对 APPROVE 使用精确匹配，对 JSON 使用模式/值检查。仅规范化允许的差异。当你的消费者只需要一个数字时，接受数字周围的散文会掩盖失败。

测试已知正确、错误和格式错误的响应。对于退款阈值，包含恰好 $200 和 30 天，然后包含略高于每个边界的值。

我们的开发检查器曾因遗漏 ord 和 type 而拒绝了有效的 Python 代码。我们在最终研究前修正了它，指定 CPython 3.12.10/WASI 并设置资源限制。否则，检查器失败会被算作模型的过错。

完整研究的运行器会隔离生成的代码，并在缺少沙箱设置时停止。教学示例不执行任何生成的代码。

步骤 3. 运行三任务 Python 示例

下载配套 ZIP 文件。在解压之前，先将其 SHA-256 校验和与以下值比较：

a38ee17a2eb7090f9f4849a605cc8214691c889ca0ae40c121259603592178e8

PowerShell：

Get-FileHash .\benchmark-reader-companion.zip -Algorithm SHA256

Linux 或 macOS：

# Linux
sha256sum benchmark-reader-companion.zip
# macOS
shasum -a 256 benchmark-reader-companion.zip

如果值不同，请停止并检查下载。值匹配后，解压 ZIP。你需要 Python 3.12 或更高版本。标准库教学运行器、JSON 示例和比较在 Windows x64 和 Linux 上通过了离线检查。macOS 尚未测试。捆绑的完整研究沙箱和原生 Ori 设置仅支持 Windows x64。

从解压后的文件夹中：

pythonverify_package.py
pythonthree_tasks.pycheck

该检查会打印 OFFLINE reference 和 grader checks passed；零推理调用。完整脚本按文件顺序如下。其配套模块处理请求、持久化和报告。

"""三个精确契约；从解压后的配套文件运行（标准库）。"""
importargparse
fromdatetimeimportdatetime, timezone
fromdecimalimportDecimal
importjson
frompathlibimportPath
importre

fromreader_coreimportexecute, reconcile, report, read, load_config, finish_grade

TASKS=[
{"id":"invoice"，"prompt":"两条未付项目分别花费 3 x 12.50 USD 和 2 x 4.25 USD。仅返回它们的总额，且恰好保留两位小数。"，"expected":"46.00"},
{"id":"utc"，"prompt":"将 2026-10-18T10:30:00+02:00 转换为 UTC。仅返回 YYYY-MM-DDTHH:MM:SSZ。"，"expected":"2026-10-18T08:30:00Z"},
{"id":"refund"，"prompt":"策略：仅当金额 <= 200 USD 且天数 <= 30 天时批准。金额=200 USD；天数=30 天。仅返回 APPROVE 或 DENY。"，"expected":"APPROVE"},
]

defrefund_policy(amount, days):
return"APPROVE"ifDecimal(str(amount))<=200anddays<=30else"DENY"

defgrade(task, text, finish):
terminal=finish_grade(finish)
ifterminal:
returnterminal
ifnotisinstance(text,str)ornottext.strip():
return{"passed":False,"classification":"empty"}
text=text.strip()
patterns={"invoice":r"\d+\.\d{2}",
"utc":r"\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z",
"refund":r"APPROVE|DENY"}
valid=bool(re.fullmatch(patterns.get(task["id"],r"\d+\.\d{2}"), text))
passed=validandtext==task["expected"]andfinish=="stop"
return{"passed": passed,"classification":"pass"ifpassedelse
("incorrect"ifvalidelse"malformed"}

在使用分数之前，请检查其参考值和拒绝规则。这些离线测试样例覆盖了边界判定、无效格式和截断答案，且不会调用模型。

defoffline():
money=Decimal(3)*Decimal("12.50")+Decimal(2)*Decimal("4.25")
assertformat(money,".2f")==TASKS[0]["expected"]
utc=datetime.fromisoformat("2026-10-18T10:30:00+02:00")
assertutc.astimezone(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")==TASKS[1]["expected"]
assertrefund_policy(200,30)==TASKS[2]["expected"]
foramount, days, expectedin[(200.01,30,"DENY"), (200,31,"DENY"),
(199.99,29,"APPROVE"), (0,0,"APPROVE")]:
assertrefund_policy(amount, days)==expected
fortaskinTASKS:
assertgrade(task, task["expected"],"stop")["passed"]
forbadin("wrong",None,"",'{"answer": 46}',"APPROVE please"):
assertnotgrade(task, bad,"stop")["passed"]
assertnotgrade(task, task["expected"],"length")["passed"]
assertnotgrade(TASKS[0],"47.00","stop")["passed"]
assertnotgrade(TASKS[2],"DENY","stop")["passed"]
print("OFFLINE reference and grader checks passed; zero inference calls.")

将检查与花费分开。命令行接口默认执行离线验证，在进行推理之前需要显式指定实时选项和额度。

defmain(tasks=None, grader=grade, default_config="demo-config.json", offline_check=None):
parser=argparse.ArgumentParser(description=__doc__)
parser.add_argument("operation",nargs="?",default="check",
choices=["check","plan","run","report","reconcile"]
parser.add_argument("--config",default=default_config)
parser.add_argument("--run-dir",type=Path,default=Path("runs/demo"))
parser.add_argument("--live",action="store_true")
parser.add_argument("--max-usd",default="0")
parser.add_argument("--resume",action="store_true")
parser.add_argument("--tasks"，help="可选的精确契约自定义任务 JSON")
args=parser.parse_args()
ifargs.operation=="check":
ifargs.tasks:
parser.error("请使用带有自身 offline_check 的示例入口点；check 不接受 --tasks 覆盖")
ifoffline_checkisnotNone:
offline_check()
eliftasksisnotNoneorgraderisnotgradeorargs.tasks:
parser.error("自定义 tasks/graders 需要 offline_check=... 以进行其自身的参考和 fixture 检查")
else:
offline()
return
selected=read(args.tasks)ifargs.taskselse(tasksiftasksisnotNoneelseTASKS)
config=load_config(args.config)
ifargs.operation=="report":
print(json.dumps(report(args.run_dir),indent=2))
elifargs.operation=="reconcile":
reconcile(args.run_dir,live=args.live)
print(json.dumps(report(args.run_dir),indent=2))
else:
execute(args.run_dir, selected, config, grader, args.max_usd,
live=args.live,resume=args.resume,plan=args.operation=="plan")

if__name__=="__main__":
main()

配置并检查计划

使用提供的 Luna 配置来设置模型、重复次数、token 配额和提供商约束：

{
"models": [
"openai/gpt-6-luna"
],
"repeats":1，
"max_tokens":1024，
"settings": {
"openai/gpt-6-luna": {
"provider": {
"require_parameters":true，
"allow_fallbacks":true，
"max_price": {
"prompt":0.09999999999999999，
"completion":0.5，
"request":0
}
},
"reasoning": {
"effort":"low"
}
}
}
}

Sol 的配置保留了重复/token 设置，但使用其自己的价格上限：

{
"models": [
"openai/gpt-6.1-sol"
],
"repeats":1，
"max_tokens":1024，
"settings": {
"openai/gpt-6.1-sol": {
"provider": {
"require_parameters":true，
"allow_fallbacks":true，
"max_price": {
"prompt":2.0，
"completion":10.0，
"request":0
}
},
"reasoning": {
"effort":"low"
}
}
}
}

models 选择候选模型，repeats 指定每个任务的请求次数，max_tokens 设置补全配额。推理可能会在可见输出之前消耗该配额。离线检查不会发起任何 API 调用。付费运行需要显式指定 —live 标志。因长度被截断的响应会直接失败，不会重试。

价格上限以每百万 token 的美元计；Luna 的提示词上限约为 $0.10。如果提供商不再支持已保存的设置，运行器必须停止，而不是静默更改它们。提供商回退不会切换模型或重新发送推理。

pythonthree_tasks.pyplan--configluna-config.json

实际离线输出：

{"planned_calls"：3，"max_tokens"：1024，"models"：["openai/gpt-6-luna"]，"repeats"：1，"estimated_reservations_usd"："0.0023543749999999999565625"}

预留额度是本地成本估算，不是账户冻结或保证上限。先做计划，再选择额度。

教学选择调用次数预估预留额度
Luna，三个任务3$0.0023544
Sol，三个任务3$0.0470875
Luna，下方 JSON 任务1$0.00080725
Sol，下方 JSON 任务1$0.016145

更改任务、重复次数或 token 数都会改变估算值。如果支出超过估算值，脚本会停止发送新请求。

进行一次小规模付费运行

在以下位置创建密钥API 密钥设置，添加额度，并配置合适的密钥限额。在终端中本地设置该变量。

PowerShell：

$env:OPENROUTER_API_KEY = "YOUR_OPENROUTER_API_KEY"

Bash 或 Zsh：

exportOPENROUTER_API_KEY="YOUR_OPENROUTER_API_KEY"

如果已配置现有变量，可复用它。该包不会加载 .env。对于随附的三任务 Luna 配置：

pythonthree_tasks.pyrun--configluna-config.json--run-dirruns/my-luna--live--max-usd0.01
pythonthree_tasks.pyreconcile--run-dirruns/my-luna--live
pythonthree_tasks.pyreport--run-dirruns/my-luna

对账执行只读的生成元数据查询。报告显示响应覆盖率，即已完成响应数除以计划试验数，以及通过/评分、失败、已验证成本和请求时间中位数。在账单得到验证之前，报告会将其成本保持为未解决状态。请求时间不包括评分和元数据；它不是首 token 时间。

实际结果会有差异。下面的合成示例仅用于说明报告方式，不代表模型测量结果。

第 4 步。添加你自己的任务和评分器

随附的 custom-tasks.json 展示了任务格式：

[
{
"id"："custom-total"，
"prompt"："四件物品每件花费 12.50 USD。仅返回总计，且恰好保留两位小数。"，
"expected"："50.00"
}
]

python custom_task.py check 会独立地用 Decimal 计算其参考值，并测试正确、错误和格式错误的答案。自定义金额 ID 使用两位小数的评分器。另一个合约需要自己的评分器和检查。

完整的 json_extraction.py 分三部分按文件顺序给出。它允许 JSON 空白和键顺序的差异，但拒绝缺失、多余或重复的键以及错误的类型。一个符合 schema 但值错误的对象是不正确的。被过滤或异常结束有单独的分类。

"""一个完整的精确 schema JSON 提取示例；默认离线检查。"""
importjson

fromreader_coreimportfinish_grade
fromthree_tasksimportmain

CUSTOMER_EMAIL="mira@example.test"
ORDER_CODE="A-104"
ITEM_COUNT=3
SOURCE_TEXT=("Customer: Mira. Email: mira@example.test. Order: A-104. "
"Items: 3. Gift wrap: no."）

# 从独立指定的源事实定义参考字段。
# 不要要求模型（或评分器）生成参考值。
EXPECTED={"email":CUSTOMER_EMAIL,"order_id":ORDER_CODE,
"item_count":ITEM_COUNT,"gift_wrap":False}
TASKS=[{"id":"order-extraction","grader":"exact-order-json-v1",
"prompt":"从该订单中提取 email、order_id、item_count 和 gift_wrap。"
"仅返回一个 JSON 对象，且恰好包含这些键。email 和 order_id "
"是字符串；item_count 是整数；gift_wrap 是布尔值。"+SOURCE_TEXT,
"expected":EXPECTED}]

仅 JSON 语法是不够的。拒绝重复的键和无效的数字值，然后在将字段与参考值比较之前验证 schema。

defstrict_json(text):
defpairs(items):
result={}
forkey, valueinitems:
ifkeyinresult:
raiseValueError("Duplicate JSON key"）
result[key]=value
returnresult
defnonfinite(value):
raiseValueError("Nonfinite JSON number"）
returnjson.loads(text,object_pairs_hook=pairs,parse_constant=nonfinite)

defgrade(task, text, finish):
terminal=finish_grade(finish)
ifterminal:
returnterminal
ifnotisinstance(text,str）ornottext.strip():
return{"passed":False,"classification":"empty"}
try:
actual=strict_json(text)
except(ValueError,TypeError):
return{"passed":False,"classification":"malformed"}
types={"email":str,"order_id":str,"item_count":int,"gift_wrap":bool}
schema_ok=(type(actual)isdictandactual.keys()==types.keys()
andall(type(actual[key])iskindforkey, kindintypes.items()))
ifnotschema_ok:
return{"passed":False,"classification":"malformed"}
passed=actual==task["expected"]
return{"passed": passed,"classification":"pass"ifpassedelse"incorrect"}

同时检查接受和拒绝两种情况。这些测试用例区分了合法但错误的值与格式错误的输出，并验证过滤或截断不能算作通过。

CORRECT='{"order_id":"A-104","email":"mira@example.test","gift_wrap":false,"item_count":3}'
WRONG='{"email":"other@example.test","order_id":"A-104","item_count":3,"gift_wrap":false}'
MALFORMED=["not JSON",'```json\n'+CORRECT+'\n```',
'{"email":"mira@example.test"}',CORRECT.replace('3}','true}'),
CORRECT.replace('3}','3.0}'),CORRECT.replace('3}','NaN}'),
CORRECT[:-1]+',"item_count":3}',CORRECT[:-1]+',"extra":1}']

defoffline():
assertEXPECTED=={"email":"mira@example.test","order_id":"A-104",
"item_count":3,"gift_wrap":False}
assertf"Email:{CUSTOMER_EMAIL}."inSOURCE_TEXT
assertf"Order:{ORDER_CODE}."inSOURCE_TEXT
assertf"Items:{ITEM_COUNT}."inSOURCE_TEXTand"Gift wrap: no."inSOURCE_TEXT
task=TASKS[0]
assertgrade(task,CORRECT,"stop")["passed"]
assertgrade(task, json.dumps(EXPECTED,indent=2),"stop")["passed"]
assertgrade(task,WRONG,"stop")["classification"]=="incorrect"
fortextinMALFORMED:
assertgrade(task, text,"stop")["classification"]=="malformed", text
assertgrade(task,"","stop")["classification"]=="empty"
assertgrade(task,CORRECT,"content_filter")["classification"]=="content_filtered"
assertgrade(task,CORRECT,"length")["classification"]=="truncated"
print("OFFLINE JSON extraction: independent source facts, schema, correct/wrong/malformed fixtures passed; zero requests.")

if__name__=="__main__":
main(tasks=TASKS,grader=grade,offline_check=offline)

最后的 main(…) 调用将任务、评分和参考检查连接到运行器。调整源事实和预期字段，然后运行：

pythonjson_extraction.pycheck
pythonjson_extraction.pyplan--configluna-config.json

预期的 check 输出：

OFFLINE JSON extraction: independent source facts, schema, correct/wrong/malformed fixtures passed; zero requests.

使用单独的文件夹。这些额度仅适用于已发布的单案例计划。

pythonjson_extraction.pyrun--configluna-config.json--run-dirruns/json-luna--live--max-usd0.01
pythonjson_extraction.pyrun--configsol-config.json--run-dirruns/json-sol--live--max-usd0.03
pythonjson_extraction.pyreconcile--run-dirruns/json-luna--live
pythonjson_extraction.pyreconcile--run-dirruns/json-sol--live

开始前设置相等的重复次数。一个案例重复三次测试的是变异性，而非工作负载覆盖。在得出更广泛的结论之前，添加有代表性的边界案例和留出案例。

第 5 步。比较已保存的运行并处理缺失的答案

对于你已保存的 JSON 运行：

pythoncompare_runs.pyruns/json-lunaruns/json-sol--outputcomparisons/json

这会写出 comparison.md 和 comparison.json，不进行推理或重新评分。它会校验契约、设置和身份；不兼容的运行需要调查，而不是静默排名。

先离线演练：

pythonsynthetic_comparison.pyruns/comparison-demo
pythoncompare_runs.pyruns/comparison-demo/lunaruns/comparison-demo/sol--outputcomparisons/full

表格包含这些合成夹具值，以缩写列显示：

夹具标签已完成/计划通过/已评分已过滤已验证成本/100中位秒数
Luna6/65/61$0.0001000.150
Sol5/65/50不可用0.155

Sol 的夹具有一个缺失的答案和一张未验证的账单。它的 5/5 分数缺乏完整覆盖。这些数字既不衡量任何一个模型。

保留一个不确定的试验及其保留项。修复访问或速率限制问题，然后以不变的配置、来源和额度继续：

pythonjson_extraction.pyrun--configluna-config.json--run-dirruns/json-luna--live--max-usd0.01--resume

恢复仅继续从未尝试过的试验。已知账单无法恢复缺失的文本。如果我们找不到某个请求的生成记录，报告会将其标记为未解决。不要丢弃运行或删除尝试。README 涵盖了崩溃后的过期锁。

要比较每个参与者都回答过的案例：

pythoncompare_runs.pyruns/comparison-demo/lunaruns/comparison-demo/sol--common-completed--outputcomparisons/common

显式交集保留原始覆盖范围并列出排除项。它可以选择较容易的案例，且不会修复缺失的账单。绝不在未披露的情况下比较不同的子集。

可选的 60 任务运行器和运行时设置位于配套材料中。其历史结果提供了一个更大的完整示例。

哪个模型在我们的基准测试中表现最好？

每个模型收到 40 个基线任务和 20 个困难任务，各运行三次，共得到 120 个基线评分和 60 个困难评分。这些结果描述的是在我们固定设置下的 60 个合成任务，完成于 2026 年 10 月 20 日。AA 表示来自我们带日期的公开快照的 Artificial Analysis Intelligence Index。

模型与 API ID基线 %困难 %合计通过数每 100 次任务响应成本中位秒数AA 指数
Claude Haiku 5.5
anthropic/claude-haiku-5.5		90.876.7155/180$0.034343.3743.4
Claude Sonnet 5.5
anthropic/claude-sonnet-5.5		47.545.084/180$0.472732.3356
GPT-6 Luna
openai/gpt-6-luna		98.373.3162/180$0.018483.8138.1
GPT-6.1 Sol
openai/gpt-6.1-sol		100.0100.0180/180$0.244903.5251.8
Gemini 3.8 Flash
google/gemini-3.8-flash		95.096.7172/180$0.304123.3840.9
DeepSeek V4.1 Flash
deepseek/deepseek-v4.1-flash		93.375.0157/180$0.003944.6624.7
Grok 4.7
x-ai/grok-4.7		99.296.7177/180$1.034625.9746.4
MiMo V2.6 Flash
xiaomi/mimo-v2.6-flash		89.263.3145/180$0.031565.0037.9
Mistral Large 4.0
mistralai/mistral-large-4-0		90.051.7139/180$0.5894531.4538.4
GLM 5.3
z-ai/glm-5.3		92.573.3155/180$0.060831.5944.8

每 100 次任务响应成本是 180 个计分答案的核实成本按比例折算到 100 的结果。它不包括运营开销和未解决的账单。中位秒数衡量本地请求的耗时。

三项发现指导了在该数据集上的选择。

  1. 最高通过率。Sol 以每 100 次响应约 $0.2449 的成本通过了 180/180。

  2. 最低响应成本。DeepSeek 每 100 次成本约 $0.00394，通过 157/180，有 14 次截断。Luna 以约 $0.01848 通过 162/180。请根据你所需的通过率和失败后果来选择。

  3. 输出合规性会影响得分。Sonnet 的 66 个格式错误响应涵盖 21 个发票、30 个日期和 15 个退款试验。原始答案在提示仅要求一个数字或 JSON 时包含了说明。该得分既衡量答案正确性，也衡量契约合规性，而非纯粹的推理能力。

每个模型行合计 180。最后一行合计全部 1,800 个响应。类别记录的是未通过的检查，而非其根本原因。

模型通过错误格式错误截断空
Haiku15571800
Sonnet84306600
Luna16218000
Sol1800000
Gemini1728000
DeepSeek15709140
Grok1773000
MiMo145813140
Mistral13987251
GLM15518700
总计1526100120531

全部 53 条被截断的响应仍然失败。

该研究请求了 8,192 个 token，并在支持的情况下使用低推理。有 16 次试验需要替换请求，因为此前的尝试没有返回答案。其中一次替换也没有返回答案，需要再次派发，因此针对 16 个选定的答案共进行了 17 次替换派发。没有对任何返回的答案进行重试。配套程序保留了每一次尝试。

已知的研究费用为$5.1032，加上$0.5383为未解决的账单预留。读者方案估计 Luna 的 180 次研究试验为 $0.97，Sol 的为 $19.46。路由、日期以及原始的并发/恢复调度限制了对串行读者运行器的比较。

公开的 LLM 基准测试与您自己的相比如何？

我们通过我们的基准测试 API于2026 年 10 月 20 日 10:03 UTC获取了一份 Artificial Analysis 快照，匹配了精确的规范模型版本。

Spearman 相关性比较排名顺序，从 −1（排名相反）到 +1（排名一致）。在十个模型上：

集合Spearman 相关性
基线0.115
困难0.183
合并0.109

在此样本中一致性较弱。不同的任务和设置使得无法就基准测试的普遍可靠性得出结论。使用公开分数进行初筛，然后评估您的工作负载。

每个任务应该运行多少次？

在 600 个模型-任务对中，有 68 个模型通过了部分重复而失败了其他重复。保留每一次重复。这些是对 60 个案例的重复观察，而不是每个模型的 180 个不同案例。接近的排名需要更多留出案例和重复。

常见问题

我需要多少个测试案例？

从一小组覆盖单个工作流常见输入、边界和已知失败的案例开始。十个经过仔细审查的示例可以支持初步探索，但它们不提供统计保证。当差异接近或失败代价高昂时，用有代表性的留出案例进行扩展。重复评估一致性；它们不能替代覆盖范围。

我可以使用 LLM 作为评判者吗？

是的，对于语气或解释质量等难以精确检查的属性。用人工标注的示例验证其评分标准，并检查分歧。对可计算的答案和必需的 schema 保留代码检查。我们的LLM-as-a-judge 指南解释了这种方法。

后续步骤

使用我们的黄金评估数据集指南从你的应用中构建一个具有代表性的集合。比较候选方案，然后在检查上对拉取请求设门禁。