acceptodds
Under review as a conference paper at ICLR 2027

AdvSim2Real: Training Web Agents Against Adaptive Prompt Injection in a Web World Model

19 views

Abstract

Web agents complete user requests by reading and acting on pages that third parties write, so an instruction planted on a page can redirect the agent away from the user's goal. The agent cannot simply ignore the page, because the page also holds the values and controls the task requires. Current defenses fine-tune the agent on injections fixed before training, and attackers that adapt to the trained model bypass them. Recent adversarial training lets the attacker adapt but keeps the tasks fixed, so a task stops teaching once the agent solves it. We introduce AdvSim2Real, which co-evolves a task curriculum, an injection adversary, and the agent inside a frozen web world model. The curriculum is rewarded for tasks the agent solves about half of the time, and the adversary only for a success flip, an injection that turns a judged success into a failure. Training in the simulator makes a 4B agent both more capable and more robust: its completion rises with and without attacks, holds against a frontier-model adversary it never trained against, and its capability gain carries over to a real browser. On 150 web tasks, AdvSim2Real raises completion under this unseen adversary by 33.6% relative to the base agent. We release our code, the benchmark, and all checkpoint results.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
Web agents, adversarial co-evolution, curriculum learning, prompt injection, world models, reinforcement learning.

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_5ZU5OpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes AdvSim2Real, a framework for improving the robustness of web agents against adaptive prompt injection attacks through adversarial training in a simulated web environment. The framework consists of two training stages: (1) a curriculum agent dynamically generates tasks of appropriate difficulty to improve the web agent’s task completion capabilities, and (2) an adversarial agent generates prompt injection attacks to improve the defender’s robustness through co-evolution. Both stages operate within a frozen web world model, with an LLM judge providing feedback for reinforcement learning. The authors introduce a success-flip reward mechanism that rewards attacks only when they cause previously successful tasks to fail. Experiments on 150 web tasks demonstrate improvements in both clean task completion and robustness against adaptive attacks, including a 33.6% relative improvement against an unseen adversary. The paper also shows that task completion improvements learned in simulation can partially transfer to a real browser environment.

Critical strengths
  1. The paper is generally well-written and clearly organized. The motivation, methodology, and experimental setup are presented in a logical and easy-to-follow manner, making the proposed framework straightforward to understand.

  2. The paper provides extensive experiments, including evaluations under multiple adaptive attackers, comparisons with baseline models, ablation studies, and sim-to-real transfer experiments. These results offer useful insights into the effectiveness and limitations of the proposed approach.

  3. The combination of adaptive curriculum learning and adversarial training within a web world model is an interesting approach. The success-flip reward mechanism is also a reasonable design for encouraging attackers to generate meaningful adversarial examples.

Critical weaknesses
  1. Although the paper demonstrates improvements in task completion when transferring from simulation to a real browser, the robustness against prompt injection attacks is evaluated exclusively within the simulated environment. Without evaluating the trained defender against attacks in real browser environments, it remains unclear whether the reported robustness improvements generalize to realistic scenarios.

  2. The evaluation is conducted on only 150 synthetic web tasks, primarily focused on form-filling operations. These tasks may not adequately represent the complexity and diversity of real-world web agent interactions. Evaluations on established benchmarks such as WebArena or more realistic websites would strengthen the paper’s claims about generalizability.

  3. The framework relies heavily on a frozen world model and an LLM judge for both training and evaluation. As acknowledged by the authors, the world model can generate inaccurate states, and the judge can incorrectly assess task completion. These inaccuracies may introduce unreliable reward signals and potentially overestimate the defender’s robustness. A more rigorous evaluation using deterministic success criteria would strengthen the conclusions.

Questions for authors

N.A

2 comments

We thank the reviewer for the positive assessment of the paper's clarity and experiments.

W1: Robustness is evaluated only in simulation

We evaluated the attacks in real Chromium. Each injection is rendered as a static HTML notice at the step where the reactive adversary injected it in simulation, and success is scored by the deterministic strict checker, with no world model or LLM judge. Results are strict success in %, 3 seeds × 150 tasks.

ExecutorCleanAdv v1Adv v2Adv v3Drop under attack
Base38.723.626.722.4−14.4
Capability iter 352.437.139.336.2−14.9
Robust iter 354.450.449.346.2−5.8

