acceptodds
Under review as a conference paper at ICLR 2027

WEBACT: Test-Time Learning of Verifiable Action Interfaces for Web Agents

Abstract

A web agent that has just finished a routine cannot call that routine again. Its next task begins again from browser primitives, and the agent works out the same clicks and keystrokes a second time. Making the routine callable via skill induction solves only part of the problem. A routine that worked once can be invoked on a page where it cannot work, and even on the right page it can run to the end without producing the effect that the task needed. We study test-time learning of verifiable action interfaces, where an agent learns reusable operations together with the conditions under which they should be used. Our framework, Webact, learns an ActSpec for each routine: a parameterized plan, a rule for finding its targets on the current page, a condition for when it may be invoked, and a check on the effect it should produce. Every one of these fields is taken from the trace that the routine was learned from. Successful attempts add operations, failed attempts add constraints, and each invocation outcome adjusts which operations the planner prefers, all without changing model weights. On WebArena tasks, the learned action interface improves task success by 32.8% relative to a primitive-action baseline while using 42.9% fewer tokens per task, and the gain holds on live websites. Removing either of the two learned conditions lowers success. Further trace analysis revealed the consequences of applying a wrong skill: once the planner selects an operation on the wrong page, it adopts a sub-goal that the task never had, and rejecting the call does not remove that sub-goal.

Primary area:
applications to computer vision, audio, language, and other modalities
Keywords:
Web Agents, Test-Time Learning, Action Interface Learning, Intent-Level Actions, Verifiable Actions, LLM Agents

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_rPDEOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

Summary

This paper proposes WebAct, a framework that enables web agents to learn reusable action interfaces from interaction traces without updating model weights. Each learned operation contains a parameterized plan, target-resolution rules, invocation conditions, and checks on the intended effect. Successful attempts contribute reusable operations, while failed attempts provide constraints that inform subsequent action selection. The method is evaluated on held-out WebArena tasks and additional web settings, with results showing improved task completion and reduced token usage.

Critical strengths

Strengths

  1. The paper identifies an important limitation of existing skill-learning approaches. Learning a reusable procedure is not sufficient if the agent cannot determine when the procedure applies or whether its execution produces the desired outcome. WebAct addresses these issues by integrating invocation conditions and effect checks into the learned action representation. This makes the proposed interface more operationally explicit than a collection of unqualified reusable routines.

  2. The framework combines several learning signals into a coherent test-time learning loop. The method uses successful traces to expand the action interface, failed attempts to derive constraints, and invocation outcomes to update action preferences. The resulting system learns both what operations are available and when they should be selected, while keeping the underlying model weights fixed. The component ablations provide evidence that invocation conditions and effect checks can materially affect task performance.

  3. The empirical evaluation includes both performance and efficiency measurements. On 613 held-out WebArena tasks, WebAct improves task success from 20.39% to 27.08% while reducing reported action calls and tokens per task. The additional evaluations on WebVoyager and the analysis of incorrect skill invocation help establish that the method's benefits are not limited to a single aggregate benchmark result.

Critical weaknesses

Weaknesses

  1. The distinction from prior skill-learning and tool-learning approaches could be more sharply established. The paper discusses existing methods that learn executable skills, validate routines, or filter them using preconditions. WebAct's contribution appears to lie in the particular combination of parameterized plans, applicability conditions, effect checks, and feedback-driven interface updates. The paper would benefit from a more direct comparison that isolates which part of this combination provides a capability that previous approaches cannot achieve, beyond an improvement from integrating several established mechanisms.

  2. The strongest mechanism-level evidence is concentrated in a limited setting. The Reddit ablations show large effects when invocation conditions or effect checks are removed, but such results do not necessarily establish the same mechanism's contribution across different applications. More systematic component ablations across multiple websites would clarify whether the observed effects are general properties of the design or are partly driven by particular application interfaces and task distributions.

  3. The reliability of learned conditions under environment changes remains an important open question. The learned invocation and effect predicates are derived from observed interaction traces. Although the paper provides evidence of within-application transfer, predicates inferred from a limited set of source interactions may become overly specific, stale, or misleading when page structure and behavior change. Stronger evaluation under substantial interface changes, unseen layouts, and misleading or incomplete effect signals would help establish the robustness of the learned interface.

Questions for authors
  1. Clarification In the frozen-interface evaluation, the paper states that induction stops while confidence updates and operation retirement remain active. Could the authors clarify whether task outcomes from the held-out evaluation stream are used to update action preferences or retire operations, and when this feedback becomes available to the agent? This distinction matters for interpreting the results as frozen-interface transfer versus online adaptation during evaluation.

  2. Assessment-critical evidence WebAct's central contribution is the combination of reusable plans, invocation conditions, effect checks, and failure-derived constraints. Could the authors clarify how much of the improvement over prior skill-learning methods remains when the compared systems use the same source traces, warm-up tasks, backbone, and evaluation budget? In particular, which controlled results most directly isolate the contribution of the verifiable interface design, rather than the benefits of learning reusable operations more generally?

