The Agentive Operating System for Physical Space

Docs • Hardware • Installation • Agent CLI & MCP • Blueprints • dimTELE: Remote Teleop • Development

⚠️ Pre-Release Beta ⚠️

About

Dimensional is the modern operating system for generalist robotics. We are setting the next-generation SDK standard, integrating with the majority of robot manufacturers.

With a simple install and no ROS required, build physical applications entirely in python that run on any humanoid, quadruped, or drone.

Dimensional is agent native -- "vibecode" your robots in natural language and build (local & hosted) multi-agent systems that work seamlessly with your hardware. Agents run as native modules — subscribing to any embedded stream, from perception (lidar, camera) and spatial memory down to control loops and motor drivers.

Navigation and Mapping SLAM, dynamic obstacle avoidance, route planning, and autonomous exploration — via both DimOS native and ROS Watch video	Perception Detectors, 3d projections, VLMs, Audio processing
Agentive Control, MCP "hey Robot, go find the kitchen" Watch video	Spatial Memory Spatio-temporal RAG, Dynamic memory, Object localization and permanence Watch video

Hardware

Quadruped	Humanoid	Arm	Drone	Misc
🟩 Unitree Go2 pro/air 🟥 Unitree B1	🟨 Unitree G1	🟨 Xarm 🟨 AgileX Piper	🟧 MAVLink 🟧 DJI Mavic	🟥 Force Torque Sensor

Installation

Guided installation (recommended)

Use the official installer to set up system dependencies, Python 3.12, and dimOS:

curl -fsSL https://raw.githubusercontent.com/dimensionalOS/dimos/main/scripts/install.sh | bash

See scripts/install.sh --help for non-interactive and advanced options.

See installer options, or platform notes:

• 🟩 Ubuntu 22.04 / 24.04
• NixOS / General Linux (not CI-tested)
• 🟧 macOS

Full system requirements, tested configs, and dependency tiers: docs/requirements.md

Manual installation

If you need to install without the script, follow the system-package and Python steps for Ubuntu, macOS, or Nix.

Quickstart

Activate the environment using the command printed by the installer, then run:

# Replay a recorded quadruped session (no hardware needed)
# NOTE: First run will show a black rerun window while ~75 MB downloads from LFS
dimos --replay run unitree-go2

# The installer's default extras include simulation support.
# Run quadruped in MuJoCo simulation
dimos --simulation run unitree-go2

# Run humanoid in simulation
dimos --simulation run unitree-g1-sim

# Control a real robot (Unitree quadruped over WebRTC)
export ROBOT_IP=<YOUR_ROBOT_IP>
dimos run unitree-go2

Featured Runfiles

Full blueprint docs: docs/usage/blueprints.md

Agent CLI and MCP

The dimos CLI manages the full lifecycle — run blueprints, inspect state, interact with agents, and call skills via MCP.

dimos run unitree-go2-agentic --daemon   # Start in background
dimos status                              # Check what's running
dimos log -f                              # Follow logs
dimos agent-send "explore the room"       # Send agent a command
dimos mcp list-tools                      # List available MCP skills
dimos mcp call move_to --arg x=0.5 --arg relative=true  # Call a skill directly
dimos stop                                # Shut down

Full CLI reference: docs/usage/cli.md

dimTELE: Remote Teleop

dimTELE is hosted teleoperation for DimOS robots: operate them remotely from any browser or Quest headset over WebRTC. The robot dials out to a hosted broker, so you don't need to open any inbound ports on the robot's network. It works behind a home router, on Wi-Fi, wired LAN, or cellular.

1. Open the Dimensional console, sign in, and create an API key (API keys → Create key).

2. Run a teleop blueprint on the robot, passing the key as TRANSPORTS__BROKER__API_KEY:

   # Robot dials out to the broker with your API key
   TRANSPORTS__BROKER__API_KEY=<your-api-key> \
   dimos run teleop-hosted-go2-transport
   

3. Your robot appears under Available Robots — click Connect and drive the robot from the browser.

Full guide: dimTELE • WebRTC internals

Usage

Use DimOS as a Library

See below a simple robot connection module that sends streams of continuous cmd_vel to the robot and receives color_image to a simple Listener module. DimOS Modules are subsystems on a robot that communicate with other modules using standardized messages.

import threading, time, numpy as np
from dimos.core.coordination.blueprints import autoconnect
from dimos.core.core import rpc
from dimos.core.module import Module
from dimos.core.stream import In, Out
from dimos.msgs.geometry_msgs import Twist
from dimos.msgs.sensor_msgs import Image, ImageFormat

class RobotConnection(Module):
    cmd_vel: In[Twist]
    color_image: Out[Image]

    @rpc
    def start(self):
        threading.Thread(target=self._image_loop, daemon=True).start()

    def _image_loop(self):
        while True:
            img = Image.from_numpy(
                np.zeros((120, 160, 3), np.uint8),
                format=ImageFormat.RGB,
                frame_id="camera_optical",
            )
            self.color_image.publish(img)
            time.sleep(0.2)

class Listener(Module):
    color_image: In[Image]

    @rpc
    def start(self):
        self.color_image.subscribe(lambda img: print(f"image {img.width}x{img.height}"))

if __name__ == "__main__":
    autoconnect(
        RobotConnection.blueprint(),
        Listener.blueprint(),
    ).build().loop()

Blueprints

Blueprints are instructions for how to construct and wire modules. We compose them with autoconnect(...), which connects streams by (name, type) and returns a Blueprint.

Blueprints can be composed, remapped, and have transports overridden if autoconnect() fails due to conflicting variable names or In[] and Out[] message types.

A blueprint example that connects the image stream from a robot to an MCP-backed LLM agent for reasoning and action execution.

from dimos.core.coordination.blueprints import autoconnect
from dimos.core.transport import LCMTransport
from dimos.msgs.sensor_msgs import Image
from dimos.robot.unitree.go2.connection import go2_connection
from dimos.agents.mcp.mcp_client import McpClient
from dimos.agents.mcp.mcp_server import McpServer

blueprint = autoconnect(
    go2_connection(),
    McpServer.blueprint(),
    McpClient.blueprint(),
).transports({("color_image", Image): LCMTransport("/color_image", Image)})

# Run the blueprint
if __name__ == "__main__":
    blueprint.build().loop()

Library API

• Modules
• LCM
• Blueprints
• Transports — Zenoh, LCM, DDS, ROS 2
• Data Streams
• Configuration
• Visualization
• Web: cockpit, web SDK, relay

Demos

Development

Develop on DimOS

export GIT_LFS_SKIP_SMUDGE=1
git clone https://github.com/dimensionalOS/dimos.git
cd dimos

# Run the default test suite (uv run syncs deps on demand; --all-groups
# only needed for self-hosted tests / mypy — see docs/development/testing.md)
uv run pytest --numprocesses=auto dimos

Multi Language Support

Python is our glue and prototyping language, but we support many languages via LCM interop.

Check our language interop examples:

• C++
• Lua
• TypeScript