visor
PLAYWRIGHT-LIKE MOBILE AUTOMATION

Give your AI agent hands and eyes inside your mobile app.

Visor discovers an iOS or Android app, learns its screens and routes, then gives agents fast, reliable control without starting from scratch on every action.

Run your first mobile flowSee how Visor works

Works with iOS and Android

Head-to-head: Visor vs live Appium MCP

Nearly 3× faster overall. Up to 5.7× on deep routes.

Across four live mobile flows, Visor's map-driven execution cut total navigation time by 66%. All four route plans replayed on the first try without rediscovery.

2.9×

faster overall

723s with Appium MCP → 249s with Visor

5.7×

faster on the deepest flow

183s with Appium MCP → 32s with Visor

31%

fewer execution tokens

168k with Appium MCP → 116k with Visor

The shallow one-tap deposit flow was effectively tied. Both approaches returned the same answer on the deepest lookup and reached the same app-state block on the blocked investment flow—the gains came from faster navigation, not skipped work.

Learn once. Reuse the route.

Stop making your agent rediscover the app one screen at a time.

A first run learns screen nodes and confirmed edges. Repeated flows can target a known destination, reuse the route, and verify arrival—with fewer discovery steps and fewer agent round trips.

App map / checkout flow

Discovering screens and recording safe edges

MAP LEARNING
HomeBrowseProductCheckoutinspect → act → inspect
The first pass observes live UI source, identifies screen variants, and records confirmed transitions.

Without memory

Without memory: Look → reason → act → repeat

Raw Appium/MCP can inspect and control the device. The agent still coordinates discovery again as it moves between screens.

With app memory

With Visor: Target → route → verify.

The first run teaches the map. Later runs reuse confirmed routes and live destination checks.

The head-to-head benchmark showed the largest gains on deeper paths, where route reuse avoids repeated discovery.

Measured across four head-to-head mobile flows
A live agent-to-device loop

Control the app. Observe the result. Verify what changed.

Semantic actions and learned navigation give the agent hands. Screenshots, UI source, destination checks, and structured results give it eyes.

representative agent session
DEVICE CONNECTED

Semantic control

Target meaning, not brittle coordinates.

Learned navigation

Reach known screens through verified routes.

Live evidence

Capture what the user actually sees.

  1. 01Discover
    visor discover --app-id com.example.app --crawl
  2. 02Tap
    visor tap --target accessibility=Continue
  3. 03Type
    visor act --name type --target accessibility=Search --value shoes
  4. 04Wait
    visor wait --for "text=Results" --timeout 8000
  5. 05Navigate
    visor navigate --to myapp://checkout
  6. 06Observe
    visor screenshot --label checkout --output artifacts
  7. 07Verify
    visor run scenarios/checkout-smoke.json --output artifacts-test

UI-source observation is also available with visor source --label checkout --output artifacts.

Condensed structured result

status: ok
{
  "status": "ok",
  "artifacts": [
    "artifacts/checkout.png"
  ],
  "data": {
    "run": {
      "status": "ok",
      "map": {
        "enabled": true,
        "used": true
      },
      "assertions": [{
        "target": "text=Checkout",
        "status": "passed"
      }]
    }
  }
}

Destination contract verified

Representative output uses the current Visor response model: run status, map usage, assertions, and artifact paths.

The agent interaction layer

Four primitives for operating a live mobile app.

Interaction

Act

Tap semantic targets, type into fields, navigate, scroll, wait, and control real iOS or Android screens.

Live evidence

See

Capture screenshots and UI source from the running app so the agent works from observed state, not code intent.

App memory

Remember

Keep learned screen variants, semantic targets, confirmed edges, and destination contracts in a reusable app map.

Reliable outcomes

Verify

Check destinations and assertions, then write structured results, screenshots, source, and reports for review.

Built on a proven driver layer

Appium drives the device. Visor learns the app.

Appium remains the device-driver foundation. Visor adds the agent-oriented layer that discovers application structure, remembers routes, verifies destinations, and returns evidence an agent can act on.

Foundation

Appium + Appium MCP

  • Device sessions
  • Element discovery
  • Gestures and actions
  • Screenshots and page source

Agent layer

Visor

  • Application discovery
  • Persistent screen memory
  • Route planning
  • Destination verification and evidence

“Playwright-like” describes the mental model: direct, reliable automation for an agent. Appium still owns device-level execution.

One tool, more than visual QA

Use the same live loop across mobile work.

Navigation, debugging, smoke verification, review evidence, and UI accuracy all benefit from an agent that can operate the running app.

Debug live state

Inspect the screen and UI source users actually encounter, then act on the evidence.

Repeat product flows

Navigate familiar paths without coordinating fresh discovery at every screen.

Run smoke flows

Execute ordered interactions and verify visible destinations and assertions.

Review with evidence

Keep structured results, screenshots, source dumps, timelines, and reports.

Tune implementation accuracy

Compare a running UI with its design target and reduce visual drift over successive passes.

Implementation accuracy / one use case

Pixel accuracy is one workflow, not the whole product.

Keep the design target beside the live app, spot missing icons, clipped content, and spacing drift, then reduce manual verification passes with fresh evidence after each change.

Design target, initial drift, informed correction

Review the gap between the intended Figma screen, an initial implementation, and a result refined with live Visor evidence.

Figma target
Design reference

The design contract the agent has to satisfy, including layout, icons, spacing, and content hierarchy.

Figma weather design reference.
Basic agent
Initial implementation

Without live app feedback, the agent missed icons, clipped content, and shipped layout drift.

One-shot generated result showing layout drift and missing details.
Agent + Visor
Live verification loop

With Visor in the loop, the agent can inspect live evidence, patch drift, and rerun while keeping each result reviewable.

Visor-assisted final result closely matching the Figma design.
Your agent can test the screen it changed

Run your first mobile flow.

Connect a running iOS or Android app, teach Visor the route, and give your agent reliable control with evidence at every step.

Run your first mobile flowView GitHub
npm install -g visor-ai
Open sourceMIT LicenseTypeScript CLIiOS + Android