Agents & MCP
An agent that taps, types and reads.
mobilerun runs an agent on a real phone that taps, types and reads any app. It ships as two agent models, fast and thinking, and it is driven by the LLM of your choice. One API call runs the task.
agent fast + thinking
LLM your choice
reads a11y tree
connect hosted MCP
Capabilities
One call, a real run.
| Capability | What it does | In the API |
|---|---|---|
| Run a task | One API call drives the app: client.tasks.run({ deviceId, task }). Toggle reasoning, vision, maxSteps and stealth per call. | client.tasks.run |
| Structured output | Pass an outputSchema and the agent returns typed JSON, not a screenshot for you to parse. The task hands back the data you asked for. | outputSchema → JSON |
| Reads the screen | The agent reads the accessibility tree, not just pixels. Fewer tokens and cleaner steps than a vision-only run, with vision still there when a screen needs it. | a11y tree |
| Your LLM | Drive the agent with the LLM of your choice: Claude, Gemini, GPT, Kimi or Grok. Bring the key, keep the model call yours. | bring your own |
One call
One sentence in, a real run out.
No flow to build, no selectors to maintain. Post the task, pick the model, get the run back. Attach to it for the live trajectory.
agent.ts
import Mobilerun from '@mobilerun/sdk'
const client = new Mobilerun() // reads MOBILERUN_CLOUD_API_KEY
const task = await client.tasks.run({
deviceId: 'dev_...',
task: 'Open DoorDash and reorder my usual',
})
console.log(task.status) // queued -> running -> completed What it sees
It screenshots when it needs to look.
The agent reads the accessibility tree first, so most steps stay fast and cheap. When a screen needs eyes it takes a screenshot, and every shot is pinned to the step that produced it. Watch it live, or replay the whole run after.
Live view
- Attach to a running task and watch the device in real time
- Every step streams a screenshot as the agent takes it
- Step in by hand with tap, type and swipe when you need to
Step trajectory
- Each step is an event: queued, screenshot, tool call, result
- Click a step to see exactly what the agent saw and did
- No more guessing why a run failed on step 47
Replay & history
- Scrub the full recording once the run finishes
- Screenshots, tool calls and typed output, kept as an audit trail
- See full observability →
watch.ts
const stream = await client.tasks.attach(task.id) // live SSE
for await (const event of stream) {
if (event.type === 'ScreenshotEvent') {
save(event.screenshotUrl) // what the agent just saw
}
} Two agent models, one runtime
- mobile-agent-fast for quick, repeatable taps and reads
- mobile-agent-thinking when a flow needs a plan before it acts
- Both drive real apps on a real device, step by step
- The agent layer is ours, the LLM underneath stays yours
Same agent, in your editor
- A hosted MCP server plugs the agent into Claude Code, Cursor and VS Code
- Remote MCP at api.mobilerun.ai/v1/mcp, authorized with a Bearer key
- Same runtime, same real devices, from the tools you already use
- No local daemon to babysit, no setup to keep alive
FAQ
Agents, common questions.
Do you ship your own LLM?+
No. mobilerun ships the agent layer, two models called mobile-agent-fast and mobile-agent-thinking. The reasoning is driven by the LLM of your choice: Claude, Gemini, GPT, Kimi or Grok. You bring the key, we drive the phone.
What is the difference between fast and thinking?+
mobile-agent-fast is built for quick, repeatable taps and reads. mobile-agent-thinking plans a multi-step flow before it acts. Pick one per task, or let the runtime choose.
How does one task run?+
One API call: client.tasks.run({ deviceId, task }). Set reasoning, vision, maxSteps and stealth as options. Pass an outputSchema and you get typed JSON back instead of a screenshot to parse.
Why read the accessibility tree instead of pixels?+
The agent reads the accessibility tree the app already exposes, so a step costs fewer tokens and lands cleaner than vision only. Vision stays available for the screens that need it.
Does the agent take screenshots?+
Yes. It reads the accessibility tree by default and takes a screenshot when a screen needs eyes. Each shot streams as a ScreenshotEvent pinned to its step, and you can grab one any time with client.devices.state.screenshot(deviceId).
Can I run the agent from my editor?+
Yes. A hosted MCP server plugs the same agent into Claude Code, Cursor and VS Code. Point them at the remote MCP endpoint at api.mobilerun.ai/v1/mcp with your Bearer key and you drive real devices from the tools you already use.
Also on the platform: real devices · observability · the framework · pricing
Give any LLM a phone.
One API call runs the task on a real device, driven by the LLM you choose. Plug the same agent into your editor over MCP.