GO TO A SECTION

↑ ↓ to navigate · Enter to openExplore all sections →
FDEInterviews logo
arXiv preprint

Mobile-Agent-v3: Fundamental Agents for GUI Automation

Alibaba's GUI agent splits each step into Manager, Worker, Reflector and Notetaker roles, all one open model. AndroidWorld 73.3, though the gain over end to end also swaps 7B for 32B.

Breakdown by FDE Interviews · 11 min read · Updated

About the original · 2025
AUTHORS
Ye, Zhang, Xu, Liu, et al.
FROM
Tongyi Lab, Alibaba Group
PUBLISHED
Aug 2025 · arXiv preprint
CITED BY
196Semantic Scholar · Oct 2026
IN THIS BREAKDOWN · 10 SECTIONS

You can read 21% of this breakdown.

01

The paper in one minute

The paper introduces two things. GUI-Owl is a vision-language model trained to operate graphical interfaces on Android, Ubuntu, macOS and Windows: locate elements, answer questions about screens, plan and act. It is trained on data produced in a cloud fleet of virtual devices, where the model itself generates trajectories, a judging pipeline keeps the correct ones, and the improved model generates the next round. A final stage uses online reinforcement learning with a single advantage per whole trajectory.

Mobile-Agent-v3 is a framework that uses GUI-Owl in four roles.

  • The Manager turns the user's instruction into an ordered list of subgoals, using retrieved knowledge, and updates the list after every step: moving finished subgoals, re-prioritizing, or inserting corrective ones after a failure.
  • The Worker looks at the current screen, picks the most relevant subgoal it can act on, and performs one action, recording its reasoning and what it expected to happen.
  • The Reflector compares the screen before and after with the Worker's intent and returns SUCCESS or FAILURE with a reason, such as "login failed: 'Invalid credentials' is visible".
  • The Notetaker, triggered only after successful steps, saves information later screens will need, such as a verification code.

The loop stops when no subgoals remain or the Worker finds nothing it can execute.

On live benchmarks, GUI-Owl-7B acting alone scored 66.4 on AndroidWorld and 29.4 on OSWorld-Verified. Mobile-Agent-v3 with GUI-Owl-32B scored 73.3 and 37.7.

THE IDEA, VISUALLY
FOUR ROLES, ONE MODEL, ONE STEP AT A TIME Manager subgoal list; re-plans Worker acts on one subgoal Reflector before vs after screen Notetaker keeps codes, names S_t → S_t+1 on SUCCESS only Reflector output: SUCCESS or FAILURE plus a reason, e.g. "login failed: 'Invalid credentials' is visible". PER STEP: ~3 MODEL CALLS INSTEAD OF 1 Manager, Worker and Reflector run every step; the Notetaker runs after successful steps. A RAG module adds knowledge before the first plan. Stops when the subgoal list is empty, or the Worker finds no executable subgoal (stalemate). No latency or cost per task is reported. ONLINE BENCHMARKS (TABLE 7) AndroidWorld OSWorld-V. GUI-Owl-7B, end to end 66.4 29.4 Mobile-Agent-v3 (32B) 73.3 37.7 UI-TARS-1.5 64.2 – OpenCUA-32B – 34.8 Claude-4-sonnet – 43.9 Framework and model size change together: no GUI-Owl-32B end-to-end score is reported. ONLINE RL ON OSWORLD-VERIFIED, 15 STEPS start (desktop 7B) 27.1 offline filtering, peak 29.1 no replay buffer, peak 31.5 full method 34.9 axis starts at 20; one advantage per whole trajectory TRAINING THE REFLECTOR It mostly said SUCCESS. Kept: failures whose feedback led to a success next step, plus all-success trajectories; then positives and negatives balanced 1:1.
Mobile-Agent-v3 wraps each GUI action in a plan, a check and a memory: the Manager keeps the subgoal list, the Reflector compares screens before and after, and the Notetaker keeps information that will disappear from the screen. Each role is another model call per step.
Research notes: the problem, approach and results
66.4 → 73.3

AndroidWorld: GUI-Owl-7B end to end, then Mobile-Agent-v3 running GUI-Owl-32B

29.4 → 37.7

OSWorld-Verified for the same pair; Claude-4-sonnet scored 43.9

27.1 → 34.9

OSWorld-Verified after trajectory-level online RL on a desktop-tuned 7B, with a 15-step limit

THE PROBLEM

Agents that operate phone and desktop apps through screenshots make small errors that compound: a tap that did not register, a field filled on the wrong screen, a one-time code that scrolled away. Where an app has no API, the agent must work from pixels, and it needs a way to notice its own mistakes.

THE IDEA

Train one GUI model (GUI-Owl) that can act end to end or play roles, and wrap it in a loop: a Manager plans and re-plans subgoals, a Worker acts on one, a Reflector judges from the before and after screens whether it worked and why not, and a Notetaker saves transient facts. Train the model on trajectories produced in cloud emulators, with trajectory-level online RL.

THE RESULT

GUI-Owl-7B alone scored 66.4 on AndroidWorld and 29.4 on OSWorld-Verified. Mobile-Agent-v3, running GUI-Owl-32B, scored 73.3 and 37.7, the best reported for open-model frameworks, though Claude-4-sonnet scored 43.9 on OSWorld-Verified. No 32B end-to-end score separates the framework's contribution from the larger model's.

02

Why it matters to an FDE

Many enterprise workflows run through applications with no usable API: an insurer's claims portal, a supplier's ordering site, a legacy desktop ERP screen. GUI agents are the fallback, and this paper is a clear reference design for making them more reliable.

Separate acting from checking. The Reflector's job is to ask whether the action did what the Worker intended, using the screen before and after. Silent failures (a tap that did not register, a dropdown that did not open) are the main way GUI agents go wrong, and an explicit check catches many of them.

Keep transient facts outside the screen history. A code shown once, an order number on a confirmation page: the Notetaker turns them into notes that persist after the screen changes.

Plans should change after failures. The Manager inserts corrective subgoals when the Reflector reports a failure instead of retrying blindly.

Two cautions. First, every role is another model call: roughly three per step instead of one, which multiplies latency and cost on long tasks; the paper reports neither. Second, the Reflector judges success from images. When the application exposes state (an accessibility tree, a DOM, a database row, an API you can read even if you cannot write), check that instead. The authors also found their Reflector leaned heavily toward saying SUCCESS, and had to rebalance its training data.

THE FULL BREAKDOWN

Understand the mechanism. Try it on a real problem.

Unlock this breakdown and 149 more papers.

Premium opens every paper in full, plus every answer, concept, course and guide on the site. One payment for six months of access.

6 months · One payment · No auto-renewal

Get Premium · ₹2,000 / $25
  • ◇1 architecture diagram
  • </>1 runnable code experiment
  • ▦2 results tables
  • ?5 interview questions with answers
  1. 03Key takeaways

    The roles' inputs and outputs, how GUI-Owl was trained, what the numbers show, and misreadings

    Free account
  2. 04How it works

    The loop step by step, the trajectory production pipeline and trajectory-level RL

    Premium
  3. 05The numbers that matter

    End-to-end and framework scores, the RL ablations and what is not reported

    Premium
  4. 06Try it yourself

    Check the headline comparison, then simulate what reflection and notes buy and cost

    Premium
  5. 07Where it breaks

    The model-size confound, missing cost and ablations, reflection bias and benchmark limits

    Premium
  6. 08Using it on a deployment

    Building a GUI agent for an app with no API: roles, checks, notes and approvals

    Premium
  7. 09Interview angles

    Five questions this paper prepares you for, with answer hints

    Premium
Back to the paper library →