Ceraph: The Playwright MCP for React Native

July 14, 2026Ike Studios LLC

Every developer who has shipped a mobile app knows the testing story. You write the feature, then you write the tests — an Appium script, a Detox flow, a Maestro YAML — and then you maintain those tests forever as the UI moves under them. AI coding agents rewrote the first half of that story: they write the feature now. This post is about the second half — giving those same agents the ability to test what they built, on a real device, the way a person would.

That is what Ceraph does. It is an MCP server that lets an AI coding agent drive and test your React Native or Expo app end-to-end (E2E) on real devices and virtual runtimes: tap, type, swipe, deep-link, screenshot, and read runtime errors — so a code change is verified against the running app, not just against the type checker. If you already know Playwright's MCP for the web, Ceraph is that, for React Native — and then more, because Ceraph runs inside the app rather than driving it from outside.

What is an MCP, briefly?

The Model Context Protocol (MCP) is an open standard Anthropic introduced in 2024 and has since handed off to neutral governance — the Agentic AI Foundation, a Linux Foundation project with Anthropic, OpenAI, Google, Microsoft, and AWS all at the table — for handing an LLM agent a set of tools it can call. An MCP server exposes typed actions; an MCP client — Claude Code, Cursor, Codex, VS Code, Antigravity, and others — lets the model behind it (Anthropic's Claude, OpenAI's GPT, Google's Gemini, or xAI's Grok) invoke them mid-conversation. Ceraph ships as one npm package, @ceraph/react-native-mcp, and every capability below is a tool your agent can call while it works. No new service, no separate test runner — the agent you already code with gains hands and eyes on the device.

From Selenium to AI agents

For twenty years, testing a UI meant writing a script. Selenium put the browser under program control back in 2004; WebDriver — the protocol nearly every tool since has built on — followed a few years later and merged into Selenium in 2011. Cypress and Playwright modernized the web side with faster runs, smarter waiting, and less flake, but the shape held: a human writes the selectors and assertions, then keeps them green as the interface changes.

Mobile inherited the same model. Appium brought WebDriver to native apps, wrapping Apple's XCUITest and Android's UIAutomator behind one API. Detox added gray-box synchronization built for React Native; Maestro made flows declarative with YAML. These are good tools — but every one of them still needs a person to author the test, encode the selectors, and babysit the script as screens move. That maintenance tax is why so many mobile test suites quietly rot.

Agentic testing changes the assumption underneath all of it. The agents in Claude Code, Cursor, and Codex already write the feature; what they have lacked is a way to use the app they just changed — to open the screen, walk the flow, and see whether it actually works. Ceraph closes that gap. Instead of a human maintaining a script against brittle selectors, the agent drives the running app directly, reads a structured accessibility snapshot to decide what to do next, and adapts when the layout shifts. The test author and the test runner become the same agent: the one that wrote the code.

That is the line between scripted automation and agentic testing. Selenium, Appium, and Playwright run a script you wrote and maintain; Ceraph hands the agent the primitives and lets it test the way a person does — look, act, look again — no selector file to keep alive.

The agentic loop: edit, ask, drive on device

Agentic testing only pays off when the agent can see what it did. The Ceraph loop is tight:

You edit code — add a screen, fix a bug, tweak a form.
You ask your agent to test what the change touched.
The agent drives the app on your selected runtime, observes each screen, and reports what passed and what looks off.

Under the hood that is four moves the agent repeats: ceraph_start to reach a ready state, ceraph_snapshot to observe, a screen_* primitive to act, then snapshot again. It is the same observe–act–observe agent loop that makes browser automation with Playwright reliable, brought to mobile.

What the agent can do

Bring the app up — ceraph_start takes the project to a ready-to-test state in one call and stops with a concrete fix if something blocks it.
See and act on the screen — ceraph_snapshot gives the agent an app-aware structured view with stable refs; screen and device actions let it tap, type, swipe, deep-link, rotate, and capture the rendered result.
Catch failures while it works — runtime errors land in the conversation instead of disappearing behind a redbox or silent crash.
Test mobile-specific flows — deterministic camera and gallery media make capture, scanning, and picker experiences testable.
Go further — verified paths become clean recordings with evidence under the ignored .ceraph/recorded-runs/ workspace, agent hooks automate test user setup and resolve test blockers, and live style evidence supports visual review.

Platform support

Ceraph supports iOS and Android. iOS devices and Simulators run on macOS through Xcode and WebDriverAgent. Android devices and Emulators run on macOS, Windows, or Linux through ADB and UiAutomator2.

Headless is worth knowing about: pass target: "headless" and the simulator runs without a Simulator.app window. It is the right target for cloud Macs, machines without a display, and unattended or background agent verification.

Android has the same product surface as iOS: managed bring-up, deterministic snapshots, screen primitives, runtime errors, camera and gallery testing, project-owned hooks, recorded runs, and style evidence. Android Emulators support both windowed and no-window execution; USB-connected physical devices are supported as well.

How it slots into your agent

Ceraph is client-agnostic — it works with any MCP client. Run one command in your React Native project root:

npx @ceraph/react-native-mcp@latest init

init auto-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. Your agent supplies its own tokens; Ceraph hands it the driving and testing primitives. There is nothing new to learn: you keep vibe coding in the editor you already use, and now the agent can prove its work on a real device.

Playwright's MCP is the right starting comparison because it established the loop: observe the screen, act on it, read the errors, iterate. Ceraph gives your agent that loop in React Native — and then keeps going, because a browser automation tool has to treat the page as a black box and Ceraph does not.

Playwright can only work with what the page exposes. Ceraph's React Native-specific integration adds app-aware snapshots, deterministic camera and gallery testing, project-owned hooks, live style evidence, and clean recordings of verified paths. Calling primitives is the floor, not the product.

That is React Native testing your agent can actually run — agentic, end-to-end, on a real device, with reach into the app that no general-purpose driver has.

Ready to try it? Get started here.