6 comments
AuthorsOpenReview ↗

Response to Reviewer rPDE

We thank you for your insightful review and for highlighting the core distinction between learning how to execute a routine and learning when to apply and verify it. Below, we directly address your questions and provide the requested cross-application evidence.

AuthorsOpenReview ↗

W1 & Q2. Controlled evidence isolating the verifiable interface design

Direct Answer:

To isolate the contribution of our verifiable interface (Pre+Post+Locate) from general skill reuse or extra exploration, we provide two strictly controlled comparisons:

  1. Identical Source Traces, Backbone, and Budget (WebVoyager, Table 1): Using the exact same exploration traces generated by SkillWeaver, the same Gemini-2.5-Flash backbone, and the same 15-decision budget, WebAct induces 6 ActSpecs and solves 46/129 (35.7%) tasks vs. SkillWeaver's 26/129 (20.2%) (+20 tasks / +15.50 pp). This holds exploration experience constant and directly isolates the benefit of structured ActSpec contracts.

  2. Controlled Gate Ablations Retaining Identical Executable Routines (GitLab & Shopping): To isolate Pre and Post checks from the benefit of reusable macro-actions (Plan+Locate), we evaluated variants starting from the exact same warm-up library, backbone, and budget:

    Gate ConfigurationGitLab (144 tasks)Shopping (150 tasks)
    Full ActSpec (Pre + Post)54 (37.50%)42 (28.00%)
    Disable Pre (Post only)25 (-29 tasks / -20.14 pp)27 (-15 tasks / -10.00 pp)
    Disable Post (Pre only)47 (-7 tasks / -4.86 pp)23 (-19 tasks / -12.67 pp)
    Disable Both (Plan+Locate only)22 (-32 tasks / -22.22 pp)18 (-24 tasks / -16.00 pp)
    Primitive-Only Baseline (AgentOccam)38 (26.39%)25 (16.67%)

    Critically, disabling both gates performs worse than the primitive baseline on both apps (22 vs. 38; 18 vs. 25), proving that reusable macro-actions alone are insufficient—and even harmful—without runtime applicability and effect verification.

AuthorsOpenReview ↗

W2. Mechanism evidence beyond Reddit

We completed full Pre/Post ablations on GitLab (code collaboration) and Shopping (e-commerce), which together account for 33 of the 41 net task gains in Table 3. As shown in the table above, both domains confirm the exact same mechanism pattern observed on Reddit: the full contract outperforms every ablated variant, while the relative impact of Pre vs. Post reflects domain structure (Pre prevents cross-view misinvocations in GitLab, while Post verifies search/filter state transitions in Shopping).

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

This is a work on programmatic skill induction/generation from past and test-time experience to augment a web agent's action space with reusable composite actions.

Critical strengths
  • The learned actions generalize better within an application and tend to perform better than the baselines selected by authors on two web benchmarks.
  • Learning preconditions along with the actions turns out to be pretty important in helping the agent select an appropriate learned action.
Critical weaknesses
  • The setting of learning reusable programmatic skills for web agents from past experience is not novel both before test-time (e.g., SkillWeaver [1]) and at test-time (e.g., ASI [2]). These are mentioned in the paper and related work and the results of the WEBACT method on the benchmarks are compared with SkillWeaver in the evaluation, but the improvement feels like it might stem from smaller implementation/engineering details rather than from genuinely new conceptual insights. e.g., noting preconditions for learned actions has also been done by past methods like TheoryCoder-2 [3] and SkillWeaver.

[1] Zheng et al., Skillweaver: Web agents can self-improve by discovering and honing skills, arXiv 2025.
[2] Wang et al., Inducing Programmatic Skills for Agentic Tasks, COLM 2025.
[3] Zergham et al., Learning Abstractions for Hierarchical Planning in Program-Synthesis Agents, arXiv, 2026.

Questions for authors

Please see weakness above.

6 comments
AuthorsOpenReview ↗

Response to Reviewer oKbm

We thank you for recognizing the within-application generalization of our learned actions and the importance of invocation conditions. Below, we clarify why WebAct represents a distinct conceptual contribution—bidirectional test-time interface evolution with decoupled runtime verification—and substantiate it with mechanistic and controlled empirical evidence.

AuthorsOpenReview ↗

W1 (O1). Conceptual distinctions from SkillWeaver, ASI, and TheoryCoder-2

