How to Give an AI Agent Full Control of a Real iOS or Android Device (over MCP)

#mcp #ai #testing #mobile

AI agents are getting good at writing code, browsing the web, and calling APIs. But there's one surface most of them still can't touch: a real phone. Not a simulator, not a screenshot fed back to the model — an actual iOS or Android device, driven with the fidelity of a human's fingers.

This guide shows you how to give an agent exactly that, over the Model Context Protocol (MCP). By the end, your MCP client — Claude Desktop, Cursor, Cline, or your own — will be able to open a real device, tap and type on it, see what the app is doing, capture and mock network traffic, spoof GPS, and even explore an app and generate test scripts. All of it as MCP tools the agent can call directly.

What you'll be able to do

Once connected, the agent has the same reach a human tester has on a real device:

Control — real taps, press-and-hold, swipes, drag, and typing (native, hardware-level input, not a laggy screen-share overlay)
See — live screenshots, on-device web inspection, the UI element tree / DOM
Inspect the network — capture every request the app makes, and mock any request or response to force error states and edge cases
Simulate — set GPS location anywhere on earth
Automate — explore an app, find issues, and generate runnable test scripts

Prerequisites

An MCP-capable client (Claude Desktop, Cursor, Cline, or any client that speaks MCP)
A free RobotActions account (that's what exposes the real devices as MCP tools)

Step 1 — Get your RobotActions API token

The device tools are gated behind a personal API token — no anonymous access, by design.

Sign up at robotactions.com — one click with Google or GitHub.
Open your workspace, click your profile avatar (top-right) → API Tokens.
Click New token, name it (e.g. "Claude Desktop"), and copy it now — it's shown once.

You'll pass this as a bearer token when you connect.

Step 2 — Connect your MCP client

You have two paths. Pick the one that matches your client.

Option A — Claude.ai / Claude Desktop (remote connector)

Add RobotActions as a remote MCP connector pointing at:

https://mcp.robotactions.com/mcp

When prompted, authenticate with the API token from Step 1 (Authorization: Bearer <your-token>). The connector handles the rest.

Option B — Cursor, Cline, or a local MCP config

Use the connector package to wire it into your MCP config:

npx @robotactions/mcp init

Or add it manually — endpoint https://mcp.robotactions.com/mcp, with your token as the Authorization: Bearer header. (RobotActions is also listed on the official MCP registry, Smithery, and glama if your client installs from there.)

Reload your client and you should see the RobotActions tools appear.

Step 3 — Your first commands on a real device

Now just talk to your agent. Try:

"List the available devices, open an Android one, and take a screenshot."

The agent will call the device-list and screenshot tools and hand you back a real frame from a real phone. From there:

"Open the Settings app, go to Wi-Fi, and turn it off."

The agent taps and swipes on the actual device — real touches, not a simulated overlay.

Step 4 — The part agents couldn't do before

This is where it gets interesting. Because the agent has full access — visual and programmatic — you can ask it to do things a screen-share bot never could:

Inspect and mock the network:

"Capture the network calls this app makes on launch, then mock the /profile response to return an empty state, and show me how the app renders it."

Force a location:

"Set the device's GPS to Tokyo and check that the store locator updates."

Explore and test:

"Walk through the checkout flow, flag anything that looks broken, and generate a test script that reproduces it."

The agent sees the screen, reads the network and the UI elements, and drives the input — so "test this app" becomes a single instruction instead of a week of setup.

Why this matters

Mobile test infrastructure was built for humans staring at a remote screen. As agents start doing real work, they need to operate real devices with human-level fidelity — and reach everything programmatically, not just the pixels. Exposing real-device control as first-class MCP tools is what turns "an agent that can see a phone" into "an agent that can actually use one."