acceptodds
Under review as a conference paper at ICLR 2027

Long-Horizon Web Agents Need a State Beside the Trajectory

Abstract

LLM agents struggle on long-horizon tasks for two reasons. First, the policy fails to attend to evidence that is scattered across a long trajectory yet needed for the next decision. It tends to commit to actions without grounding them in the current evidence. Second, when the current environment differs from training in ways the trajectory does not reveal, the policy falls back on training-time priors rather than checking the current environment. We propose Cast (Coded Agent with STate), an agent loop that maintains a small, structured state alongside the trajectory and exposes it to the policy at decision time. This state collects evidence relevant to the next decision as the trajectory unfolds, so the policy reads it from one place rather than recovering it from the trajectory. Environment-side fields are either filled from the current observation or marked as unknown, so an unresolved fact is visible to the policy before it acts. Deterministic code updates the state after every step with no language-model call, and a fixed contract ties a few state values to behavioral constraints. On WebArena, Cast improves success rate across backbones without any offline exploration corpus. Under targeted environment perturbations spanning latent shifts, execution noise, and structural changes, Cast outperforms the baseline. Our code is available at: https://anonymous.4open.science/r/cast-5DB6/README.md.

Primary area:
foundation or frontier models, including LLMs
Keywords:
LLM agents, web agents, long-horizon tasks, structured state, WebArena

Reviews

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

The paper argues that long-horizon web agents fail for two structural reasons, both stemming from latest-observation conditioning at∼πθ(⋅∣xins,ot,hta)a_t \sim \pi_\theta(\cdot \mid x_{\text{ins}}, o_t, h^a_t), i.e. a prompt containing only the instruction, the current observation and the growing list of past action labels:

  1. Trajectory-side failure ("effective information distance"). Decision-relevant content is present in the prompt but distant from the prediction site or scattered across turns. A controlled probe (Fig. 1, built from real WebArena trajectories, n=27n=27 prompt variants over 12 tasks, Qwen2.5-14B-Instruct, greedy) varies placement while holding the gold answer fixed: short+concentrated 100%, long+concentrated 88.9%, short+distributed 48.1%, long+distributed 11.1%, long+distributed+state block 100%. The reading is that accuracy is governed by layout, not context length.
  2. Environment-side failure ("marginalization trap"). Because the model learns a marginal Pθ(b∣a)=∫P(b∣a,x)P(x∣a) dxP_\theta(b\mid a)=\int P(b\mid a,x)P(x\mid a)\,dx and the prompt has no slot in which an unobserved environment variable xx can be marked unknown, the policy silently substitutes a training-time default. A second probe (Fig. 2, 20 real baseline failure points, 4 regimes ×\times 5 cases) compares the standard trace with the same trace plus an oracle slot naming the missing fact: 7/20 (35%) →\to 18/20 (90%). The latent-fact control is 5/5 in both; the three episode-specific regimes (execution error, stale locator, unverified write) go 0/5$\to$5/5, 2/5$\to$5/5, 0/5$\to$3/5. Method — CAST (Coded Agent with STate). The agent loop is rewritten as st+1=U(st,ot+1,at,et+1)s_{t+1}=U(s_t,o_{t+1},a_t,e_{t+1}) and at∼π(⋅∣xins,ot,hta,st,ct)a_t\sim\pi(\cdot\mid x_{\text{ins}},o_t,h^a_t,s_t,c_t). sts_t is a bounded, typed record (13 slots in the reported instance: trajectory bookkeeping, environment flags, termination fields) advanced by deterministic, per-slot code UU that reads only the most recent interaction — no learned weights, no retrieval, no extra LM call. Three principles generate the rules: action effect (error / URL change / observation change / repeat counts), termination evidence (task mode + visible absence or completion markers via a fixed regex lexicon), and budget. ctc_t is a fixed prompt contract that ties state values to behavior: a stop-content clause (rejecting placeholders, hedged stops and empty strings; requiring a concrete value when evidence is visible) and a forbidden-action clause (barring an action class after ≥3\geq 3 repeats with no observation change, and both members of a 3-cycle). The key argument for the contract is that under latest-observation conditioning the previous observation is gone, so the policy cannot establish "this just had no effect" from its own input — the contract is what converts state facts into constraints.
Critical strengths
  1. A cheap, implementable design principle with a real effect on open models, and a non-obvious insight about why state must be paired with a contract. The "facts that admit a deterministic extraction rule belong in code, facts that require linguistic judgment remain in the policy" split is a clean partition, and CAST implements it at zero marginal inference cost — no extra LM call, no retrieval index, no exploration corpus, no training. On gpt-oss-20b this lifts WebArena from 14.7% to 25.6%, a 74% relative improvement, while matching a retrieval-based dynamics-grounding method that needs a GPT-4.1 exploration corpus. The accompanying insight — that sts_t alone is inert because a policy may read and ignore it, so a fixed ctc_t is required to convert state values into constraints, and that the forbidden-action clause is not computable from the latest-observation prompt because the previous observation has been dropped — is a genuinely useful conceptual contribution: it separates "inform the policy" from "constrain the policy" and shows the latter needs the former. Consequential because this is an actionable, low-cost recipe that others can adopt immediately, and it is the part of the paper most likely to survive.
  2. The failure-mode decomposition as a diagnostic instrument. Figure 6b decomposes residual failures into premature stop, repeat loop, drift, hallucinated stop, step truncation and other, and shows the mechanism-level shift between variants: removing the contract block brings premature stop / repeat loop / hallucinated stop back, whereas removing state slots trades successes for step-truncated runs. This is more informative than a scalar success rate and gives the paper a defensible causal story for which component fixes which failure. Consequential because it is the only place in the paper where the claim "component X addresses failure Y" is tested rather than asserted, and it is the template a stronger version of this paper should follow on the full benchmark with proper statistics.
