Speed11 min read
What makes a phone agent fast
Lusor's median is 48.2 s per AndroidWorld task, against 216.9 s for the times Mobilerun publishes. Comparing the two medians, that is 4.5× faster. Here is where the time in a phone agent's step goes, which design choices shorten it, where Lusor was slower, and what the speed costs.
TL;DR
- Lusor's median is 48.2 s per AndroidWorld task, against 120.5 s for agent-qa and 216.9 s for Mobilerun's published times. Comparing the two medians, Lusor is 4.5× faster than Mobilerun.
- The time in a step goes to five things: reading the screen, the model deciding, the phone acting, the app settling, and any retry. A task's time is the time per step multiplied by the number of steps.
- Three design choices that Lusor publishes work on those levers: a model run at low reasoning effort, the screen given to the model as structured text, and tools that do more in one call.
- Lusor was not faster everywhere. It was slower than Mobilerun's published time on 5 of the 116 tasks, 4 of them in the Tasks app.
- The same run passed 116/116 tasks on Mobilerun's fork of the grader and 114/116 on Google's original grader, and its model calls cost $2.95. It did not enforce AndroidWorld's step budget, and 22 tasks went over theirs.
Speed is the part of a phone agent a person feels first. A task that takes moments by hand is not worth handing to an agent that takes many times longer. On AndroidWorld, Lusor's median is 48.2 s per task, against 216.9 s for the per-task times Mobilerun publishes. Comparing the two medians, that is 4.5× faster.
The gap is not one trick. A phone agent's time on a task is the number of steps it takes multiplied by how long each step takes, and both come from design choices that can be named. This post goes through where the time in a step goes, which published choices shorten Lusor's runs, where Lusor was slower, and what the speed does and does not cost. Every figure is on the benchmark page or in Lusor's AndroidWorld run report.
How fast is Lusor on AndroidWorld?
Lusor's median is 48.2 s per task across all 116 AndroidWorld tasks, against 120.5 s for agent-qa and 216.9 s for Mobilerun, the two entries that can be compared per task because both publish a time for each of the 116 tasks. The run used one trial per task, with DeepSeek V4.1 Flash at low reasoning effort choosing every action inside the Lusor Harness, on 9 November 2026.
| Median per task | Total, 116 tasks | |
|---|---|---|
| Lusor Harness, DeepSeek V4.1 Flash | 48.2 s | 8,617.8 s |
| agent-qa, gpt-6-sol, as published | 120.5 s | 20,729 s |
| Mobilerun, GPT-6 Astra, as published | 216.9 s | 30,768.3 s |
Two speed figures are on the benchmark page, and they answer different questions. Dividing one median by the other, 216.9 s by 48.2 s, gives 4.5×. Dividing Lusor's time by Mobilerun's published time task by task, then taking the median of the 116 ratios, gives 0.19, which is 5.2× faster per task. The first compares each system's typical task, which need not be the same task. The second compares every task with itself.
The clocks are not identical. Lusor's time runs from the agent's start to its finish. The others are the per-task times each team publishes, from its own runs and not from a run beside Lusor's. agent-qa's published time has no documented method, so that comparison is indicative.
Where does the time go in a phone agent's step?
The time in a step goes to five things: reading the screen, the model deciding, the phone acting, the app settling, and any retry when the step did not land. The benchmark page draws Lusor's loop as read screen, choose action, check, act, verify, repeat, and every phone agent runs some version of it.
- Reading the screen. The agent needs the current screen before it can decide. A screenshot, a structured list of what is on screen, or both have to be captured on the phone and handed to the model. The more the model is given to read, the longer its turn takes.
- Model thinking. The model reads the goal, what has happened so far and the screen, then chooses the next action. How long that takes depends on the model and on how much reasoning it is asked to do before it answers.
- Acting. The tap, the typing or the swipe is carried out on the phone, and the agent learns whether it went through.
- Waiting for the app to settle. After a tap, the app opens a screen, loads a list or finishes an animation. Reading too early means deciding on a screen that is about to change. Waiting too long is time spent on nothing.
- Retries. A tap that missed, a field that did not take its text, or a turn into the wrong screen has to be noticed, undone and done again. Each retry is a whole extra step, with its own read and its own decision.
Two of the five belong to the phone and the app: an action takes as long as the phone needs to carry it out, and a screen takes as long to settle as the app needs. The other three are design choices: how much the model is given to read, how much it reasons before answering, and how often a step has to be repeated. A task's time is then the time per step multiplied by the number of steps, so an agent gets faster by making steps shorter, by needing fewer of them, or both.
What makes Lusor's runs fast?
Three design choices that Lusor publishes work on those levers: a model run at low reasoning effort, the screen given to the model as structured text, and tools that do more in one call.
A model at low reasoning effort. DeepSeek V4.1 Flash chose every action in the run at low reasoning effort, the way Lusor runs it in production. A task can take many model calls, so the wait on every call adds up, and a model that answers sooner shortens every step of the task.
The screen as structured text. Lusor gives the model the screen as structured information and carries out phone actions, such as tapping, typing and scrolling, through tools, instead of asking the model to drive the phone with free-form text. The public API shows the shape of it: the screen comes back as an element tree in text, where each interactive element carries an index that can be tapped directly. The direct control docs describe that tree and the actions that go with it.
Tools that do more in one call. The Lusor Harness supplies list-reading tools that gather what is on screen across a long list, page by page, so the agent can work across several screens of information. The public API documents two more ways to save a round trip for anyone driving a phone from their own code. An action can return the screen as it is right after the action, which skips a separate read. A chain runs several actions in one request, with waits placed where the screen needs time to settle. Both are covered under chains and capture, and chains appear as single steps in the run's published per-task data.
What the run does not show is how much each choice contributes. AndroidWorld compares complete systems, and the other entries used different models in different harnesses. The time belongs to the whole system: this model, at this effort, inside this harness.
Is Lusor faster on every task?
No. Lusor was slower than Mobilerun's published time on 5 of the 116 tasks and faster on the other 111. Dividing Lusor's time by Mobilerun's published time for each task sorts the 116 tasks into four bands.
| Tasks | Share of the 116 | |
|---|---|---|
| 5× faster or more | 62 | 53% |
| 2 to 5× faster | 41 | 35% |
| 1 to 2× faster | 8 | 7% |
| Slower | 5 | 4% |
The slower tasks cluster in one app. Tasks is the only one of the 21 apps where Lusor's median was slower: 175.8 s against 146.9 s, with 4 of its 6 tasks taking longer than Mobilerun's published times. One of them, TasksHighPriorityTasks, passed but took 273.3 s against a published 193.5 s.
| Tasks | Lusor Harness, median | Mobilerun, published median | |
|---|---|---|---|
| Simple Calendar | 17 | 42.2 s | 170.3 s |
| Settings | 15 | 24.2 s | 125.6 s |
| Markor | 14 | 40.7 s | 220.9 s |
| Broccoli | 13 | 108.2 s | 429.7 s |
| Tasks | 6 | 175.8 s | 146.9 s |
A median says what a typical task takes. It does not say what the slowest one takes, and a person waiting on an agent notices the slow ones. That is why the per-task times are published, and not only the median.
Does speed cost accuracy?
On this benchmark it did not cost passes: the same run passed 116/116 tasks on Mobilerun's fork of the grader and 114/116 on Google's original grader, which failed two tasks that Lusor completed but read differently from that grader.
The speed was not bought by skipping the checking. The Lusor Harness runs focused checks that compare actions and saved values with the request and with what the agent has read, so the model does not simply declare success. Those checks are extra model calls. Their cost is in the reported figure, and the clock runs from the agent's start to its finish.
The trade-off shows up elsewhere. AndroidWorld sets a step budget for each task. Lusor's run did not enforce it, and 22 of the 116 tasks used more device actions than their budget, while Mobilerun's published run stayed within it on every task. A fast run is not necessarily a short one: an agent can take more actions than its budget allows and still finish sooner when each step is quicker.
A model that decides quickly also has limits this benchmark does not reach. The run was one seed on emulators, one trial per task, in 21 apps, with every task starting from the same Android snapshot. What the leaderboard hides lists what that leaves unmeasured. For harder work the model is a setting, not a fixture: the docs on choosing a model list which models suit simple tasks and which suit complex ones, and picking one that reasons for longer trades some of the speed for it.
Does a faster agent cost more?
Not in this run, where the faster system was also the cheaper one: the model calls for all 116 tasks cost $2.95, including the helper checks, against Lusor's estimate of about $108.70 for Mobilerun on the same tasks.
Time and cost share a cause. Both grow with the number of model calls a task takes and with how much each call reads and reasons, so a choice that shortens the model's part of a step tends to make that step cheaper too. Per task, Lusor's median cost was $0.017, against an estimated $0.689 for Mobilerun.
Two cautions go with those figures. Mobilerun's is Lusor's estimate, not Mobilerun's bill: Mobilerun does not publish its token use, so the estimate multiplies each task's published action count by $0.0766, the per-call cost Lusor measured running GPT-6 Astra at low effort in its own harness. And $2.95 is model cost only. It is not a subscription price, and it does not include hardware or infrastructure.
The checking is a small part of that bill. The helper models that read lists and run checks account for $0.20 of the $2.95.
How should a speed claim be read?
Read a speed claim for what was timed, against what, and how the ratio was taken, because each of those can move the number. These questions apply to Lusor's figures as much as to any other.
- What does the clock cover? Lusor's time runs from the agent's start to its finish. Another team's published time may start and stop somewhere else.
- Was it run side by side? Mobilerun's and agent-qa's times are the ones each team publishes, from its own runs.
- Is it a ratio of medians or a median of ratios? The same data gives 4.5× one way and 5.2× the other.
- On how many tasks was it slower? Here, 5 of 116.
- How many trials per task? One trial means a single timing for each task, not an average.
- Did the fast runs pass, and on which grader? A time only counts for a task that was completed.
- What did the speed cost? A time without the model cost beside it is half of the answer.
The full comparison is on the AndroidWorld benchmark page, and each task's time, steps and recording are in the task explorer. To time the agent on a task that is not a benchmark, start with a plan: Lusor is free to start, with no credit card needed.
Frequently asked questions
How fast is Lusor on AndroidWorld?
Lusor's median is 48.2 s per task across all 116 AndroidWorld tasks, against 120.5 s for agent-qa and 216.9 s for Mobilerun, the two entries that can be compared per task. Lusor's time runs from the agent's start to its finish. The others are the per-task times each team publishes.
How is "4.5× faster" calculated?
It divides one median by the other: 216.9 s for Mobilerun's published times by 48.2 s for Lusor. The benchmark page also reports 5.2× faster per task, which divides Lusor's time by Mobilerun's published time task by task and takes the median of the 116 ratios (0.19).
Where does a phone agent spend its time?
In each step, on five things: reading the screen, the model deciding, the phone acting, the app settling, and any retry when the step did not land. A task's time is the time per step multiplied by the number of steps, so an agent gets faster by making steps shorter, by needing fewer of them, or both.
Is Lusor faster than Mobilerun on every task?
No. Lusor was slower than Mobilerun's published time on 5 of the 116 tasks and faster on the other 111. Tasks is the only one of the 21 apps where Lusor's median was slower: 175.8 s against 146.9 s.
Does the speed come at the cost of accuracy?
On this benchmark it did not cost passes: the same run passed 116/116 tasks on Mobilerun's fork of the grader and 114/116 on Google's original grader. Lusor's run did not enforce AndroidWorld's step budget, and 22 of the 116 tasks used more device actions than theirs. The run was one seed and one trial per task.
Does a faster phone agent cost more to run?
Not in this run. The model calls for all 116 tasks cost $2.95, including the helper checks, against Lusor's estimate of about $108.70 for Mobilerun on the same tasks. That figure is an estimate, not Mobilerun's bill, and $2.95 is model cost only: it is not a subscription price and does not include hardware or infrastructure.