Mobilewright vs Maestro: Code-First Mobile Testing with Auto-Waiting

Mobilewright vs Maestro, feature by feature

Dimension	Mobilewright	Maestro
Authoring	Real TypeScript code, Playwright-style API	Declarative YAML flows
Programmability	Full language — loops, conditionals, fixtures, types, npm packages	YAML commands + JavaScript (evalScript/runScript), when: conditions, repeat loopsReal logic is possible, but lightweight and scripted
Type safety / IDE	Full TypeScript types + autocomplete	YAML — no type safety, limited editor tooling
Auto-waiting	Built into every action and assertion	Built in — automatically waits for content and animations
Element selection	getByRole / getByLabel / getByText / getByTestId / getByType — chainable	text, id, index, relational (above/below), state matchers
iOS	Simulators AND real iOS devices. UIKit, SwiftUI, React Native, Expo	Simulators onlyReal iOS devices not supported per Maestro's docs; physical iPhones only via third-party clouds
Android	Emulators + real devices. Native Android, React Native, Expo	Emulators + real devices
AI agent / MCP	Agent-ready by design — accessibility tree, deterministic code	MCP server + assertWithAI / extractTextWithAIAI commands are experimental and use the Maestro Cloud LLM backend
Reporting	HTML report, screenshots, video, JUnit/JSON	JUnit + HTML locally; richer reports via Maestro Cloud
CI	Documented CI guide; built-in workers + sharding	Maestro CLI in any CI; Maestro Cloud for hosted runs
Cloud device farm	Mobile Next Cloud — the same scripts run unmodified	Maestro Cloud — hosted devices and parallel runs
Best for	Engineers who want real code + Playwright DX	Teams wanting quick, low-code YAML flows
License	Apache 2.0, open source	Apache 2.0, open source (CLI)

Write tests in real TypeScript

Maestro flows are YAML lists of commands. That's wonderfully readable for a straight-line path, but the moment you need data-driven loops, shared setup, or branching, you drop into embedded JavaScript snippets and the YAML starts fighting you.

Mobilewright is TypeScript top to bottom. Loops, conditionals, fixtures, helper functions and npm packages are just code — with types and autocomplete the whole way.

import { test, expect } from '@mobilewright/test';

test('add three items to cart', async ({ screen }) => {
  for (const name of ['Coffee', 'Tea', 'Water']) {
    await screen.getByRole('button', { name: `Add ${name}` }).tap();
  }
  await expect(screen.getByText('3 items')).toBeVisible();
});

Loops, variables and types — no YAML, no embedded JS snippets.

Auto-waiting, no flakiness

Credit where it's due: Maestro auto-waits too — it deliberately tolerates the instability of mobile by waiting for content and animations, so you rarely write manual sleeps. That's a real strength.

Mobilewright's model is the Playwright one: explicit actionability checks (exists, visible, enabled, stable) before each action, plus assertions that retry until they pass or time out — all expressed as code you can read and reason about.

await screen.getByRole('button', { name: 'Checkout' }).tap();
await expect(screen.getByText('Order placed')).toBeVisible();

Every action and assertion auto-waits and retries until it passes or times out.

Real iOS devices, not just simulators

Maestro's own documentation states that running tests on physical iOS devices is not supported yet — iOS runs against the Simulator, and real iPhones are only reachable through third-party device clouds.

Mobilewright drives real iOS hardware and simulators through one API. The test you write against a simulator is the same test you run on a physical device — or unmodified on Mobile Next Cloud.

Built for AI agents

Both tools ship an MCP server, so both can be driven by AI assistants. Maestro goes further with experimental AI commands like assertWithAI and extractTextWithAI — powerful, but they route through the Maestro Cloud LLM rather than running locally.

Mobilewright takes a deterministic path: it exposes the platform accessibility tree so agents act on real roles, labels and values, and your tests stay plain, reviewable TypeScript. It comes from the team behind Mobile MCP.

// mobilewright.config.ts — attach the accessibility tree on failure
use: {
  viewTree: 'on-failure',
}

Agents read the real element tree — not a screenshot routed through a cloud model.

Frequently asked questions

Is Mobilewright open source?

Yes. Mobilewright is open source under the Apache 2.0 license and the code is on GitHub. Maestro's CLI is also Apache 2.0; its hosted cloud is the paid product.

Can I migrate from Maestro?

Yes. Maestro flows map to Mobilewright tests command by command: tapOn becomes getByText(...).tap() and assertVisible becomes expect(...).toBeVisible(). You trade YAML for TypeScript and gain loops, conditionals and types without embedded JS snippets.

Does Mobilewright support real iOS devices?

Yes. Mobilewright runs on real iOS devices as well as simulators. Maestro's documentation states that running tests on physical iOS devices is not supported yet, so this is a meaningful difference if you need to test on real iPhones.

Does Maestro have AI features?

Yes — Maestro ships an MCP server and experimental AI commands such as assertWithAI and extractTextWithAI that use its cloud LLM. Mobilewright is also agent-ready, but takes a deterministic approach: agents read the accessibility tree and your tests stay plain TypeScript.

YAML or code — which should I choose?

If you want the simplest possible flows that anyone on the team can read and edit, Maestro's YAML is hard to beat. If you want real programmability — loops, conditionals, fixtures, types and npm packages — choose Mobilewright.

Does Mobilewright work with AI agents?

Yes. It is agent-ready by design: it exposes the platform accessibility tree so agents act on real elements and roles rather than guessing coordinates. It comes from the team behind Mobile MCP.