Critical weaknesses
  1. Every quantitative claim is under-powered, and the central claim fails precisely where it matters most — the strongest backbone. There is no seed variance, no confidence interval and no significance test anywhere in the paper. The three perturbation regimes use n=24n=24 each (one task =4.17=4.17 pp, so "+25.0" is six tasks); the ablation uses n=53n=53 (one task =1.9=1.9 pp, so every component contribution in the ladder — +1.9+1.9, +1.9+1.9, +0.0+0.0, +1.9+1.9 — is exactly one task); the motivating probes use 27 prompt variants and 20 cases. Most consequentially, the three main-table results are not comparable in strength: the gain is monotonically decreasing in backbone capability (+10.9 pp on gpt-oss-20b, +4.6 pp on Qwen2.5-14B, +0.6 pp on gpt-5.4), and the gpt-5.4 result is a single run whose net gain is within any plausible noise band. Decomposing it by site makes the problem sharper: on gpt-5.4 the +0.6 pp average is the sum of +17.0 pp on Reddit (n=106n=106, ≈+18\approx+18 tasks) and −11.7 pp on GitLab (n=180n=180, ≈−21\approx-21 tasks), with Multi also negative (−4.1). GitLab is exactly the site that supplies +19.5 pp for the gpt-oss-20b headline (+3.9 pp on Qwen), i.e. the same site flips sign across backbones. Combined with the fact that Reddit and GitLab contribute roughly 75% of the gpt-oss-20b gain, the paper's claim that the effect "is spread across the six sites … targets no site-specific feature" and is "tied to the conditioning rather than to a particular model" is not supported. Consequential because the abstract's "improves success rate across backbones" and Section 1's "consistent gains across backbone scales" are the paper's headline claims, and the honest reading of Table 1 is "CAST substantially helps weak/open backbones and does nothing measurable for a frontier model, with a large site-level regression." Either the framing must change to a capability-dependent claim, or paired multi-seed runs with per-task outcomes (McNemar) and intervals must be supplied.
  2. The evidence that the two diagnosed bottlenecks are the binding constraints is thin and partly circular, and the stress subsets are selected on the outcome. Figure 2 — the sole empirical support for the "marginalization trap" — hands the model the ground-truth missing variable in an oracle slot, so "the correct action becomes selectable once the missing fact is named" is close to tautological; the control regime (latent fact) shows no effect at all (5/5 both), and the unverified-write regime recovers only to 3/5 even with the oracle, which undercuts the claim that a representational locus is "the fundamental remedy". n=20n=20, one backbone, greedy decoding. Figure 1 is the paper's most quotable number (11.1% at LD) and it rests on 27 prompt variants drawn from 12 tasks, of which 3 are "calibration variants of a single task" that were "added so that LD is non-zero"; since LD scores exactly 3/27, the natural inference is that LD is ≈0/24\approx 0/24 on the real items, i.e. the headline collapse is carried by three hand-inserted rows of one task. The perturbation study compounds this: Section 6.2 states the subsets were constructed to isolate "regime[s] where the GenericAgent baseline is known to drift", and the failures themselves are injected by the authors, so the +16.7 to +25.0 pp gains measure whether CAST handles the failure modes it was built for, not robustness in general — and the AI-use statement says LLM assistants "selected fixed WEBARENA task subsets used during development", so even the selection is not fully auditable. Consequential because Section 3 is the paper's motivation: if these probes are illustrative rather than probative, the paper is an empirical systems paper with a weak baseline, not a diagnosis of why agents fail.
Questions for authors
  1. Statistics. How many independent runs per condition are reported? Can you provide paired per-task outcomes and intervals for Table 1, the three 24-task subsets and the 53-task ablation? Is the gpt-5.4 average gain (+0.6 pp) distinguishable from zero, and what explains the −11.7 pp GitLab regression on gpt-5.4 given that GitLab is the site driving the gpt-oss-20b gain? (Clarification.)
  2. Baselines. Can you run at least one memory/reflection baseline (e.g. an AgentOccam-style observation-formatting baseline, or a reflection/AWM-style memory) in your own harness on the same backbones? Does CAST still add value over those, and does a contract-only prompt (stop-content + loop-breaking clauses, no state slots) capture most of the gain? (Clarification — this determines whether the contribution is the state or the prompt.)
3 comments
AuthorsOpenReview ↗

Response to Reviewer me3v (1/3): w1 / q1

Thank you very much for the thorough review. We are grateful for your assessment that the split between code-computed facts and language judgment is a clean partition, and that pairing a state that informs with a contract that constrains is a useful insight. Your reading of Table 1 is the right one, and we will adopt it in the revised paper.


w1 / q1: Every quantitative claim is under-powered: no seed variance, intervals, or tests, and small subsets. The gain decreases with backbone capability. On GPT-5.4 the +0.6 average is the sum of +17.0 points on Reddit and -11.7 on GitLab, the site that drives the gpt-oss-20b gain, and Reddit and GitLab supply about 75% of that gain. How many independent runs are reported, can you provide paired per-task outcomes and intervals, is the GPT-5.4 gain distinguishable from zero, and what explains the GitLab regression?

