Mobile Testing MCPs Compared: Ceraph vs Agent Device vs Mobile MCP
A year ago the question for a React Native team was whether their testing framework had an MCP. That question is settled for Maestro and Appium, which both ship official agent integrations. The interesting development is the class of tools that skipped the framework entirely and shipped as an MCP from day one: @mobilenext/mobile-mcp and Callstack's agent-device. No YAML, no spec files, no test runner — just an agent, a device, and a set of tools.
Ceraph is in that class too, and this post is about what separates the three. The short version: mobile-mcp and agent-device are device-control layers that happen to work with React Native apps. Ceraph is built inside React Native. That distinction sounds like positioning until you look at what each one can actually reach — and there are capabilities on one side of it that the other side cannot implement at all, no matter how much engineering goes in.
Two things to say plainly and then set aside. Ceraph supports iOS and Android physical and virtual runtimes for React Native and Expo. At the driver layer it uses WebDriverAgent/XCUITest on iOS and UiAutomator2 on Android. The argument below is not about the driver. It is about what sits above it.
The landscape at a glance
| Ceraph | agent-device | mobile-mcp | |
|---|---|---|---|
| Origin | Purpose-built for React Native and Expo | Callstack — universal device control | Mobile Next — platform-agnostic mobile automation |
| Platforms | iOS + Android, physical and virtual runtimes | iOS, Android, HarmonyOS, tvOS, Android TV, Amazon Vega OS, web, macOS, Linux | iOS + Android, simulator and real device |
| What the agent sees | One app-aware structured snapshot with stable refs | Accessibility tree with @eN refs; React component tree as a separate inspection | Accessibility tree, "falling back to screenshots + coordinates only when needed" |
| App bring-up | One call from project to ready-to-test | Session opens against an installed app; you start Metro yourself | Launch an installed app |
| React Native runtime errors | Surfaced to the agent automatically | Logs and crash context | Crash reports |
| Run project code inside the app | Yes — project-owned hooks | No | No |
| Camera testing | Yes — deterministic images and videos | No (permission toggles only) | No |
| Live style evidence | Yes | No | No |
| Repeatable runs | Verified replay → reviewable evidence | Self-healing .ad scripts (v0.20.0); strict Maestro YAML export | Screen recording only, no replay |
| Setup | npx @ceraph/react-native-mcp@latest init — auto-configures every MCP client it detects | CLI install, then per-client MCP setup | Add the MCP server to your client config |
| License / price | Free Starter + $9/mo Pro; proprietary commercial license | MIT | Apache 2.0 |
Device control is not React Native access
Every tool in this comparison can tap, type, swipe, and screenshot. That is table stakes, and it is where the similarity ends.
A device-control layer talks to the operating system. It asks iOS for the accessibility tree and asks XCTest to send a tap. Everything it knows about your app arrives through that OS-level keyhole. React Native happens to render into it, so React Native apps work — the same way Flutter apps work, and native apps, and a TV shell.
Ceraph is built specifically for React Native. That app-aware integration gives the agent one structured snapshot with the roles, names, bounds, state, and stable refs it needs to act reliably, rather than making it reconcile separate inspection modes.
That access is not a nicer snapshot format. It is a different set of things you can do:
Your agent can establish app-owned test state. Project-owned hooks can use the app's existing test setup to create a disposable session, entitlement, feature flag, or other prerequisite the UI cannot reliably reach.
This is the answer to the question every mobile E2E setup eventually hits: how do I test the screen behind the login wall, the paywall, the feature flag, the expired-subscription state? A device-control agent can only answer it by driving the UI — which means real credentials typed into a real form on every run, and no path at all to a state the UI cannot reach. A hook establishes disposable state directly, then lets the agent continue through the representative UI flow. An external process cannot do this. It is not a missing feature on their roadmap; there is no seam in the operating system where it would go.
Your agent can test camera flows. iOS blocks external processes from supplying deterministic camera input — which is why no general-purpose device controller in this comparison can reliably test an ID scan, a profile capture, or a document upload. Ceraph makes those flows testable with development-only images and videos, while production builds continue to use the real camera.
Your agent can see styles, not just pixels. Ceraph can return live style evidence alongside the snapshot, so the agent can review theming and layout without guessing from pixels alone. An accessibility tree does not carry that evidence, and a screenshot leaves it for a vision model to infer.
Bring-up is a product feature, not a prerequisite
The gap that shows up first in daily use is smaller and more annoying than any of the above.
ceraph_start is one call that takes an Expo or bare React Native app from cold to ready-to-test, including getting an Expo dev client past its launcher screen. It does only the work that is missing and stops at the first blocked step with a concrete remediation.
The alternatives start further along the path. agent-device has a Metro bridge and a reload command, and its own docs instruct you to run yarn expo start --dev-client --port 8081 yourself before the agent takes over. mobile-mcp launches an installed app. Neither builds your app from source, and neither knows what an Expo dev-client launcher screen is or how to get past it.
That difference is small on the first run and compounding on the hundredth, because it is the step that fails when your laptop sleeps, when the LAN IP changes, or when the phone drops off Metro mid-session — the moments where an agent otherwise stalls and hands the problem back to you.
Replay: evidence, or another artifact to maintain?
Both Ceraph and agent-device can repeat a verified path. They mean different things by it.
agent-device saves working steps as .ad scripts "for local use or CI," and exports strict Maestro YAML — as of v0.20.0, those scripts self-heal stale selectors automatically. That is still a test artifact: a file in your repo, authored once and kept green as the UI moves, now with an agent doing the repairs instead of a person. It is the same maintenance contract the incumbent frameworks offer, re-entered through a nicer front door.
ceraph_record_run turns an already-verified path into a clean MP4 with structured UI snapshots and screenshots tracing the flow under the app's ignored .ceraph/recorded-runs/ workspace. The result is evidence you can review without adding another test script to maintain.
The distinction matters because it decides what you own afterward. One approach hands you a script to keep green. The other hands you ignored local evidence to review without adding a maintained test artifact.
What breadth costs
agent-device targets iOS, Android, HarmonyOS, tvOS, Android TV, Amazon Vega OS, web, macOS and Linux. That surface area is not free, and it is worth being precise about who pays for it.
A tool that must work on nine targets can only build on what all nine have in common: an accessibility tree and a way to send input. Every capability in the section above — running your code inside the app, injecting camera frames, reading render-time styles — exists precisely because Ceraph declined that constraint. Leanness is the mechanism, not a consolation. You cannot ship React-Native-specific app access on Linux, so a universal tool never builds it, and its React Native support settles at what a devtools bridge can observe from outside.
The same holds for install surface. Ceraph is one npm package and one command:
npx @ceraph/react-native-mcp@latest initThat configures every MCP client it detects — Claude Code, Cursor, Codex, VS Code, Antigravity — installs runtime-error delivery, and offers browser sign-in when you choose Pro. Starter requires no account. There is no CLI to learn alongside the MCP, no daemon to reason about, and no per-platform backend to keep straight.
On licensing: Ceraph uses its proprietary Ceraph Software License Agreement. Starter remains free for internal development and testing, while Pro requires an active subscription. Using Ceraph materials to recreate its features for any purpose, modification, reverse engineering, redistribution, competitive use, and bypassing subscription controls are prohibited. Documented extension points remain available for project-owned hooks, configuration, fixtures, and test artifacts.
The scope statement worth making plainly: Ceraph supports React Native and Expo apps on iOS and Android, with managed bring-up, diagnostics, deterministic snapshots, the full primitive surface, runtime errors, camera/media testing, hooks, execution traces, styles, and recording. It remains deliberately focused on React Native apps rather than broadening into a generic controller for every operating system.
Which one to pick
- Building a React Native or Expo app on iOS or Android? Pick Ceraph. Your agent gets an app-aware snapshot, one-call bring-up past the dev-client launcher, runtime errors in the conversation, testable camera flows, and hooks and recorded runs that reach blocked state and leave reviewable evidence. Nothing else in this comparison implements those React-Native-specific capabilities without becoming a React Native tool.
- Need a non-mobile target or broader operating-system coverage? Use agent-device for that surface. It covers targets Ceraph deliberately does not, at the level each operating system exposes.
- Not a React Native app at all? Use agent-device or mobile-mcp as a general-purpose device controller.
Where this leaves you
Being MCP-first is no longer a differentiator — every tool in this post is, and more are coming. What separates them is how deep into your app the agent can actually see, and that ceiling is set by scope. A universal device controller is bounded by what nine operating systems agree to expose. Ceraph's ceiling is the app itself and your own source code: state your UI cannot reach, deterministic camera media the platform driver cannot inject, and styles no accessibility tree carries.
For a React Native or Expo team, that is not a tradeoff. It is the whole point.
Try it on your own app — get started.