# Ui.Vision MCP (npm · uivision-mcp-bridge)

MCP server for browser and desktop automation: OCR, image recognition, real mouse and keyboard input

- Trust score: 66/100 (medium)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-09-20

## Components

- npm · `uivision-mcp-bridge`: 66/100 (this document), [markdown](https://verifymcp.io/servers/a9t9-uivision-mcp/uivision-mcp-bridge.md), [page](https://verifymcp.io/servers/a9t9-uivision-mcp/uivision-mcp-bridge)

## Channel facts

- Registry: `npm`
- Package: `uivision-mcp-bridge`
- Version: `1.7.18`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-09-20.

- **Supply Chain Security**: 100/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - No install/post-install scripts declared.
  - 0 of 1 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 45/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 2 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 68/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 5050 tokens (~202/item across 25 items; 25 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability not yet verified: not enough scan history yet (needs a 30-day window).
- **Tool Coverage**: 92/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 75% of tool parameters carry a description.
- **Tool Safety**: 75/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - 0 of 2 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation; "send_chat" implies "send" and declares no destructiveHint at all, which the MCP spec reads as destructive by default.
  - An AI judge read all 25 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 60/100
  - Spec-recency check failed: implements MCP spec 2025-06-18; the latest is 2026-07-28.

**Unverified: 1 category.** A category scored 0 because we could not verify it: a data source with nothing on this package, evidence we could not reach, or a check we could not run. We only credit what we can confirm.

## Install

### How do I install the Ui.Vision MCP server?

Ui.Vision MCP runs locally as an npm package, launched with npx -y uivision-mcp-bridge. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add a9t9-uivision-mcp -- npx -y uivision-mcp-bridge
```

### Cursor

```json
{
  "mcpServers": {
    "a9t9-uivision-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "uivision-mcp-bridge"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "a9t9-uivision-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "uivision-mcp-bridge"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add a9t9-uivision-mcp -- npx -y uivision-mcp-bridge
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "a9t9-uivision-mcp": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "uivision-mcp-bridge"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add a9t9-uivision-mcp --command npx --arg -y --arg uivision-mcp-bridge
```

### Hermes

```yaml
mcp_servers:
  a9t9-uivision-mcp:
    command: "npx"
    args: ["-y", "uivision-mcp-bridge"]
```

### Netclaw

```json
{
  "McpServers": {
    "a9t9-uivision-mcp": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "uivision-mcp-bridge"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add a9t9-uivision-mcp -t stdio -c npx -a -y uivision-mcp-bridge
```

### Other

```json
{
  "mcpServers": {
    "a9t9-uivision-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "uivision-mcp-bridge"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-09-20 (score 66, 0)

- [functional regression] Security disclosure: unverified → fail

### 2026-09-19 (score 66, 0)

- [functional regression] Security disclosure: fail → unverified

### 2026-09-17 (score 66)

First indexed and scored.

## MCP tools (25)

### `bridge_status` (~86 tokens)

Reports whether the Ui.Vision browser extension is currently connected to this bridge. Call this first if other tools fail — it tells you whether the extension side panel is open and the bridge is enabled in its settings. Several browsers can be connected at once; the status lists each one by label (chrome#1, firefox#1, ...) and marks the ACTIVE one that tool calls go to.

### `run_status` (~115 tokens)

What the macro runner is doing RIGHT NOW: whether a run is in progress, which macro the editor holds, and the freshest log lines. Unlike every other tool, this ANSWERS WHILE run_macro is still executing (extension 10.0.172+) — poll it from a second client/session to watch a long run live instead of waiting blind. screenshot is likewise answerable mid-run for a visual peek.

Input parameters:

- `lines` (number): How many of the latest log lines to include (1-100, default 20).

### `select_browser` (~135 tokens)

Switches which connected browser the other tools talk to. Several browsers (or several instances of one browser) can hold a bridge connection at the same time; bridge_status lists their labels. Pass a full label ("chrome#2") for an exact instance, or a bare family name ("firefox") for the most recently connected instance of that family.

Input parameters:

- `target` (string, required): Connection label from bridge_status: "chrome#1", "firefox#2", or a bare family name like "firefox".
- `why` (string): One short sentence shown in the Ui.Vision log: what this call does and why.

### `open_panel` (~239 tokens)

Opens the Ui.Vision panel when the extension is NOT connected: signals the browser over a background wake channel (extension 10.0.170+) to open the Ui.Vision app in a tab. This is the ONLY way the panel opens without a human click — the extension never opens it by itself. Works when the panel or its tab was closed, and even when the browser sits in the tray with zero windows (a window is created). Call this whenever bridge_status shows no tool connection but a wake channel; the panel connects within a few seconds. Pass target ("chrome", "firefox") to wake one browser family; omit to wake every browser that is not yet connected. If it reports no wake channel, the browser process is not running (or the extension predates 10.0.170) — a human must start the browser, then retry.

Input parameters:

- `target` (string): Optional browser family from bridge_status ("chrome", "firefox", "edge", ...). Omit to wake all disconnected browsers.
- `why` (string): One short sentence shown in the Ui.Vision log: what this call does and why.

### `list_macros` (~61 tokens)

Lists all macros stored in Ui.Vision (name and id). Use open_macro to load one into the editor before reading or running it.

Input parameters:

- `why` (string): One short sentence shown in the Ui.Vision log: what this call does and why.

### `open_macro` (~88 tokens)

Opens the macro with the given name in the Ui.Vision editor and returns its JSON. Subsequent get_macro/set_macro/run_macro calls operate on it. Note: unsaved editor changes may be discarded.

Input parameters:

- `name` (string, required): Macro name as returned by list_macros
- `why` (string): One short sentence shown in the Ui.Vision log: what this call does and why.

### `get_authoring_guide` (~103 tokens)

Returns the Ui.Vision macro authoring guide: the uiv.* JavaScript API for JS script macros (finders, actions, OCR, vision), the classic command table, locator rules and best practices. CALL THIS ONCE BEFORE WRITING YOUR FIRST MACRO in a session — macros written without it usually use invented APIs and fail.

Input parameters:

- `why` (string): One short sentence shown in the Ui.Vision log: what this call does and why.

### `get_macro` (~70 tokens)

Returns the macro currently loaded in the Ui.Vision editor, as Ui.Vision JSON. A JS script macro comes back with a "Script" field (its program) instead of Commands.

Input parameters:

- `why` (string): One short sentence shown in the Ui.Vision log: what this call does and why.

### `send_chat` (~132 tokens)

Sends a message to the REAL in-panel AI Chat — the configured chat model runs it with its own agent tools, exactly as if a user had typed it. Returns immediately; a chat run takes minutes, so poll get_chat until it reports running:false. For self-testing the chat agent end-to-end.

Input parameters:

- `message` (string, required): The chat message, verbatim as a user would type it
- `new_chat` (boolean): Start a fresh conversation first (abandons any run in progress)
- `why` (string): One short sentence shown in the Ui.Vision log: what this call does and why.

### `get_chat` (~69 tokens)

Returns the in-panel AI Chat transcript and whether a run is in progress (running:true/false). Poll this after send_chat; the transcript is text-only (inline images are omitted).

Input parameters:

- `why` (string): One short sentence shown in the Ui.Vision log: what this call does and why.

### `reload_extension` (~119 tokens)

Reloads the Ui.Vision extension from disk (same as the chrome://extensions reload button) — the way to load a freshly built version without a human click. The bridge connection dies with the panel; on startup the panel app reopens as a TAB and reconnects, and the new hello reports the loaded version. If no reconnect arrives within ~15s the new build failed to start and needs a human at chrome://extensions.

Input parameters:

- `why` (string): One short sentence shown in the Ui.Vision log: what this call does and why.

### `run_selftest` (~267 tokens)

Runs every self-test of Settings > Desktop Automation in one go: native host connection, WASM image-search engine, desktop screenshot, real mouse input delivery, home-directory read/write, visual compatibility (colors, scaling, screenshot coordinates) and a test macro inside the desktop app - and returns ONE report that starts with "SELFTEST: ALL OK" or "SELFTEST: PROBLEMS FOUND", then one line per test with verdict and detail. Call it FIRST when a macro misbehaves (clicks land elsewhere, colors or images are not found, nothing happens on the desktop): it separates an environment problem from a macro problem in about half a minute. The Settings page opens as a tab while the tests run (the visual test shows a chart, the input test moves the mouse - hands off) and closes again unless keep_open. Pass tests to run a subset.

Input parameters:

- `keep_open` (boolean): Leave the Settings tab open with the results (default false).
- `tests` (array): Subset of tests to run; default: all.
- `timeout_seconds` (number): Longest wait for the report, 30-600 (default 240).
- `why` (string): One short sentence shown in the Ui.Vision log: what this call does and why.

### `get_ai_settings` (~87 tokens)

Reports the ACTIVE AI provider/model as the chat will resolve it, which providers have keys stored (booleans only — keys never cross the bridge), the per-provider model settings, computer-vision scope and OCR engine. Call before set_ai_settings to plan a change.

Input parameters:

- `why` (string): One short sentence shown in the Ui.Vision log: what this call does and why.

### `set_ai_settings` (~255 tokens)

Switches AI settings for independent runs (e.g. benchmark sweeps): provider (uivision | openrouter | anthropic | local), uivision_tier (free | pro), openrouter_model / anthropic_model / local_model / local_base_url, cv_scope (browser | desktop), ocr_engine (1|2|3 OCR.Space, 90 AI provider, 98 built-in cross-platform, 99 OS reader). Only switches between providers the user already configured — API keys can NOT be set or read over the bridge (Settings > AI is the only way in). Refused while a chat run is in progress. Takes effect from the next AI call.

Input parameters:

- `anthropic_model` (string)
- `cv_scope` (string)
- `local_base_url` (string)
- `local_model` (string)
- `ocr_engine` (number)
- `openrouter_model` (string): e.g. "openai/gpt-5.6-luna"
- `provider` (string)
- `uivision_tier` (string)
- `why` (string): One short sentence shown in the Ui.Vision log: what this call does and why.

### `set_macro` (~256 tokens)

Apply changes to the macro in the Ui.Vision editor — pass the complete Ui.Vision JSON. PREFER the JS script form {"Name": "name", "Script": "<JavaScript using the uiv.* API>"} over the classic Commands table (call get_authoring_guide for the uiv.* API before writing your first script). When fixing or extending a classic Commands-table macro, CONVERT it to a JS script in the same call and fix it there, preserving its targeting technique (visual stays visual) — recommend the conversion in your summary; keep the classic form only if the user explicitly insists on a table macro. The user's original macro file is never overwritten: the first change to a user macro is saved as a new copy in the "AI Generated" folder, which then becomes the macro being edited. Returns the macro name that was written, or a validation error.

Input parameters:

- `allow_visual_to_dom` (boolean): Set true ONLY after the user explicitly agreed to convert a visual macro to DOM-selector commands.
- `macro_json` (string, required): The complete macro as a Ui.Vision JSON string.
- `why` (string): One short sentence shown in the Ui.Vision log: what this call does and why.

### `create_macro` (~170 tokens)

Create a NEW macro from the given Ui.Vision JSON and save it in the "AI Generated" folder under a new, unique name. PREFER the JS script form {"Name": "...", "Script": "<JavaScript using the uiv.* API>"} over the classic Commands table — scripts are modern JS with real control flow and are the recommended way to build macros. Call get_authoring_guide for the uiv.* API before writing your first script. The new macro opens in the editor — refine it afterwards with set_macro. Returns the final macro name.

Input parameters:

- `macro_json` (string, required): The complete macro as a Ui.Vision JSON string, including a descriptive Name.
- `why` (string): One short sentence shown in the Ui.Vision log: what this call does and why.

### `delete_macro` (~108 tokens)

Delete a macro from the "AI Generated" folder — cleanup for scratch and test macros this or an earlier session created there. Only macros inside "AI Generated" can be deleted; everything else is refused (the user deletes those in the panel). Returns a confirmation.

Input parameters:

- `name` (string, required): Macro name as returned by list_macros — must be under "AI Generated/".
- `why` (string): One short sentence shown in the Ui.Vision log: what this call does and why.

### `run_macro` (~459 tokens)

Run a macro against the browser tab and wait for it to finish (can take minutes). Three forms: pass "macro" (a name from list_macros) to open and run that stored macro; pass "script" (inline JavaScript) to run code directly without creating a macro; pass neither to run whatever is currently open in the editor — that last form depends on editor state, so prefer naming the target. Returns the execution log, including the error and failing line if it fails, plus a picture of the page/screen after the run with ONLY the macro's own actions and finder results marked: arrows at its clicks, numbered boxes at image/OCR matches (each number resolves to a legend line with exact coordinates), blue search-area rectangles, a magnified inset of the last click. No other overlay is painted — read what OCR recognised from the text legend, not the picture.

Input parameters:

- `log_limit` (number): Max characters of run log (and of the final-variables dump) to return, 1000-40000; default 4000. When the log is longer, its HEAD is dropped and an explicit "…N earlier log lines omitted" marker says…
- `look` (string): What to return about the page AFTER the run, so one call acts and looks: "delta" (default) = the tree lines that appeared or disappeared since the last look, with refs; "tree" = the full tree (6000 c…
- `macro` (string): Name of a stored macro (as returned by list_macros, e.g. "AI Generated/my_macro.js") — it is opened into the editor and then run. Mutually exclusive with "script".
- `script` (string): Inline JS script to run directly — plain modern JavaScript with real newlines and real quotes, NO JSON escaping. The editor and stored macros are not touched; use create_macro instead when the script…
- `why` (string): One short sentence shown in the Ui.Vision log: what this call does and why.

### `browser_snapshot` (~399 tokens)

Returns the structure of the browser tab Ui.Vision plays in. Default mode "tree": the page as an accessibility tree — one line per node with role, accessible name and state (value, checked, expanded, disabled, offscreen), nested by container. Every interactive node carries [ref=N], and ref=N is a LOCATOR: act on it right away with uiv.page.click('ref=12'), uiv.page.fill('ref=7', text) or uiv.$('ref=12') (match object, e.g. uiv.browser.click(uiv.$('ref=12'))). Refs are numbered per page load and renumbered on navigation: call browser_snapshot again after uiv.goto or a navigating click. mode "fields": the classic list of form fields, buttons and links with id=/name=/css= locators plus refs. Pass "url" to open that page first; omit it to inspect the current tab. Cannot see into closed shadow roots; cross-origin iframes are listed separately.

Input parameters:

- `find` (string): Optional, tree mode. Return only the nodes whose line contains this text (case-insensitive: a role, a name, a word of it) with their refs — a cheap look-up instead of the whole tree. Example: "downlo…
- `max_chars` (number): Optional, tree mode: character budget 2000-60000 (default 12000); the result reports how many nodes were cut.
- `mode` (string): Optional. "tree" (default): accessibility tree with [ref=N] per interactive node. "fields": fields/clickables list with locators.
- `url` (string): Optional. Navigate the tab here first, wait for the load, then inspect.
- `why` (string): One short sentence shown in the Ui.Vision log: what this call does and why.

### `click_at` (~212 tokens)

EXPLORATION ONLY: click the point (x, y) read off the MOST RECENT screenshot — the extension converts the picture's pixels to the page or screen itself, so "click the thing in the picture" is one call. A browser screenshot clicks in the tab (trusted click, any frame); a desktop screenshot clicks on the screen through the XModule. Returns what changed on the page afterwards (like run_macro look: "delta"). A point is NOT a locator: for a macro that will be saved, act by ref/locator (browser_snapshot) or by a saved element image instead.

Input parameters:

- `look` (string): What to return afterwards; default "delta".
- `why` (string): One short sentence shown in the Ui.Vision log: what this call does and why.
- `x` (number, required): Pixels from the left edge of the last screenshot (a zoomed view counts as the last screenshot).
- `y` (number, required): Pixels from the top edge of the last screenshot.

### `type_at` (~137 tokens)

EXPLORATION ONLY: click the point (x, y) of the MOST RECENT screenshot and type text there (key names like ${KEY_ENTER}, ${KEY_TAB}, ${KEY_CTRL+a} are honoured). Same conversion and same caveat as click_at. Returns what changed on the page afterwards.

Input parameters:

- `look` (string): What to return afterwards; default "delta".
- `text` (string, required): The text to type after the click.
- `why` (string): One short sentence shown in the Ui.Vision log: what this call does and why.
- `x` (number, required)
- `y` (number, required)

### `screenshot` (~564 tokens)

Returns a screenshot of the visible part of the browser tab Ui.Vision plays in. Coordinates passed to save_element_image / save_relative_image are absolute pixels in this image. scope: "desktop" captures the WHOLE SCREEN instead (needs the RealUser XModule) — the way to see browser UI outside the page (toolbar, extension popups, native dialogs) and to verify desktop automation. ZOOM: pass x/y/width/height (all four) to get a MAGNIFIED view of that region of the screenshot you already have, instead of a new capture. A full-screen capture is shrunk to fit, leaving a toolbar icon or checkbox a few pixels wide — too coarse to place a crop box on, and guessing one there picks the NEIGHBOURING element about as often as the right one. Zoom first whenever the target is under ~40 px, then read coordinates off the magnified view; it becomes the coordinate frame for the next save_element_image call. Regions nest; a call with no region returns to the full view. On the very first screenshot a region is skipped (there is nothing to magnify yet) and you get the full capture. MARKS: pass marks: "elements" to get the visible interactive elements NUMBERED on the picture (red boxes) plus a legend mapping every number to its locator and viewport rect — pick by number, act by locator, never by a pixel estimated off the picture. IMAGE CONTRACT (this tool and run_macro alike): every picture is the real capture; the only markings ever added are numbered candidate boxes (elements, image matches, OCR matches), blue search-area rectangles, arrows/rings for the macro's own input and a magnified inset of the last click — each number has a legend line with exact coordinates, nothing else is painted (no OCR word overlay), and no marking is ever page content.

Input parameters:

- `height` (number): Zoom region height.
- `marks` (string): Optional. "elements" numbers the visible interactive elements of the tab (browser scope only) and returns a number -> locator + rect legend. Ignored with a zoom region.
- `scope` (string): Optional. "browser" (default) = the current tab; "desktop" = the whole screen via the XModule.
- `why` (string): One short sentence shown in the Ui.Vision log: what this call does and why.
- `width` (number): Zoom region width. Include surroundings — a region tight around the target gives nothing to judge its identity by.
- `x` (number): Optional zoom region: left edge, in pixels of the last screenshot. Give all four of x/y/width/height or none.
- `y` (number): Zoom region: top edge.

### `save_element_image` (~321 tokens)

Crop a rectangle from the MOST RECENT screenshot and save it as a Ui.Vision vision image, for image-based commands like "XClick | Target: <name>.png" or uiv.findImage('<name>.png') in a JS script. Coordinates are absolute pixels in the last screenshot (or in the last magnified view, which converts back itself — never scale by hand). SIZING: crop a normal control tightly with a few px of margin, but do NOT crop a SMALL or FLAT target tight — the matcher keys on structure, and a plain patch matches everywhere while one icon in a row of icons looks like all its neighbours. For those, take a WIDER box with the target EXACTLY CENTRED, including stable surroundings (for a toolbar icon: the icons to its left and right). Clicks still land on the target, because the finders return the match CENTRE. Returns the saved file name plus a picture of the SURROUNDINGS with a red box around the saved area, so you can check the crop against its neighbours, and warns when the crop is too small or too featureless to match reliably. Re-crop with THE SAME NAME to overwrite.

Input parameters:

- `height` (number, required)
- `name` (string, required): Base name for the image file (letters, digits, underscore)
- `why` (string): One short sentence shown in the Ui.Vision log: what this call does and why.
- `width` (number, required)
- `x` (number, required)
- `y` (number, required)

### `save_relative_image` (~183 tokens)

Create a green/pink RELATIVE vision image from the MOST RECENT screenshot, for commands like "BClickRelative | Target: <name>.png". The green box marks the anchor element that is searched on the page; the pink box marks where to click, relative to the anchor. Coordinates are absolute pixels in the last screenshot.

Input parameters:

- `anchor_height` (number, required)
- `anchor_width` (number, required)
- `anchor_x` (number, required)
- `anchor_y` (number, required)
- `name` (string, required): Base name for the image file (letters, digits, underscore)
- `target_height` (number, required)
- `target_width` (number, required)
- `target_x` (number, required)
- `target_y` (number, required)
- `why` (string): One short sentence shown in the Ui.Vision log: what this call does and why.

### `get_page` (~415 tokens)

Alias of browser_snapshot (the older Ui.Vision name) — identical behaviour. Returns the structure of the browser tab Ui.Vision plays in. Default mode "tree": the page as an accessibility tree — one line per node with role, accessible name and state (value, checked, expanded, disabled, offscreen), nested by container. Every interactive node carries [ref=N], and ref=N is a LOCATOR: act on it right away with uiv.page.click('ref=12'), uiv.page.fill('ref=7', text) or uiv.$('ref=12') (match object, e.g. uiv.browser.click(uiv.$('ref=12'))). Refs are numbered per page load and renumbered on navigation: call browser_snapshot again after uiv.goto or a navigating click. mode "fields": the classic list of form fields, buttons and links with id=/name=/css= locators plus refs. Pass "url" to open that page first; omit it to inspect the current tab. Cannot see into closed shadow roots; cross-origin iframes are listed separately.

Input parameters:

- `find` (string): Optional, tree mode. Return only the nodes whose line contains this text (case-insensitive: a role, a name, a word of it) with their refs — a cheap look-up instead of the whole tree. Example: "downlo…
- `max_chars` (number): Optional, tree mode: character budget 2000-60000 (default 12000); the result reports how many nodes were cut.
- `mode` (string): Optional. "tree" (default): accessibility tree with [ref=N] per interactive node. "fields": fields/clickables list with locators.
- `url` (string): Optional. Navigate the tab here first, wait for the load, then inspect.
- `why` (string): One short sentence shown in the Ui.Vision log: what this call does and why.

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/a9t9-uivision-mcp/uivision-mcp-bridge#diagnostics

## Score history

- 2026-09-20: 66
- 2026-09-19: 66
- 2026-09-18: 66
- 2026-09-17: 66

## Common questions

### What is the Ui.Vision MCP server?

Ui.Vision MCP is listed in the public MCP registry as io.github.A9T9/uivision-mcp. MCP server for browser and desktop automation: OCR, image recognition, real mouse and keyboard input. This page covers its npm package (uivision-mcp-bridge).

### Is the Ui.Vision MCP server safe to use?

Ui.Vision MCP scores 66 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 20 September 2026. It declares no install or post-install scripts. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the Ui.Vision MCP server expose?

Ui.Vision MCP exposes 25 tools: bridge_status, run_status, select_browser, open_panel, list_macros, and 20 more. Their descriptions and schemas cost roughly 5,050 tokens of context every time the server is loaded.

### Is the Ui.Vision MCP server still maintained?

Ui.Vision MCP is still listed as active in the MCP registry. We last reached this channel on 20 September 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the Ui.Vision MCP server under?

Ui.Vision MCP declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- npm package: https://www.npmjs.com/package/uivision-mcp-bridge
- Socket report: https://socket.dev/npm/package/uivision-mcp-bridge
- Repository: https://github.com/A9T9/RPA
- Website: https://ui.vision/mcp
- Changelog RSS feed: https://verifymcp.io/servers/a9t9-uivision-mcp/uivision-mcp-bridge.xml
- Changelog JSON feed: https://verifymcp.io/servers/a9t9-uivision-mcp/uivision-mcp-bridge.json
- HTML version of this page: https://verifymcp.io/servers/a9t9-uivision-mcp/uivision-mcp-bridge