> Mobilewright vs Maestro: Code-First Mobile Testing with Auto-Waiting
> Canonical: https://mobilewright.dev/compare/mobilewright-vs-maestro/

Comparison · vs Maestro

# Mobilewright vs Maestro

Real TypeScript and a Playwright-style API — the power of code, with auto-waiting and AI-agent support built in.

Last updated: October 18, 2026

## 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 loops (Real 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 only (Real 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 / extractTextWithAI (AI 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 that removes most manual waits

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.

## Related comparisons

*   [**Mobilewright vs Appium** — A Playwright-style API for iOS & Android — auto-waiting, no servers, no XPath, built for AI agents.](/compare/mobilewright-vs-appium/)
*   [**Mobilewright vs Detox** — Detox tests React Native from inside the app. Mobilewright tests any app from the outside, on simulators and real devices.](/compare/mobilewright-vs-detox/)
*   [**Mobilewright vs WebdriverIO** — Both are TypeScript. WebdriverIO reaches a phone through an Appium server; Mobilewright talks to the device directly.](/compare/mobilewright-vs-webdriverio/)
