acceptodds
Under review as a conference paper at ICLR 2027

VISTA: Verifiable Self-Curriculum for Training GUI Agents

Abstract

Training GUI agents requires scalable supervision for long-horizon interactions in stateful environments, where success is often difficult to specify and verify. Existing approaches rely on human annotations, large teacher models, or manually specified evaluators. We introduce VISTA, a lightweight framework for verifiable self-curriculum learning that uses a small VLM to generate training tasks and their executable evaluators. Conditioned on the agent’s current capabilities, the model synthesizes tasks, environment configurations, and evaluators, retaining task–evaluator pairs that pass execution-based verification. The verified tasks support agentic reinforcement learning, and the updated agent informs subsequent task synthesis, forming a self-improvement loop. Our models VISTA-8B and VISTA-9B post-trained on top of Qwen3-VL-8B and Qwen3.5-9B show up to 4.7% and 4.3% absolute improvement of resolve rate on OSWorld-verified and WAA-V2 over their respective base models. Training with self-curriculum also improves performance on OSWorld-G and ScreenSpot-Pro even without grounding-specific supervision and reduces the average number of interaction steps. These results show that GUI agents can be improved through self-generated, executable supervision.

Primary area:
applications to computer vision, audio, language, and other modalities
Keywords:
GUI Agent, Agent Harness, Model-harness Co-evolving

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_c3sQOpenReview ↗
Rating
1
Confidence
3
Informativeness
1
Presentation
3
Soundness
1
Read review
Paper summary

This paper proposes VISTA, a framework for automatically synthesizing verifiable training tasks for GUI agents without relying on human annotations or stronger teacher models. The framework is evaluated using two backbone models, Qwen3-VL-8B-Instruct and Qwen3.5-9B, resulting in VISTA-8B and VISTA-9B, respectively. The proposed method produces approximately 3.8K validated tasks across the two backbones. Experimental results demonstrate improvements on several GUI benchmarks.

Critical strengths
  1. The paper tackles an important challenge in GUI agent training: how to obtain scalable and reliable supervision without relying on human annotations or expensive teacher models. The idea of jointly generating tasks and executable evaluators is promising.
  2. VISTA combines task generation, verification, and RL training into a relatively straightforward pipeline. Reusing verified tasks and evaluators is also a useful design for scaling up data generation.
  3. The method consistently improves both backbone models on OSWorld-Verified and WindowsAgentArena-V2. The improvements on OSWorld-G and ScreenSpot-Pro also suggest some generalization beyond the training tasks.
Critical weaknesses
  1. The self-curriculum claim is not well supported. The growing task and evaluator pools do not necessarily indicate increasing task difficulty. Moreover, continuous GUI training might even degrade the model’s task-generation or evaluator-generation abilities, raising doubts about whether VISTA truly achieves policy-adaptive curriculum learning.

  2. Task quality is not sufficiently evaluated. Human evaluation mainly checks task validity, but valid tasks are not necessarily useful. The model may generate simple tasks that provide little learning value. Task difficulty and training value remain unclear.

  3. The baseline comparisons are insufficient. The paper lacks direct comparisons with stronger CUA agents that have undergone dedicated RL post-training, making it difficult to fully assess the advantages of VISTA’s synthetic data. The data advantages of Vista need to be demonstrated to enable it to surpass work using other data strategies for reinforcement learning.

  4. Evaluator correctness is not sufficiently guaranteed. Checking executability and semantic relevance does not guarantee that evaluators capture all task requirements or provide reliable rewards.

  5. Scalability depends on existing verification infrastructure. VISTA relies heavily on predefined, environment-specific functions and APIs. Its effectiveness on new applications without such infrastructure remains unclear.