While prior work induces skills or preconditions, WebAct addresses a fundamentally different problem: how an agent governs an expanding action space at test time without a world model, by coupling local execution contracts with bidirectional (success + failure) interface updates:

  1. Vs. SkillWeaver [1] (Structured Runtime Contracts & Global Failure Constraints vs. API Docstrings):

    • Interface Representation: SkillWeaver synthesizes Python APIs and records prerequisite notes in natural-language docstrings (§2.2–2.3). WebAct jointly extracts a formal, four-part runtime contract ⟨op(args),Locate,Pre,Plan,Post⟩\langle \text{op}(\text{args}), \text{Locate}, \text{Pre}, \text{Plan}, \text{Post} \rangle from a single state-transition segment (§3.2–3.3), decoupling entry applicability (Pre), dynamic target grounding (Locate), execution (Plan), and outcome verification (Post).

    • Bidirectional Interface Updates: SkillWeaver uses logs to debug individual API code. WebAct uses successes to expand operations (Atask\mathcal{A}_{task}) and failures to extract context–action constraints (C\mathcal{C}, Algorithm 3) that prune failure-prone patterns across the entire action library in matching contexts, rather than staying isolated inside one skill's docstring.

  2. Vs. ASI [2] (Per-Invocation Contextual Verification vs. Admission-Time Validation):

    • ASI validates induced skills once at library admission by replaying the source trajectory (§2.3). However, passing admission validation does not guarantee validity under new arguments or shifted page states. WebAct embeds Pre, Locate, and Post directly into the runtime action interface so every subsequent invocation is verified against the live page context and intended local effect.
  3. Vs. TheoryCoder-2 [3] (Model-Free Grounded Contracts vs. World-Model Symbolic Search):

    • TheoryCoder-2 learns PDDL operators alongside a Python transition model, relying on symbolic planners (Fast Downward) and model-based search to ground operators into primitives (§2.2–3.2). In open-ended web environments where learning an accurate transition model is intractable, WebAct eliminates world-model learning entirely: it extracts grounded contracts directly from observed browser transitions and lets the LLM planner compose them natively with primitives.
AuthorsOpenReview ↗

W1 (O2). Why these differences yield genuine research insights (beyond engineering)

Our architecture exposes three mechanistic phenomena that prior skill-learning methods neither isolate nor explain:

  1. Wrong-page invocation causes irreversible "Sub-goal Hijacking" (Table 2 & Table 14): Removing Pre drops Reddit success to 0/85, whereas weakening Locate or freezing confidence updates yields 28/85 and 29/85—even though all three variants have 0% executor acceptance. Trace diagnostics (§4.5) reveal why: invoking a skill on an inapplicable page injects a false sub-goal into the planner's context that persists even after the executor rejects the call. Thus, Pre (cognitive gating before selection) and Post (execution verification afterward) solve fundamentally different failure modes.

  2. Action generalization and predicate generalization are decoupled failure modes (Appendix G): Separating Plan from Post uncovered a critical insight: a learned search Plan generalized cleanly to 16 new queries, yet its Post predicate overfitted to the source trace's query ("Iphone 14"), causing 21 false rejections. Skill reliability therefore cannot be measured merely by whether code executes; learning generalizable verification predicates is a distinct sub-problem.

  3. Decisive gains on identical exploration traces & cross-application ablations:

    • Same exploration traces (Table 1): Using the exact same exploration traces collected by SkillWeaver on WebVoyager, WebAct's 6 ActSpecs solve 46/129 (35.7%) tasks vs. SkillWeaver's 26/129 (20.2%) (+15.50 pp), ruling out exploration volume and proving the superiority of our contract representation.

    • Cross-application gate ablations: On GitLab and Shopping (see table in Response to Y83C-W4), disabling Post drops success by 4.86 pp (54→47) and 12.67 pp (42→23), while disabling both gates drops performance below the primitive baseline (22 vs. 38; 18 vs. 25).

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

This paper introduces WEBACT, which learns reusable ActSpecs from web interaction traces by combining parameterized operations, target localization, invocation preconditions, and effect postconditions without updating model weights. The empirical results prove that WEBACT consistently improves the performance across multiple benchmarks.

Critical strengths
  1. The representation of this paper is good and easy to follow.
Critical weaknesses
  1. The baseline performance reported in this paper appears to be significantly lower than the original results reported. However, the changes of backbone and budget do not obviously account for this. The reported rerun results also use more token than the original results. The authors need to report more detailes about the rerun baselines.
  2. One ActSpec invocation counts as a single decision but executes several primitives. The episode length is 15 decisions, smaller than AgentOccam's own setting and WebArena's setting. WebAct therefore effectively gets a longer horizon.
  3. The token calculation metric is wrong. In the process, each logged step stores the cumulative per-task token count, making the token couting squred.
  4. The ablations do not isolate the claimed mechanisms, and most secondary comparisons are within noise.
Questions for authors

See weaknesses above.

8 comments
AuthorsOpenReview ↗

Response to Reviewer Y83C

