> ## Documentation Index
> Fetch the complete documentation index at: https://visorai.dev/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Visor overview

> Give AI agents verified interaction, semantic navigation memory, and evidence from running mobile apps.

Visor lets AI agents operate running mobile apps, remember what they learn, and verify the result against the live UI.

<Info>
  **2.9x faster in one internal four-flow comparison with live Appium MCP navigation.**
  Across four mobile flows, Visor's map-driven execution finished in 249
  seconds versus 723 seconds for the Appium MCP baseline: a 2.9x speedup and 66%
  less execution time. The deepest flow was 5.7x faster, and Visor used 31%
  fewer execution tokens overall.
</Info>

The comparison reached the same answers and the same app-state block in both
approaches. All four Visor route plans replayed on the first try without route
rediscovery. The shallow, one-tap flow was effectively tied; the largest gains
appeared as navigation depth increased. This was one app and one fixed task set,
not a general performance guarantee; results will vary with the app, device,
route depth, and existing map state.

It does six things:

1. Connects to a running iOS or Android app.
2. Builds compact semantic memory for screens, safe actions, and known routes.
3. Executes deterministic preferred and recovery paths in one request.
4. Performs real UI actions and captures targeted evidence from the live app.
5. Evaluates assertions against observed UI state.
6. Persists reports and artifacts so a person or an LLM can review what happened.

## What Visor is for

Visor is built for cases where code alone is not enough to verify behavior.

Typical agent-driven use cases:

* Discover a new app once, then reuse the resulting semantic map across tasks.
* Navigate known flows without repeatedly inspecting screenshots or UI source.
* Recover from unknown screens with exact observation tokens and safe alternate paths.
* Verify that a UI change actually rendered on screen.
* Compare before and after state using screenshots and UI source.
* Run the same scenario repeatedly to measure stability.
* Produce machine-readable evidence for review, debugging, or automation.

## Product scope

Visor currently supports mobile applications only.

Supported scope today:

* Android apps through Appium and UiAutomator2.
* iOS apps through Appium and XCUITest.
* Real device or simulator interaction.

Out of scope today:

* Web applications.
* Desktop applications.
* Rich assertion types beyond visibility checks.

## Core building blocks

The product is organized around a small set of concepts.

| Concept | What it means |
| - | - |
| Target | The UI element or screen location Visor should act on. |
| Action | A direct operation such as tap, type, navigate, wait, screenshot, or source capture. |
| Agent memory | Compact semantic screens, safe actions, routes, reliability, and unresolved gaps. |
| Route | One or more ordered safe paths executed inside a single daemon request. |
| Scenario | A JSON document that defines a repeatable sequence of steps and optional assertions. |
| Assertion | A rule checked after the steps finish. Today, visibility is the supported assertion type. |
| Artifact | A file written during or after execution, such as a screenshot, XML source dump, or summary report. |
| Determinism score | A stability score that shows how often repeated runs produced the same signature. |

## Documentation map

Read the pages in this order if you are new to Visor:

* [Agent setup](/docs/quickstart)
* [Core concepts](/docs/concepts)
* [Agent memory and deterministic routes](/docs/features/app-map)
* [Platforms and runtime](/docs/platforms-and-runtime)
* [Interactions](/docs/features/interactions)
* [Targeting and selectors](/docs/features/targeting-and-selectors)
* [Evidence capture](/docs/features/evidence-capture)
* [Scenarios](/docs/features/scenarios)
* [Assertions and determinism](/docs/features/assertions-and-determinism)
* [Artifacts and reports](/docs/features/artifacts-and-reports)

Use the reference section when you need exact field names, inputs, outputs, or error behavior:

* [Command reference](/docs/reference/command-reference)
* [Scenario schema](/docs/reference/scenario-schema)
* [Response schema](/docs/reference/response-schema)
* [Errors and exit codes](/docs/reference/errors-and-exit-codes)

## What Visor returns

Every operation returns a structured response envelope.

The envelope always tells you:

* whether the operation succeeded or failed
* when it started and ended
* which artifacts were produced
* what the next logical action is
* which structured payload belongs to the operation

Longer flows such as scenario runs also write files to disk so the run can be audited after the fact.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.