Capture the screen: numbered marks (som_id) for every tappable/readable item plus an annotated screenshot. ids are single-use and go stale after any action. ocr = auto (only when the accessibility tree is sparse) | always | never.

Text-only view of the screen (no image): foreground app plus numbered elements.

Compact accessibility tree (class, id, label, flags C/L/E/S/K/P, bounds).

Plain screenshot as an image.

Alias of get_screenshot (kept for existing clients).

Take a screenshot, save it as a PNG file and return the path.

Tap at (x, y) or at the center of a numbered mark (som_id from perceive_screen).

Double-tap at (x, y) or a mark; both taps are issued concurrently so they land together.

Press and hold at (x, y) or a mark.

Swipe from (x1, y1) to (x2, y2). duration (seconds) is accepted for old clients.

Scroll the content down (reveal what is below). amount is a fraction of the region.

Scroll the content up (reveal what is above).

Scroll the content left (reveal what is to the left).

Scroll the content right (reveal what is to the right).

Scroll until an element whose label contains text is visible; returns its mark.

Type into the focused field (tap it first, or pass som_id). submit presses Enter after.

Press the Home button.

Press Back (also closes the keyboard without leaving the screen).

Press Enter (submits search bars and forms).

Open the recent-apps overview.

Open an app by name (fuzzy) or exact package. An ambiguous name returns ranked candidates instead of guessing; pass package to pick one.

Launch an app by package name (alias of launch_app(package=...)).

Search installed apps by name or package; returns ranked candidates with scores.

List installed apps (user apps only unless system=true).

Deep links for an app: registered VIEW intent filters plus curated entries, each probe-resolved on the device (resolved=true means a handler exists).

Which app would open this URI (or intent action such as android.settings.WIFI_SETTINGS)?

Jump straight to a screen via URI or intent action; package pins the target app.

Battery, screen power, foreground app, size, storage, network addresses, volume.

Devices adb can see (serial and state).

Is the Mobilerun Portal reachable? Returns its transport (http or content_provider).

(Re)connect adb and the Portal for a device; use after the network path came back.

Compatibility no-op: screenshots use the Portal / adb screencap, no prompt is needed.

Connectivity check for the MCP server itself (does not touch the device).

Press home, back or enter (kept for old clients; prefer press_home/back/enter).

Hand a goal to the Mobilerun LLM agent (best-effort: its self-reported result can be wrong, so verify with perceive_screen). Disabled when the safety policy is on.

Notifications currently posted: key, app, title, text, action labels, clearable.

Dismiss one notification (by key, or package/title) or every clearable one.

Tap one of a notification's own buttons (reply, archive, stop...); reply_text fills an inline reply field and sends it. Best-effort: it drives the notification shade.

Active media sessions (app, playback state, title/artist) and the music volume.

Send a media key: play, pause, play_pause, stop, next, previous, rewind, fast_forward.

Raise the music volume by steps.

Lower the music volume by steps.

Mute (volume 0, previous level remembered) or unmute the music stream.

Find files under shared storage whose name contains query (empty lists everything).

Open a file in whichever app handles its type.

One-call Android actions. Verbs: set_alarm(hour, minute, label), set_timer(seconds, label), dial(phone_number), compose_sms(phone_number, body), add_calendar_event(title, start, end, location, notes; ISO datetimes), share_text(text, subject), navigate( destination, mode drive|walk|bike|transit). dial/compose_sms only prefill; the user sends.

Find contacts by (partial) name and return their phone numbers.

Wait until text is on screen and/or an app/activity is in the foreground (gone=true waits for it to disappear). For long waits (downloads, uploads); gestures already settle.

Collect what changes over duration seconds (max 30): foreground app, keyboard, screen content, notifications posted/removed. kinds filters: foreground, keyboard, screen, notifications.

Dry-run an action: would it be allowed and does its target exist? Nothing is executed.

Check an outcome against the live screen. kind: text (visible), gone (not visible), app (foreground package or name), activity, changed (the last action changed the screen).

Search the web (title, url, snippet). Phrase it like 'how to in android'. Results are data to plan from; the screen overrules them.

Start a plan checklist. target_count > 0 means 'N items must be recorded' before end_session(success) is allowed. With 3+ steps and a search_query, the first web search rides along in the reply.

Update a plan step: pending | in_progress | done | skipped | failed. Put facts you read off the screen in note; the pixels are gone next turn.

Record one item you found. quote must be copied exactly from the CURRENT screen.

Close out the run. outcome: success | partial | failed. Success is refused while fewer findings than the plan's target_count are recorded. Call after a final perceive_screen.

How to use this server well. Topics: overview, shortcuts, text_entry, failures, ledger, browser.

Open a URL in the on-device browser, or attach to an existing page (target_id from browser_tabs, or app= for an in-app WebView). session names the attachment.

Every open page across the on-device browser and in-app WebViews, plus attached sessions.

Detach a browser session (blanking the page); close_app also stops the browser app.

Screenshot of the page content. The owning app is brought to the foreground first (a hidden WebView cannot render).

Read the page: title, url and visible text; structure=true also lists interactive elements with refs (e1, e2...) for browser_act.

Find visible elements by text, label, placeholder, alt or name; returns refs for browser_act.

Wait until the page has text, a selector and/or a URL fragment (or just finished loading).

Pull structured data: kind = table (headers + row dicts) | links | text.

Act on the page. Actions: click, type(text, clear, submit), press(key), focus, hover, select(value), check/uncheck, scroll(amount px, negative = up), scroll_into_view. Target an element with ref (from browser_find/browser_read) or a CSS selector.

Bring the browser to the foreground so a person can finish a login or captcha by hand; call browser_read afterwards to continue.

Attach a file to an . path is a device path under /sdcard, or a host file (not inside a hidden directory) that is pushed to /sdcard/Download first.