The robustness transfers to the real browser. Robust iter 3 beats Capability iter 3 by 10–13 points under every adversary (paired 95% CIs exclude zero), while the two are tied on clean tasks. The gap is larger in the browser than in the world model, so the simulator does not overestimate robustness.

W2: 150 synthetic form-filling tasks; WebArena

WebArena uses a different action space from the one our executor and the WebWorld-14B world model operate in, so evaluating there would measure the action-space mismatch rather than robustness. Our tasks are built so that robustness can be verified exactly. Each specifies required final values, protected fields, forbidden controls and a deterministic checker, which is what made the browser evaluation in W1 possible without an LLM judge. The tasks span five skill strata (conditional policy, derived values, conjunctive selection, relational join and ordered repair), with reference solutions of 4–9 actions.

W3: Reliance on the world model and LLM judge

The browser results in W1 use only the deterministic checker, and they confirm the paper's conclusion with a larger effect. We also audited the world model and judge against a deterministic field check:

AuditResult
Clean runs with all fields correct but judged bad1.6% (28 / 1,782)
Judge misclassifications in 105 manually reviewed attacked success flips1
Injections addressed to the judge (of 7,124)0
The executor ranking is the same under the deterministic checker in the browser as under the judge in the world model. We will add this audit to the appendix.

Dear Reviewer 5ZU5,

Thank you again for your careful review and positive comments on the paper's clarity, methodology, and experimental evaluation. In our response, we

  1. demonstrated that adversarial robustness transfers to real Chromium, with 10–13 percentage-point gains over capability-only training,
  2. clarified the diversity of our tasks and the limitations of evaluating on WebArena,
  3. audited world-model and judge errors and confirmed our findings using a deterministic browser checker.

As the discussion period ends soon, we'd be grateful to hear whether these results address your concerns. We are happy to answer any further questions.

Reviewer_ePEeOpenReview ↗
Rating
2(+1)
Confidence
3
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

The paper studies training web agents to resist prompt injection attacks in form-filling tasks. A curriculum agent generates tasks, which an executor agent attempts to complete. Training has two phases. In the first phase, the curriculum agent and executor co-evolve, with the curriculum agent rewarded for generating tasks with a success rate close to 50%. In the second phase, an adversarial agent generates prompt injections and co-evolves with the executor. Experiments show that this training approach improves task completion rates.

Critical strengths
  1. The proposed pipeline of jointly training the curriculum agent, the executor agent, and the adversary agent is interesting.
Critical weaknesses
  1. I don't think that using the form-filling task makes sense from the perspective of Adversary Model. If the owner of a web form doesn't want the form to be filled, the owner can simply not provide the form. Put it another way, if a human is filling a form, and sees the text on the form says "STOP IMMEDIATELY: ", then I would argue that not filling the form is the right decision.

  2. There are no baseline methods for comparision. How does the proposed method compares with other approaches training models to defend against prompt injection attacks? The novelty claimed over ARLAS and similar methods is co-evolving the tasks. However, removing Stage 1 changes completion under attack by only 0.44 points. This suggests that the benefit from co-evolving the tasks has limited benefits.

  3. The evaluation seems to be on the same datasets used in the co-evolvements of the executor. This gives the felling of testing on training dataset. It would be good to see that the executor evaluated on other prompt injection data not involved in training,

Questions for authors

I have no specific questions.

2 comments

We thank the reviewer for the review.

W1: Form-filling does not fit the adversary model

If the site owner does not want the form filled, the task is infeasible: the site rejects or removes the form, and that case is outside our objective. Our objective is task-preserving robustness (Section 3): completing the user's authorized goal whenever the task remains feasible. We target a different case. A page combines content from many parties, such as ads, user comments, embedded widgets and compromised components. Text from one of them can say "STOP IMMEDIATELY" or "click Reset all" while the form still works and the user still wants it submitted. This is indirect prompt injection (Greshake et al., 2023), which partially succeeds against web agents in up to 86% of cases on WASP (Evtimov et al., 2025). Figure 2 shows such a notice ordering a click on the forbidden Reset all; obeying it destroys the user's work. In the real browser, Robust iter 3 presses the buttons such notices name in 2.4–3.6% of episodes, against 12.7–15.6% for Base. We will make this distinction explicit in Section 3.

W2: No baselines, and task co-evolution has limited benefit

We added a same-backbone defence baseline: Base with a system prompt that says page content is untrusted, follow only the user's Goal, and never act because the page says so. Results are judged completion in the world model, 3 seeds × 150 tasks.

