Skip to content

M\(^2\)-Miner: Multi-Agent Enhanced MCTS for Mobile GUI Agent Data Mining

🕒 Published (v1): 2026-01-01 · Source: ICLR · Venue: ICLR 2026 · link

Why this paper was selected

Multi-agent MCTS for GUI agent trajectory data mining at scale [ICLR 2026]

Ask a follow-up

Open an assistant pre-loaded with this paper's context.

💬 Ask ChatGPT✦ Ask Claude

TL;DR

M\(^2\)-Miner is an automated mobile GUI agent data-mining framework that replaces costly manual annotation with MCTS-guided exploration, augmented by a three-agent collaborative system and an intent recycling strategy. It produces a multi-intent tree structure capturing richer trajectory diversity than flat per-intent datasets. A progressive model-in-the-loop training loop iteratively improves mining success rate across three curriculum stages.

Problem

High-quality GUI agent training requires large-scale intent–trajectory pairs, but existing approaches suffer from three compounding failures: (1) manual annotation is prohibitively expensive (hours per entry); (2) automated mining yields poor-quality data with redundant steps, ambiguous intents, and biased paths; (3) flat, single-path trajectory structures limit intent diversity and provide insufficient signal for robust agent training. Vanilla MCTS applied directly to this domain incurs exponential cost due to random expansion and rollout-based reward estimation.

Method

M\(^2\)-Miner builds an intent-trajectory tree \(\mathcal{T} = (V, A, P, I)\) where each node \(v\) stores a screenshot \(\text{img}_v\), action metadata \(\text{meta}_v\), Q-value \(Q_v\), visit count \(N_v\), and task status \(\text{stat}_v \in \{\text{success}, \text{failure}, \text{intermediate}\}\).

Collaborative multi-agent framework enhances two MCTS phases: - InferAgent (expansion): generates \(K\) candidate actions from the current screenshot using multiple distinct MLLMs, preventing redundant generation via prompt injection of prior actions. - OrchestraAgent (expansion): merges equivalent actions and sorts survivors via \(K-1\) multi-choice queries, assigning decreasing initial UCT values to child nodes. - JudgeAgent (simulation): replaces costly rollout with process-based reward. For intermediate nodes, reward is the normalized logit confidence: $\(r_{\text{intermediate}} = \frac{\exp(\text{logits}_{\text{valid}})}{\exp(\text{logits}_{\text{valid}}) + \exp(\text{logits}_{\text{invalid}})}\)$ Q-values update incrementally: \(Q_i = \frac{Q_{i-1} \times N_{i-1} + R_i}{N_{i-1}+1}\).

Intent recycling: after tree construction, an MLLM-based filter scores all root-to-node paths; surviving paths receive MLLM-generated intents; JudgeAgent validates terminal status; passing pairs are added to the dataset without re-mining.

Progressive model-in-the-loop training runs three curriculum stages—basic intents (app-function-derived + conditional rewriting), complex intents (multi-step combinations + failed-intent retry), and recycled intents—each stage fine-tuning InferAgent and JudgeAgent on all data accumulated so far.

Key Contributions

  • First MCTS-based automated mobile GUI agent data-mining framework with multi-agent MCTS enhancement replacing random expansion and rollout-based evaluation.
  • Three-agent collaborative system (InferAgent + OrchestraAgent + JudgeAgent) targeting expansion efficiency and process-based reward estimation.
  • Intent recycling strategy converting non-primary MCTS tree paths into additional intent–trajectory pairs, producing a multi-intent tree structure.
  • Progressive model-in-the-loop training curriculum (basic → complex → recycled intents) that co-evolves mining agents and data complexity.
  • M\(^2\)-Miner-Agent dataset: 2,565 trajectories, 20k images, average length 7.8, collected with minimal manual inspection.

Results

  • 64Ă— efficiency boost over vanilla MCTS at task length 9.
  • GUI agents fine-tuned on M\(^2\)-Miner data achieve state-of-the-art performance on several commonly used mobile GUI benchmarks (specific benchmark names and numeric scores are in truncated sections).
  • Intent recycling produces measurably broader intent distribution than baselines (t-SNE visualization comparison vs. OS-Genesis and vanilla tree approaches).
  • Ablation studies confirm each component (multi-agent framework, intent recycling, progressive training) independently contributes to success rate and data quality.

Limitations

  • Dataset size (2,565 trajectories) is modest relative to manually annotated corpora; quality depends on minimal manual inspection that does not fully disappear.
  • The three specialized agents (InferAgent, OrchestraAgent, JudgeAgent) require separate training pipelines; warm-up on public datasets introduces dependency on pre-existing labeled data.
  • Evaluation is confined to mobile GUI environments; generalization to desktop or web environments with non-vision (HTML-based) parsing is explicitly noted as out of scope.
  • Benchmark-specific performance numbers and comparisons against key baselines (UI-TARS, AutoGLM) are in the truncated portion of the paper, limiting reproducibility assessment here.
  • Intent recycling quality depends on the MLLM filter's ability to score trajectory quality accurately; miscalibration could introduce noisy labels.

Relevance to Harnesses / Meta-Harnesses

M\(^2\)-Miner is a canonical data-generation meta-harness: it wraps an MCTS search engine, multiple specialized MLLM agents, a progressive training loop, and an automated labeling pipeline into a unified layered infrastructure (data / engine / algorithm / agent / execution / environment layers) that runs end-to-end without human intervention at scale. The model-in-the-loop pattern—where outputs of the harness feed back to retrain the agents driving the harness—exemplifies a self-improving meta-harness design applicable beyond GUI data to any domain where automated trajectory collection drives policy improvement. The explicit layered architecture and phased curriculum design offer a reusable blueprint for harness engineers building closed-loop data-flywheel systems. The intent recycling mechanism is a particularly transferable harness-level optimization: reusing intermediate artifacts from one pipeline run to seed the next without re-execution.