acceptodds
Under review as a conference paper at ICLR 2027

WebCoder: Scaling General Frontend Development with Artifact-Grounded Agentic Reinforcement Learning

Abstract

Real-world frontend development requires agents to compose reproduction, generation, modification, and repair over an evolving application state. Learning a general policy for this process requires translating heterogeneous execution feedback into task-aligned rewards and effective credit assignment across long sequences of interdependent actions. We introduce **WebCoder**, a general frontend development agent trained with artifact-grounded agentic reinforcement learning. Our key idea is to assess diverse development activities through their effects on a shared executable artifact and its satisfaction of task requirements. We build Webdev-World, an executable environment that integrates code editing, application execution, browser inspection, and on-demand skills while preserving project state across interactions. An independent verifier evaluates the final application against task requirements to provide terminal rewards, while changes in intermediate artifact progress redistribute the resulting rollout advantage across development segments. Context compaction and message-tree sample construction support training on trajectories beyond a single context window while avoiding repeated loss computation on shared generated history. We further introduce Webdev-Bench to evaluate composed development requirements within a single project. On Webdev-Bench, WebCoder-27B raises requirement satisfaction from 64.8 for its Qwen3.8-27B base model to 72.8, exceeding Claude-Opus-4.8 (65.1) and GPT-5.4 (59.6); on Vision2Web, it improves the average visual and functional score from 41.1 to 62.4, on par with Claude-Opus-4.8. Ablation studies confirm the contributions of artifact-grounded credit assignment and long-horizon training.

Primary area:
foundation or frontier models, including LLMs
Keywords:
Agentic Reinforcement Learning, Multimodal Coding Agent, Frontend Development, Long-Horizon Credit Assignment

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_4aQbOpenReview ↗
Rating
2(+1)
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper presents WebCoder, a frontend development agent trained with artifact-grounded reinforcement learning in an executable environment called Webdev-World. The method combines terminal artifact verification, progress-based credit assignment, context compaction, and message-tree training to support long development trajectories. WebCoder-27B improves over its Qwen3.8-27B base model on Webdev-Bench and Vision2Web, with particularly large reported gains in functional and interaction scores.

Critical strengths
  1. The paper addresses a meaningful limitation of prior screenshot-to-code work by treating frontend development as a persistent, multi-round process involving generation, modification, debugging, and preservation of existing behavior.
  2. The experimental section includes comparisons with many proprietary and open-source systems, and examples of both successful and failed applications.
Critical weaknesses
  1. The reward is not sufficiently aligned with dynamic frontend functionality. The training reward mainly combines deterministic DOM-based checks with VLM judgments of static screenshots. Table 2 explicitly states that interactions are not executed, meaning that buttons, filters, forms, navigation links, or state transitions may appear visually complete while being nonfunctional. This mismatch is especially concerning because functional and interaction performance is a central claim of the paper.
  2. The paper does not clearly explain why RL produces the reported improvements. The current ablations demonstrate the usefulness of context compaction and artifact-grounded credit assignment within the proposed framework, but they do not isolate the contribution of RL itself. Compute-matched comparisons with SFT, rejection sampling, or other non-RL alternatives are missing. Moreover, the case studies focus mostly on final outcomes rather than showing how reward signals and intermediate credit assignment change the model's behavior during development.
  3. The empirical validation remains limited. WebCoder is trained only from Qwen3.8-27B, so it is unclear whether the proposed method generalizes across model families and scales. Evaluating other models as inference-only baselines does not address this concern. In addition, the human evaluation is based on screenshots rather than direct operation of the applications, making it insufficient for independently validating interaction-heavy claims.
Questions for authors
  1. Why does the training verifier not execute required interactions, and how well does the current reward correlate with independently executed functional tests?
  2. Can the authors provide trajectory-level case studies showing how RL and intermediate credit assignment improve specific behaviors, together with compute-matched SFT or rejection-sampling baselines?
  3. Does the method remain effective when applied to another base model family or model scale?
6 comments
AuthorsOpenReview ↗

Author Response (Part 1)

We thank Reviewer 4aQb for the thorough and constructive review. Below we provide our detailed responses to the reviewer's comments.


W1: The reward is not sufficiently aligned with dynamic frontend functionality. The training reward mainly combines deterministic DOM-based checks with VLM judgments of static screenshots. Table 2 explicitly states that interactions are not executed, meaning that buttons, filters, forms, navigation links, or state transitions may appear visually complete while being nonfunctional. This mismatch is especially concerning because functional and interaction performance is a central claim of the paper.

Q1: (1) Why does the training verifier not execute required interactions, and (2) how well does the current reward correlate with independently executed functional tests?

We thank the reviewer for the insightful comments. We first clarify a key distinction: all of the paper's conclusions about functional and interaction performance come from independent evaluations that actually execute interactions; the training reward is only an optimization signal inside the training loop. The Webdev-Bench IS (90.8 versus 79.8 for the base model) is graded by an acceptance agent that actually operates the applications in a browser, item by item (Appendix B.2.3), and the Vision2Web FS (67.1 versus 45.7) comes from functional tests executed with playwright by the benchmark's evaluator (Appendix B.1). Regarding Q1-(1), using a low-cost artifact signal for the training reward is an efficiency-driven design choice, detailed below. Regarding Q1-(2), our new consistency experiment shows that the terminal training reward correlates strongly with independently executed acceptance scores (Spearman ρ = 0.782, Table 1).