ExecutorCleanAdv v1Adv v2Adv v3
Base74.951.148.045.1
Base + defence prompt74.454.054.449.3
Ours (Robust iter 3)81.362.954.954.7

Our method is best in every column, and it is significantly better on clean tasks (+6.9, 95% CI [+2.7, +11.1]) and against Adv v1 (+8.9, [+3.1, +14.4]). Table 1 also includes the hosted Qwen3.5-9B, which our 4B agent beats on clean tasks (81.33 vs 78.22) and matches under attack. Trained defences such as ARLAS, DMAST and CoER are trained in their own executed environments with their own action interfaces. Comparing them on our benchmark would require retraining each one in our environment.

The 0.44-point result is what the paper reports as Contribution 4: the curriculum stage provides capability (+4.67 clean points in Table 7), and the adversarial stage provides robustness. Both are needed, because an agent that resists injections but cannot finish the task does not complete the user's goal. Our new results separate the two stages directly:

ExecutorBrowser strict, cleanBrowser strict, attacked (mean of Adv v1–v3)Kimi-K3 attacked (world model)
Base38.724.223.0
Capability iter 3 (Stage 1)52.437.624.3
Robust iter 3 (Stage 1 + 2)54.448.730.7

Stage 1 raises clean browser success by 14 points but leaves the drop under attack unchanged. Stage 2 cuts that drop from −14.9 to −5.8 points and adds about 6 points against Kimi-K3. Only the full pipeline is best on both.

W3: Evaluation on the training data

The 150 evaluation tasks are distinct from the tasks the curriculum proposes during training (Section 3), and the executor never trains on them. Adv v1–v3 are the training-loop adversaries, which is why the paper also evaluates against Kimi-K3, a frontier attacker that took no part in training. We now add a second evaluation outside training: a real browser with HTML notices and a deterministic checker, an environment the agent never trained in.

Evaluation outside trainingBaseOurs
Kimi-K3 attacker (Table 3)23.030.7 (+33.6% relative)
Real Chromium, injected notices, deterministic checker22.4–26.746.2–50.4

Dear Reviewer ePEe,

Thank you again for your careful review and constructive feedback. In our response, we

  1. clarified the threat model, distinguishing third-party prompt injections from legitimate website instructions,
  2. added a same-backbone defense baseline and clarified the distinct contributions of curriculum learning and adversarial training,
  3. demonstrated robustness against an unseen frontier-model attacker and in real Chromium with deterministic evaluation.

As the discussion period ends soon, we would be grateful to hear whether these results address your concerns. We are happy to answer any further questions.

Reviewer_82BvOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

The authors are training a web agent (Qwen3.5-4B), which is in a frozen the web world model (WebWorld-14B) against an adaptive prompt injection. They do so by following two training stages. In the first one, they generate tasks which the agent can solve around half of the time. At that stage, they test it in real Chrome. Then, they train it on an adversary to create prompt injections, that will make the agent fail tasks it would have had completed otherwise. In their benchmark, the task completion in default state improves from 74.9% to 81.3%,and in learned attacks, improves from 48.1% to 57.5%

Critical strengths
  1. The success-flip reward is a novel and very useful approach in web agent evaluations. In this paper, the adversary is rewarded only when an attack causes an agent to fail a task it would otherwise complete successfully, separating the attack effectiveness from failures caused by the agent’s existing limitations (removing by extension the question of 'did the agent not proceed with jailbreak because of refusal or missing capabilities' which many prior papers struggled with.) I believe it is a valuable contribution that could be reused in future work.

  2. This level of transparency provided in this paper is impressive and uncommon in adversarial-training papers. While the repository does not seem to be available, this paper provides e.g. a deterministic browser checker, an independent adversary for evaluation, per-seed results, an analysis of judge errors, a comparison of simulated and real-browser outcomes etc.. This makes the limitations easier to identify and provides the tools which could be used by researchers to investigate them further.