R w1 / q1: You are right on each point, and we should have reported the site-level analysis ourselves. In Table 1, we report one evaluation per condition, without confidence intervals or significance tests. The GPT-5.4 gain is not distinguishable from zero. We will remove "improves success rate across backbones" and "consistent gains across backbone scales", and the statements that the effect is "spread across the six sites" and "tied to the conditioning rather than to a particular model". The revised paper states the capability-dependent claim you describe: CAST substantially helps smaller open-weight backbones and gives no measurable gain on GPT-5.4, where it also causes a site-level regression on GitLab.

Runs and statistics in Table 1. Table 1 reports one evaluation per condition. As noted in Table 1, for Qwen2.5-14B-Instruct the baseline (17.0) and GTTA (21.0) entries are the numbers reported by Chen et al. (2025), so that row is not a same-environment comparison, and we will mark it more prominently. In Table 1, gpt-oss-20b goes from 119 to 208 of 812 tasks (+10.9 points, unpaired 95% interval [+7.1, +14.8]) and GPT-5.4 goes from 285 to 290 (+0.6 points, [-4.0, +5.3], p = 0.80).

Paired per-task outcomes. In our recovered per-task paired records for gpt-oss-20b on all 812 tasks (108/812 for the baseline vs. 204/812 for CAST, from an earlier grading of the same runs), 36 tasks are solved only by the baseline and 132 only by CAST (+96 tasks / +11.8 points; task-family cluster-bootstrap 95% interval [+7.45, +16.56], two-sided exact McNemar p < 1e-11). Multi-seed variance across repeated runs is not yet measured and will be stated as a limitation.

GPT-5.4 and the GitLab regression. The regression in Table 1 matches your calculation: GitLab goes from 86 to 65 of 180 tasks (-21 tasks; unpaired p = 0.025), next to a rise from 33 to 51 of 106 on Reddit (where the baseline run experienced rate-limiting errors). One plausible hypothesis is that on a stronger backbone, CAST's repeat-action prohibition and stop guard over-constrain valid exploratory steps or retries on multi-step GitLab workflows; however, because per-task logs for our GPT-5.4 run are not available and our endpoint access for re-running GPT-5.4 is currently unavailable, we cannot provide a verified per-task attribution of the 21 lost GitLab tasks between the state and the contract. We will report the GitLab regression prominently in the main text as a negative result on a frontier backbone.

Site concentration. On gpt-oss-20b, the per-site changes in Table 1 are GitLab +35, Reddit +32, Shopping Admin +18, Shopping +4, Map +1, and Multi-site -1 tasks. GitLab and Reddit supply 67 of the 89 additional tasks (75%) while holding 35% of the benchmark, and GitLab changes sign between backbones. This contradicts our earlier statement that the effect is spread evenly across sites, which we will remove.

Summary and planned revisions. Our results support a large, statistically significant paired gain on gpt-oss-20b concentrated on GitLab and Reddit, alongside no measurable overall difference on GPT-5.4 and a site-level regression on GitLab. We will revise the abstract, Section 1, Section 6.1, and Section 7 to state this capability-dependent claim, add the confidence intervals and paired statistics to Table 1, mark the Qwen2.5-14B-Instruct row as taken from prior work, and report the site-level breakdown and the GPT-5.4 GitLab regression in the main text.


AuthorsOpenReview ↗

Response to Reviewer me3v (2/3): w2


w2: The evidence that the two diagnosed bottlenecks are the binding constraints is thin and partly circular. Figure 2 hands the model the missing fact through an oracle slot. Figure 1's LD result is carried by three calibration rows. The stress subsets are selected where the baseline drifts, with failures injected by the authors, and LLM-selected subsets are not fully auditable. If the probes are illustrative, the paper is an empirical systems paper, not a diagnosis.

R w2: Thank you for this careful analysis. We agree that the two probes in Section 3 are too small and too constrained to establish that the diagnosed bottlenecks are the binding constraints by themselves, and that Figure 4 does not measure robustness to general environment shifts. We accept your characterization of the paper as an empirical systems study of a low-cost component, with Section 3 serving as motivation. Each item is addressed below.

Figure 1. Your inference is correct: LD answers 0 of the 24 non-calibration items, and its 3 correct responses are the three calibration variants, which Appendix B.1 notes were added so that LD is non-zero. The conditions also differ in more than placement: SC, LC, and LD+S each state the resolved answer, SD splits it among distractors, and LD is a truncated failed history that lacks sufficient evidence. Figure 1 is therefore a diagnostic upper-bound probe of how a given answer is used under different presentations, not evidence that spatial layout alone causes the drop. A new comparison that changes only position (31 tasks, same evidence verbatim, no answer field) gives 23/31 vs. 25/31 for raw page evidence (4 improvements, 2 regressions) and 25/31 vs. 26/31 for distilled facts (2 and 1), with task-family bootstrap 95% CIs of [-14.29, +20.93] and [-8.34, +13.90] percentage points (both including zero). A full example is in our response to Reviewer 9f4i (1/2).

Figure 2. We agree on its scope: 20 cases, one backbone, and an oracle slot, which Appendix B.2 notes cannot show that a deployed pipeline can populate the slot at run time. Two clarifications: the latent-fact cases are at ceiling in both conditions (5/5), so the change comes from the other 15 cases (2/15 to 13/15); and the unverified-write regime reaches only 3/5 even with the oracle, which shows that naming the missing fact is not always sufficient without a behavioral constraint. We will remove "the fundamental remedy" and state the marginalization account as a motivating hypothesis rather than a proven bottleneck.

