I've been experimenting with AI-assisted tooling in my React Native workflow for a while now, but Callstack's newly launched Mobile Tester Agent is the first tool that genuinely made me stop and reconsider how I think about mobile QA. If you've ever spent an afternoon untangling broken Detox selectors after a UI refactor, or wrestled with Appium's driver setup at 11pm before a release, this is worth your attention.
What Is Mobile Tester Agent?
Mobile Tester Agent is an AI-powered testing agent built by Callstack — the same team behind Re.Pack, react-native-paper, and React Native Testing Library. Unlike traditional end-to-end testing frameworks, it doesn't rely on element selectors, accessibility IDs, or pre-compiled test scripts. Instead, it uses a visual AI model to understand your app's UI at runtime and execute test scenarios written in plain English.
The core idea is straightforward: you describe what you want to test in natural language, and the agent figures out the rest. It visually identifies buttons, input fields, navigation elements, and content on the screen — the same way a human tester would — then taps, types, scrolls, and swipes its way through your app to verify the expected behaviour.
How It Works
Under the hood, Mobile Tester Agent connects to a running app instance — either a simulator, an emulator, or a real physical device — and captures screenshots at each interaction step. A multimodal vision model analyses each frame to determine what is currently visible and what action is needed next to progress toward the test goal.
The agent operates in a continuous loop: observe the screen, reason about the next action, execute the action, observe the result. This loop continues until the scenario is either verified successfully or a failure condition is detected. Because the agent reasons from pixels rather than a DOM or accessibility tree, it handles dynamically rendered content, animations, and loading states in a way that selector-based tools simply cannot.
In my experience, this observation-action loop is where Mobile Tester Agent earns its place. Traditional E2E tests fail silently when a loading spinner delays an element's appearance. The agent waits, reasons that the app is still loading, and tries again — behaviour that previously required explicit wait conditions and retry logic scattered across your test suite.
Setting Up Mobile Tester Agent
Setup is considerably lighter than Detox or Appium. You install the agent package, provide an API key for the underlying vision model, and point it at your running app. For a standard Expo or React Native CLI project the configuration looks roughly like this:
# Install the agent CLI
npm install --save-dev @callstack/mobile-tester-agent
# Create a config file
touch mobile-tester.config.js// mobile-tester.config.js
module.exports = {
platform: 'ios', // 'ios' | 'android'
target: 'simulator', // 'simulator' | 'emulator' | 'device'
apiKey: process.env.MOBILE_TESTER_API_KEY,
screenshotInterval: 500,
};There is no Gradle plugin to configure, no Detox binary to compile, and no XCUITest runner to provision. You start your app normally — npx expo start or npx react-native run-ios — and then invoke the agent against the running instance. For teams that have struggled with Detox's build-time setup, this alone is a significant quality-of-life improvement.
Writing Test Scenarios
This is where Mobile Tester Agent departs most dramatically from conventional testing tools. Tests are not code. They are natural language descriptions of user journeys. Here are three scenarios I've been running against a sample e-commerce app:
// scenarios/auth.test.txt
Log in with the email "test@example.com" and password "Test1234!".
Navigate to the Profile tab.
Verify that the user's name "Alex Johnson" is displayed on screen.// scenarios/cart.test.txt
Add 3 items to the shopping cart from the product listing page.
Navigate to the cart screen.
Apply the promo code "SAVE20" in the discount field.
Verify that the order total reflects a 20% discount.// scenarios/onboarding.test.txt
Launch the app for the first time as a new user.
Swipe through all onboarding screens.
Tap "Skip" on the final screen.
Verify that the home screen loads and the main navigation is visible.Each scenario reads like a manual QA test case — because that's essentially what it is. The agent interprets these instructions, translates them into device interactions, and reports back with a pass/fail result along with screenshots captured at each step. Non-developers can write these. A product manager can write these. That is not a small thing for teams where QA coverage has historically been gated on engineering time.
Real Device Testing
One of the more compelling capabilities is genuine real-device support. Simulator and emulator testing catches most regressions, but hardware-specific behaviour — font rendering differences, actual touch latency, real network conditions — has always required physical devices. Mobile Tester Agent connects to real devices over ADB on Android and via the standard iOS device tunnel on iOS.
In my testing against a physical iPhone 14, the agent handled the higher-resolution screenshots without any configuration changes. The vision model adapted to the actual pixel density and the slightly different rendering of system fonts on real hardware versus the simulator. That adaptability is exactly what you want from a visual testing approach — no magic strings, no device-specific selectors, no separate test branches for device versus simulator runs.
Comparison with Detox and Maestro
To be direct about where each tool fits, here is how Mobile Tester Agent compares to the two most popular alternatives in the React Native ecosystem today:
| Feature | Mobile Tester Agent | Detox | Maestro | Appium |
|---|---|---|---|---|
| Test language | Plain English | JavaScript/TypeScript | YAML | Java / JS / Python |
| UI interaction method | Visual AI | Accessibility IDs / selectors | Accessibility IDs / text | XPath / selectors |
| Setup complexity | Low | High (build config required) | Medium | Very high |
| Selector brittleness | None | High | Medium | Very high |
| Execution speed | Slower (vision model latency) | Fast | Fast | Medium |
| CI/CD integration | Early support | Mature | Mature | Mature |
| Non-developer authoring | Yes | No | Partially | No |
| Real device support | Yes | Yes | Yes | Yes |
Detox remains the right choice for teams that need deterministic, fast test suites with precise control over timing and mocking. Maestro is excellent for mobile teams who want YAML-driven flows without the Detox build overhead. Mobile Tester Agent earns its place when your pain point is selector maintenance or when you need to hand test authorship to non-engineers.
Limitations to Know Upfront
It would be dishonest to present this as a complete replacement for established testing tools. Mobile Tester Agent is early software, and a few limitations matter in practice.
Execution speed is the most significant one. Each step in a scenario requires a screenshot capture, a round-trip to the vision model's API, and a response to parse before the next action is taken. On a fast network, individual steps take roughly one to two seconds. A scenario with fifteen steps can take thirty seconds or more to complete. For a large test suite that Detox might finish in two minutes, the agent could take twenty. This matters in CI environments where pipeline time has a real cost.
The tool also requires an external API key for the vision model, which introduces a network dependency and an ongoing cost. For teams with strict data residency requirements, sending screenshots of your app's UI to an external model endpoint may require legal review. Callstack has indicated that on-premise and self-hosted model options are on the roadmap, but they are not available at time of writing.
Finally, the CI/CD integration story is still developing. GitHub Actions support exists but is not as polished as Detox's mature ecosystem of cloud runners and caching strategies. Expect to do some configuration work to get reliable pipeline runs today.
The Future of Mobile QA
What excites me most about Mobile Tester Agent is not what it does today but what it represents architecturally. Selector-based testing has always had a fundamental problem: it couples your test suite to your implementation details. Every UI refactor — renaming a component, restructuring a screen, updating a design system — breaks tests that were perfectly valid from a user's perspective. Developers spend time fixing tests rather than fixing bugs.
Visual AI testing decouples the test from the implementation. The scenario "log in and verify the user's name is displayed" remains valid whether you restructure your navigation, rename your components, or migrate from one UI library to another. The agent adapts; the test doesn't need to be rewritten. For small teams where a single developer is simultaneously the engineer, the QA engineer, and the release manager, eliminating that maintenance burden is genuinely valuable.
I also think the natural language interface unlocks a different kind of test coverage. In my experience, engineers write tests for paths they've already thought about. Product managers and QA specialists think about edge cases from a user's perspective and often surface scenarios that engineers wouldn't think to automate. If both groups can write test scenarios without learning a testing framework, coverage improves across the board.
Getting Started
If you want to try Mobile Tester Agent on an existing React Native or Expo project, the path is low-friction enough to justify a few hours of experimentation even before committing to it as a primary testing strategy.
Start by identifying two or three critical user flows in your app — authentication, your core purchase or conversion flow, and onboarding are good candidates. Write those flows as plain English scenarios. Run the agent against your development build on a simulator. Review the screenshot trail it produces for each step and compare the agent's interpretation of your UI against your own understanding of it.
That review process is itself valuable independent of the test results. Watching an AI navigate your app the way a first-time user would exposes assumption gaps in your UI that you've become blind to through familiarity. In one session I discovered that our loading state on the cart screen was ambiguous enough that the agent — and presumably real users — couldn't tell whether the app was processing a request or had silently failed.
Mobile Tester Agent is available through Callstack's tooling ecosystem. Check the official Callstack GitHub organisation and their documentation site for the latest installation instructions, as the package is under active development and the setup details are evolving rapidly. For small teams who can't staff a dedicated QA function, it's one of the more promising tools to emerge in the React Native ecosystem this year.