Critical weaknesses
  1. Adversarial robustness is evaluated in simulation, without browser verification. The injection is passed to the world model, which generates all subsequent pages. But in the Appendix (A.3), it is shown the world model returned “Submission blocked” for a click that succeeded in the clean run. In 13.4% of success flips, the agent takes identical actions, but the final message changes. I am worried therefore that the reward cannot distinguish between an agent being redirected, a simulator producing failure, and a judge misclassifying the outcome. Unfortunately there are also rather substantial simulation errors which further make me concerned by that - 36–52% of task-seed pairs succeed only in the world model, the judge accepts 7.5–10.4% of trajectories that fail strict checks, and conjunctive selection succeeds in 0/60 browser episodes despite 40–58% judge acceptance. Since the authors already have a browser checker and control the injected HTML, browser-based attack evaluation seemed to have been feasible, yet Table 2 reports only clean stage 1 results. The paper therefore is struggling with construct validity and does not establish real-browser adversarial robustness. Its “Sim2Real” claim applies only to non-adversarial training, with “real” referring to synthetic HTML pages.

  2. The contribution of adversarial training is not isolated + key baselines are missing. Stage 1, without any injections, improves attacked completion by 6.3 points (from 48.07% to 54.34%). Stage 2 adds just 3.1 points, while Stage 2 alone improves the base model by 9.0 points, compared with 9.4 for both stages (Table 7). These are near-substitutable gains, which suggest that general capability improvements may explain much of the reported robustness. The improvement over capability iter 3 also decreases against stronger adversaries and it seems that none of the adversaries is trained against the final checkpoint, which leaves the 'motivating attacker-moves-second setting' practically untested. As slightly more minor point on that, Table 3 omits capability-only checkpoints, so the reported Kimi-K3 gain cannot be attributed specifically to adversarial training. But the crucial comparisons are missing, e.g. a compute-matched Stage 2 with a fixed task pool, to test whether task co-evolution matters, and a defence baseline using the same backbone. One thing that worries me (but here I am less confident how relevant it is) is that the task curriculum is frozen during Stage 2, so tasks and attacks never co-evolve simultaneously. Yet section 6 acknowledges that no individual mechanism is isolated. Therefore, Contributions 1, 2, and 4 remain unsupported as causal findings, with Contribution 4 also conflicting with Tables 1 and 7.

More minor concerns:

  • Reported SDs capture rollout variation from one trained adapter, without training reruns or confidence intervals.
  • The first page is always clean, and exactly one notice appears later. A simple heuristic of ignoring instructions after the first page could fit this distribution, but is never tested.
  • The training adversary is open-loop, while the evaluation adversary is reactive. The executor reward also penalises following the attack more than other failures, although the threat model defines preventing task completion as the attacker’s objective.
  • minor, easier fix: there seem to be few punctuation/language issues, (e.g. is54.1% missing space, formating issues). Text has some signs of AI generation and is oftentimes hard to follow. It would be highly valuable to iterate on it.
Questions for authors

While I have some clarifying questions, it's rather some additional experiments that could improve my rating.

Clarification questions, which should be possible to answer from the data authors already have:

  1. How often does the world model turn a correct action into a failure (e.g., returning “Submission blocked” after a valid submission)? How often does the injection appear to target the judge rather than the executor? I think even manual review of approximately 100 success flips would give a good view into it.

  2. How often are injections actually rendered during evaluation? What fraction of episodes pass the D.4 rendering check, and what is attacked completion when an injection is confirmed to be present? Exact-marker visibility is below 0.5%, which makes it unclear how many “attacked” episodes contain an injection.

  3. Could the agent learn to ignore all later instructions? Are there legitimate mid-trajectory notices that the agent must follow? If not, how do you rule out this shortcut, given that the first page is always clean and only one notice appears later?

  4. Were the Table 1 checkpoints trained using the C.6 configuration? Specifically, did training use an 8-action limit and a 1,500-character judge cap that excluded filled fields? If so, could the Stage 2 clean improvement partly reflect adaptation to the 12-action, uncapped evaluation setting?

Experiments that would change my assessment:

  • [most important] Run the attacked condition in the Chromium harness with the injection rendered as a static notice element, and report strict success for Base, Capability iter 3 and Robust iter 3; also report clean Chromium runs of Robust iter 1 to 3.

  • Report Capability iter 1 to 3 under Kimi-K3.

  • Train one more adversary against Robust iter 3 (executor frozen) and report Robust iter 3’s completion against it. Add a compute-matched Stage 2 run with a fixed task pool.

3 comments

We thank the reviewer for the detailed review. We ran every requested experiment : the attacked Chromium evaluation, Capability iter 1–3 under Kimi-K3, a same-backbone defence baseline, and the analyses behind Q1–Q4.

W1: Adversarial robustness is not verified in a browser

