Back

BreakingWeb 是怎么设计出来的

把网页搭成能打分的世界,再一点点把它弄坏

·28 min read·Agents, Benchmark, Research

发表
NeurIPS 2026, Datasets & Benchmarks Track
机构
Duke NLP Lab
合作
Prof. Shuyan Zhou
时间
Jan 2026 — Present

先交代一下背景。web agent 是一类让大模型自己操作浏览器的系统:它看网页(截图或者 DOM),决定点哪里、输入什么,一步步完成"帮我把这封邮件转给老板""在这个价格挂一个止损单"这样的任务。评估它们的 benchmark 通常是这样的:准备一批网站和任务,让 agent 去做,最后数做对了多少。

一个 web agent 在 benchmark 上拿了 60 分,这个数字到底说明了什么?它是看不懂页面,是忘了自己做到哪一步,还是被一个假的"已保存"提示骗了?大部分 web benchmark 回答不了这个问题,因为它们只给一个总分。

BreakingWeb(论文:Constructing Challenging Browser-Use Tasks by Controlled Environment Interventions)想回答的就是这个问题。做法说起来很简单:先把七个完整的网站搭出来,让每个任务都能从后端状态精确判对错;然后对同一个任务再跑一遍"被弄坏"的版本,比如请求超时、假装保存成功、塞进一个长得很像的诱饵。两次分数的差,就是 agent 在某一种能力上的短板。

结果是:六个前沿 agent 在干扰版上的通过率平均下降 22.9 个点,而人类只下降 5.7 到 10 个点。agent 失败的主要原因不是不会点,而是"以为自己做完了"。

这篇文章记录的是这个 benchmark 的设计过程,主要讲六件事:

  • 为什么环境是从小做起、一步步推大的
  • 环境里的"活"机制,比如会自己动的股价
  • 怎么让每个任务都 verifiable
  • 怎么让很多人写出同一个标准的任务
  • 打分和匹配,以及怎么把它画出来
  • 结果说明了什么

一、从小做起,一步步推大

这个项目不是一开始就有七个网站。它是从很小的东西开始的,每次发现"太浅了,分不开",就再往大推一步。下面按时间把这几步记下来。

2025 年 10 月。 最早的版本在合作者的仓库里,网页根本不是真的服务器,而是由 LLM "模拟"出来的:agent 点一个按钮,LLM 生成下一页应该长什么样。好处是什么网站都能"造",坏处是没有真实的后端状态。agent 说"我已经把邮件归档了",我们没有任何地方可以去查这件事是不是真的发生了。

2026 年 2 月 12 日。 我把它重写成一个独立的 benchmark,后来收敛成十个单页 HTML 挑战。每个页面只考一个点:一个藏得很深的设置项、一个要翻两页才能对上的数字、一个看起来已经提交但其实没提交的表单。页面是真的了,对错可以在页面状态里查到。

2026 年 3 月初。 单页版很快碰到天花板。页面太浅,强一点的 agent 一眼看穿,弱一点的卡在和能力无关的地方,比如某个按钮的写法太怪。更根本的问题是,单页之间没有共享状态,没法考"记住自己做过什么",也没法考"做完以后回头检查",而这两件恰恰是我们最想测的。

2026 年 3 月 13 日。 写了一份设计文档,标题就是转向 complex environments。核心想法是:与其造很多浅页面,不如造几个完整的网站,前端是真的 React,后端是真的数据库,任务的对错从后端状态里判。

2026 年 3 月 19 日。 第一个完整环境 Gmail 上线,带 20 个任务。它是试验田:收件箱、会话、标签、搜索、设置,后面所有环境的结构都是从这里抄过去的。月底第一次给所有任务加上了"被弄坏"的版本。

