- Rating
- 2
- Confidence
- 3
- Informativeness
- 2
- Presentation
- 2
- Soundness
- 2
Read review
Paper summary
The paper argues that GUI agents fail in groups: tasks sharing some property, such as near-duplicate entries in a list or an option hidden in a long-press menu, tend to fail together. So repair should target the property, not the individual failed tasks. The authors build a task generator whose tasks are written from hand-designed feature labels. They run three 8B agents on a pool of about 1,000 generated tasks and greedily search for label combinations with unusually high failure rates. Each candidate is then checked against control tasks with the feature turned off. For the slices that survive, they generate new tasks with the same labels, record solutions with scripted per-family executors, and fine-tune the agents with LoRA plus a rehearsal set. Success on the target slices goes up by 20–29 points, while gains on AndroidWorld are small (1–5 points) and not significant individually. The paper also releases FeatBench, a 974-task labelled benchmark.
Critical strengths
The main idea is neat: because a slice is defined by the generator’s own settings, the thing that describes a failure also tells you how to make training data for it, and how to build a feature-off control to check that the feature is really the cause. This removes the need for a stronger teacher, which matters here since the 30B models fail these tasks about as often as the 8B ones. The control check is not just decoration either: it threw out two high-failure slices whose difficulty actually came from the app. The experiments within this setting are also reasonably careful. The untargeted-data ablation matches the generator, apps and data budget (+13.1 vs +20.0), and the split-half analysis keeps slice selection separate from evaluation.
Critical weaknesses
Most of the gain is in-distribution. The features, repair tasks, executors and FeatBench all come from the same generator, so large gains on target slices are expected. The real test is AndroidWorld and AndroidLab, and there the gains are 1–5 points and none is significant. MAI-UI does not move on AndroidLab, and UI-Venus is worse than both baselines there. The paper also never compares against simpler ways of choosing what to oversample, such as picking features by hand or having an LLM summarize failures. So it is unclear whether the mining step matters, or whether the gain just comes from putting more data where the test set is.
Narrow scope, and the headline number is inflated. Every task family needs hand-designed features, a generator and a scripted executor, and the method can only find failures that the feature list already anticipates. The claim that 12 slices cover 59.6% of failures includes the two slices the paper itself rejects. Without them, the figure is about 50%.
The executor does much of the work. It scrolls through and reads every candidate before choosing, which is exactly the behavior that fixes the near-duplicate failures. The fix comes from engineering, not from the diagnosis.
Questions for authors
Table 6 counts the two rejected slices toward the 59.6% coverage. Could the authors also report coverage using only the confirmed slices?
The body-text slice was not rejected but received no repair data. Are its tasks included in the 275 target tasks?
In Appendix C, how is a slice handled when its gap falls between X− and X+?
Are results of the untargeted-data ablation available for MAI-UI and UI-Venus, and how much do the results vary across training seeds?
Have the authors compared slice mining with simpler ways of choosing target features, such as manual selection from failure cases or LLM-summarized failures, under the same generator and data budget?
I find the core idea interesting. If the authors can address these points, especially Q1, Q4 and Q5, I would be happy to reconsider my score.
5 comments
Response to Reviewer Bpor (Part 2/2)
Q1: Coverage of confirmed slices
Thank you for pointing this out. Counting only confirmed slices gives 647 of the 1,294 failures in the discovery pool, which equals to 50.0%. We now report this coverage in the main text and the caption of Table 6.
Q2: The body-text slice and target tasks
FeatBench contains no task from the body-text slice, so none is included in the 275 target tasks. For repair, a slice must contain at least five discovery tasks; with fewer examples, the failures may be specific to those tasks rather than the feature. The body-text slice contains four tasks and therefore received no repair data. We have added this criterion to Section 3.4.
Q3: Slices between the confirmation thresholds
A gap between X− and X+ leaves the slice neither confirmed nor rejected. We then distinguish its use for training from its use in evaluation:
- Repair data. Among slices with at least five discovery tasks, we exclude only those rejected by the check (Section 3.3). An intermediate slice still has a failure rate of at least 75% in the discovery pool, and the check has not ruled out its feature as the cause. It therefore receives repair data.
- Target evaluation. Only confirmed slices contribute target tasks. Tasks from an intermediate slice are excluded, so the reported target-task gains come from confirmed slices only.
We have clarified these rules in Appendix C.
Q4: Untargeted controls and training seeds
We extended the comparison with untargeted data to MAI-UI and UI-Venus to test whether the advantage of selecting slices also holds for these agents. To assess training variability, we trained GUI-Owl with each type of data under two additional seeds, giving three seeds in total.
Table 3. Success on the target tasks (%) with untargeted and targeted data. GUI-Owl reports the mean ± standard deviation over three training seeds.
| Agent | Base | + untargeted tasks | + Slice2Fix tasks |
|---|---|---|---|
| GUI-Owl-1.5-8B (three training seeds) | 43.6 | 55.3 ± 1.5 (+11.6) | 66.8 ± 2.9 (+23.2) |
| MAI-UI-8B | 31.6 | 40.7 (+9.1) | 55.7 (+24.0) |
| UI-Venus-1.5-8B | 5.1 | 23.6 (+18.5) | 33.8 (+28.7) |
Targeted data gives larger gains on both additional agents. For GUI-Owl, each Slice2Fix run (+20.0 to +25.8) exceeds each untargeted run (+10.2 to +13.1), so the advantage is consistent across the tested seeds. We have added these results to Appendix E.
Q5: LLM-based target selection
Thank you for suggesting this comparison. Selecting targets manually requires reviewing many failure trajectories to identify recurring task properties. Our discovery pool alone contains 1,294 failed trajectories, so manual selection is difficult to scale. We therefore implemented an LLM baseline to automate the proposed failure-summary approach.
In a single prompt, GPT-5.4 received all failed discovery tasks and their feature labels, and was asked to summarize the agents' weaknesses and select feature combinations to repair. We generated repair tasks for those combinations with the same generator and executors, and fine-tuned GUI-Owl with the same data budget and training recipe as Slice2Fix.
Table 4. Success on the target tasks (%) of GUI-Owl with targets chosen in different ways. The rows other than the LLM row are from Tables 1 and 3 of the paper.
| Targets chosen by | Success (%) |
|---|---|
| Base agent, no added tasks | 43.6 |
| No targets (untargeted tasks) | 56.7 (+13.1) |
| LLM | 58.2 (+14.5) |
| Mining (Slice2Fix) | 63.6 (+20.0) |
Under the same budget, LLM-selected targets reach 58.2%, compared with 63.6% for mining. The LLM's targets emphasize application-level operations. Three of its descriptions are:
- "scrolled multi-item deletion and disambiguation in Pro Expense"
- "attribute-based screen reading and filtered querying in Tasks"
- "scrolled event deletion using name/date/time disambiguation in Simple Calendar"
The last operation has a failure rate of 16.2% in the discovery pool, below the pool-wide 42.2%. Mining uses both successful and failed tasks to rank feature combinations by excess failure. This identifies high-failure properties within an operation, such as other entries sharing the target's name, and directs repair data to those conditions. We have added this comparison to Appendix E.
We hope these answers address the reviewer's concerns, and we would be grateful if the reviewer would reconsider the score.
Response to Authors
Thanks for the response and the extra experiments. The coverage fix, the clarified slice rules, and the untargeted controls with seeds answer Q1–Q4, and the Contacts experiment is a nice addition.
That said, my main concern about the method hasn't really changed. The Contacts tasks still come from the same generator and features, so they don't tell us much about transfer outside it. On AndroidWorld and AndroidLab the gains are still small, the seed runs only cover GUI-Owl, and the MAI-UI and UI-Venus results from before aren't discussed. The LLM baseline is a good start, but with one seed on one agent and a gap close to the seed variation, I'm not yet convinced that mining is what makes the difference. The LLM also only sees failed tasks, which isn't quite a fair comparison.
More broadly, every task family still needs hand-designed features, a generator, and a scripted executor, and the method can only find failures the feature list already covers. To me this reads more as a solid engineering pipeline than a strong method contribution.
So I'll keep my score, but I appreciate the effort that went into the rebuttal.
Response to Reviewer Bpor (Part 1/2)
We thank the reviewer for the clear summary and concrete questions. Below we describe the additional comparisons and clarify the coverage and evaluation rules. Changes are marked in blue in the revised paper.
W1: Value of slice mining and external transfer
To distinguish the effect of slice selection from simply adding data, our untargeted control uses the same generator, applications, operations and data budget as slice-directed repair (Table 3 of the paper). On GUI-Owl, untargeted data gains +13.1 points, while data for the mined slices gains +20.0. The additional gain therefore comes from selecting the repair tasks. We extended this comparison to the other two agents, three training seeds on GUI-Owl and LLM-selected targets; mining gives larger gains in each comparison (Q4 and Q5).
To test transfer to a new application, we built deletion tasks in Contacts, which appears in neither the discovery pool, the repair data nor FeatBench. We included tasks with same-name contacts and controls without same-name distractors. The controls test whether the agents can perform the deletion when name ambiguity is absent. We evaluated the Slice2Fix models from Table 1 of the paper without retraining.
Table 1. Success (%) on the new Contacts tasks.
The contrast between the control and same-name tasks reproduces the failure pattern in Contacts. On the same-name tasks, the existing repairs gain +15.3 to +23.7 points across the three agents, showing that the benefit transfers to this new application.
AndroidWorld and AndroidLab were constructed independently of the repaired slices. To assess whether the gains on these benchmarks persist across training runs, we trained GUI-Owl under two additional seeds and evaluated each of the three models three times.
Table 2. Success (%) of GUI-Owl with Slice2Fix under three training seeds on the external benchmarks.
Every training seed improves over the base agent on both benchmarks. We have added the Contacts and seed results to Appendix E.
W2: Feature reuse and coverage
The features describe properties such as how a target is identified and how similar its distractors are. These properties recur across applications and operations, so the feature set is shared across task families. The 19 features in Table 4 of the paper describe all 20 families in our ten applications, and we used the same features to label the 116 AndroidWorld tasks.
A new family largely reuses this vocabulary, the generator code implementing it and common executor steps. A coding agent writes the remaining family-specific code, which is validated automatically (Appendix F). If a failure involves a property outside the vocabulary, we add a feature as another generator option and rerun mining on the trajectories already collected. Q1 reports the coverage of the confirmed slices.
W3: Task selection and the shared executor
To separate task selection from the executor's behavior, all three controls use the same reference executors as Slice2Fix. Each executor scrolls through and reads every candidate in the same way; the training tasks differ. On GUI-Owl's target tasks, instance-level repair gains +12.6 points (Table 1 of the paper), untargeted data gains +13.1 (Table 3 of the paper), and LLM-selected targets gain +14.5 (Table 4 below). Data for the mined slices gains +20.0.
The executor supplies correct actions, but the choice of tasks determines which failures those actions train the agent to handle. For example, only 40 of the 261 untargeted deletion tasks contain near-duplicates. Reading every candidate in all 261 tasks does not concentrate the demonstrations on near-duplicate failures. Mining selects such conditions explicitly, which accounts for the additional benefit beyond using the same executor.