Regarding Q1-(1): why the training verifier does not execute interactions.

  1. We are well aware that agent-executed functional checking is the most direct measure of interactive behavior, and this is exactly how all results reported in the paper are obtained: the Webdev-Bench acceptance agent and the Vision2Web functional tests both operate the running application. Inside the training loop, however, it is costly: an agent-executed check takes a median of 2.0 minutes per artifact, versus 5.6 seconds for the terminal reward measurement (Table 2), and every training step scores the terminal artifacts of all rollouts.
  2. The low-cost reward stays strongly correlated with execution-based checks at about 1/21 of the cost. The terminal reward correlates strongly with independently executed acceptance scores (Spearman ρ = 0.782, Pearson r = 0.881, Table 1). Since the reward enters GRPO through group normalization (Eq. 7), where its role is to rank rollouts within a task group, a strong rank correlation is the property that matters.
  3. This trade-off matters more at scale. Reward measurement cost grows linearly with the number of rollouts, so a 21× cheaper verifier directly determines how far training can scale to larger models and more data.

Regarding Q1-(2): correlation between the terminal reward and independently executed functional tests.

We randomly sample 120 artifacts from training. For each artifact, the source code is placed into a fresh container, dependencies are installed, and the project is built with Vite; an independent acceptance agent (Codex + GPT-6-Astra), which has no access to the training reward, then checks every task requirement in a browser. Each requirement is decomposed into several sub-checks, an acceptance score is computed as the fraction of sub-checks passed, and this score is paired with the artifact's terminal training reward.

Table 1. Correlation between the terminal training reward and independently executed acceptance scores.

Spearman ρPearson r
0.7820.881

Table 2. Measurement cost of the two procedures.

MeasurementMedian timeMean time
Terminal reward (build + screenshot + VLM scoring)5.6 s6.8 s
Independent acceptance agent (build + browser operation)2.0 min2.0 min

In addition, the intermediate potential signals used during training are validated in the same way: over 421 randomly sampled pairs of adjacent project states from training trajectories, the direction of potential changes agrees with independent execution-based checks at Cohen's κ = 0.856 (the full cross-tabulation and analysis are provided in our response to Reviewer 4Ab4's Q1 and are not repeated here).

AuthorsOpenReview ↗

Author Response (Part 2)

W2: The paper does not clearly explain why RL produces the reported improvements. The current ablations demonstrate the usefulness of context compaction and artifact-grounded credit assignment within the proposed framework, but they do not isolate the contribution of RL itself. (1) Compute-matched comparisons with SFT, rejection sampling, or other non-RL alternatives are missing. (2) Moreover, the case studies focus mostly on final outcomes rather than showing how reward signals and intermediate credit assignment change the model's behavior during development.

Q2: Can the authors provide (1) trajectory-level case studies showing how RL and intermediate credit assignment improve specific behaviors, together with (2) compute-matched SFT or rejection-sampling baselines?

