Your own device lab,
Plug real phones into one Mac. Watch, tap, and capture them from a browser.
Control and capture,
Hardware you own — same live feed, mocks, and scripts as every other source.
One Mac, dozens of phones
Connect the devices and they appear in the dashboard, provisioned and ready to control. No per-phone wiring, no lab software to babysit.
Watch it. Touch it. Live.
Low-latency H.264 mirroring streams each phone's screen into your browser, and your taps, swipes and keystrokes round-trip to the physical device. It feels like the phone is on your desk — because somewhere, it is.
Automate the whole fleet
Find-and-tap flows, app installs and launches, batch automations, schedules and screen recordings — run them on one phone or across all of them at once.
Capture comes included
Every farmed phone's HTTPS routes through the same capture pipeline as everything else. Control and traffic live in one feed — not two products stitched together.
One prompt drives it all
The entire farm is scriptable over MCP and BusyBro. 'Screenshot every phone and run the login flow' is a sentence, not a sprint.
Self-hosted. No seat fees.
It's your hardware and your daemon — inspectable, restartable and upgradable from anywhere. Real devices without a per-minute bill.
From USB hub
One host runs the farm daemon; everything else — mirroring, control, capture, health — arrives in your browser and your tools.
- 01
Plug in and they appear
Phones connect over powered USB hubs to one host. The farm daemon discovers each one over ADB — model, OS version, battery, state — and keeps a self-healing device list.
- 02
Mirror in the browser
scrcpy streams each screen as H.264, hardware-decoded in your browser with WebCodecs. Taps, swipes and keystrokes round-trip to the physical device — one phone, or a live grid of many.
- 03
Paired like any device
The host signs in and pairs as a Busymate device, so the fleet shows up in the dashboard with live health — and phone traffic routes through the shared capture pipeline into the same feed as every other source.
- 04
Driven by tools
Every action — shell, input, apps, files, automations, recovery — is an MCP tool, so a script, the dashboard, or an AI assistant can run one phone or the whole rack.
Drive it. Intercept it.
The differentiator isn't any one of these — it's all three in one session. Remote-drive a real device, watch every request it makes, and let an agent run the flow, from the same dashboard.
Drive it
Remote-control every phone from the dashboard — the H.264 mirror in your browser, your taps and keystrokes on the physical device. One screen or a live grid of the whole fleet.
Intercept it
While you drive, the phone's traffic routes through the same MITM proxy as every other source. You see every request the device makes — decrypted, searchable, replayable — in the same feed.
Automate it
The farm_* and ios_* tools put the whole fleet on the MCP surface, so an AI agent can run entire flows and read the captured traffic in the same session — OAuth 2.1 only, writes confirm-gated, raw-power tools admin-only.
Every action
The same operations behind the dashboard's Farm view are callable over MCP — by you, a script, or an AI assistant.
Mirror & input
Live screen and real touches: tap, swipe, long-press, type, hardware keys and screenshots — on one phone or across the selection.
- farm_start_mirror
- farm_input
- farm_screenshot
- farm_mobile_tap
- farm_mobile_swipe
- farm_mobile_type
Apps & files
Install and uninstall builds, launch and kill apps, grant permissions, push and pull files — fleet-wide, with per-device results.
- farm_install_app
- farm_app_lifecycle
- farm_grant_permission
- farm_push_file
- farm_pull_file
UI automation
Dump the live UI hierarchy and find-and-tap elements by text or id — the primitive that agent-driven flows are built from.
- farm_dump_ui
- farm_find_and_tap
- farm_mobile_list_elements
Network & settings
Toggle Wi-Fi and airplane mode, set the device proxy, change system settings — per phone or across the fleet.
- farm_set_wifi
- farm_set_proxy
- farm_set_airplane
- farm_set_setting
Automations & schedules
Record and replay flows, run scripted automations with variables across devices in parallel, and put any of it on a schedule.
- farm_run_automation
- farm_replay_recording
- farm_schedule
- farm_set_variables
Fleet health
Health checks, one-command healing and onboarding, reboots, daemon restart and hot update — recovery is a tool call, not a drive to the rack.
- get_farm_phone_health
- heal_farm_fleet
- onboard_farm_fleet
- farm_reboot
- update_farm_daemon
iPhones are first-class too: the ios_* twins mirror the same surface for iOS devices — mirroring, screenshots, input, apps and URLs.
As deep as the device
Busymate meets each phone where it is — standard tooling on a stock device, and full fidelity when you own root or a jailbreak.
| Method | How it captures | When it's used |
|---|---|---|
| Proxy MITM | HTTPS decrypted through the shared proxy CA | The default on any phone. Some certificate-pinned apps won't decrypt. |
| No-root packet capture | Full packet capture via a local VPN, no root (PCAPdroid) | When the capture app is installed and the VPN is granted once. |
| Rooted Android — tcpdump | Full-fidelity packet capture on the device itself | Used automatically when the device is rooted. |
Honest limit: proxy MITM can't decrypt apps that pin their own certificates. That's a property of the app, not a switch — root or a jailbreak buys you packet-level fidelity where you have it.
Standard iPhones — WebDriverAgent
Stock iPhones join with WebDriverAgent: mirroring, screenshots, input, app lifecycle, installs and opening URLs — no jailbreak required.
Jailbroken sub-fleet — bmtouchd
On a jailbroken iPhone the on-device bmtouchd engine injects input at the OS event layer (IOHIDEvent) and reads the framebuffer directly — no WebDriverAgent, no signing. Each device is routed to the engine it supports automatically.
Everything's already
Two ways in. Bring your own phones and one Mac, or rent devices from a managed fleet that's ready to drive the moment you sign in — either way you land in the same browser dashboard.
Self-host your rack
Your hardware, your daemon — inspectable, restartable and upgradable from anywhere. No seat fees, no shared tenancy, and traffic that never leaves infrastructure you control.
Rent, fully managed
Skip sourcing hubs and cables. Rent real devices from a managed fleet — provisioned, paired and online the moment you sign in. Same dashboard, same tools, same live capture.
Renting is per device. See device-rental pricing
One rack,
Release QA on real hardware
Run the same flow on every model and OS version you own at once — with screenshots, recordings and each phone's network traffic in one feed.
Agent-run device tests
'Install the build, run the login flow, screenshot every phone' is one prompt: BusyBro or any MCP client drives the same tools you do.
Overnight automations
Schedule recorded flows or scripted automations across the fleet; check results, recordings and captures in the morning.
Remote hands
The rack lives wherever power and bandwidth are cheap; the mirror, touch control and health tooling live in your browser tab.
Before you rack
What hardware do I need?
Real phones, data-capable USB cables, powered hubs and one host machine (a Mac mini works well). Android control is built on standard ADB and scrcpy — open tooling, no proprietary lab software.
Is this cloud phones or emulators?
Neither. It's your own physical devices on your own host — no per-minute billing, no shared tenancy, and traffic that never leaves infrastructure you control.
Do I have to own the phones?
No. Self-host your own rack for zero seat fees and traffic that never leaves your infrastructure, or rent devices from a managed fleet that arrives provisioned and online — same dashboard, same tools either way. Rental is per device; the pricing page has the current plans.
Can an AI really drive it?
Yes. Every farm action is an MCP tool behind per-device opt-in and permission gates, so an assistant can screenshot, tap, install and heal exactly what you allow — and nothing you don't.
What about iPhones?
iPhones are first-class fleet members: the ios_* tool twins cover mirroring, screenshots, input, app lifecycle, installs and opening URLs on iOS devices.
How does traffic capture fit in?
Farmed phones route through the same capture pipeline as every other Busymate source, so control and traffic share one dashboard, one filter model, one export.
Get started
Connect phones to one Mac, open the dashboard, and run the fleet from a browser.