2026 年 4 月 1 日到 10 日。 真正的爆发。Robinhood(4/1,同一天写了价格引擎)、Amazon 和 Reddit(4/8)、Booking(4/9)、LMS 和 Patient Portal(4/10),十天里六个新环境接连落地。4 月 4 日接上了 Browser-Use 的 harness,第一次在 Gmail 上跑完整的 sweep:干净版通过率 65%,干扰版 48%。差距第一次清楚地出现在数字里,这让我们确信方向是对的。

2026 年 4 月 16 日以后。 环境够大了,新的问题变成"怎么判对错"。原来每个任务写的是一组手工检查,越写越不一致。于是整个打分改成 canonical diff(第四节细说),157 个 commit 把七个环境的任务一个个迁移过去。那一个月仓库里有 627 个 commit,占整个项目的六成。

2026 年 5 月到 6 月初。 补人类基线、做 trajectory 审计、一轮一轮修任务。最后一个 commit 是 6 月 3 日。

Commits per month, Oct 2025 to Jun 2026
23
16
3
15
31
146
627
156
5
Oct
2025
Nov
 
Dec
 
Jan
2026
Feb
 
Mar
 
Apr
 
May
 
Jun
 
Figure 1. The project's commit history. April 2026, when six of the seven environments were built and the scoring was rewritten, holds 61% of all 1,022 commits.

现在每个环境都是一个 React 前端加 FastAPI 后端,数据全是合成的。七个环境加起来有 337 个 API endpoint、519 个任务,前端 TypeScript 大约三万五千行。

环境内容任务API endpoints
Gmail收件箱、会话、搜索、标签、设置8433
Amazon搜索、购物车、结账、订单7056
Reddit版块、帖子、评论、投票、私信8145
Robinhood持仓、交易、期权、转账、税务7157
Booking搜房、预订、评价、收藏7854
LMS课程、作业、成绩、讨论、日历6546
Patient Portal预约、处方、化验、转诊、理赔7046

每一次往大推,都是因为上一版分不开模型。这是我在这个过程里最直接的体会:环境的深度本身就是测量工具的一部分。页面浅的时候,强模型和弱模型都能做对;只有当一个任务需要翻三层菜单、对照两个页面、记住五分钟前看到的一个数字,能力的差别才会显现出来。到了七个完整网站这一版,干净任务上最强和最弱的文本 agent 已经能拉开将近 40 个点(72.1% 对 33.1%)。

二、让环境"活"起来:Robinhood 的价格引擎

静态网站有一个根本问题:agent 第一次看到的世界和最后一次看到的一模一样。现实里不是这样。股价在动,订单会在你不看的时候成交,提醒会突然触发。我想考的恰恰是 agent 能不能意识到"世界变了,我得重新看一眼"。

所以 Robinhood 环境里有一个 PriceEngine。它有三个设计选择。

第一,按读取推进,不开后台线程。 每次 API 请求先调用 state.tick(),根据墙钟时间算出经过了多少个 tick(默认每 2 秒一个),再把价格推进到那个 tick。没有人请求的时候,世界就停着。

第二,价格走剧本,不走随机游走。 每只股票有一组关键帧 [tick, 目标价],中间线性插值,再叠一层 ±0.3% 的噪声。噪声是用固定 seed 预先生成好的,所以同一个任务每次跑出来的价格路径完全一样,结果可复现。

kf = trajectory.keyframes
if tick <= kf[0][0]:
    base = kf[0][1]
elif tick >= kf[-1][0]:
    base = kf[-1][1]
else:
    for i in range(len(kf) - 1):
        t0, p0 = kf[i]
        t1, p1 = kf[i + 1]
        if t0 <= tick <= t1:
            progress = (tick - t0) / (t1 - t0) if t1 != t0 else 0
            base = p0 + (p1 - p0) * progress
            break
if trajectory.noise_pct > 0 and tick > 0:
    noise_val = noise_list[tick % len(noise_list)]
    base *= 1 + noise_val * (trajectory.noise_pct / 100)