Questions for authors
  1. Why not use stronger models to generate tasks for smaller models? This is a common approach, so a comparison with stronger teacher-generated data would be helpful. If VISTA is more effective, could the authors also validate it on state-of-the-art models?

  2. How is task quality and diversity ensured? Semantic similarity filtering can remove duplicates, but it does not guarantee diversity in task difficulty, complexity, or learning value. Could the authors provide further analysis?

  3. Regarding the Task-Evaluator Relevance Check, this relevance judgment is still performed by the model and does not form an independent and reliable correctness proof.

  4. For Execution-Based Verification, how does VISTA distinguish task infeasibility from limited agent capabilities? If the agent fails during verification, how can the framework determine whether the issue is the agent’s ability, an incorrect setup, or a flawed evaluator?

  5. How do the authors ensure that generated evaluators provide correct rewards? An evaluator may be executable and semantically relevant while missing important requirements.

3 comments
AuthorsOpenReview ↗

Responses to Reviewer c3sQ (part 1/3)

We thank the reviewer for their thoughtful review. We would like to emphasize that the central question of VISTA is whether a single 8B–9B-scale VLM can generate verifiable supervision that improves its own desktop GUI capabilities, without relying on a stronger external teacher. We appreciate the reviewer's recognition of the downstream improvements. We further provide additional synthesis statistics, intermediate checkpoint evaluations, and controlled ablations to address the concerns.

Q1: Why not use a stronger model to generate tasks for the smaller model?

Using a stronger teacher would address a different research question. If a larger model generates tasks and evaluators for an 8B student, improvements in the student demonstrate its ability to consume externally generated supervision, rather than its ability to generate useful supervision itself. VISTA instead assigns task creation, verification, and GUI action to the same 8B–9B-scale backbone within each run. This procedure improves OSWorld-Verified from 30.98% to 35.43% for Qwen3-VL-8B and from 40.95% to 45.68% for Qwen3.5-9B. Both backbones also improve by +4.25 percentage points on WindowsAgentArena-V2. A stronger-teacher comparison would help quantify the additional benefit of larger generators, but our primary finding is that useful self-generated supervision is already achievable at the 8B–9B scale.

W1: What supports the term "self-curriculum"?

VISTA's self-curriculum combines verification-driven pool evolution with iterative policy optimization. Accepted task–evaluator pairs are incorporated into retrieval pools, and the updated policy is used for subsequent synthesis rounds. To further validate this process, we provide evidence from three perspectives.

(1) Task synthesis dynamics. We report per-round synthesis statistics below.

BackboneRoundProposed TasksAccepted TasksAccept. (%)Avg. Tokens
8BR11,28975258.346.9
8BR21,03250348.756.2
8BR31,02825224.560.1
9BR11,8781,13860.648.0
9BR21,59279249.761.9
9BR31,31936827.968.2

Both backbones exhibit declining task acceptance rates (8B: 58.3% -> 24.5%; 9B: 60.6% -> 27.9%) alongside increasing average task-instruction lengths (8B: 46.9 → 60.1 tokens; 9B: 48.0 -> 68.2 tokens). These trends are consistent with increasingly selective synthesis as the pools expand. Longer instructions may reflect more elaborate task requirements, although we do not treat instruction length as a direct measure of difficulty.

(2) Progressive policy improvement. To examine whether the policy improves throughout self-curriculum training, we manually curated a fixed held-out set of 100 GUI tasks spanning browsers, office applications, coding tools, media, and file-editing software. This set is separate from the synthesis pools and downstream benchmarks.

BackboneBase (%)R1 (%)R2 (%)R3 (%)
8B25.036.043.051.0
9B38.047.061.070.0

Both backbones improve consistently across successive checkpoints, with overall gains of +26.0 and +32.0 percentage points. These results provide direct evidence of progressive policy improvement during the iterative synthesis and training process.

(3) Contribution of evolving pools. We additionally conduct fixed-pool ablations under the same RL training budget. We compare fixed task/evaluator pools, evolving tasks with fixed evaluators, and jointly evolving task/evaluator pools (VISTA-Full), using task pools of comparable scale.

BackboneTask PoolEvaluator PoolOSWorld-Verified (%)WAA-V2 (%)
8BFixedFixed32.6611.34
8BEvolvingFixed33.499.92
8B (VISTA-Full)EvolvingEvolving35.4312.29
9BFixedFixed43.7420.56
9BEvolvingFixed44.0323.40
9B (VISTA-Full)EvolvingEvolving45.6824.11