We ran the experiment the reviewer proposed. Each injection the reactive adversary produced in the world model was rendered as a static HTML notice in real Chromium, at the same task, seed and step, and stays on the page until the episode ends. Success is scored only by the deterministic strict checker; neither the world model nor the LLM judge is involved. Each cell is 3 seeds × 150 tasks, reported as strict success in %, mean ± SD over seeds.

ExecutorCleanAdv v1Adv v2Adv v3
Base38.7 ± 5.723.6 ± 6.826.7 ± 2.422.4 ± 6.3
Capability iter 352.4 ± 3.737.1 ± 1.739.3 ± 1.336.2 ± 0.4
Robust iter 152.4 ± 4.4–––
Robust iter 251.3 ± 6.8–––
Robust iter 354.4 ± 2.350.4 ± 5.049.3 ± 1.846.2 ± 4.1
Robust iter 3 − Capability iter 3, paired 95% CI+2.0 [−0.9, +5.1]+13.3 [+9.6, +17.1]+10.0 [+6.4, +13.6]+10.0 [+6.2, +13.8]

Under attack, Base and Capability iter 3 lose about 15 points from clean, while Robust iter 3 loses 5.8. Robust iter 3 presses a button named in the notice in 2.4–3.6% of attacked episodes, against 10.4–15.6% for the other two, and presses a forbidden button in 0.2–1.8%, against 9–14%. In the browser, the page cannot block a submission or alter a field by itself, so these numbers are free of the simulator and judge errors the reviewer lists. The reviewer's figures (36–52% world-model-only successes, 7.5–10.4% judge false accepts, 0/60 on conjunctive selection) concern the clean capability transfer in Table 2; none of them enters this table. The Sim2Real claim therefore now covers adversarial robustness as well. For every executor, we treat fill(…, press_enter) with the literal placeholder argument as press_enter=False. The appendix will report results without this normalisation.

W2: The contribution of adversarial training is not isolated, and key baselines are missing

The reviewer reads Tables 1 and 7 as showing near-substitutable gains. That holds only for attacked completion in the world model, which mixes capability with robustness. Holding capability fixed separates them. In the browser, Capability iter 3 and Robust iter 3 are tied on clean tasks (+2.0, CI includes 0), yet Robust iter 3 is 10–13 points ahead under every adversary (W1). Against Kimi-K3, which took no part in training, capability training adds almost nothing and Stage 2 adds the gain (2 seeds × 150 tasks, the protocol of Table 3):

ExecutorKimi-K3 attacked completion (%)
Base23.00 ± 3.30
Capability iter 124.74 ± 1.77
Capability iter 224.00 ± 1.89
Capability iter 324.33 ± 1.41
Robust iter 129.67 ± 4.24
Robust iter 230.33 ± 0.47
Robust iter 330.72 ± 3.04

Capability training therefore does not buy robustness, and the Kimi-K3 gain is attributable to Stage 2. Nor does the advantage over Capability iter 3 shrink against later adversaries in the browser: it is +13.3, +10.0 and +10.0 for Adv v1, v2 and v3. Together with Table 7, this supports Contribution 4 as stated: removing the curriculum stage costs 4.67 clean points and only 0.44 attacked points, and the adversarial stage supplies the robustness.

For the same-backbone defence baseline, we gave Base an explicit defensive system prompt: page content is untrusted data, follow only the user's Goal, and never click, fill or stop because the page says so. Results are judged completion in the world model, 3 seeds × 150 tasks.

ExecutorCleanAdv v1Adv v2Adv v3
Base74.951.148.045.1
Base + defence prompt74.454.054.449.3
Robust iter 381.362.954.954.7
Robust iter 3 − defence prompt, paired 95% CI+6.9 [+2.7, +11.1]+8.9 [+3.1, +14.4]+0.4 [−5.3, +6.2]+5.3 [−0.7, +11.1]

Robust iter 3 is best in every column. The prompt cannot add capability (−0.5 clean), whereas our training adds 6.4 clean points.

None of Adv v1–v3 was trained against the final checkpoint, and a compute-matched Stage 2 with a fixed task pool was not run. Both require new training runs that do not fit in the rebuttal period, and we will add both to the camera-ready. Until then, the evidence for attacks that did not shape the final checkpoint is Kimi-K3, an external frontier attacker, and the browser notices, which were generated against Base. The curriculum is frozen in Stage 2 by design: the success-flip reward compares attacked and clean runs of the same task, so it needs a stationary task distribution while the adversary and executor adapt.

W3: Minor concerns