第三,价格一动,后果级联。 cascade_update 按顺序做五件事:更新股价和买卖价;更新持仓的盈亏;检查挂单,限价单、止损单该成交的就成交,同时生成持仓、交易记录和通知;检查价格提醒;最后重算总资产。还有一个校验器会拒绝不合理的剧本,比如单个 tick 涨跌超过 2%。

一个具体的任务:rh_live_stop_loss_execution。指令是"你持有 5 股 NVDA,在当前价下方 8% 设一个止损单"。剧本里 NVDA 从 875 跌到 800,大约 50 秒后跌破止损线。agent 要算对价格、挂对单,然后等。正确的结局不只是"挂了一个单",而是单子成交、多了一条卖出记录、多了一条通知、NVDA 持仓消失。

A stop-loss order against a moving price
pass:ordersstop 805.00 · filled
pass:transactions+ sell 5 NVDA @ 798.70
pass:notifications+ Stop order filled
pass:positionsNVDA deleted
Figure 2. NVDA follows its scripted path from 875 to 800. The order fills when the price crosses the stop, and the fill cascades into a transaction, a notification and a closed position.

这也给打分出了难题:一个做对了的 agent 会在后端留下一串连带的变化,打分器必须知道哪些变化是"应该有的"。这一点在第四节会再讲。

三、把网页弄坏:四层干扰

有了能精确打分的干净任务,下一步是给每个任务配一个"被弄坏"的版本。干扰分四层,按发生的时机排:

层什么时候改什么
seedagent 进场之前数据内容:诱饵、同名实体、钓鱼邮件、误导性提醒
server会话开始时数据结构:打乱时间戳、隐藏条目、变慢
network每一次请求HTTP 响应的时机、状态码和内容
client页面加载和跳转时DOM 和交互:吞掉点击、假横幅、弹窗、标签错位

我最喜欢的一个是 misleading_success。agent 点了"保存",前几次请求根本没有到达真正的后端,中间层直接返回 HTTP 200 和 {"success": true, "message": "Saved."}。页面上弹出一个绿色的"已保存",但数据库里什么都没写。人类用户偶尔也会被这种事坑到,而一个好的 agent 应该回头确认一下设置是不是真的生效了。

The same save, clean and with misleading_success
What the agent sees
Vacation responder
Out until Dec 2.
Save changesSaved.
POST /api/settings → 200
{"success": true, "message": "Saved."}
What the backend holds
settings.vacation.enabled
falsetrue
1 write
pass:Passsetting is on in the database
Figure 3. In the intervention run the toast still says Saved, but the backend panel shows no write. Grading reads the backend, so this run fails.

现在的 535 个干扰变体覆盖了全部 519 个任务。用得最多的手段是加诱饵(236 次)、静默失败(179 次)、先报错再成功(71 次)、返回过期数据(70 次)和假装成功(52 次)。每个变体都声明自己针对哪一种认知能力,一共七种:grounding、state tracking、backtracking、verification、planning、exploration、patience。

按论文的归类,这些手段一共是 29 个干扰家族(变体文件里具体的 layer 加 action 组合有 52 种)。

干净版和干扰版成对出现,这是整个设计的核心:同一个 agent、同一个任务,只差一个干扰,分数的下降就能归到那个能力上。

四、让每个任务都 verifiable

早期的检查是一条条手写的表达式,问题很多。举一个真实的例子:Patient Portal 有个任务要 agent 给每一种过期疫苗各约一次接种,检查写的是 len(new_appointments) >= 1。一个 agent 随手约了两个不相干的预约,拿了满分。

4 月中我们把整个打分重写成 canonical diff。核心想法就一句话:一个任务对不对,完全由"初始状态到最终状态的变化"决定。作者写下应该发生的变化,agent 实际造成的变化和它比对。

一个任务的 YAML 长这样(删掉了几条不变量):

task_id: gmail_star_email
instruction_template: Find the email from Alice Chen with subject "Project Update
  — Q1 Milestones" and star it.