Stress subsets (Figure 4). One factual correction: no failure was injected. The three groups are subsets of unmodified tasks, selected by fixed deterministic rules from existing runs. Appendix C described a planned intervention design that was not run for Figure 4, which was our error; the exact rules and all 69 task IDs are in our response to Reviewer 9f4i (2/2). Your point about outcome-based selection applies directly to Group 2, which selects on the baseline's own rollout outcome (terminal status ERROR/TRUNCATED or at least 25 steps), so its gain is biased upward. Groups 1 and 3 are selected on task properties only (instruction value-lookup keywords; program_html evaluator type). In the original runs, the tasks solved only by the baseline vs. only by CAST are 1 vs. 6, 1 vs. 5, and 0 vs. 6 (two-sided exact McNemar p = 0.125, 0.219, and 0.031, unadjusted; Fisher exact p = 0.23, 0.19, 0.11). Figure 4 therefore measures performance on targeted task subsets rather than robustness to perturbations, and we will rename and describe the groups accordingly.

Auditability. In the AI-use statement, coding assistants implemented and ran the deterministic filtering scripts under our direction; the resulting task-ID lists are fixed files. We will include the selection rules and task IDs for the Figure 4 groups, the 53-task ablation set, and the probe items in Appendix C and in the anonymous repository.

Summary and planned revisions.

  • Role of the probes and subsets. We will present the probes in Section 3 as motivating diagnostics rather than standalone proofs of the two bottlenecks, note that Group 2 of Figure 4 is selected on baseline outcomes, and frame the paper as an empirical study of a low-cost runtime state-and-contract component.
  • The base agent. Our base agent follows the implementation of Chen et al. (2025), who report 30.0% for GPT-4.1 in the same setting; this gives context for why our absolute numbers sit below BrowserGym leaderboard systems that use different prompts or search, though it does not fully explain the level of our GPT-5.4 score.

We will present Section 3 as motivation, remove "the fundamental remedy" and "solely due to spatial layout", and rewrite Section 6.2 and Appendix C to match the actual selection rules.


AuthorsOpenReview ↗

Response to Reviewer me3v (3/3): q2


q2: Can you run at least one memory or reflection baseline in your own harness on the same backbones? Does CAST still add value over it, and does a contract-only prompt (stop-content and loop-breaking clauses, no state slots) capture most of the gain? This determines whether the contribution is the state or the prompt.

R q2: Thank you for this question, which goes to the core of how state and contract interact. Full 812-task evaluations of four additional variants in our harness (model-written memory, raw observation diff, state-only, and contract-only) are currently in progress and not yet complete in time for this response, so we do not claim a completed full-benchmark quantitative split between them here. Below we state how the four variants are defined, what our existing evidence and the architecture of the prompt establish, and what remains an open empirical question until those runs finish.

1. Why a contract-only prompt cannot replicate the loop-breaking condition in our harness. In our latest-observation conditioning setup, the policy prompt at step tt contains the task instruction, the current page observation oto_t, and the list of past action strings htah^a_t; the previous observation ot−1o_{t-1} is dropped.

  • The stop-content clause of the contract (forbidding placeholder strings such as 'Done' or 'Upvoted' and requiring a literal value) is a pure prompt instruction and does not depend on state slots.
  • By contrast, the forbidden-action clause ("if same_action_repeat_count >= 3 with no observation change, or two_action_cycle_count >= 3 with no observation change, that action class is forbidden") depends on whether consecutive observations changed (ot=ot−1o_t = o_{t-1}) and whether the last action returned an error. Because ot−1o_{t-1} is absent from the baseline prompt, a contract-only prompt with no state slots can only give generic advice ("do not repeat an action that had no effect"), leaving the policy unable to verify from its current input whether the previous action changed the page. Conversely, a state-only prompt supplies those facts without explicitly forbidding the next repeat.

2. In-harness variants under evaluation.

  • Model-written memory. The policy may emit an optional <memory>...</memory> note in the same response as its action, carried into subsequent prompts without a separate memory-generation call.
  • Observation diff. The policy receives deterministic line additions and deletions between consecutive raw accessibility-tree observations, computed before normalization or prompt truncation.
  • State only. The state block is added and the contract is removed.
  • Contract only. A rewritten, standalone instruction set expressed in terms of visible evidence and action history, without the CAST runtime-state block or the executable stop guard.

3. Other baselines and the 53-task ablation.

  • AgentOccam, Reflexion, and AWM. AgentOccam restructures the current accessibility tree and action space without extra calls, addressing single-step observation formatting rather than cross-step state tracking. Reflexion-style methods retry across multiple episodes after failure, and AWM induces workflows across tasks; both operate across episodes rather than within a single-attempt rollout with no separate state-maintenance call. We will add a comparison table and discussion of AgentOccam, AWM, ABBEL, PABU, and VLAA-GUI in Section 2.
  • The 53-task ablation and full-benchmark outcome shifts. In Section 6.3, the cumulative ladder on the 53-task subset has a total spread of 3 tasks (30/53 to 33/53), which is too small a sample to statistically resolve the individual contribution of each component. At full-benchmark scale, Figure 5 shows where outcomes move on gpt-oss-20b: episodes that end with a stop and no reward fall from 578 to 402 of 812, while truncated episodes rise from 124 to 201 and successes from 110 to 204. This does not separate state from contract, which the full-benchmark variants in progress will test.

Thank you again for the detailed and constructive review.


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