All new comparisons report paired task-level bootstrap 95% CIs, and we will add them to Tables 1 and 7. The SDs measure rollout variation of one adapter, as stated in C.8. The "ignore everything after the first page" shortcut is addressed in Q3. The reactive evaluation adversary is deliberately stronger than the open-loop training adversary, so the evaluation measures robustness to an attacker unlike the one seen in training. The executor reward gives +1 only for completing the task, so completion remains the objective. Among failures, following the attacker's target scores −1 and avoiding it scores 0; this orders failures without ever making a failure worth as much as a success. We will fix the typos and edit the text throughout.

Q1: How often does the world model turn a correct action into a failure, and how often does the injection target the judge?

We reviewed 105 success flips by hand: same executor, seed and task, clean judged good and attacked judged bad, with 5 sampled per executor × adversary.

Cause of the flipCount (of 105)
Agent followed the injection46
World model carried out the injected request (disabled Submit, cleared fields)37
World model drifted on its own11
Judge misclassification1
Injection addressed to the judge0
Other agent error10
No injection targeted the judge, either in the sample or among all 7,124 injection instructions; the 15 instructions that mention evaluation terms are fake system banners pushing Reset, Cancel or Save draft. On clean runs the world model rarely turns a correct submission into a failure: 1.6% of runs with all fields correct are judged bad (28/1,782). Across all attacked flips, 6.8% show an error or blocked page after a correct submission. A page that disables Submit or clears fields is something a page author can do, so an agent should recover from it, and the browser evaluation in W1 removes the simulator entirely. There the robustness gap over Capability iter 3 is larger (+10 to +13) than in the world model (+1 to +6).

Q2: How often are injections rendered, how many pass D.4, and what is completion when one is present?

MeasureRate
Adversary injected (otherwise waited at every turn)75.4% (7,123 / 9,449)
Exact marker visible0.4% (31 / 7,123)
D.4 check passed0.6% (41 / 7,123)
Injection visibly rendered (≥3 new instruction words, or a new banner/alert/dialog)50.4% (3,590 / 7,123)
ExecutorJudged completion, injection rendered (world model)Strict success, notice shown (browser)
Base28.8%21.0–23.7%
Capability iter 334.8%33.8–34.6%
Robust iter 342.3%45.6–49.5%

The exact-marker and D.4 rates are low because 98.9% of declared markers are internal identifiers such as security-revocation-banner that never appear in the instruction sent to the world model, so they measure the marker format, not delivery. By content, 50.4% of injections are visibly rendered. That is a lower bound, since it misses silent tampering with fields. When the injection is present, Robust iter 3 has the highest completion both in the world model and in the browser, where exposure is exact.

Q3: Could the agent learn to ignore all later instructions?

No. Later pages carry content the agent must act on. The world model returns validation feedback such as "Invalid total quote. Expected 90.20" in 5.3% of clean episodes with a submission, and the agent must read it, correct the value and resubmit. Under attack, the agent must notice and repair fields the injection cleared. An agent that ignored everything after the first page would fail both. Robust iter 3 instead has the highest clean completion of all checkpoints, 81.3% in the world model and 54.4% strict in the browser, and the highest completion when the injection is rendered. In the browser it reads the notice and still finishes the form, but presses the buttons the notice names in only 2.4–3.6% of episodes.

Q4: Were the Table 1 checkpoints trained with the C.6 configuration?

Stage 1 (Capability) used the C.6 configuration: an 8-action limit and the 1,500-character per-page judge cap, which could truncate field values on long pages. Stage 2 (Robust) also used an 8-action limit, but its judge was uncapped. No checkpoint was trained with 12 actions, so the action budget cannot explain a Stage 2 gain. The judge cap could in principle contribute to Stage 2's clean gain in the world model. However, the browser has no judge and no cap, and there Robust iter 3 leads Capability iter 3 by +2.0 clean, the same margin as in the world model (81.33 vs 79.33). We will state the per-stage settings in C.6.

Dear Reviewer 82Bv,

Thank you again for your detailed review and for recognizing the value of our success-flip reward and evaluation transparency. In our response, we

  1. demonstrated adversarial robustness in real Chromium, with 10–13 percentage-point gains over capability-only training,
  2. added capability-only results against Kimi-K3 and a same-backbone defense baseline,
  3. audited success flips, injection rendering, and judge errors, and clarified our training and evaluation settings.

As the discussion period ends soon, we would be grateful to hear whether these results address your main concerns. We are happy to answer any further questions.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.