difficulty: easy
canonical_diff:
  update:
    - entity: emails
      where: {id: {expr: "x == target['target_email_id']"}}
      changes: {is_starred: {eq: true}, labels: {superset: [starred]}}
  invariant:
    - collection: state.emails
      filter: "a.id != target['target_email_id']"
      preserve: ALL
    - collection: state.sent
      preserve: ALL
  named_invariants:
    - {name: Agent starred the target email, ref: update[0], severity: high}
    - {name: Agent did not send emails, ref: invariant[1], severity: high}

它会被编译成两类检查:

  • 正向义务:create、update、delete 里的每一条,都是"必须发生"的变化。
  • 反向不变量:invariant 里的集合"不许动",constraints 是额外的布尔条件。
From task spec to checks
canonical_diff:
update:
changes:
invariant:
named_invariants:
Must happen
  • emails[target].is_starred == true
  • emails[target].labels ⊇ {starred}
Agent starred the target email · high
Must not change
  • emails where id ≠ target: unchanged
  • sent: unchanged
    Agent did not send emails · high
Not in the spec: any change to a collection outside all three buckets is swept up as a high-severity side effect.
Figure 4. Each line of the spec compiles to one check. Positive obligations must be matched by the agent's changes; invariants must stay untouched.

写这些 YAML 时最好用的一个思考工具是三桶模型。后端里的每一个集合必须放进且只放进一个桶:

  1. 必须变:任务要求的变化发生在这里。
  2. 冻结:preserve: ALL,一点都不能动。
  3. 静默:会有无关紧要的变化,明确声明不管。

一个集合如果没被放进任何桶,它的任何变化都会被当成"意外的副作用",按高严重度扣分。这个规则逼着作者把后端想清楚:取消一个 Booking 预订,系统会不会自动生成一条改签建议?在 Robinhood 挂一个限价单,成交后会不会多一条通知?这些连带变化都必须提前写进去。

五、很多人,一个标准

519 个任务不是一个人写的。论文有 11 位作者,仓库里有大约五个人的提交,我自己占了七成左右。人一多,最大的风险就是每个人对"一个好任务"的理解不一样。

我们的办法是把标准写成文档,再把文档变成测试。

TASK_GENERATION_STANDARD.md 定了几条硬规则:

  • 指令必须写清动作、目标、选择条件、完成标准、排除项和平局规则。
  • 禁用 "appropriate"、"reasonable"、"as needed" 这类模糊词;写了 "latest" 就必须说按哪个字段比。
  • 主要评测必须是状态变化,不能检查回复里有没有某个关键词。没有例外。
  • 指令要求 agent 读或比较的每一个字段,必须真的在页面上渲染出来,防止信息不对称。
  • 难度越高,最少检查数越多:easy 2 正 1 反,frontier 6 正 3 反。

canonical diff 时代又加了一份 1,285 行的写作协议,把写一个任务拆成十步:解析指令、列出后端副作用、确定实体、逐字段分类、分桶、推正向 diff、推不变量、命名、可行性检查、预览加对抗测试。"没有一步是可选的。"

每个任务进库之前要过一条六关的流水线:

A task moving through the validation pipeline
pp_book_overdue_vaccines
Book one vaccination for each overdue vaccine.
  1. 1Has a canonical_diffpass:
  2. 2Schema loadspass:
  3. 3Preview renderspass:
  4. 4Round-trip smoke testpass:
  5. 5Adversarial batteryfail:rejected
  6. 6Equivalence vs past trajectoriesnot run
predicate
create appointments, count ≥ 1
wrong state
one unrelated appointment, no vaccine booked
score
1.00, should be below 1
fail:Rejectedthe check never pins which vaccine
Figure 5. Stage 5 synthesizes a wrong final state for every authored predicate. If the wrong state still scores as a pass, the task is rejected.