Compared with fixed task and evaluator pools, VISTA-Full improves OSWorld-Verified by +2.77/+1.94 points and WAA-V2 by +0.95/+3.55 points for the 8B/9B backbones. Furthermore, enabling evaluator-pool evolution alongside task-pool evolution improves performance across all four comparisons. These results provide empirical support for jointly evolving task and evaluator pools, although they do not separately isolate the contribution of generator checkpoint updates.

AuthorsOpenReview ↗

Responses to Reviewer c3sQ (part 2/3)

W2, Q2: Could the tasks be valid yet provide little learning value?

Validity alone does not guarantee learning value. Our evidence comes from evaluating the resulting policies on tasks with independent benchmark evaluators. OSWorld-Verified and WindowsAgentArena-V2 assess task completion using their own success criteria, rather than VISTA's synthesized training evaluators. Both backbones improve on these benchmarks, including transfer from Linux-based synthesis to Windows environments.

Furthermore, Table 5 in the paper draft shows consistent improvements on an independently curated set of 100 held-out tasks across successive policy checkpoints. These results provide additional evidence that the synthesized supervision supports learning beyond the training tasks.

Regarding task complexity, Tables 12-13 report accepted tasks across ten software domains. For the 8B generator, estimated mean interaction lengths range from 10.51 steps in Thunderbird to 22.74 steps for multi-application tasks. Figure 6 additionally illustrates a task requiring multiple spreadsheet modifications while preserving unrelated cell values. We do not infer individual task difficulty or marginal learning contribution solely from these statistics.

W3: What do the baseline comparisons establish?

Our comparisons address two different objectives. For final agent performance, Table 6 compares VISTA with UI-TARS, OpenCUA, ScaleCUA, GUI-OWL, and DART-GUI. VISTA-9B achieves 45.68% on OSWorld-Verified, exceeding DART-GUI-7B (42.13%), the strongest comparator reported in the table.

For training supervision, Figure 4 compares VISTA against SFT on AgentNet, one of the few publicly available, large-scale human-annotated GUI datasets suitable for training computer-use agents. Unlike VISTA, AgentNet provides demonstration trajectories without interactive environments or executable evaluators, naturally supporting SFT rather than outcome-based RL.

To make the comparison meaningful, we match the number of training tasks as closely as possible and use the same backbone models and optimization steps. The different supervision formats prevent exact matching of rollout exposure and compute. Therefore, Figure 4 compares the practical effectiveness of these training pipelines rather than isolating intrinsic data quality. O

AuthorsOpenReview ↗

Responses to Reviewer c3sQ (part 3/3)

W4, Q3, Q5: Why trust a reward when the model also judges evaluator relevance?

We agree that model-generated relevance judgments alone cannot guarantee evaluator correctness. This motivates our independent human audit, which explicitly examines evaluator completeness and false-positive/false-negative behavior.

As described in Section 3.3, three experts independently audited 200 candidates across all ten domains, assessing task feasibility, setup correctness, task–evaluator relevance, evaluator completeness, and potential evaluator errors. Their majority judgments agreed with the automatic filtering decisions in 184 cases (92%). The pipeline incorrectly accepted 12 candidates (6%) and rejected four valid candidates (2%), as reported in Table 3b.

Importantly, the 92% agreement measures candidate admission decisions, not per-rollout reward accuracy. These results characterize the reliability and remaining limitations of our verification pipeline. The independent downstream benchmark evaluations further demonstrate that the resulting supervision remains useful despite residual verification errors.

Q4: Can VISTA distinguish an infeasible task from one the actor failed to solve?

A failed rollout alone cannot reliably distinguish task infeasibility from insufficient actor capability. VISTA therefore combines static checks for malformed code, invalid arguments, and unavailable APIs with environment-based verification (Appendix A.1).

When a candidate cannot pass verification, it is excluded from the training pool, regardless of whether the failure results from task infeasibility or the current actor's limitations. This conservative admission criterion may reject feasible tasks beyond the actor's current capabilities. We therefore interpret rejected candidates as failing the admission criteria, rather than necessarily being infeasible.