The authors propose an improvement to the web agent framework - GenericAgent developed by ServiceNow (https://github.com/ServiceNow/AgentLab/) - called CaST (Coded Agent with STate) in which they maintain a small, structured, running state of the trajectory. This state is added this to the model prompts at every trajectory step to improve the agent's performance on WebArena. , the state is computed via code and not LLM calls, and captures information like encountered errors, ineffective repetitive actions (trajectory side fields), whether page indicates an element is absent/task is completed (environment side fields), and task type, remaining steps, forbidden next actions (control side fields) etc. They claim that adding this information to the end of the prompt is required, because models are fail at web navigation tasks when this kind of state information is either scattered across the trajectory or earlier observations get dropped completely in certain agent designs. They show that CaST beats another baseline GTTA on WebArena when using Qwen2.5-14B-Instruct (21.6% v/s 21.0% SR) and GPT-OSS-20B (25.6% v/s 25.0% SR) while GTTA leads CaST when using GPT-5.4 (35.7% vs 36.2% SR). GTTA is a dynamic grounding baseline, which retrieves over a corpus of GPT4.1's exploration trajectories generated during test time.

Critical strengths
  1. The experiment designs in Section 3.2 and Section 3.3 are interesting, they show that prompt layout / large effective information distance for trajectory side failures can cause accuracy drops; they also conduct an experiment to show that model training time priors can lead them to ignore environment side failures. Both these experiments show potential, but these sections are hard to read and the experimental details are not provided clearly to evaluate if they are generalizable enough.
Critical weaknesses
  1. This methodology does not beat sota webarena results on the WebArena leaderboard. One example from Dec 2025 is WebOperator + GPT-4o at 54.6% SR which uses a much weaker model backbone compared CaST + GPT 5.4 at 35.7% SR. The improvements shown on top of the baseline agent on the frontier models like GPT-5.4 is not beyond noise (35.1 v/s 35.7) which makes the technique less useful for adoption by the wider research community as a reliable method of improving their web agentic designs.
  2. The concept of introducing a state capturing past errors, remaining turn/token budgets, past actions attempted etc is not novel enough. This is an incremental improvement to the baseline GenericAgent agent that the paper builds upon.
  3. The paper can benefit from comparing with more, and recent baselines from the literature on WebArena with comparable model backbones.
  4. To demonstrate generalizability of the technique, it would also benefit to show improvements on other web agentic benchmarks like OS World v2 (https://github.com/xlang-ai/OSWorld-V2), BrowseComp (openai.com/index/browsecomp/) , WebBench, GAIA etc.
Questions for authors
  1. Which models are Fig. 1 and Fig 2 using?
  2. Will the proposed approach require a complete rewrite for other web navigation benchmarks / other baseline agents instead of GenericAgent?
3 comments
AuthorsOpenReview ↗

Response to Reviewer oNhQ (1/3): w1

Thank you very much for the detailed review and for the pointers to recent systems and benchmarks. We are glad that you found the experiment designs in Sections 3.2 and 3.3 interesting, and we apologize that these sections were hard to read. We address your points in order.


w1: The method does not beat state-of-the-art WebArena results: WebOperator with GPT-4o reaches 54.6%, against 35.7% for CAST with GPT-5.4. The gain on GPT-5.4 (35.1 vs. 35.7) is within noise, which makes the technique less useful for adoption.

R w1: Thank you for raising this. Both observations are correct: CAST is not a state-of-the-art system, and the reported GPT-5.4 difference does not establish a benefit. A single difference of this size does not justify a claim that CAST reliably improves frontier agents, and we will remove the statements that it gives consistent gains across backbones. Below we clarify what the comparison with WebOperator measures, what sets the absolute level of our numbers, and the capability-dependent scope supported by the results.

What the comparison with WebOperator measures. WebOperator reports 54.6%, 42.7%, and 24.4% with GPT-4o at search-step budgets of 20, 10, and 5 (its Table 3). It is a complete system whose candidate generation, scoring, and backtracking differ from the agent used in our study, so its score is valuable system-level context but does not isolate the contribution of a state component. CAST uses no search. We do not claim that CAST is better at equal cost, or that adding it to WebOperator would improve that system.

The base agent and the absolute level. Our implementation is derived from the GTTA codebase of Chen et al. (2025) and uses a BrowserGym/AgentLab agent with a chain-of-thought prompt that reads the current page and the list of past actions, with a 30-step budget and no search. Describing it as "the standard GenericAgent" was imprecise; we will correct this and give the exact prompt and configuration. In their setting, Chen et al. report 30.0% for GPT-4.1 and 12.0% for GPT-4o mini, against 31.4% for GPT-4o and 17.4% for GPT-4o mini with GenericAgent on the BrowserGym leaderboard. These numbers give context for the absolute level of the implementation we followed. They do not fully explain the level of our GPT-5.4 score.

Capability-dependent effect and paired statistics. Table 1 reports one evaluation per condition. On GPT-5.4 the difference is 285 vs. 290 of 812 tasks (+0.6 points, 95% CI [-4.0, +5.3], p = 0.80), which is within noise. On gpt-oss-20b, success in Table 1 rises from 119 to 208 of 812 tasks (+10.9 points, unpaired 95% CI [+7.1, +14.8]); in our recovered per-task paired records (108/812 for the baseline vs. 204/812 for CAST, from an earlier grading of the same runs), 36 tasks are solved only by the baseline and 132 only by CAST (+96 tasks / +11.8 points, task-family cluster-bootstrap 95% CI [+7.45, +16.56], two-sided exact McNemar p < 1e-11). On Qwen2.5-14B-Instruct, CAST reaches 21.6% against the 17.0% baseline and 21.0% GTTA reported by Chen et al. (2025). We will therefore revise the paper's claim to a capability-dependent one: CAST substantially helps smaller open-weight backbones while providing no measurable gain on a frontier model.

Summary of scope and limitations.

  • Not a leaderboard claim. CAST is a runtime state-and-contract component added to a fixed base agent, and we do not present it as a competitor to search-based or fine-tuned systems.
  • Main finding. The state is computed by code, with no separate model call to produce it, and the empirical benefit is concentrated on smaller open-weight models rather than frontier models.
  • Limitation. Table 1 reports one evaluation per condition, so multi-seed run-to-run variance is not yet measured; we will state this explicitly.

We will revise the abstract, Section 1, and Section 6.1 to state this capability-dependent claim, report the intervals and paired statistics above, and describe the base agent in full.


AuthorsOpenReview ↗

Response to Reviewer oNhQ (2/3): w2 / w3


w2: A state that records past errors, remaining budget, and attempted actions is not novel enough. This is an incremental improvement to the baseline agent.

R w2: Thank you for the candid assessment. We agree that the individual signals are standard, and we will not present counters, memory, or loop detection as new ideas. The contribution we propose is their explicit division between a code-maintained state and instructions to the policy.

Relation to prior loop-handling mechanisms. While the original WebArena harness terminates an episode after three repeated actions, CAST instead informs the policy which action class had no effect and allows the episode to continue. Concurrent work on desktop agents, VLAA-GUI (Han et al., 2026), also targets premature stops and loops using an agent-level verifier and a reflection-based loop breaker.

What we claim.

  1. Division of labor. Code maintains a bounded record of cross-step facts: whether an action produced an error, whether the page changed, how often an action class repeated without effect. Each value is traceable to an update rule, and the policy still does the language interpretation and the action choice. Belief-state agents such as ABBEL (Lidayan et al., 2025) and PABU (Jiang et al., 2026) instead have the model write and update its own state.
  2. State paired with a contract. The rule against repeating an action three times without a page change needs both a count and a comparison of consecutive pages. In our setting earlier pages are absent from the prompt, so the action history alone cannot establish that condition. The state supplies it, and the contract tells the policy what to avoid.
  3. Empirical boundary. On all 812 tasks, adding this code-maintained state and contract lifts gpt-oss-20b from 14.7% to 25.6% (matching GTTA's 25.0% without an offline exploration corpus), while having no measurable effect on GPT-5.4.

Scope of the ablation evidence. Section 6.3 reports component ablations on a 53-task subset, where the total spread is small (30 to 33 tasks). At full-benchmark scale, Figure 5 shows where outcomes move on gpt-oss-20b: episodes that end with a stop and no reward fall from 578 to 402 of 812, while truncated episodes rise from 124 to 201 and successes from 110 to 204. This does not separate state from contract, which the full-benchmark variants in progress (state-only, contract-only, model-written memory, and raw observation diff) will test; we state the absence of completed full-benchmark ablations against those alternatives as a limitation.


w3: The paper would benefit from comparison with more, and more recent, WebArena baselines with comparable model backbones.

R w3: Thank you for this suggestion. We agree that comparison with GTTA alone does not establish an advantage over recent agent designs. We will expand the comparison and keep published results separate from matched evaluations.

Published results for context. They use different backbones and protocols and are not our reproductions.

MethodBackboneAdditional resourceSuccess (%)
StePGPT-4-turbohuman-written policy library33.5
AWMGPT-4workflows induced from earlier tasks35.5
WebPilotGPT-4oMCTS37.2
AgentOccamGPT-4-turbonone (base version, without the judge)43.1
WebOperatorGPT-4otree search, search-step budget 2054.6
Go-BrowseQwen2.5-7Bfine-tuning21.7
AgentTrekQwen2.5-32Bfine-tuning22.4
Learn-by-InteractCodestral-22Btraining24.2
TTIGemma 3 12Bonline RL26.1
A3Qwen3.5-9Bfine-tuning41.5
WebChallenger32B LLM + 7B VLMsite exploration, several calls per step56.3

AgentOccam is the most relevant, because it also changes what the policy observes. AWM tests a different use of memory: workflows reused across tasks, where CAST computes a fixed set of signals within one trajectory. These are differences in mechanism, and they do not establish a performance advantage for CAST.

Matched comparisons. We do not yet have a completed AgentOccam run with gpt-oss-20b, or a completed baseline and CAST comparison on a recent open backbone such as Qwen3.5-9B. Your request for broader matched-baseline evidence remains a limitation of the current evaluation, and we will state it as such.

We will state the contribution as above in Section 1, and add this table with the discussion of the WebArena harness rule, VLAA-GUI, ABBEL, PABU, AgentOccam, and AWM to Section 2.


AuthorsOpenReview ↗

Response to Reviewer oNhQ (3/3): w4 / q1 / q2


w4: To show generalizability, results on other web agentic benchmarks would help, such as OSWorld-V2, BrowseComp, WebBench, or GAIA.

R w4: We agree: the current evidence is limited to WebArena. Its navigation, information-retrieval, and form-filling tasks cover several settings within one benchmark, but this is not a substitute for a second benchmark. A cross-benchmark evaluation is not complete, so we do not report evidence of transfer.

How the listed benchmarks relate to the method as it stands.

BenchmarkRelation to CAST
OSWorld-V2desktop control from screenshots; it needs a different base agent, and CAST's action-effect rules read URL and page-text changes
BrowseComp, GAIAsearch-and-answer and general-assistant tasks; the failures CAST targets (repeating an action that has no effect, stopping without visible evidence) are less central there
WebBenchtasks on live websites, where results vary across runs

Among the method papers we compare with, some evaluate only on WebArena (such as AgentOccam), and others add one of WebVoyager, Mind2Web, MiniWoB++, or WorkArena. A second benchmark of that kind, with the same browser interface and a different site, is the natural next step. We will state the limitation in the main text and make no claim of demonstrated generalization to desktop-control or search-and-answer benchmarks.

q1: Which models do Figures 1 and 2 use?

R q1: Both figures use Qwen2.5-14B-Instruct with greedy decoding (temperature 0). This is specified in Appendices B.1 and B.2, and we apologize that the captions did not say so; we will add the model and the decoding setting to both captions. Details of the Figure 1 probe are in our response to Reviewer 9f4i (1/2).

q2: Will the approach require a complete rewrite for other web navigation benchmarks or other base agents?

R q2: No. The separation between state update and policy can be reused, but the interface and the environment-dependent rules need adaptation. We will replace the implication that changing a lexicon is always sufficient with this breakdown.

ComponentWhat is reusableWhat may need adaptation
Error, repeat, and action-effect trackingcounting and comparison logicmapping the host's actions, observations, errors, and page identity into those signals
Step budgetremaining-step calculationthe host's step counter and termination convention
Completion and absence evidencerecording observed evidence or an unknown valuetask-type rules, completion and absence phrases, and checks specific to the new interface
Contractlinking state values to instructions for the next actionaction syntax, answer format, and stop conventions; strings such as "N/A" are not universal

For another web-agent framework, integration needs access to each action and its resulting observation, error information, and page identity, and a place to insert the state and contract into the policy prompt. A framework that already maintains these signals can reuse its own bookkeeping. For desktop environments, URL-based checks need an alternative, and action classes may need remapping.

This supports a modular implementation. It is not a claim that every new environment needs only a few changed lines, and we do not yet have a completed transfer evaluation to show how well an adapted agent performs.

We will clarify these dependencies in Section 4 and in the limitations. Thank you again for the concrete suggestions.


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

CAST augments long-horizon web agents with a compact, deterministically updated runtime state alongside the interaction history. The policy reads the current observation, history, state, and a fixed behavioral contract, retaining one model call per step. On all 812 WebArena tasks with a 30-step budget, it reports success-rate gains across three backbones. Gains for Qwen2.5-14B-Instruct, GPT-5.4, and GPT-OSS-20B are 4.6, 0.6, and 10.9 percentage points, respectively. Targeted perturbations and component ablations further assess the combined design.

Critical strengths
  1. Separating computable bookkeeping from language-based judgment is a clear and inspectable implementation contribution. Sections 4.2–4.4 explain how deterministic rules update state from errors, URL/observation changes, repeated actions, and remaining budget. One schema, rule set, and manually specified lexicon serve all six websites. The fixed behavioral contract turns these state values into actionable constraints without adding per-step model calls.

  2. The 10.9 percentage-point gain for GPT-OSS-20B on the complete benchmark is practically useful. Table 1 reports an increase from 14.7% to 25.6% across 812 tasks, close to GTTA's reported 25.0%. CAST achieves this without GTTA's offline exploration corpus, supporting the practical value of its comparatively simple runtime design.

Critical weaknesses
  1. The pure positional interpretation of Figure 1 needs a clearer distinction between evidence placement and answer explicitness. Recovery after adding a compact state block supports changing evidence presentation, but does not by itself separate placement from concentration or preprocessing of the answer evidence. Please clarify this distinction when interpreting Section 3.2. Table 1 and Figure 6 still support the empirical value of the combined design.

  2. Figure 4's three 24-task comparisons would be easier to audit with a compact record of the backbone, task IDs, and actual fault-injection rates. These configuration details would connect the reported gains to the evaluated settings. This is a reporting clarification rather than an established experimental error or an independent rejection criterion.

Questions for authors
  1. For Figure 1, please provide one representative set of the five prompts and mark the source of the answer-relevant facts in each. Are those facts equally explicit in SC, LC, SD, LD, and LD+S, or does constructing the compact state also perform semantic condensation or inference? Please use the example to clarify which changes the positional interpretation is intended to isolate.

  2. Please provide the backbone, task IDs, and fault-injection rates for Figure 4's three groups of 24 tasks. Briefly describe how the subsets were selected and when the rules and lexicon were finalized relative to debugging and final evaluation. This is the same configuration clarification as weakness 2; it does not presume contamination or request a new large-scale experiment.

3 comments
AuthorsOpenReview ↗

Response to Reviewer 9f4i (1/2): w1 / q1

Thank you for the careful and constructive review. We appreciate your recognition of the inspectable bookkeeping/judgment separation and the practical value of the full-benchmark gain on gpt-oss-20b.


w1 / q1: Figure 1's positional reading does not separate evidence placement from explicitness. Are the facts equally explicit in the five conditions, and what is the reading meant to isolate?

R w1 / q1: Thank you for this question; your reading is right: the facts are not equally explicit. SC and LD+S contain the resolved answer; LC places a summary sentence with that value before the history, and SD splits the value across three short snippets with near-miss distractors. LD contains failed-baseline URLs, actions, and page observations truncated to 650 characters each. For the items LD fails on, this history lacks sufficient evidence for the complete answer. The constructor copies the final answer of a separate successful run, rather than inferring it from LD. These contrasts change evidence availability and presentation together with placement.

One example. Item 208_v0: question "Find the customer name and email with phone number +1 2058812302", reference answer "John Smith, [email protected]".

ConditionAnswer-relevant fact in the promptSourcePosition
SC (short, concentrated)final_answer: John Smith, [email protected]successful-run final answershort prompt, near prediction
LC (long, concentrated-but-far)The decisive observed page value was: John Smith, [email protected]; distractor: John Smith, [email protected]summary line written from the successful-run final answerbefore 3 actions and 4 observation records
SD (short, distributed)John Smith, john.smith.xyz, @gmail.com; 4 occurrences of John Smith, [email protected] as distractorssuccessful-run final answer split into three pieces, with near-miss distractorsinterleaved in a short prompt
LD (long, distributed)navigation, clicks and parsing error; no customer record linking the phone to a name/emailfailed-baseline URLs, actions and truncated observationsthroughout the history
LD+S (long with state)final_answer: John Smith, [email protected], with an instruction to override the historysuccessful-run final answerafter LD, near prediction

Figure 1 is a diagnostic probe (Appendix B.1) and should be read as an upper bound; we apologize that Section 3.2 did not say so. The block tests whether an already resolved target value can be used near prediction. The deployed CAST state (Table 2) has no final_answer field; its update code tracks only trajectory and environment signals.

A comparison that changes only position. We also ran a comparison with no final_answer field in any condition. Within a row, the two prompts contain the same evidence verbatim and have the same total length; only its position changes (31 tasks, Qwen2.5-14B-Instruct, greedy decoding, scoring rule fixed before running).

Evidence formFarNearNet change in correct answers
Raw page evidence23/31 (74.2%)25/31 (80.6%)+2 items
Distilled facts25/31 (80.6%)26/31 (83.9%)+1 item

"Far" places evidence before fixed background observations; "Near" places it immediately before the final question. The table uses strict full-answer scoring.

Takeaways from the comparison.

  • Net differences are small in this panel. LC gives 88.9% with the resolved answer stated before the history. In the new comparison, the raw-evidence row has 4 improvements and 2 regressions; the distilled row has 2 and 1. A post-hoc content check gives net differences of 1 and 0. These counts do not establish a general upper bound on position effects.
  • The large drops coincide with answer fragments among distractors or missing facts. SD gives 48.1%; LD gives 11.1% with truncated failed history. Missing facts in LD cannot be attributed to forgetting: these prompts do not establish that the baseline previously obtained them.

We fully agree with you that the evidence for the combined design is the end-to-end evaluation. We will revise Section 3.2 to distinguish missing, scattered, and distant evidence, remove the statement that performance degrades "solely due to spatial layout", add the comparison above, and add the full example prompts as Appendix B.3. Thank you for helping us clarify this.


AuthorsOpenReview ↗

Response to Reviewer 9f4i (2/2): w2 / q2


w2 / q2: Figure 4's three 24-task comparisons need a compact record: the backbone, the task IDs, the actual fault-injection rates, how the subsets were selected, and when the rules and lexicon were finalized relative to debugging and final evaluation.

R w2 / q2: Thank you for asking for this record, and we apologize that it was missing. The backbone is gpt-oss-20b. No fault was injected: the three groups are subsets of unmodified WebArena tasks, selected by fixed rules from existing baseline and CAST runs, as Section 6.2 states. Appendix C described an intervention-based design that we had planned but did not run for Figure 4. Its description was wrong, and we apologize for this error. The rules and lexicon were developed iteratively on WebArena from baseline failure patterns; the timeline is below.

Configuration.

ItemRecord
Backbonegpt-oss-20b, baseline and CAST
Task pool641 tasks with complete, format-clean baseline/CAST trajectory pairs in the run snapshot
Group 1 (24 tasks)single-site tasks whose instruction or task pattern matches value-lookup keywords (price, quantity, status, and similar)
Group 2 (24 tasks)baseline terminal status ERROR/TRUNCATED or at least 25 steps; additionally, write/search/navigation keywords or an evaluator other than pure string_match
Group 3 (24 tasks)the task's evaluator includes program_html
Fault injectionnone; an injection rate is not applicable
Observed action-error feedbackBaseline only: Group 1, 23/128 (17.97%); Group 2, 123/576 (21.35%); Group 3, 13/182 (7.14%). Numerator: post-action observations with nonempty last_action_error; denominator: recorded baseline action steps. Separately logged terminal exceptions are not included in this feedback field.
Task IDs72 group entries, 69 distinct tasks (31, 555 and 560 occur in two groups). Group 1: 132, 133, 134, 135, 136, 32, 33, 34, 35, 70, 27, 28, 29, 30, 31, 21, 22, 23, 24, 25, 0, 1, 2, 3. Group 2: 106, 182, 398, 412, 416, 555, 560, 31, 69, 595, 596, 597, 118, 238, 274, 275, 276, 243, 455, 456, 459, 460, 417, 419. Group 3: 389, 392, 394, 395, 396, 552, 553, 554, 555, 562, 556, 557, 558, 560, 561, 356, 369, 370, 372, 373, 399, 400, 401, 402

Selection was deterministic: Group 1 prioritized string_match candidates then sorted by site and task ID, Groups 2 and 3 sorted by site and task ID, and each group used a first pass capped at five tasks per site followed, if needed, by an uncapped pass in the same order until 24 tasks were selected. The groups are defined only by the rules above. The script does not check whether page facts changed between episodes, and it does not detect no-progress windows.

Timeline of rules and lexicon. WebArena has no separate development split. The rules and lexicon were developed iteratively from baseline failure trajectories and diagnostic subsets, and were also checked on full-benchmark runs before the final configuration was fixed; the update code has no task-ID or URL branches.

Summary and planned revisions. Figure 4 compares the baseline and CAST on three task subsets selected by fixed rules from existing runs, with recorded action-error feedback at the rates above; it is not a synthetic perturbation study and does not test robustness to environment shifts. We will name the groups by their selection rules, drop the terms "latent shift", "execution noise", and "structural shift", rewrite Appendix C with the selection rules, exclusion criteria, and task IDs above, align Section 6.2 with them, and state the development timeline in the paper. Thank you again for asking for this record; it led us to find and correct the error in Appendix C.


Thank you for your response, but after reading it carefully, I have decided to keep my score as is.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.