第五关最有意思:对抗测试会针对每一条作者写下的条件,自动合成一个违反它的错误结局。如果这个错误结局还能拿满分,说明检查写漏了,任务退回。

标准写出来不等于没有 bug。4 月底我们拿 Sonnet 4.6 把全部 1,049 个 run 跑了一遍,然后反过来审计打分器:按失败的检查描述聚类,逐个判断是评测 bug、任务设计 bug、前端 bug,还是真的是 agent 不行。结果审出了 30 多种模式,大部分已经修复。

几个典型的:

  • 种子数据按全局取第一个匹配,但指令说的是"这门课里的",十多个任务干净版直接 0 分。
  • 取消预订会自动生成改签建议,没人把这个集合写进白名单,每次扣 0.2。
  • 题目要求的操作在界面上根本没有入口。

一个很朴素的诊断规则帮了大忙:干净版的失败率如果很高,先怀疑题目,再怀疑模型。这件事让我意识到,做一个 verifiable benchmark 最难的部分,是验证你的验证器。

六、打分、匹配,以及把它画出来

打分的流程是这样的:

  1. 对比初始快照和最终后端状态,得到 agent 造成的所有变化。
  2. 拿每一条正向义务去找匹配的变化。
  3. 检查不变量和约束。
  4. 剩下没被认领的变化,统一做一次"副作用清扫"。

难点在第二步的一对多情况。比如"给每一种过期疫苗各约一次接种":作者那边是一组槽位(每种疫苗一个),agent 那边是一组观察到的变化(它实际约的预约)。一个预约满足某个槽位的条件,就连一条边。然后求这张二分图的最大匹配。

我们没有用库,_bipartite_matching 是手写的增广路算法(Kuhn)。匹配上几个槽位,就拿几成分。多约出来的预约会留给副作用清扫去扣分,所以"约一大堆碰运气"占不到便宜。

最后的分数是:

score=clamp⁡(matched weighttotal weight−∑penalties, 0, 1)\text{score} = \operatorname{clamp}\Big(\frac{\text{matched weight}}{\text{total weight}} - \sum \text{penalties},\ 0,\ 1\Big)

扣分按严重度:critical 0.30、high 0.20、medium 0.15、low 0.10。另外,任务的"通过"要求没有任何失败项,所以一个 run 可以拿 0.8 分但不算通过。

还有一个细节:一个变化如果找对了实体、但属性错了(比如约对了疫苗、约错了日期),它只记一次"缺失的正向义务",不会再被当成意外副作用扣第二次。审计之前,这个重复扣分影响了好几类任务。

Required slots matched to observed changes

One booking per overdue vaccine.

RequiredMatchAgent produced
  • Tdappass:
  • HPV dose 2pass:
  • Flupass:
  • Tdap · Dec 2
  • HPV · Dec 3
  • Flu · Dec 4
Matched 3 of 3 slots1.00
pass:1.00pass
Figure 6. Solid lines are the chosen matching; dashed lines are other valid edges. Unmatched slots lose credit, and surplus changes go to the side-effect sweep.

这张图其实是从我们的调试面板里来的。control.html 的评测侧栏会把每个一对多的条目画成三栏:要求的槽位、匹配、agent 实际产生的变化。实线是选中的匹配,虚线是其他可能的边。写任务、修 bug 的时候,看一眼这张图比读一屏日志快得多。

七、结果说明了什么

论文评测了六个文本模式的 agent(用无障碍树)、三个只看截图的像素模式 agent,以及人类。每个 agent 在 519 个任务上各跑一遍干净版和干扰版:

Agent干净干扰下降
Gemini-3.1-Pro72.1%44.5%27.6
Gemini-3-Flash63.2%42.6%20.6
GPT-5.461.3%35.1%26.2
Opus-4.754.5%31.6%22.9
Sonnet-4.650.3%28.1%22.2
GPT-5.4-mini33.1%15.2%17.9
Gemini-3.1-Pro(像素)28.1%13.1%15.0
Opus-4.7(像素)33.7%15.8%17.9
GPT-5.4(像素)10.2%5.6%4.6
人类,第一次做76.4%66.4%10.0
人类,熟悉之后80.7%75.0%5.7