W5: What does "a single small VLM" assume about verification infrastructure?

VISTA assumes access to an interactive environment that exposes sufficient state for executable verification, together with an initial function catalog. We refactor OSGym's setup and evaluator utilities into reusable Python function interfaces, from which the model can construct new task-specific evaluators.

Appendix A.1 describes the validation of generated code through parsing, signature checks, and execution. Tables 12-13 report 937 and 1,565 accepted evaluators for the 8B and 9B backbones, respectively. Thus, while VISTA does not eliminate the need for environment instrumentation, it reduces the need to manually author a separate evaluator for each generated task. Limited state accessibility remains an important boundary of the approach.

We hope the additional synthesis statistics, intermediate checkpoint evaluations, and fixed-pool ablations address the reviewer's concerns regarding self-curriculum. Together with the human audit and independent downstream evaluations, these results support our central finding that 8B–9B-scale VLMs can generate verifiable supervision that improves their own GUI performance, while also providing evidence for the benefit of jointly evolving task and evaluator pools.

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

VISTA uses one small VLM as task creator, verifier, and GUI actor. It generates instructions, setup scripts, and executable evaluators, filters candidates, and reuses accepted examples for further synthesis. About 3,800 tasks are used for GRPO training. The reported gains cover OSWorld-Verified and WindowsAgentArena-V2, with a 200-candidate human audit of task filtering.

Critical strengths

Using an 8B/9B model for synthesis and checking could reduce dependence on stronger teacher models. The improvements on both Linux and Windows are useful, and the human audit gives some evidence that the generated supervision is usable.

Critical weaknesses

The general synthesis idea is already present in WebFactory and EvoCUA. VISTA's Table 1 acknowledges much of this overlap. The remaining claim is that a single small model and an expanding evaluator pool provide an effective self-curriculum. That could be useful, but it is not isolated in the experiments. Algorithm 1 updates the pools without showing policy updates, and there is no frozen-generator or fixed-pool control. I therefore lean toward rejection: the paper shows useful synthetic supervision, but does not yet show that the proposed self-curriculum is the reason it works.

The AgentNet comparison does not resolve this. AgentNet is used for SFT, whereas VISTA uses GRPO, with global batch sizes of 32 and 128 in Table 8. Matching 350 optimization steps does not match data exposure or compute. The result cannot support the claim that VISTA's data are better than human-annotated data by themselves.

Questions for authors
  1. Beyond using a smaller model, what does the evolving evaluator pool add over the reusable verification library in EvoCUA? Please give the actual synthesis/training schedule and identify which model checkpoint generates each round.

  2. Can you compare a fixed task/evaluator pool with the proposed updating pool under the same RL budget? This is the control most relevant to the self-curriculum claim.

  3. Please report the training exposure in the AgentNet comparison and clarify which OSWorld tasks/setup scripts/evaluators initialize the pools and how evaluation tasks are excluded.

2 comments
AuthorsOpenReview ↗

Responses to Reviewer ykdu (part 1/2)

We thank the reviewer for the detailed feedback. We provide additional ablations and clarify the scope of our contributions and experimental comparisons.

W1: Novelty and insufficient validation of self-curriculum.

We acknowledge that WebFactory and EvoCUA have explored automated task synthesis, executable verification, and iterative agent training. Rather than claiming these components as individually novel, VISTA investigates whether a VLM with fewer than 10B parameters can establish a self-curriculum by generating and verifying supervision for its own improvement, without relying on a stronger external teacher. Importantly, our contribution also lies in jointly evolving task and evaluator pools, rather than relying solely on a fixed verification library.

To address the reviewer's concern that the observed improvements may come from synthetic supervision rather than the proposed self-curriculum, we provide three complementary pieces of evidence.

(1) Evolution of synthesized supervision. VISTA alternates between synthesis and policy optimization. In each round, the updated policy generates task–evaluator pairs using the accumulated retrieval pools. The following table reports the synthesis statistics across three rounds.