We thank you for recognizing the clarity of our presentation and for catching the token aggregation issue. Below, we directly address your four concerns.

AuthorsOpenReview ↗

W1. Baseline performance gap, reproduction details, and token usage

Direct Answer:

The gap between our AgentOccam baseline (20.39%) and its published numbers stems from evaluating on a different backbone (Gemini-2.5-Flash vs. GPT-4-Turbo), tighter budget (15 vs. 20 steps), and the 613-task held-out split—all of which are held 100% identical between AgentOccam and WebAct. Furthermore, on a stronger backbone where AgentOccam matches its published strength, WebAct still outperforms it.

  • Backbone sensitivity accounts for the baseline score: AgentOccam's own paper reports sharp sensitivity to the LLM backbone on its 190-task dev split: 44.2% with GPT-4-Turbo vs. 33.7% with Gemini-1.5-Flash (AgentOccam Appendix D). In our Appendix F paired experiment with Gemini-3.5-Flash-Lite, AgentOccam reaches 38.89% (56/144, matching its published 37.8% GitLab result), and WebAct still improves success to 40.97% (59/144) while cutting calls/task from 9.15 to 7.89.

  • Token metric difference & correction: AgentOccam's Tables 4/16 report observation tokens per step (GPT-2 tokenizer), whereas we report total LLM tokens per task. After fixing the cumulative counting bug (W3), WebArena costs are 95.41K (AgentOccam) vs. 63.85K (WebAct).

Shared Experimental SettingPaired AgentOccam vs. WebAct Configuration
Backbone & ObservationsGemini-2.5-Flash; webpage text + accessibility tree
Split & Budget151 warm-up / 613 held-out tasks; 15 planner decisions/attempt (max 3 attempts)
Token MetricTotal LLM tokens per evaluation task (final per-attempt cumulative count)
AuthorsOpenReview ↗

W2. Does an `ActSpec` simply give WebAct an unfair longer horizon?

Direct Answer:

No—longer horizon alone degrades task success. While an ActSpec compresses recurring primitive steps into one planner decision, our new cross-application ablations show that multi-step macro-actions without runtime verification perform significantly worse than primitive actions alone:

  • In our Pre/Post ablations, the multi-step Plan and Locate primitives remain completely intact (preserving the exact same expanded execution horizon).
  • Yet, when Pre and Post are disabled, success collapses below the primitive-only AgentOccam baseline: 22/144 vs. 38/144 on GitLab, and 18/150 vs. 25/150 on Shopping.
  • Without applicability and effect checks, macro-actions mislead the planner into pursuing wrong sub-goals. Thus, WebAct's gains come from verifiable action abstraction, not merely executing more primitives per step.

Comments on the paper

1 comment
AuthorsOpenReview ↗

General Response to All Reviewers and AC

We thank all reviewers for their constructive feedback and for recognizing the clarity of our action representation (Y83C), the within-application generalization of learned operations (oKbm), and the importance of coupling execution plans with applicability and effect checks (rPDE).

Across all reviews, the central question is whether WebAct's gains stem from its verifiable action-interface formulation (ActSpec + bidirectional experience updates) rather than longer horizons, extra exploration data, or minor engineering details. In this revision, we establish our core claims with three decisive updates:

  1. Unconditional macro-actions hurt performance; verifiable conditions drive the gain (New Cross-Application Ablations on GitLab & Shopping): To address requests for multi-domain mechanism evidence (Y83C-W2/W4, oKbm-O2, rPDE-W1/W2/Q2), we ran full Pre/Post ablations on GitLab (144 tasks) and Shopping (150 tasks)—the two apps driving 33 of our 41 net task gains. Across all three evaluated domains (Reddit, GitLab, Shopping), disabling Pre and Post while keeping multi-step macro-actions intact drops success below the primitive-only baseline (e.g., 22/144 vs. 38/144 on GitLab; 18/150 vs. 25/150 on Shopping). This directly shows that longer effective horizons alone are counterproductive; WebAct's gains come from governing when routines apply and verifying what they achieve.

  2. Corrected Token Accounting (Y83C-W1/W3): We fixed the cumulative token aggregation bug identified by Reviewer Y83C across all tables. All task success rates remain identical, and WebAct achieves a 33.07% token reduction on WebArena (63.85K vs. 95.41K tokens/task) and 31.50% on WebVoyager Online (61.43K vs. 89.68K).

  3. Sharper Conceptual & Protocol Boundaries (oKbm-W1, rPDE-W1/W3/Q1): We sharply distinguish our model-free, runtime-verified interface evolution from SkillWeaver, ASI, and TheoryCoder-2, and explicitly define our frozen-evaluation protocol as "frozen acquisition with adaptive reuse" (where library induction stops, while local executor verdicts update action confidence and retirement without accessing ground-truth task labels).

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.