(干净分是由论文表 2 的干扰分加下降值得到的。)

几件值得注意的事:

下降很大,而且很普遍。 六个文本 agent 平均下降 22.9 个点。每个 agent 在干净版能做对的任务里,有 39.6% 到 68.0% 会在干扰版上失败。

人类几乎不受影响。 熟悉任务之后的人类只下降 5.7 个点,而且在两边都做完的 run 上,人比 agent 快大约五倍(中位数 34 秒对 Gemini-3.1-Pro 的 184 秒)。差距最大的能力是 patience、verification 和 backtracking:人类和 agent 的下降差分别是 52.4、38.3 和 33.3 个点。

成对设计确实把总分拆开了。 以 Gemini-3.1-Pro 为例,它在 verification 上掉了 39.4 个点、backtracking 掉了 37.8、grounding 掉了 34.5,而 planning 只掉了 9.6。一个"72 分的 agent"变成了一张很具体的短板清单。exploration 的下降最小,但那是因为它的干净基线本来就最低,不能读成强项。

Where the clean-to-intervention drop lands
All tasks
44.5−27.6
Grounding
fail:42.3−34.5
Planning
59.6−9.6
State tracking
48.8−13.1
Backtracking
fail:40.2−37.8
Patience
48.0−24
Exploration
37.8−10.8
Verification
fail:40.8−39.4
cleanintervention
Figure 7. Gemini-3.1-Pro, pass rate under intervention by primitive, with the drop from the clean run. Verification, backtracking and grounding take the largest hits; planning barely moves.

agent 主要败在"以为自己做完了"。 在 3,037 个归类的失败 run 里,最多的一类是"接受了假的成功"(1,454 次),其次是重试死循环(790 次)和过早宣布完成(433 次)。文本 agent 的失败里 75% 是这种信念类失败:页面告诉它"已保存",它就信了。只看截图的 agent 则相反,57% 是动作类失败,连按钮都点不准。

fail:75%of text-agent failures are belief failures

这也是为什么第三节那个假的"Saved"提示是我最喜欢的干扰:它直接打在今天的 agent 最薄弱的地方。

八、优点,和还没做好的地方

我觉得这套设计做对了几件事:

  • 成对比较。 一个总分变成了一张按能力拆开的表:同一个 agent 可能在 backtracking 上掉很多,在 planning 上几乎不掉。这比"它得了 40 分"有用得多。
  • 按后端状态打分。 一个假的"已保存"盖在一次没写进去的操作上,算失败。界面骗得了 agent,骗不了打分器。
  • 可复现。 自托管、合成数据、固定 seed,价格路径都是剧本。每次 sweep 都记录 git SHA。
  • 两种 harness。 文本模式用无障碍树,像素模式只看截图,可以把模型能力和 harness 的影响分开。
  • 人类参照。 140 个任务、干净和干扰各一遍,每人先冷启动再熟练各做一次,一共 630 次人类尝试。
  • 对 benchmark 本身的审计。 对抗测试、可解性测试、轨迹审计,这些是让分数可信的基础设施。

还没做好的地方:

  • 七个环境都是英文的消费级网站,测的主要是闭源前沿模型。
  • 合成环境没有真实网站的限流、风控和第三方脚本,能不能迁移到真实网页还是个开放问题。
  • exploration 这一列的干净基线偏低,暂时不能读成强项。
  • Robinhood 的价格按墙钟推进,慢的 agent 可能错过一个价格窗口,这会把速度混进 patience 的测量里。

如果要用一句话总结这个项目:环境要足够深,才能把能力分开;打分要足够严,分数才有意义;而让打分器足够严,花的力气比搭环境还多。

Comments