# AI Rover Studio (npm · ai-rover-mcp)

Let an AI agent drive a 2D robot rover simulator in the browser: sensors, camera, wiring and code.

- Trust score: 67/100 (medium)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-05

## Components

- npm · `ai-rover-mcp`: 67/100 (this document), [markdown](https://verifymcp.io/servers/taewankung-ai-rover-mcp/ai-rover-mcp.md), [page](https://verifymcp.io/servers/taewankung-ai-rover-mcp/ai-rover-mcp)

## Channel facts

- Registry: `npm`
- Package: `ai-rover-mcp`
- Version: `1.1.2`
- 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-11-05.

- **Supply Chain Security**: 98/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.
  - 30 of 93 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 4 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 70/100
  - AI-judged instruction clarity (good).
  - Tool/resource definitions use about 3958 tokens (~96/item across 41 items; 41 tools + 0 resources), lean.
  - 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**: 85/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 54% of tool parameters carry a description.
- **Tool Safety**: 94/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - 3 of 4 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 42 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); 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 AI Rover Studio MCP server?

AI Rover Studio runs locally as an npm package, launched with npx -y ai-rover-mcp. 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 taewankung-ai-rover-mcp -- npx -y ai-rover-mcp
```

### Cursor

```json
{
  "mcpServers": {
    "taewankung-ai-rover-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "ai-rover-mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "taewankung-ai-rover-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "ai-rover-mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add taewankung-ai-rover-mcp -- npx -y ai-rover-mcp
```

### opencode

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

### OpenClaw

```bash
openclaw mcp add taewankung-ai-rover-mcp --command npx --arg -y --arg ai-rover-mcp
```

### Hermes

```yaml
mcp_servers:
  taewankung-ai-rover-mcp:
    command: "npx"
    args: ["-y", "ai-rover-mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "taewankung-ai-rover-mcp": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "ai-rover-mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add taewankung-ai-rover-mcp -t stdio -c npx -a -y ai-rover-mcp
```

### Other

```json
{
  "mcpServers": {
    "taewankung-ai-rover-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "ai-rover-mcp"
      ]
    }
  }
}
```

## 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-11-01 (score 67, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-10-31 (score 52)

First indexed and scored.

## MCP tools (41)

### `open_simulator` (~37 tokens)

Open simulator

Open the AI Rover Studio page in the default browser and wait (up to 15 s) for it to connect to this MCP server.

### `connection_status` (~20 tokens)

Connection status

Report whether the simulator page is connected to this MCP server.

### `get_observation` (~45 tokens)

Get observation

Current robot pose (x, y, heading_deg), velocity, every enabled sensor reading, face display state, plus simulation status (running, autopilot, power, lamp position).

### `read_sensors` (~27 tokens)

Read sensors

Fresh readings from all enabled sensors, with their mounting position, angle, range and unit.

### `drive` (~168 tokens)

Drive

Move the rover for a fixed time: forward / backward, or turn left / right in place. Turns autopilot off and starts the simulation. Rotation speed is about 2 rad/s (≈115°/s), so turning 90° takes ≈0.8 s. Forward speed is 65 % of max speed (≈61 px/s at the default 55 % power; backward ≈51 px/s). With wait=true (default) it returns the observation after the move finishes. The rover stops on collisions.

Input parameters:

- `direction` (string, required)
- `seconds` (number): Duration, 0.2–10 s (default 2 for forward/backward, 1 for turns)
- `wait` (boolean): Wait for the move to finish before returning (default true)

### `turn` (~74 tokens)

Turn by degrees

Turn the rover in place by an exact angle (+ = right / clockwise, − = left) at ≈115°/s, then return the observation. Unlike drive left/right there is no 0.2 s minimum, so small corrections (e.g. 7°) are exact.

Input parameters:

- `degrees` (number, required)

### `run_program` (~241 tokens)

Run a rover program

Run JavaScript on the robot with the `rover` library (same as the Code page; it replaces any running program and starts the simulation). Top-level await works. Motion (await): rover.forward(s), backward(s), turn(deg), left(s), right(s); rover.drive(speed −1…1, turn °/s) keeps going; rover.stop(); rover.power(%). Readings (sync, 50 ms snapshots): rover.read(id), sensors(), distance() (nearest sonar/IR cm), light() (%), bumped(), pose(), time(). Head/face: await rover.head(deg), trackLight(on), headAngle(); rover.face(emotion, text), say(text, s). Buttons: pressed(id), onButton([id], fn(event)), await waitButton([id]). Time/output: await wait(s), await rover.until(fn, timeout), log(...). Customise: await rover.module(name, on), addSensor({type,name,x,y,angle,range}), updateSensor(id, fields), removeSensor(id), sensorList(). Returns immediately; poll get_program for status and the console.

Input parameters:

- `code` (string, required)

### `stop_program` (~23 tokens)

Stop the program

Stop the running rover program (its worker is terminated, the wheels stop).

### `get_program` (~45 tokens)

Program status

The current/last rover program: code, status (idle, running, listening, done, stopped, error), error { message, line } and the last 50 console lines.

### `stop` (~23 tokens)

Stop

Emergency stop: cancel any movement, turn autopilot off and pause the simulation.

### `set_simulation` (~31 tokens)

Start / pause simulation

Start (running=true) or pause (running=false) the physics simulation.

Input parameters:

- `running` (boolean, required)

### `set_autopilot` (~45 tokens)

Autopilot

Enable the built-in rule-based autopilot (seeks the light, backs away from obstacles; also starts the simulation) or disable it.

Input parameters:

- `enabled` (boolean, required)

### `set_power` (~51 tokens)

Motor power

Set motor power in percent (10–100). Max speed is 170 px/s at 100 % (drive uses 65 % of it forward, 55 % backward).

Input parameters:

- `percent` (number, required)

### `set_emotion` (~74 tokens)

Face expression

Show an expression on the robot's face display (emulated SSD1306 128×64 OLED); the message appears in the top text line and scrolls if long. Held ~5 s before sensor-driven emotions resume.

Input parameters:

- `emotion` (string, required)
- `message` (string): Speech text shown under the face

### `display_text` (~108 tokens)

Show text on the display

Make the rover "say" a text on the Face Display module (128×64 OLED): a small rover face with a talking mouth and the text typed out in a speech bubble (Thai supported, ~11 characters per line, 2 lines per bubble, extra bubbles follow). Returns to the big face after `seconds`, or once every bubble has been shown if that takes longer.

Input parameters:

- `seconds` (number): How long to show it (default 6)
- `text` (string, required)

### `set_display` (~151 tokens)

Choose the display module

Fit a different Face Display module: "ssd1306" (0.96" 128×64 monochrome OLED, I²C; default), "ssd1331" (0.95" 96×64 colour RGB OLED, SPI) or "st7789" (1.3" 240×240 colour IPS TFT, SPI). Faces and text adapt to the resolution; colour modules show a colour per emotion. `panel` changes the SSD1306 glass colour. Returns read_display.

Input parameters:

- `model` (string)
- `panel` (string): SSD1306 panel colour: yellow-blue (top 16 rows yellow, rest blue; the default), white, blue or yellow

### `draw_display` (~329 tokens)

Draw a picture on the display

Show a picture on the Face Display module for `seconds`, then return to the face. Pass one string per pixel row, at most the module's resolution (SSD1306 128×64, SSD1331 96×64, ST7789 240×240; see read_display). Characters space . 0 - _ are dark. On colour modules (SSD1331, ST7789) these letters pick a colour: R red, O orange, Y yellow, G green, C cyan, B blue, P purple, M pink, W white, A grey, N brown, K black; any other character is white, and `palette` adds or overrides letters. On the monochrome SSD1306 every non-blank, non-black character is a lit pixel and colour comes from its panel variant (`panel`). The picture is centred; `scale` enlarges each pixel (e.g. 64×32 with scale 2 fills 128×64) and is lowered if it would not fit. Returns read_display, so the result shows what the module actually displays.

Input parameters:

- `palette` (object): Extra colour letters, e.g. {"s": "#87ceeb"} (colour modules)
- `panel` (string): SSD1306 panel colour: yellow-blue (top 16 rows yellow, rest blue; the default), white, blue or yellow
- `rows` (array, required): Pixel rows, top to bottom
- `scale` (integer): Pixel size (default 1)
- `seconds` (number): How long to show it (default 10)

### `read_display` (~65 tokens)

Read the display

Read back what the Face Display module is showing: mode (face/text), text lines, module stats (frames, fps, bytes) and the actual 128×64 pixels from the module's GDDRAM as ASCII art (█▀▄, 2 pixel rows per line).

### `move_light` (~43 tokens)

Move light source

Move the light source to world coordinates (clamped to 42–758 × 42–478).

Input parameters:

- `x` (number, required)
- `y` (number, required)

### `reset_world` (~42 tokens)

Reset world

Put the rover back at its start pose (120, 265, heading 0°) and the light at (690, 70). Turns autopilot off.

### `send_chat` (~72 tokens)

Send chat command

Send a message to the in-page Agent Chat (offline Thai/English command parser, e.g. "ไปหาแสง", "อ่านเซนเซอร์", "เดินหน้า 2 วินาที") and return the rover's reply. It shows up in the chat panel.

Input parameters:

- `text` (string, required)

### `get_manifest` (~28 tokens)

Get robot manifest

The Robot Capability Manifest (ai-cartridge/body-v1): motors, installed sensor modules and display.

### `list_sensors` (~29 tokens)

List sensors

All configured sensors (enabled or not) with id, type, mounting position, angle and range.

### `add_sensor` (~132 tokens)

Add sensor

Install a new sensor on the rover body. Unspecified fields use the type defaults (centre of the body, facing forward).

Input parameters:

- `angle` (number): Facing angle in degrees, 0 = forward, 90 = right side (wrapped to −180…180)
- `enabled` (boolean)
- `name` (string): Display name
- `range` (number): Detection range in cm
- `type` (string, required)
- `x` (number): Local x in px (forward +, rear −)
- `y` (number): Local y in px (right side +, left side −)

### `update_sensor` (~140 tokens)

Update sensor

Change a sensor's name, type, mounting position, angle, range or enabled flag. Use list_sensors to find ids.

Input parameters:

- `angle` (number): Facing angle in degrees, 0 = forward, 90 = right side (wrapped to −180…180)
- `enabled` (boolean)
- `id` (string, required)
- `name` (string): Display name
- `range` (number): Detection range in cm
- `type` (string)
- `x` (number): Local x in px (forward +, rear −)
- `y` (number): Local y in px (right side +, left side −)

### `remove_sensor` (~22 tokens)

Remove sensor

Uninstall a sensor by id.

Input parameters:

- `id` (string, required)

### `set_module` (~79 tokens)

Install / remove a module

Install or remove a body module: "wheels" (drive motors + wheels; without them the rover cannot move), "head" (pan servo that turns the face and the light sensors), "display" (AI Face Display OLED) or "camera" (forward-facing camera).

Input parameters:

- `installed` (boolean, required)
- `module` (string, required)

### `set_head` (~135 tokens)

Turn the head

Control the Head module (pan servo, needs set_module head first). angle_deg turns the face to −90…90° relative to the body (+ = right, servo ≈180°/s) and switches to manual. track_light=true makes the head find and follow the light with its own light sensors: it sweeps the full range, settles on the brightest angle and keeps hill-climbing (rescans if the light is lost). Light sensors are directional (brightest when facing the lamp) and ride on the head. Starts the simulation.

Input parameters:

- `angle_deg` (number)
- `track_light` (boolean)

### `press_button` (~120 tokens)

Press a button

Press a push-button module (a sensor of type "button") for `seconds` and release it, like a person would. Held ≥ 0.8 s is a long press. The built-in program reacts: short press toggles the head's light tracking (happy face), long press stops everything (driving, autopilot, tracking; pauses the simulation). Returns the press event.

Input parameters:

- `id` (string, required): Button sensor id (list_sensors)
- `seconds` (number): How long to hold it (default 0.2 s)

### `get_button_events` (~71 tokens)

Button events

Button presses since the last call (oldest first, then cleared): { id, name, press: "short" | "long", seconds, at (ms epoch) }, plus every button and whether it is held right now. People press buttons in the simulator page; poll this to react to them.

### `get_head` (~33 tokens)

Head status

Head module status: angle_deg, target_deg, mode (manual / track_light), tracking phase and the head light brightness.

### `capture_camera` (~107 tokens)

Capture camera image

Take a picture with the rover's forward-facing camera (needs the camera module). Returns a 320×240 first-person PNG (walls, colored obstacles, colored floor tape, the light source) and a JSON list of what is in view: type (obstacle / tape / light), id, color, bearing_deg (0 = straight ahead, + = right) and distance_cm.

Input parameters:

- `fov_deg` (number): Change the horizontal field of view first (default 60°)

### `get_sensor_map` (~114 tokens)

Get sensor map

The map the rover has built from its own sensors only (not the true layout): an occupancy grid of 10 px cells as ASCII rows ("#" occupied by a sonar/IR echo or bumper hit, "." free, " " unknown, "@" rover, a capital letter = floor color read by a color sensor), camera landmarks with estimated world x/y, bumper hit points, the pose and exploration stats. clear=true wipes the map first.

Input parameters:

- `clear` (boolean): Clear the map before returning it (default false)

### `get_wiring` (~215 tokens)

Get wiring

How the fitted rover body wires to a real microcontroller (the Wiring page): for each part (TB6612FNG motor driver, each enabled sensor, the display module, the camera) every pin and where it goes (MCU pin or 5V / 3V3 / GND / VBAT rail), the power budget per rail, issues found (pin conflicts, missing pins, 5 V signals into 3.3 V pins, duplicate I²C addresses, ESP32 strapping / ADC2 pins) and a ready-to-use pin file (Arduino pins.h, or pins.py with BCM numbers on the Pi). `board` switches the board first: "esp32" (ESP32 DevKit V1), "uno" (Arduino Uno R3) or "raspberrypi" (Raspberry Pi 4/5 40-pin header; analog sensors go through an ADS1115 on I²C, the camera on the CSI ribbon).

Input parameters:

- `board` (string)

### `get_bom` (~125 tokens)

Get parts list

Bill of materials for building the fitted rover body for real (the parts tab on the Wiring page): the board, motor driver, every enabled sensor, display, camera and head servo, plus the parts the circuit needs around them (chassis, battery, buck converter, voltage-divider resistors, level shifter …), each with quantity, approximate price in THB and shop links when known, and a plain-text list to copy. `board` switches the board first: "esp32", "uno" or "raspberrypi".

Input parameters:

- `board` (string)

### `get_firmware` (~184 tokens)

Get firmware

A complete program for the real robot, generated from the fitted body and the wiring pin map: an Arduino sketch (rover_firmware.ino) for "esp32" / "uno", or a Python script (rover.py) for "raspberrypi". It drives the TB6612FNG wheels, reads every enabled sensor, turns the head servo (with light tracking), draws faces on the display and runs the same auto emotions / rule-based autopilot as the simulator. Text commands over Serial 115200 / stdin: READ, F|B|L|R <s>, AUTO 0|1, POWER <%>, HEAD <deg>, TRACK 0|1, EMO <emotion> [text], SAY <text>, STOP. Returns { name, text }. `board` switches the board first.

Input parameters:

- `board` (string)

### `list_world` (~34 tokens)

List world layout

World size, light position, all obstacles (id, kind, shape, position, size, color) and colored floor tapes.

### `add_obstacle` (~159 tokens)

Add obstacle

Place an object in the world to test sensors, collisions or the camera. Kinds: cylinder / ball (circle, radius r), box / wall (rectangle w × h, rotated by angle°). Unspecified size and color use the kind's defaults. Refused if it would overlap the rover.

Input parameters:

- `angle` (number): Rotation in degrees for box / wall
- `color` (string)
- `h` (number): Height (depth) for box / wall
- `kind` (string, required)
- `r` (number): Radius for cylinder / ball
- `w` (number): Width for box / wall
- `x` (number, required): World x (px)
- `y` (number, required): World y (px)

### `remove_obstacle` (~26 tokens)

Remove obstacle

Remove an obstacle by id (see list_world).

Input parameters:

- `id` (string, required)

### `add_color_tape` (~114 tokens)

Add colored floor tape

Stick a strip of colored tape on the floor (for the color sensor, line following and the camera). A color sensor over the tape reads its color name.

Input parameters:

- `angle` (number): Rotation in degrees (0 = along x)
- `color` (string, required)
- `length` (number): Length in px (default 100)
- `width` (number): Width in px (default 18)
- `x` (number, required): Centre x (px)
- `y` (number, required): Centre y (px)

### `remove_color_tape` (~28 tokens)

Remove colored floor tape

Remove a floor tape by id (see list_world).

Input parameters:

- `id` (string, required)

## Diagnostics

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

## Score history

- 2026-11-05: 67
- 2026-11-04: 67
- 2026-11-03: 67
- 2026-11-02: 67
- 2026-11-01: 67
- 2026-10-31: 52

## Common questions

### What is the AI Rover Studio MCP server?

AI Rover Studio is an MCP server listed in the public MCP registry as io.github.taewankung/ai-rover-mcp. Let an AI agent drive a 2D robot rover simulator in the browser: sensors, camera, wiring and code. This page covers its npm package (ai-rover-mcp).

### Is the AI Rover Studio MCP server safe to use?

AI Rover Studio scores 67 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 5 November 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 AI Rover Studio MCP server expose?

AI Rover Studio exposes 41 tools: open_simulator, connection_status, get_observation, read_sensors, drive, and 36 more. Their descriptions and schemas cost roughly 3,609 tokens of context every time the server is loaded.

### Is the AI Rover Studio MCP server still maintained?

AI Rover Studio is still listed as active in the MCP registry. We last reached this channel on 5 November 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 AI Rover Studio MCP server under?

AI Rover Studio 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/ai-rover-mcp
- Socket report: https://socket.dev/npm/package/ai-rover-mcp
- Repository: https://github.com/taewankung/ai-rover-mcp
- Website: https://ai-rover.app/
- Changelog RSS feed: https://verifymcp.io/servers/taewankung-ai-rover-mcp/ai-rover-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/taewankung-ai-rover-mcp/ai-rover-mcp.json
- HTML version of this page: https://verifymcp.io/servers/taewankung-ai-rover-mcp/ai-rover-mcp