We thank the reviewer for the insightful comments. We add two sets of analyses: (1) a training-paradigm comparison with SFT and RFT (responding to W2-(1) and Q2-(2), with closely matched training-trajectory scale; WebCoder's Avg is 11.7 and 11.1 points higher, respectively); (2) an analysis of how reward and credit assignment affect development behavior (responding to W2-(2) and Q2-(1), from three angles: a post-training same-task behavioral comparison, a per-segment credit case study on a training trajectory, and behavioral changes over the course of training).

(1) Comparison with SFT and RFT (responding to W2-(1), Q2-(2))

Setup. All three methods are initialized from Qwen3.8-27B. SFT performs supervised training on existing development trajectories; RFT filters candidate trajectories with the same reward system as WebCoder's RL and then performs supervised training; WebCoder optimizes with GRPO on its own rollouts. The training-trajectory scales are closely matched: SFT and RFT use about 3.8k and 3.6k trajectories respectively, and WebCoder's training samples about 3.7k rollouts.

Table 3. SFT / RFT / WebCoder on Vision2Web L2.

MethodTraining paradigmEffective loss tokensVSFSAvg
SFTSupervised training on existing trajectories337M45.755.650.7
RFTSupervised training on trajectories filtered by the RL reward system315M44.158.451.3
WebCoderOwn rollouts + GRPO291M57.767.162.4

Results. WebCoder's average score is 11.7 and 11.1 points higher than SFT and RFT, respectively; RFT improves the functional score by 2.8 points over SFT. Under comparable scales of training trajectories and effective loss tokens (with WebCoder using the fewest loss tokens, 291M), neither imitating existing development trajectories nor supervised training on trajectories filtered by the same reward system reaches the performance of WebCoder's RL recipe, providing comparative evidence for adopting RL for iterative policy optimization.

(2) How reward and credit assignment affect development behavior (responding to W2-(2), Q2-(1))

WebCoder first completes a development trajectory; the terminal reward is then computed from the final artifact, and the intermediate artifact potentials assign advantages to the development segments. These signals act on subsequent policy updates rather than instantly changing behavior within the same trajectory. We therefore analyze their effect on behavior from three angles.

1. Post-training same-task behavioral comparison. On the same set of 66 Vision2Web L2 tasks, we compare the development behavior of the full WebCoder with the variant trained without artifact-grounded credit assignment (A1). The follow-up modification rate after failed checks is the fraction of failed checks that are followed, within the same observation chain and before the next check, by at least one project-modifying call.

Table 4. Development behavior of the full WebCoder versus A1 on the same tasks.

MetricFull WebCoderw/o credit assignment (A1)
Follow-up modification rate after failed checks100%70%
Rate of passing the next check after a post-failure modification100%83.3%
Final scores VS / FS / Avg57.7 / 67.1 / 62.446.7 / 58.4 / 52.6

The model trained with artifact-grounded credit assignment follows up on failed checks with modifications more consistently, and its modifications more often pass the next check, corresponding to the 9.8-point gap in final scores: the credit-assignment training changes observable development behavior.

2. A per-segment credit case study on a training trajectory. We select a training trajectory of a long-screenshot replication task, independently render the project states at several segment boundaries, and replay the potentials (the reference page height is about 6,743px).

AuthorsOpenReview ↗

Author Response (Part 3)

Table 5. Per-segment development behavior, replayed potentials, and independently rendered states of one replication trajectory.

SegmentDevelopment behavior and project stateReplayed potential Φ\PhiIndependent render: text characters / page height
0Reads the reference image, plans, and writes notes; the page is still an empty shell0.04827 chars / 18px
1Writes the application source files; the page is not yet wired up0.18627 chars / 18px
2Continues writing and completes the wiring; checks with webshot0.6012,451 chars / 6,401px
3–8Iterative fine-tuning0.601—
9Continues editing and checks the page0.6122,862 chars / 7,181px
10–19Continues checking and polishing0.612final 2,862 chars / 6,804px

The potential tracks artifact progress by development stage: it rises slightly while the source files are being written (0.048 → 0.186), rises sharply once the wiring is completed and the page renders real content (0.186 → 0.601), changes marginally during the polishing phase, and the final page height converges close to the reference (6,804px versus 6,743px). The large jumps of the potential align with independently verifiable rendering milestones, supporting the design of constructing process signals from artifact states and assigning segment-level credit from progress changes.

3. Behavioral changes over the course of training. Appendix F analyzes training-time behavior based on 1,556 rollouts from Stage 1; here we add the follow-up modification rate after failed checks (defined as above).

Table 6. Development-behavior changes over training (Early / Trough / Recovery).

MetricEarlyTroughRecovery
Redundant-operation rate0.24%2.45%0.86%
Observed skill invocation rate24.1%15.7%20.8%
Observed webshot invocation rate79.8%66.9%78.7%
Follow-up modification rate after failed checks72.5%66.7%80.0%

During the reward trough, redundant operations increase, skill and webshot invocations decrease, and the follow-up modification rate after failed checks also drops; during the reward recovery, all behavioral metrics improve together, while the evaluation score on the fixed anchor set rises from 0.346 to 0.575 over the same period (Figure 4). Reward changes are accompanied by changes in the agent's development behavior, constituting process-level evidence that the reward signal acts on development behavior.

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

This paper introduces WebCoder, a frontend development agent trained with artifact-grounded reinforcement learning. The framework combines an executable development environment, requirement-based rewards, progress-based credit assignment, and long-horizon training through context compaction and message-tree sample construction. The authors also introduce Webdev-Bench to evaluate multi-stage frontend development. Experiments demonstrate substantial improvements over the base model and competitive performance against strong proprietary models.

Critical strengths

S1. Meaningful problem formulation and a well-designed framework. The paper addresses the practical challenge of combining frontend generation, modification, and repair within a persistent application state. The proposed artifact-grounded RL framework is well motivated and technically coherent.

S2. Strong empirical results and comprehensive evaluation. WebCoder demonstrates substantial improvements over its base model and competitive performance against strong proprietary models. The introduction of Webdev-Bench, together with ablation studies, verifier analyses, and case studies, further strengthens the contribution.

Critical weaknesses

W1. Limited evidence of improvements in modification and repair capabilities. Although the paper targets general frontend development, the improvements mainly come from generation and reproduction tasks. On Brownfield tasks, WebCoder achieves the same requirement satisfaction score as the base model (89.1), leaving its effectiveness for modification and repair less clear.

W2. Insufficient isolation of methodological contributions. While the ablation studies support the effectiveness of the proposed components, comparisons with alternative credit-assignment and long-horizon training strategies remain limited. More controlled experiments would help clarify the specific contributions of the proposed mechanisms.

Questions for authors

Q1. Why does WebCoder show no improvement over the base model on Brownfield tasks? Could the authors provide more detailed results on modification and defect-repair tasks?

Q2. How well do the intermediate artifact potentials correlate with actual functional correctness and interaction success?

Q3. Could the authors compare the proposed credit-assignment mechanism with alternative process-reward or advantage-assignment strategies?

Q4. Could the authors provide more controlled ablations of context compaction and message-tree sample construction under comparable training budgets?

6 comments
AuthorsOpenReview ↗

Author Response (Part 1)

We thank Reviewer SQBA for the positive and constructive feedback. Below we provide our detailed responses to the reviewer's comments.


W1: Limited evidence of improvements in modification and repair capabilities. Although the paper targets general frontend development, the improvements mainly come from generation and reproduction tasks. On Brownfield tasks, WebCoder achieves the same requirement satisfaction score as the base model (89.1), leaving its effectiveness for modification and repair less clear.

Q1: (1) Why does WebCoder show no improvement over the base model on Brownfield tasks? (2) Could the authors provide more detailed results on modification and defect-repair tasks?

We thank the reviewer for the insightful comments. Regarding Q1-(1), the RS of Webdev-Bench uses a deliberately strict, binary per-requirement conjunctive rule: a requirement counts as satisfied only if all of its checklist items reach the top grade (Eq. 10, Appendix B.2.3). Identical RS values can therefore correspond to different item-level completion quality. To resolve this difference, we conducted a fine-grained, item-level blind audit of the Brownfield deliverables. Regarding Q1-(2), the audit results (Table 1) show that WebCoder's overall strict pass rate is 10.4 percentage points above the base model, and 16.0 percentage points higher on repair requirement items.

Audit setup. The audit covers 11 Brownfield tasks and evaluates the 22 existing deliverables of the base model and WebCoder. All deliverables are anonymized and presented in random order to an independent acceptance agent. The agent operates each application in a browser and provides verifiable evidence for every checklist item; repair items are retested by triggering the original defect and checking whether neighboring functionality is broken; interactions such as lists, filters, and search additionally undergo boundary tests (empty states, exhaustive operations, and resets). Grading uses a 0–4 scale, and grade 3 or above counts as a strict pass. This audit is a supplementary item-level analysis in addition to the original requirement-level RS.

Table 1. Item-level blind audit of the base model and WebCoder on Brownfield tasks.

Scope#ItemsBase avg. gradeWebCoder avg. gradeBase strict pass rateWebCoder strict pass rate
All tasks2862.452.6959.4%70.6%
All items in tasks with pre-injected defects2322.452.6958.6%71.1%
Repair requirement items452.562.8773.3%91.1%
Non-repair requirement items2412.432.6656.8%66.8%

Results.

  1. Repair capability. On repair requirement items, the strict pass rate is 91.1% versus 73.3% (+17.8 percentage points), with average grade 2.87 versus 2.56: under retesting that triggers the original defect and checks neighboring functionality, WebCoder's defect-repair quality is clearly higher.
  2. Modification capability. On non-repair requirement items (checklist items of modification-type requirements such as layout restructuring, re-theming, and data wiring), the strict pass rate is 66.8% versus 56.8% (+10.0 percentage points). Both requirement types benefit, and the gap is larger on repair items.
  3. Per-task and boundary behavior. In per-task comparisons, WebCoder leads on 8 of the 11 tasks, ties on 1, and trails on 2; the pass rate on the supplementary boundary tests (empty states, exhaustive operations, resets) is 76.9% versus 70.6%.
  4. Relation to the requirement-level RS (responding to "why the same RS" in Q1-(1)). Under the conjunctive rule, a requirement counts as 0 whenever any of its checklist items falls short of the top grade, no matter how much of the rest is completed (Eq. 10). For example, for a requirement with 5 checklist items, passing 3 items and passing 4 items both count as 0 in RS. Identical RS values (89.1) therefore only indicate that the two models fully satisfy the same number of requirements, and do not reflect the completion quality inside unsatisfied requirements. The item-level audit directly measures the information folded away by the binary scoring: at item granularity, WebCoder's strict pass rate is 11.2 percentage points higher overall and 17.8 percentage points higher on repair items, i.e., its quality advantage in modification and repair lies at a granularity that the requirement-level RS cannot resolve.
AuthorsOpenReview ↗

Author Response (Part 2)

Q2: How well do the intermediate artifact potentials correlate with actual functional correctness and interaction success?

We thank the reviewer for the question. We conducted a consistency experiment between changes in the intermediate potentials and independent execution-based checks: over 421 pairs of adjacent project states, the direction of potential changes agrees closely with the independent execution-based checks (Cohen's κ = 0.856, Table 2).

Setup. We randomly sample 421 pairs of adjacent project states from existing training trajectories, delimited by compaction boundaries exactly as in deployment. For each pair we compute the change in the intermediate potential ΔΦ\Delta\Phi, and an independent execution-based checking agent (Codex + GPT-6-Astra) builds and actually operates the applications at both states in containers, checking the same set of functional and interaction requirements to obtain the change in the functional pass rate ΔF\Delta F. The check uses a model family different from the training reward, has no access to the potential values, and actually executes interactions instead of relying on screenshots.

Table 2. Cross-tabulation of potential changes ΔΦ\Delta\Phi against functional pass-rate changes ΔF\Delta F from independent execution-based checks.

ΔΦ\Delta\Phi \ ΔF\Delta FFF increasesFF unchangedFF decreasesTotal
Φ\Phi increases824288
Φ\Phi unchanged93143326
Φ\Phi decreases1337
Total923218421

Results. Among the 100 pairs where the functional pass rate actually changes, the potential moves in the same direction in 85 pairs (85.0%); over all 421 pairs, the overall agreement is 94.8% (399/421), and Cohen's κ after chance correction is 0.856. Among the 92 pairs with functional improvement, the potential rises in 82 (recall 89.1%). In addition, the token-weighted centering of Eq. (6) makes the potential offsets zero-sum within each trajectory: it preserves the trajectory-level average advantage and leaves the terminal-reward-based group statistics unchanged, so potential estimation errors affect only how credit is divided among the segments of the same trajectory.

AuthorsOpenReview ↗

Author Response (Part 3)

W2: Insufficient isolation of methodological contributions. While the ablation studies support the effectiveness of the proposed components, comparisons with alternative credit-assignment and long-horizon training strategies remain limited. More controlled experiments would help clarify the specific contributions of the proposed mechanisms.

Q3: Could the authors compare the proposed credit-assignment mechanism with alternative process-reward or advantage-assignment strategies?

Q4: Could the authors provide more controlled ablations of context compaction and message-tree sample construction under comparable training budgets?

We thank the reviewer for the insightful comments. We separate the contributions of the mechanisms through three controlled comparisons: (1) a comparison between our credit-assignment mechanism and alternative advantage-assignment strategies (responding to Q3, including an end-to-end training comparison and a credit-alignment analysis on fixed trajectories); (2) a message-tree control with the effective training-token scale aligned (responding to Q4); (3) a context-compaction strategy comparison with sample construction and credit assignment fixed (responding to Q4).

(1) Comparison with alternative credit-assignment strategies (responding to Q3)

End-to-end training comparison: uniform broadcast. Broadcasting the rollout-level GRPO advantage equally to all segments is the most common advantage-assignment strategy in long-horizon agent RL. The w/o Artifact-Grounded Credit Assignment ablation in the main paper is exactly a controlled implementation of this alternative: everything except the advantage assignment (sample construction, terminal rewards, hyperparameters) is identical. The end-to-end results are Vision2Web Avg 62.4 versus 52.6 and Webdev-Bench RS 72.8 versus 64.5, and the gaps are the net contribution of segment-level credit assignment over uniform broadcast.

Credit-alignment analysis on fixed trajectories. To compare more alternatives on the same set of real training trajectories, we fix the development process and artifact states, and directly analyze the relationship between the segment-level credit produced by each scheme and independent functional acceptance results. Three schemes are compared:

  1. Terminal advantage broadcast: all segments use the same trajectory-level advantage, with no segment adjustment;
  2. Local potential change: the segment adjustment is computed from the segment's own ΔΦk\Delta\Phi_k only, with the same token-weighted centering and clipping;
  3. Ours: the segment adjustment is computed from the discounted return of potential differences, with the same centering and clipping.

An independent acceptance agent (Codex + GPT-6-Astra) functionally checks the application before and after each segment to obtain the increment in the functional pass rate. Using the discounted cumulative value of subsequent functional increments as the common reference, we report three metrics: Top-1 hit rate (whether the segment with the highest credit is the one with the largest future functional gain), cosine similarity (directional agreement between the segment-credit vector and the future-functional-gain vector), and positive-credit precision (among segments receiving positive credit, the fraction whose future functional gain is positive).

Table 3. Alignment between segment-level credit and future functional gains for the three advantage-assignment schemes. Brackets give 95% confidence intervals from 4,000 bootstrap resamples at the trajectory level. Terminal advantage broadcast assigns identical credit to all segments: its Top-1 hit rate is the chance level under random tie-breaking, and cosine similarity and positive-credit precision are undefined.

MethodTop-1 hit rateCosine similarityPositive-credit precision
Terminal advantage broadcast25.2%——
Local potential change23.2% [13%, 35%]−0.018 [−0.14, 0.11]55.8% [40%, 71%]
Ours42.9% [29%, 57%]0.202 [0.03, 0.37]69.7% [55%, 83%]
Reviewer_4Ab4OpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes WebCoder for frontend development over a persistent project state, combining terminal artifact rewards, segment-level credit assignment, and message-tree training across context compaction. It also introduces Webdev-Bench for sequential development requirements, and reports substantial improvements over the base model on both Webdev-Bench and Vision2Web.

Critical strengths
  1. The training framework addresses a practical difficulty in long-horizon agent RL. Message-tree samples retain development stages across context rewrites, while ownership masks avoid repeatedly optimizing shared generated history. The credit-assignment ablation is also useful: removing segment-level adjustments reduces Vision2Web Avg from 62.4 to 52.6.

  2. The improvements over the base model are substantial. Webdev-Bench requirement satisfaction increases from 64.8 to 72.8, while Vision2Web Avg increases from 41.1 to 62.4. Webdev-Bench also checks earlier requirements after later modifications, which is a meaningful addition to evaluating isolated webpage generation.

Critical weaknesses

The intermediate reward signals are not sufficiently validated as measures of functional progress. Appendix C.2 uses fetched-text matching for checklist tasks and source-authoring statistics, including source lines and component files, for reproduction tasks. Table 2 also states that functionality in the generation reward is assessed from screenshot cues without executing interactions. These signals can reflect content coverage and implementation activity, but it is unclear whether their changes reliably distinguish functional improvements from regressions.

The ablations do not fully isolate the contributions claimed for general frontend development. Both are evaluated only on Vision2Web L2, rather than the sequential composite tasks in Webdev-Bench. Moreover, the “w/o Compaction” baseline trains only on the first 65,536 tokens, while the full method can retain up to six selected paths, changing both the development stages and generated tokens used for training. The 7.5-point gap therefore supports the overall recipe, but does not separate the benefit of message-tree training from retaining more useful training tokens.

The human evaluation does not directly validate the interaction judgments in Webdev-Bench. Appendix H describes annotators comparing terminal and per-round screenshots, while noting that some disagreements concern filtering and state-dependent feedback that require operating the application. The repeated-grading analysis in Appendix E establishes consistency, but not whether these interactions are judged correctly; the human study reports pairwise preferences rather than agreement with individual acceptance checks. A hands-on audit would provide stronger evidence for the reported functional and interaction gains.

Questions for authors

How well do changes in the intermediate potentials agree with independently checked functional improvements and regressions? Are there cases where text coverage or source-authoring scores increase while application behavior gets worse?

Can the authors report the ablations on Webdev-Bench, including preservation of earlier requirements? For message-tree training, how does the method compare with a control that receives a matched amount of generated training tokens?

Did the human annotators operate the applications or only inspect screenshots? Can the authors report agreement with individual interaction-checklist decisions after humans exercise the relevant application states?

7 comments
AuthorsOpenReview ↗

Author Response (Part 1)

We thank Reviewer 4Ab4 for the constructive and insightful review. Below we provide our detailed responses to the reviewer's comments.


W1: The intermediate reward signals are not sufficiently validated as measures of functional progress. Appendix C.2 uses fetched-text matching for checklist tasks and source-authoring statistics, including source lines and component files, for reproduction tasks. Table 2 also states that functionality in the generation reward is assessed from screenshot cues without executing interactions. These signals can reflect content coverage and implementation activity, but it is unclear whether their changes reliably distinguish functional improvements from regressions.

We thank the reviewer for the insightful comment. The two signals discussed in W1 (the intermediate artifact potentials and the functionality dimension assessed from screenshot cues) are both positioned in our framework as low-cost artifact signals inside the training loop: the former drives segment-level credit assignment within a trajectory, and the latter is one component dimension of the terminal reward. Our new consistency experiment shows that the terminal training reward correlates strongly with independently executed acceptance scores (Spearman ρ = 0.782, Pearson r = 0.881, Table 1), at about 1/21 of the measurement cost (Table 2); the pairwise consistency validation of the intermediate potentials against execution-based checks (Cohen's κ = 0.856) is presented in our response to Q1 below.

Design positioning. The impact of measurement error in both signals is structurally constrained. The potential-based offsets are token-weighted centered to be zero-sum within each trajectory (Eq. 6): they redistribute credit across the segments of a trajectory while preserving its token-weighted average advantage, and they leave the terminal-reward-based group statistics unchanged. The terminal reward enters GRPO through group normalization (Eq. 7), where its role is to rank rollouts within the same task group. All externally reported evaluation results (Webdev-Bench RS/FS/IS and Vision2Web FS) come from independent acceptance that actually executes interactions (Appendix B.2.3) and are decoupled from the training signals.

Validation experiment: consistency between the terminal training reward and independently executed acceptance. We randomly sample 120 artifacts from training. For each artifact, the source code is placed into a fresh container, dependencies are installed, and the project is built with Vite; an independent acceptance agent (Codex + GPT-6-Astra), which has no access to the training reward, then checks every task requirement in a browser. Each requirement is decomposed into several sub-checks, an acceptance score is computed as the fraction of sub-checks passed, and this score is paired with the artifact's terminal training reward.

Table 1. Correlation between the terminal training reward and independently executed acceptance scores (120 artifacts).

Spearman ρPearson r
0.7820.881

Table 2. Measurement cost of the two procedures.

MeasurementMedian timeMean time
Terminal reward (build + screenshot + VLM scoring)5.6 s6.8 s
Independent acceptance agent (build + browser operation)2.0 min2.0 min

The terminal training reward correlates strongly with the independently executed acceptance scores, indicating that the artifact-based terminal reward (including the functionality dimension assessed from screenshot cues) reflects the requirement satisfaction measured by execution-based acceptance well. We are well aware that agent-executed functional checks are the most direct measure, which is why all reported evaluation uses them. Inside the training loop, the artifact-based reward retains a strong correlation with them (ρ = 0.782) at about 1/21 of the cost; since every training step scores the terminal artifacts of all rollouts, this trade-off matters increasingly as training scales to larger models and more data.

AuthorsOpenReview ↗

Author Response (Part 2)

Q1: (1) How well do changes in the intermediate potentials agree with independently checked functional improvements and regressions? (2) Are there cases where text coverage or source-authoring scores increase while application behavior gets worse?

We thank the reviewer for the questions. We conducted a consistency experiment between changes in the intermediate potentials and independent execution-based checks, and answer the two sub-questions below. Regarding Q1-(1), the direction of potential changes agrees closely with the independent execution-based checks (Cohen's κ = 0.856, Table 3). Regarding Q1-(2), such cases exist but are very rare (0.5% of all pairs), and the zero-sum centering of Eq. (6) preserves each trajectory's token-weighted average advantage and leaves the terminal-reward-based group statistics unchanged, so such errors affect only how credit is divided among the segments of that trajectory, within a bounded range (see Point 2 below).

Setup. We randomly sample 421 pairs of adjacent project states from existing training trajectories, delimited by compaction boundaries exactly as in deployment. For each pair we compute the change in the intermediate potential ΔΦ\Delta\Phi, and an independent execution-based checking agent (Codex + GPT-6-Astra) builds and actually operates the applications at both states in containers, checking the same set of functional and interaction requirements to obtain the change in the functional pass rate ΔF\Delta F. The check is independent in three respects: (i) it uses a model family different from the training reward; (ii) it has no access to the potential values; (iii) it actually executes interactions instead of relying on screenshots, which is exactly the validation the reviewer asks for. Both changes are categorized as increase / unchanged / decrease.

Table 3. Cross-tabulation of potential changes ΔΦ\Delta\Phi against functional pass-rate changes ΔF\Delta F from independent execution-based checks.

ΔΦ\Delta\Phi \ ΔF\Delta FFF increasesFF unchangedFF decreasesTotal
Φ\Phi increases824288
Φ\Phi unchanged93143326
Φ\Phi decreases1337
Total923218421

Regarding Q1-(1): degree of agreement.

Among the 100 pairs where the functional pass rate actually changes, the potential moves in the same direction in 85 pairs (85.0%). Over all 421 pairs, the overall agreement is 94.8% (399/421), and Cohen's κ after chance correction is 0.856. Among the 92 pairs with functional improvement, the potential rises in 82 (recall 89.1%); among the 95 pairs where the potential changes, its direction agrees with the functional change in 85 (precision 89.5%).

Regarding Q1-(2): are there cases where the scores increase while application behavior gets worse?

Yes, but they are very rare and their impact is bounded:

  1. Frequency. Among the 88 pairs where the potential increases, the independent checks show functional regression in only 2 (2.3%; 0.5% of all 421 pairs).
  2. How the impact of such errors is constrained. Each segment's advantage equals the rollout-level advantage plus a segment offset, and the offsets are token-weighted centered to be zero-sum within the trajectory (Eq. 6). Centering therefore preserves the trajectory-level token-weighted average advantage, and the group statistics, computed from terminal rewards only (Eq. 7), are unchanged: potential errors cannot alter any rollout's terminal-reward-based advantage. Within a trajectory, imperfect potentials can still bias the gradient contributions of individual segments; this bias is bounded because the potentials lie in [0, 1] and the offsets are clipped. Zero-sum centering and bounded offsets thus constrain, rather than eliminate, the impact of potential estimation errors, and the frequency above (2 of 421 pairs) shows how rarely the misleading direction occurs.
AuthorsOpenReview ↗

Author Response (Part 3)

W2: The ablations do not fully isolate the contributions claimed for general frontend development. (1) Both are evaluated only on Vision2Web L2, rather than the sequential composite tasks in Webdev-Bench. (2) Moreover, the "w/o Compaction" baseline trains only on the first 65,536 tokens, while the full method can retain up to six selected paths, changing both the development stages and generated tokens used for training. The 7.5-point gap therefore supports the overall recipe, but does not separate the benefit of message-tree training from retaining more useful training tokens.

Q2: (1) Can the authors report the ablations on Webdev-Bench, including preservation of earlier requirements? (2) For message-tree training, how does the method compare with a control that receives a matched amount of generated training tokens?

We thank the reviewer for the insightful comments. We add two sets of experiments: (1) evaluating the two ablated variants on Webdev-Bench (responding to W2-(1) and Q2-(1)); (2) a control experiment that matches the amount of effective generated training tokens (responding to W2-(2) and Q2-(2)). On Webdev-Bench, the full model's RS gain (+8.0) vanishes entirely under both ablations (64.5 / 64.9); under the token-matched control, removing the cross-segment context of the message tree reduces the Vision2Web Avg from 62.4 to 50.3, indicating that the benefit of message-tree training comes mainly from training generated tokens within their true generation context, rather than from the amount of training tokens alone.

(1) Ablations on Webdev-Bench (responding to W2-(1), Q2-(1))

Setup. The two ablated variants are identical to Section 3.3: w/o Artifact-Grounded Credit Assignment (A1, which keeps the sample construction and gives all segments of a rollout the same rollout-level advantage) and w/o Compaction (A2, linear truncation, training only on the first 65,536 tokens).

Table 4. Ablation results on Webdev-Bench.

ModelRSVSFSISAvg
Base model (Qwen3.8-27B)64.877.968.779.872.8
w/o Artifact-Grounded Credit Assignment64.572.570.588.073.9
w/o Compaction (linear truncation)64.972.573.282.973.4
Full WebCoder72.881.973.890.879.8

Results.

  1. The RS gain does not survive either ablation. The full model improves RS over the base model by +8.0 (64.8 → 72.8); removing artifact-grounded credit assignment drops RS to 64.5 (−8.3), and linear truncation drops it to 64.9 (−7.9). On composite tasks scored under the conjunctive rule, both components are necessary: without either one, training does not surpass the base model in requirement satisfaction.
  2. The benefit of long-horizon training concentrates on interactive behavior after multi-round development. The IS of the linear-truncation variant is 7.9 points below the full model (82.9 vs 90.8), consistent with the main-paper observation that WebCoder's lead over the strongest baselines comes mainly from interactions that still work correctly after multi-round development (Section 3.2).
  3. Preservation of earlier requirements (responding to Q2-(1)). The terminal acceptance of Webdev-Bench re-examines every earlier requirement after all requirements have been delivered (Appendix B.2.3), and RS uses the per-requirement conjunctive rule; the RS values in the table above therefore already incorporate the check of whether earlier behavior is preserved.

(2) A message-tree control with matched training-token scale (responding to W2-(2), Q2-(2))

To separate message-tree sample organization from the amount of training tokens, we construct a control baseline that matches the amount of effective generated training tokens: with the token scale aligned, it isolates the contribution of message-tree context organization.

Setup (controlled design). The control baseline (the independent-segment baseline) keeps all of the following identical to the full method: the same 6 selected training leaves, the same ownership partition of generated messages, the same segment advantages, the same terminal rewards and GRPO group statistics, and the same hyperparameters and number of training steps. The only difference is that the full method places each segment's generated tokens within the shared history of its message-tree path (the history serves only as loss-masked context and does not contribute to the loss), whereas the control constructs each segment as an independent sample with the cross-segment history removed. Training volume is counted by generated tokens that actually contribute to the loss: 20.10M for the full method and 17.99M for the control.

Comments on the paper

1 comment
AuthorsOpenReview ↗

Summary of Rebuttal and Revision

Dear Area Chair and Reviewers,

Thank you for the thoughtful reviews and discussion. We summarize how the rebuttal and revised PDF address the main concerns.

Score changes

ReviewerInitialCurrentFollow-upMain concerns addressed
4Ab422No reply in the thread; we followed up on 17 and 18 NovAll raised questions have been addressed: reward and potential validation (W1/Q1); ablations and token-matched control (W2/Q2); hands-on human evaluation (W3/Q3).
4aQb12Raised to 2 ("I have no further questions")The following concerns are addressed: reward alignment with executed tests (W1/Q1); RL versus SFT/RFT and case studies (W2/Q2); generalization across scale (W3/Q3); hands-on human evaluation (W3).
SQBA33Maintained ("Thank you for your detailed response")The following concerns are addressed: Brownfield modification and repair (W1/Q1); potential validation (Q2); controlled comparisons of credit assignment and compaction (W2, Q3, Q4).
Average2.02.3

Main concerns and our responses

1. Alignment of the training reward with executed functionality (4Ab4 W1/Q1; 4aQb W1/Q1)

  • The functional and interaction results come from executed evaluation (Webdev-Bench acceptance agent; Vision2Web functional tests). The training reward is a low-cost in-loop signal.
  • Terminal reward vs. executed acceptance on 120 artifacts: Spearman ρ = 0.782, Pearson r = 0.881, at about 1/21 of the cost (5.6 s vs. 2.0 min median).
  • Intermediate potentials vs. executed checks on 421 pairs of adjacent states: 94.8% directional agreement, Cohen's κ = 0.856. Of 88 potential-increase pairs, 2 show functional regression; zero-sum centering (Eq. 6) confines such errors to credit division within one trajectory.
  • See Appendices E.3 and E.4.

2. Isolating the contributions of the proposed components and of RL (4Ab4 W2/Q2; SQBA W2, Q3, Q4; 4aQb W2/Q2)

  • Webdev-Bench ablations: the full model's RS gain over the base model (+8.0) is not retained under either ablation (64.5 and 64.9).
  • Token-matched message-tree control (20.10M vs. 17.99M effective loss tokens): Vision2Web Avg 62.4 vs. 50.3, so the benefit comes from context organization rather than token count.
  • Context compaction vs. tool folding only: Avg 62.4 vs. 55.6.
  • Credit assignment on the same fixed trajectories: Top-1 hit rate 42.9% (ours), 25.2% (terminal-advantage broadcast, chance level), 23.2% (local potential change).
  • SFT and RFT at comparable trajectory scale and effective loss tokens (337M, 315M, 291M): WebCoder's Avg is 11.7 and 11.1 points higher. The comparison is matched on trajectory scale and loss tokens, not total compute.
  • Post-training behavior: after failed checks, the model trained with artifact-grounded credit assignment follows up with modifications in 100% of cases, versus 70% for the ablated variant.
  • See Appendices F and H.1–H.5.

3. Modification and repair on Brownfield tasks (SQBA W1/Q1)

  • The equal RS (89.1) reflects binary conjunctive scoring of requirements.
  • Item-level blind audit (11 Brownfield tasks, 22 deliverables, anonymized, random order, browser-operated, with repair retests and boundary tests): overall strict pass rate 59.4% to 70.6%; repair items 73.3% to 91.1%; non-repair items 56.8% to 66.8%. WebCoder leads on 8 of 11 tasks, ties on 1, trails on 2.

4. Generalization across model scale (4aQb W3/Q3)

  • On Qwen3.5-9B, with the same training framework and reward, the Vision2Web L2 average rises from 3.81 to 5.04 (+32.3%; FS +52.0%).

5. Human evaluation of interaction claims (4Ab4 W3/Q3; 4aQb W3)

  • Hands-on pairwise evaluation: WebCoder's win rate is no lower than its loss rate against all four opponents (win / tie / loss: base 52.5% / 2.5% / 45.0%; Claude Opus 4.8 50.0% / 0.0% / 50.0%; GPT-5.4 52.5% / 0.0% / 47.5%; Gemini-3-Flash 67.5% / 0.0% / 32.5%).
  • Item-level agreement with the acceptance agent over 1,047 items: 997 agree (95.22%; κ = 0.652). The agent confirms 945 of 946 human-pass items and flags 52 of 101 human-fail items.
  • See Appendix I.

Revised PDF

We have uploaded a revised PDF with all rebuttal-period changes highlighted in blue: Appendix C.2 (zero-sum wording), E.3–E.4, F, H, I, and a pointer in Section 3.3.

We thank the AC for considering our submission.

Yours sincerely, The Authors

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.