VibeBot Studio

Live drone and robotics telemetry, ROS 2 connector, flight log timeline, flight report generation, anomaly detection, and telemetry-to-code mapping — all inside VS Code.

👋 11k+ engineers installed VibeBot — help us build what you actually need

We shipped this with zero marketing. 1.1k of you found it and installed it organically.

Now we need 10 minutes of your time to build the right next features.

→ Fill the 3-question feedback form (2 minutes)

(Anonymous. Shapes what we build next.)

VibeBot Studio is an AI-powered IDE layer for drone and robotics engineers. Connect to any MAVLink drone or ROS 2 robot via UDP, Serial, or WebSocket — and see live telemetry without leaving your editor.

What's new in v0.2.6

• Anomaly Detection — Real-time statistical analysis runs continuously on your live telemetry stream:
  • Battery drain rate — flags when drain exceeds your session baseline by >20%
  • IMU drift — detects yaw drift exceeding 2°/min and sustained roll/pitch bias
  • Motor asymmetry — alerts when any motor channel deviates >15% from the mean (drone turning or motor fault)
  • Vibration FFT — runs FFT on gyroscope data and flags resonant frequencies that indicate frame or prop issues
  • All alerts appear inline in the telemetry sidebar with severity level, evidence values, and a 30-second cooldown to prevent alert fatigue
• Telemetry-to-Code Mapping — VibeBot now statically analyses your open workspace and builds a map between your source code and the telemetry it produces:
  • AST parsing (Python and C++) — traces variables like kp, ki, kd to the ROS topics or MAVLink messages they influence
  • ROS 2 topic correlation — reads your launch files and topic remappings to resolve which node publishes to which channel
  • MAVLink message correlation — maps parameter names in your PX4/ArduPilot config to their corresponding telemetry fields
  • When an anomaly fires, VibeBot highlights the relevant source file and line in your editor

Connecting a Drone (MAVLink — UDP)

Use this when your drone is connected over WiFi, SITL, or a telemetry radio already paired to your PC.

Step 1 — Install the Python dependency:

pip install pymavlink

Step 2 — Power on your drone or start SITL:

# PX4 SITL via Docker
docker run --rm -it jonasvautherin/px4-gazebo-headless:latest

# ArduPilot SITL
sim_vehicle.py -v ArduCopter --console --map

Step 3 — Open the VibeBot sidebar in VS Code (drone icon in activity bar)

Step 4 — Select the MAVLink tab → enter your drone's IP and port → click Connect

Drone IP      Port
127.0.0.1     14550    ← SITL on same PC
192.168.1.10  14550    ← Drone on WiFi

Step 5 — Live telemetry appears — Battery, GPS, Attitude, IMU, Motors, Flight Data

Connecting a Drone (Serial — USB cable or telemetry radio)

Use this when your flight controller is connected via USB cable directly, or via a SiK / RFD900 telemetry radio dongle.

Step 1 — Find your COM port:

• Windows → Device Manager → Ports (COM & LPT) → note the COM number (e.g. COM3)
• Linux / Mac → run ls /dev/tty* → look for /dev/ttyUSB0 or /dev/ttyACM0

Step 2 — Open VibeBot sidebar → select the Serial tab

Step 3 — Enter your port and select baud rate:

Step 4 — Click Connect → telemetry streams in live

Windows note: If the port doesn't appear, install the CP210x or FTDI driver for your hardware.

Connecting a ROS 2 Robot

Use this for any robot running ROS 2 — ground robots, arms, custom platforms.

Step 1 — Install rosbridge on your robot:

# ROS 2 Humble
sudo apt install ros-humble-rosbridge-server

# ROS 2 Foxy
sudo apt install ros-foxy-rosbridge-server

Step 2 — Start rosbridge on the robot:

source /opt/ros/humble/setup.bash
ros2 launch rosbridge_server rosbridge_websocket_launch.xml

This opens a WebSocket on port 9090.

Step 3 — Make sure your PC and robot are on the same network.

Step 4 — Open VibeBot sidebar → select the ROS 2 tab

Step 5 — Enter the WebSocket URL:

ws://ROBOT_IP:9090

For a robot at 192.168.1.20:

ws://192.168.1.20:9090

For testing on the same PC:

ws://localhost:9090

Step 6 — (Optional) Set a namespace if your topics use a prefix:

/drone1    →  /drone1/imu/data, /drone1/battery_state …

Step 7 — Click Connect → VibeBot subscribes to:

Flight Report

Click the 📊 icon in the telemetry sidebar header after a flight to generate a full HTML report covering:

• Session summary (duration, protocol, connection, result)
• Battery (voltage start/end, drain rate, consumed mAh, temperature)
• GPS (max altitude, max speed, satellite count)
• Flight Data (throttle avg/max, climb rate, groundspeed)
• Attitude (max roll, max pitch)
• Vibration / IMU (X/Y/Z accelerometer avg and max with health status)
• Motors (per-channel avg PWM, imbalance detection)
• Flight modes breakdown (time in each mode as % of flight)
• Events timeline (ARM, DISARM, mode changes, warnings)
• Anomaly summary (all anomalies detected during the session with timestamps and severity)
• ROS 2 topic health (message count and Hz per topic) — when using ROS 2

Reports are downloadable as HTML and printable as PDF.

Works identically for both MAVLink and ROS 2 sessions.

Flight Log Timeline

Click the 📂 icon → select an ArduPilot .bin or PX4 .ulg file → interactive timeline opens:

• Tracks: Battery %, Voltage, Throttle %, Roll, Pitch, Yaw, AGL altitude, Groundspeed, GPS satellites
• Mouse wheel to zoom any time range
• Hover crosshair to read exact values
• Event markers: ARM, DISARM, mode changes, warnings, errors

Features

Anomaly Detection — How It Works

VibeBot runs a set of lightweight, deterministic detectors on your live telemetry. No cloud. No ML model. All local, all fast.

Alerts include: timestamp, telemetry values at trigger, evidence description, and — where a code mapping exists — a link to the relevant source file.

Telemetry-to-Code Mapping — How It Works

When you open a ROS 2 or ArduPilot/PX4 workspace, VibeBot analyses your source files in the background:

1. AST scan — Parses Python and C++ files to find variables, parameters, and function calls that feed ROS topics or MAVLink messages
2. Launch file parsing — Reads ROS 2 launch files and remappings to resolve the full topic graph
3. Parameter correlation — Maps PX4/ArduPilot parameter names (e.g. ATC_RAT_RLL_P) to their telemetry fields
4. Runtime correlation — When a parameter changes in your code and the corresponding telemetry channel responds, VibeBot records the causal link

When an anomaly fires, the relevant code location is surfaced directly in the IDE.

Compatible autopilots

Windows setup

Set your Python path in VS Code settings:

1. Press Ctrl+, → search vibebot.pythonPath
2. Set the full path:

C:\Users\YourName\AppData\Local\Programs\Python\Python314\python.exe

3. Ctrl+Shift+P → Developer: Reload Window

Requirements

Roadmap

• ✅ v0.1.x — MAVLink live telemetry
• ✅ v0.2.x — ROS 2 connector, flight log timeline, serial connection, flight report
• ✅ v0.2.6 — Anomaly detection (battery drain, IMU drift, motor asymmetry, vibration FFT), telemetry-to-code mapping (AST + ROS topic/MAVLink message correlation)
• 🔜 v0.3.x — AI code review with MAVLink/ROS context, one-click SITL, performance diff
• 🔜 v0.4.x — Security audit, team license, multi-vehicle support

Issues

https://github.com/octaboomai/VibeBot/issues

License

Apache 2.0