BackboneRoundProposed TasksAccepted TasksAccept. (%)Avg. Tokens
8BR11,28975258.346.9
8BR21,03250348.756.2
8BR31,02825224.560.1
9BR11,8781,13860.648.0
9BR21,59279249.761.9
9BR31,31936827.968.2

Both backbones exhibit declining acceptance rates (8B: 58.3% → 24.5%; 9B: 60.6% → 27.9%) and increasing average task-instruction lengths (8B: 46.9 → 60.1 tokens; 9B: 48.0 → 68.2 tokens). These observations are consistent with increasingly selective synthesis as the pools expand, although instruction length alone does not establish increasing task difficulty.

(2) Policy improvement across synthesis rounds. To examine whether the policy improves alongside the evolving synthesis process, we manually curated a fixed held-out set of 100 GUI tasks covering browsers, office applications, coding tools, media, and file-editing software. These tasks are excluded from synthesis and training and are separate from the downstream benchmarks. We evaluate successive policy checkpoints on the same held-out set.

BackboneBase (%)R1 (%)R2 (%)R3 (%)
8B25.036.043.051.0
9B38.047.061.070.0

The success rates improve consistently across rounds (8B: 25.0% → 51.0%; 9B: 38.0% → 70.0%), confirming that successive synthesis rounds are accompanied by measurable policy improvements. While these results establish the iterative nature of the process, they do not alone isolate the benefit of pool evolution.

(3) Does pool evolution improve performance beyond synthetic supervision alone? To address this central concern, we therefore conduct fixed-pool ablations under the same RL optimization budget, using task pools of comparable scale.

BackboneTask PoolEvaluator PoolOSWorld-Verified (%)WAA-V2 (%)
8BFixedFixed32.6611.34
8BEvolvingFixed33.499.92
8B (VISTA-Full)EvolvingEvolving35.4312.29
9BFixedFixed43.7420.56
9BEvolvingFixed44.0323.40
9B (VISTA-Full)EvolvingEvolving45.6824.11

All three configurations use synthetic supervision, but differ in whether the task and evaluator pools evolve. VISTA-Full consistently outperforms the fixed-pool baseline, improving OSWorld-Verified by +2.77/+1.94 points and WAA-V2 by +0.95/+3.55 points for the 8B/9B backbones. Moreover, compared with evolving tasks and fixed evaluators, enabling evaluator-pool evolution yields additional gains of +1.94/+1.65 points on OSWorld-Verified and +2.37/+0.71 points on WAA-V2.

These comparisons directly address the concern that the gains could be explained solely by access to synthetic supervision. While task-pool evolution alone yields mixed results, jointly evolving task and evaluator pools consistently achieves the strongest performance, supporting the contribution of the proposed self-curriculum beyond a fixed synthetic training corpus. We note that these ablations isolate pool configurations, rather than the independent effect of updating the generator checkpoint.

AuthorsOpenReview ↗

Responses to Reviewer ykdu (part 2/2)

W2: Fairness of the AgentNet comparison and training exposure explanations

We would like to highlight that AgentNet, one of the few publicly available, large-scale human-annotated GUI datasets suitable for training computer-use agents, however, provides demonstration trajectories without interactive environments or executable evaluators, and therefore naturally supports SFT rather than outcome-based RL. This difference in supervision format makes it difficult to match training exposure and compute exactly across the two approaches. To ensure a meaningful comparison, we match the number of training tasks as closely as possible and use the same backbone models and optimization steps. While the optimization objectives and rollout exposure necessarily differ, we have clarified these experimental considerations and the scope of the comparison in the revised manuscript.

Q1: What does the evolving evaluator pool add beyond EvoCUA, and how are synthesis and training coordinated?

We acknowledge that reusable verification components are also present in EvoCUA. VISTA differs in jointly synthesizing task–evaluator pairs and incorporating verified examples and executable checking functions into evolving retrieval pools to guide subsequent synthesis, rather than relying solely on the initial verification library. Regarding the training schedule, VISTA alternates between synthesis and policy optimization. In each round, we train the agent on the newly synthesized and verified tasks until performance approaches convergence, defined as no substantial improvement on a fixed held-out set over two consecutive evaluations. We then use the updated policy checkpoint to initiate the next synthesis round, with the expanded task and evaluator pools.

