From Maestro

Maestro is already declarative YAML, so most commands map one-to-one. A flow.yaml becomes a *.test.yaml; tapOn becomes tap; runFlow becomes a module call. The main differences: Momentic adds natural-language targets and AI assertions, runs through its own runner instead of a Maestro CLI device session, and hosts emulators and simulators for you.

Before and after

A representative Maestro flow:

checkout.yaml

appId: com.example.shop
env:
  EMAIL: jeff@example.com
---
- launchApp
- tapOn: "Add to cart"
- tapOn:
    id: "cart-icon"
- assertVisible: "Gravity Blanket"
- tapOn: "Checkout"
- inputText: ${EMAIL}
- tapOn: "Place order"
- assertVisible: "Order confirmed"

The same test in Momentic:

checkout.test.yaml

fileType: momentic/mobile-test/v2
id: guest-checkout
platform: android
steps:
  - openApp: com.example.shop
  - tap: the Add to cart button
  - tap: the cart icon
  - assert: The cart lists "Gravity Blanket"
  - tap: Checkout
  - type:
      text: "{{ env.EMAIL }}"
      into: the Email field
  - tap: Place order
  - assert: An order confirmation is visible

EMAIL comes from environments[].envVariables in momentic-mobile.config.yaml or the shell, not a flow-level env: block.

Command mapping

Maestro	Momentic
`appId: com.x` + `launchApp`	`openApp: com.x` (with `activity`/`intentExtras` on Android)
`killApp` / `stopApp`	`killApp`
`tapOn: <text>` / `tapOn: {id:}`	`tap: <natural language>`; prefer visible text over test IDs
`tapOn: {point: "x%,y%"}`	`tap: "50%, 50%"` percent-pair target
`longPressOn`	`tap: { on: ..., longPress: true }`
`doubleTapOn`	`tap: { on: ..., iterations: 2 }`
`inputText` / `inputRandomText`	`type: { text: ..., into: <field> }`; use `faker` in `javascript` for random data
`eraseText`	`type` with an empty value or a focused `act`
`assertVisible` / `assertNotVisible`	`checkElementVisible` / `checkScreenDoesNotContain`, or `assert`
`assertTrue`	`javascript` step with `assert`
`scroll` / `swipe`	`scrollTo` / `swipe`
`scrollUntilVisible`	`scrollTo: { on: <target>, in: <container> }`
`back` / `pressKey`	`press` / `pressKey`
`runFlow: path` / `runSubFlow`	`module: ./path.module.yaml` with `inputs`
`runScript`	`javascript` step (Node sandbox) or `appium` step for `mobile:` calls
`evalScript`	`javascript` step
`setLocation`	`appium` step: `mobile: setGeolocation` (Android) / `mobile: setLocation` (iOS); `toggleSettings: location` only toggles GPS on Android
`setAirplaneMode` / `toggleWifi`	`toggleSettings`
`openLink` / deep links	`appium` step (`mobile: deepLink` with `url`)
`startRecording` / `stopRecording`	automatic; run artifacts include video when `recordVideo` is on
`waitForAnimationToEnd`	not needed; steps wait for the screen to settle
`extendedWaitUntil`	any condition step with `timeout:`
`takeScreenshot`	automatic per-step screenshots; `assertVisually` for visual checks
`retry`	`retries:` on a step or test
`when:` conditions	`if:` with nested `then:` steps
`repeat` / `while`	`while:` with `do:` and a condition or `maxIterations`
`env:` block + `${VAR}`	`envVariables` in config, `{{ env.VAR }}` in strings, `env.VAR` in JS
`labels:`	`labels:` (same name)
`onFlowStart` / `onFlowComplete` hooks	`before:` / `after:` sections

What does not map

Maestro Studio / element inspection. Momentic’s equivalent is the local editor’s element picker plus debugState; there is no separate inspector app.
Jest/JS scripting inside flows beyond runScript. javascript covers data and API work; it is not a general inline scripting runtime for UI logic.
maestro test --device physical devices. Remote execution is emulators and simulators only; real devices are not supported.
Maestro’s tolerance and optional-element flags. Momentic resolves targets with AI against the live view hierarchy instead of fuzzy matching rules. If you depended on optional: true, use an if: step around a check.
Cloud Maestro (maestro cloud). Scheduling and CI live in your pipeline or Momentic’s scheduled runs, not a per-flow upload.

Incremental strategy

Install momentic-mobile and keep Maestro installed: nothing conflicts.
Port one flow end to end, including its subflows as modules. Run it on a local emulator, then on a Momentic-hosted emulator by selecting a region.
Move env values into environments in momentic-mobile.config.yaml so the same test file runs against dev, staging, and prod.
Port flows in order of pain: the flows that break most on locator changes gain the most from natural-language targets and auto-heal.
Delete the .maestro directory when the Momentic suite covers the same critical paths and has passed for a few consecutive runs.

Porting at scale with a coding agent

Paste this prompt into your coding agent. It reads the Momentic skills, ports each flow, and runs the result.

Port every flow under .maestro/ to momentic-mobile tests under mobile-tests/.
Read the momentic-mobile-test skill first. Convert runFlow targets to
*.module.yaml files, keep the directory structure, move each flow's env: keys
into the project config's envVariables, and run each ported test with
npx momentic-mobile run <file> on an emulator.

Overview

Migrate to Momentic

Frameworks

Use cases

Triage

AI actions

Authentication

Page interactions

Test data & variants

Visual testing

Reporting

Upgrading

Before and after

Command mapping

What does not map

Incremental strategy

Porting at scale with a coding agent

​Before and after

​Command mapping

​What does not map

​Incremental strategy

​Porting at scale with a coding agent

​Related

Before and after

Command mapping

What does not map

Incremental strategy

Porting at scale with a coding agent

Related