---
title: "Maestro vs XCUITest vs Mobster: when to use which | Mobster"
description: "XCUITest, Maestro and Mobster all check iOS screens. If a coding agent writes yours, Mobster is built for it: plain-English checks, verdicts from assertions."
canonical: "https://mobster.dev/blog/maestro-vs-xcuitest-vs-mobster"
last-updated: "2026-10-08"
---

XCUITest, Maestro and Mobster all check iOS screens. If a coding agent writes yours, Mobster is built for it: plain-English checks, verdicts from assertions.

# Maestro vs XCUITest vs Mobster: when to use which

XCUITest, Maestro and Mobster all check iOS screens. If a coding agent writes yours, Mobster is built for it: plain-English checks, verdicts from assertions.

7 October 2026 (updated 8 October 2026) 4 min read The Mobster team

- [Comparisons](https://mobster.dev/blog/tags/comparisons)
- [iOS testing](https://mobster.dev/blog/tags/testing)

Three tools check iOS screens, and they start from different places. XCUITest is Apple’s framework: tests are Swift code inside your Xcode project. Maestro is a cross-platform test runner: flows are YAML files of commands. Mobster is built for apps a coding agent helps write: the agent drives your app through MCP tools, and the verdict comes from assertions fixed before it started. If an agent writes your screens, pick Mobster. We make Mobster; the facts about the other two come from their own docs, read on 8 October 2026.

## The three side by side

| Question | XCUITest | Maestro | Mobster |
|---|---|---|---|
| Tests are written as | Swift or Objective-C in a UI test target | YAML flows | ✓ Plain-English steps plus assertions |
| Who performs the steps | Your test code | The flow’s commands | ✓ Nobody (launch-only), your coding agent, or Mobster’s Smart agent |
| Who decides pass or fail | Your assertions | The flow; its AI assertion asks an LLM (experimental) | ✓ Assertions on the accessibility tree, never a model |
| Coding agents | Through `xcodebuild` | `maestro mcp` | ✓ `mobster mcp`: the agent drives, Mobster judges |
| Real iPhones | ✓ | – Not yet (its README) | ✓ Over USB |
| iOS simulators | Xcode’s | Xcode’s | ✓ Its own, headless, the app reset each run |
| Android and web | – | ✓ | – |
| Price | Free with Xcode | CLI free (Apache-2.0); Cloud $250 per device a month | ✓ CLI free (MIT); Mac app $34.99 one time |

[Mobster vs Maestro](https://mobster.dev/compare/maestro), [Mobster vs XCUITest](https://mobster.dev/compare/xcuitest) and [Mobster vs Appium](https://mobster.dev/compare/appium) go row by row, with the sources.

## Pick Mobster when a coding agent writes your screens

**The agent proves the screen it wrote.** It builds your app for the simulator and calls `verify_start` with the steps and what must be true. Then it drives with `screen`, `tap`, `type_text` and `swipe`, each of which returns the new screen as an outline of the accessibility tree, and calls `verify_finish`. Mobster checks the assertions on one settled read and returns the verdict with an overlay frame. The expectations are fixed before the agent touches the app, so it can’t bend them to fit what it finds. [Test your iOS app with Codex](https://mobster.dev/blog/test-ios-app-with-codex) walks through the loop.

**No model in the verdict.** A Mobster check passes when every assertion holds on one settled screen. A check whose assertions already held before the steps ran ends `needs_review`, because it doesn’t prove the flow works. What a model says about its own run is never an input. [AI end-to-end tests for iOS](https://mobster.dev/blog/ai-e2e-tests-ios-assertions) explains the rules.

**Checks anyone can read.** A check is the steps in plain English and a list of what must be true, in a YAML file you commit. An agent performs the steps, so they survive a renamed button or a new screen in the middle. Any run becomes a check with `--save`, or `save_check` from your agent. The [Checks reference](https://docs.mobster.dev/checks) has the format.

**The real iPhone too.** `mobster verify --device` checks an app you installed on your USB iPhone without clearing its data. Mobster for Mac builds, signs and renews the runner for each phone.

**Simulators you never manage.** Mobster creates its own simulators, boots them headless, builds WebDriverAgent once per Xcode version and resets the app before each run. It leaves your own simulators alone.

## Pick XCUITest or Maestro for these jobs

- **XCUITest** for a regression suite that compiles with your app and runs with `xcodebuild test` in any CI or in Xcode Cloud, written as Swift code.
- **Maestro** for one suite across Android, iOS simulators and the web, or for a hosted device cloud ($250 per device a month on Maestro Cloud, with a free trial).

## They work together

**XCUITest in CI, Mobster in the agent’s loop.** Keep the suite you have. Let the agent check each screen it changes with Mobster before it opens a pull request, and let CI run XCUITest on the result. Both find elements by accessibility identifier, so `.accessibilityIdentifier("plan_annual")` in SwiftUI serves both.

**Maestro for cross-platform regression, Mobster for the iPhone.** Maestro covers the cross-platform suite on simulators and emulators. Mobster covers what needs a real iPhone, and the agent’s loop on iOS.

## A first Mobster check

Daybreak, the sample app in Mobster’s repository, has a paywall with three plans and a script that plants a bug. The quick start, run on 28 September 2026 with the `missing-plan` bug planted, printed this:

```
✗ failed  The paywall shows three plans with Annual at $39.99 a year  (18.2 s)
  ✓ text "Choose your plan"
  ✗ count id=/^plan_/ == 3: found 2: plan_weekly, plan_monthly
  ✗ value id=plan_annual == "$39.99 / year": not found; closest: "plan_monthly"
  ✓ visible label=Restore Purchases role=button
  ✓ no_text "Loading"
```

Without the bug it exits 0.

Run the same check on your Mac. Mobster CLI is free:

```
curl -fsSL https://mobster.dev/install.sh | sh
mobster sim doctor --fix
git clone https://github.com/RadishSoftware/mobster && cd mobster-cli
xcodebuild -project examples/ios/Daybreak/Daybreak.xcodeproj -scheme Daybreak \
  -destination 'generic/platform=iOS Simulator' -derivedDataPath examples/ios/Daybreak/.build CODE_SIGNING_ALLOWED=NO build
cd examples/ios/Daybreak
mobster verify --check .mobster/checks/paywall.yaml
```

Mobster for Mac adds guided setup for your iPhone, a live view and history, for [$34.99 one time](https://mobster.dev/#pricing).

[Getting started with verify](https://docs.mobster.dev/verify) does the same with your own app. Mobster’s side here is the build of 8 October 2026, tested on an iPhone 15 Pro running iOS 26 and on iOS 26 simulators.

## Questions

- ### Is Maestro better than XCUITest?
  They suit different teams. XCUITest is Apple's framework, written in Swift inside your Xcode project and free with Xcode. Maestro writes flows in YAML and runs them on Android, iOS simulators and the web, which helps when one team tests several platforms.
- ### Can Maestro test on a real iPhone?
  Not as of 8 October 2026: Maestro's README says physical iOS devices are not yet supported. XCUITest runs on devices, and Mobster checks your app on a real iPhone over USB with Developer Mode on.
- ### Does Mobster replace an XCUITest or Maestro suite?
  It works beside them. Keep your suite for regression, and give your coding agent Mobster to check each screen it changes, on a simulator or your iPhone, before it says the work is done.
- ### Is Maestro better than Appium?
  For different jobs. Maestro writes flows in YAML and runs them on Android, iOS simulators and the web, but its README says physical iOS devices aren't supported yet. Appium drives real iPhones and simulators from test code in Java, Python, JavaScript and more, once you build and sign WebDriverAgent yourself.

## Sources

We read each of these on 8 October 2026. Reviewed by Andy Guo on 8 October 2026. Corrections are welcome at the [GitHub repo](https://github.com/RadishSoftware/mobster/issues).

- [Maestro on GitHub (README)](https://github.com/mobile-dev-inc/maestro)
- [Maestro docs: what is Maestro](https://docs.maestro.dev/get-started/what-is-maestro)
- [Maestro docs: Maestro MCP](https://docs.maestro.dev/get-started/maestro-mcp)
- [Maestro docs: assertWithAI](https://docs.maestro.dev/reference/commands-available/assertwithai)
- [Maestro pricing](https://maestro.dev/pricing)
- [Appium clients](https://appium.io/docs/en/latest/ecosystem/clients/)
- [Appium XCUITest driver: real device setup](https://appium.github.io/appium-xcuitest-driver/latest/getting-started/device-setup/)
- [Apple: XCTest](https://developer.apple.com/documentation/xctest)
- [Apple: XCUIAutomation](https://developer.apple.com/documentation/xcuiautomation)
- [Apple: running tests and interpreting results](https://developer.apple.com/documentation/xcode/running-tests-and-interpreting-results)
- [Apple: accessibilityIdentifier(_:) (SwiftUI)](https://developer.apple.com/documentation/swiftui/view/accessibilityidentifier(_:))
- [Apple: Xcode on the Mac App Store](https://apps.apple.com/us/app/xcode/id497799835?mt=12)
- [Mobster docs: checks](https://docs.mobster.dev/checks)
- [Mobster docs: test your app](https://docs.mobster.dev/quickstart/test)

## Try it on your own app

Mobster CLI is free and open source under MIT. One line installs it; then add it to your agent.

```
curl -fsSL https://mobster.dev/install.sh | sh
```

[Connect your agent](https://mobster.dev/integrations) [Developers](https://mobster.dev/developers) [Mobster for Mac](https://mobster.dev/#pricing)

## Related posts

- 7 October 2026 6 min read
  ### [How to test an iOS app with an AI agent](https://mobster.dev/blog/ai-e2e-tests-ios-assertions)
  Let a model drive your iOS app and never let it judge. Mobster decides pass or fail from accessibility tree assertions on one settled screen, with proof.
- 7 October 2026 5 min read
  ### [Test your iOS app with Codex](https://mobster.dev/blog/test-ios-app-with-codex)
  Add Mobster's MCP server to OpenAI's Codex so it checks the iOS screens it writes on a headless simulator, with pass or fail from accessibility assertions.
- 7 October 2026 7 min read
  ### [Give Claude Code a real iPhone](https://mobster.dev/blog/claude-code-real-iphone)
  Claude Code can write a SwiftUI screen but can't see it. Mobster's MCP server lets it read each screen by name, drive it, and prove it works with a verdict.