Q2: Fixed-pool comparison under the same RL budget.

We additionally compare three configurations: (1) fixed task and evaluator pools, (2) evolving tasks with fixed evaluators, and (3) jointly evolving task and evaluator pools (VISTA-Full). The variants use the same RL training budget, with task pools constructed at almost the same scales.

BackboneTask PoolEvaluator PoolOSWorld-Verified (%)WAA-V2 (%)
8BFixedFixed32.6611.34
8BEvolvingFixed33.499.92
8B (VISTA-Full)EvolvingEvolving35.4312.29
9BFixedFixed43.7420.56
9BEvolvingFixed44.0323.40
9B (VISTA-Full)EvolvingEvolving45.6824.11

VISTA-Full achieves the highest performance across both backbones and benchmarks. In particular, allowing evaluator-pool evolution alongside task-pool evolution improves OSWorld-Verified by +1.94/+1.65 points and WAA-V2 by +2.37/+0.71 points for the 8B/9B models, respectively. These comparisons provide direct evidence for the effectiveness of the jointly evolving pools, while the independent contribution of evaluator retrieval or reuse remains outside the scope of this ablation.

Q3: Pool initialization, and evaluation exclusion.

For initialization, we refactor the setup and evaluator utilities provided by OSGym into reusable Python function interfaces, which serve as the initial function library for task and evaluator synthesis. To mitigate potential benchmark contamination, we additionally constrain synthesized task instructions to remain below a predefined cosine-similarity threshold with respect to downstream benchmark tasks. This filtering is applied during synthesis to exclude highly similar task descriptions. Table 3 further shows that VISTA's synthesized tasks are more distant from OSWorld than AgentNet under cosine-centroid distance, MMD, and Fréchet embedding distance. Together, these measures reduce the risk of instruction-level overlap.

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

The paper introduces VISTA, a lightweight framework for verifiable self-curriculum learning enabling GUI agents to improve by generating tasks that can be self-verified. A single VLM generates tasks, environment configurations, and evaluators, verifies their validity, and learns from interactions using GRPO (Fig. 1 and Algorithm 1). Verified tasks and evaluators are reused for subsequent synthesis.

Critical strengths
  • Scalable, verifiable task generation. Jointly generating GUI tasks and executable evaluators is a useful approach. The human audit reports 92% agreement with automated verification decisions (Table 3).
  • Consistent empirical improvements. VISTA improves both Qwen3-VL-8B and Qwen3.5-9B across two GUI benchmarks (Tables 5 and 6). On OSWorld-Verified, VISTA-9B improves success from 40.95% to 45.68% (Table 5).
Critical weaknesses
  • Insufficient validation of the self-curriculum mechanism. The central claim is that tasks and evaluators evolve alongside the improving agent (Fig. 2). However, the paper does not isolate the effect of curriculum evolution or evaluator reuse on downstream performance. Could the authors provide ablation studies to measure these effects?

  • Clarification of what constitutes a small model. The paper refers to VISTA-8B and VISTA-9B as “small” models, but this characterization is subjective. I also noticed that the cumulative number of accepted tasks and the cumulative evaluator reuse rate are consistently higher for the 9B model than for the 8B model (Fig. 2). It is unclear whether this difference stems from the base models' capabilities, their parameter counts, or the number of tasks generated.

Questions for authors

No additional comments or questions.

I would like to note that I do not work in GUI Agents or RL. So I prefer to provide a clean review signal rather than mentioning any generic weaknesses.

1 comment
AuthorsOpenReview ↗

Responses to Reviewer TLCX

We thank the reviewer for the constructive feedback. We provide additional synthesis statistics, intermediate checkpoint evaluations, and fixed-pool ablations to address the concerns.

W1: Insufficient validation of the self-curriculum mechanism.

(1) Task synthesis dynamics. VISTA's self-curriculum is driven by verification-based feedback: accepted task–evaluator pairs are added to evolving pools and retrieved to inform subsequent synthesis (Algorithm 1). We further report the per-round synthesis statistics below.

BackboneRoundProposed TasksAccepted TasksAccept. (%)Avg. Tokens
8BR11,28975258.346.9
8BR21,03250348.756.2
8BR31,02825224.560.1
9BR11,8781,13860.648.0
9BR21,59279249.761.9
9BR31,31936827.968.2

Both backbones exhibit declining task acceptance rates across rounds (8B: 58.3% -> 24.5%; 9B: 60.6% -> 27.9%), alongside increasing average task-instruction lengths (8B: 46.9 → 60.1 tokens; 9B: 48.0 -> 68.2 tokens). These trends are consistent with increasingly selective synthesis as the pools expand, while longer task descriptions are the signals to attempt generating more elaborate tasks.

(2) Progressive policy improvement. To track policy improvement without repeatedly evaluating on downstream benchmarks, we manually curated a fixed held-out set of 100 GUI tasks spanning browsers, office applications, coding tools, media, and file-editing software. This set is separate from the synthesis pools and downstream evaluation benchmarks.

BackboneBase (%)R1 (%)R2 (%)R3 (%)
8B25.036.043.051.0
9B38.047.061.070.0

Both backbones improve consistently across successive checkpoints, with overall gains of +26.0 and +32.0 percentage points, respectively. These results provide direct evidence of progressive policy improvement throughout the self-curriculum process.

(3) Contribution of evolving task and evaluator pools. To examine the contribution of pool evolution, we compare VISTA-Full against two ablation variants under the same RL training budget. In the Fixed/Fixed setting, we construct a task pool of comparable size to VISTA-Full and keep both task and evaluator pools fixed during training. In the Evolving/Fixed setting, we continue synthesizing tasks while keeping the evaluator library fixed. VISTA-Full allows both pools to evolve by incorporating newly verified task–evaluator pairs.

BackboneTask PoolEvaluator PoolOSWorld-Verified (%)WAA-V2 (%)
8BFixedFixed32.6611.34
8BEvolvingFixed33.499.92
8B (VISTA-Full)EvolvingEvolving35.4312.29
9BFixedFixed43.7420.56
9BEvolvingFixed44.0323.40
9B (VISTA-Full)EvolvingEvolving45.6824.11

Compared with fixed task and evaluator pools, VISTA-Full improves OSWorld-Verified by +2.77/+1.94 points and WAA-V2 by +0.95/+3.55 points for the 8B/9B backbones. Further enabling evaluator-pool evolution improves OSWorld-Verified by +1.94/+1.65 points and WAA-V2 by +2.37/+0.71 points relative to evolving tasks with fixed evaluators. While the benefit of task-pool evolution alone varies across benchmarks, VISTA-Full consistently achieves the highest performance across all four comparisons. These results provide empirical support for jointly evolving task and evaluator pools, without attributing the gains to any single mechanism in isolation.

W2: Definition of "small" models and synthesis differences.

We use "small" relative to approaches that rely on substantially larger external teacher models, often at the 20B+ parameter scale, for synthesis or verification. Our objective is to investigate whether an 8B–9B-scale VLM can generate useful supervision for its own improvement. We have adopted the more precise terminology "models with fewer than 10B parameters" in the revised manuscript.

Regarding the differences between backbones, Table 5 in the paper draft shows that the 8B and 9B models generate 3,349 and 4,789 task proposals, respectively, with overall acceptance rates of 45.0% and 48.0%. Thus, the higher number of accepted tasks for 9B is partly explained by its larger synthesis volume. Evaluator acceptance ratios also differ (72.1% vs. 82.6%; Appendix A.2). Since the two backbones differ in architecture and pretraining as well as parameter count, these results cannot isolate the source of the differences. Nevertheless, both backbones exhibit similar synthesis trends and progressive policy improvements, demonstrating that VISTA can generate useful verifiable supervision across both model backbones.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.