The Agentive Operating System for Physical Space

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

About

Dimensional is the open-source operating system for general robotics. We are a runtime, SDK, and operating system that natively supports robotics primitives like navigation, manipulation, perception, spatial memory, and agentic control across all types of hardware (humanoids, drones, manipulators, quadrupeds). With Dimensional, your agent can control robots by tool calling our primitives for classical use cases in real time while using a model (VLA, LLM, frontier robotics models, etc) for learned policies. Dimensional also offers teleoperation and data management tools as hosted services or locally to help developers collect data and train policies.

Navigation and Mapping Watch video	Agentive Manipulation Watch video
Agentive Control, MCP Watch video	Spatial Memory Watch video
Agentive Control, Drone Swarm Watch video	Perception

Hardware

Quadrupeds	Unitree Go2 pro/⁠air ·  Deep Robotics Lynx M20 ·  Boston Dynamics Spot
Humanoids	Unitree G1 ·  Galaxea R1 Pro
Arms	UFactory xArm 6/⁠7, Lite6 ·  AgileX Piper ·  OpenYAM ·  OpenArm  Galaxea A1Z ·  MakerMods Metal ·  Seeed reBot B601-⁠DM ·  A-⁠750
Drones	DJI (via RosettaDrone / MAVLink)
Sensors & teleop	Livox Mid-⁠360 ·  Intel RealSense ·  Meta Quest / PICO ·  Force Torque Sensor

stable beta alpha experimental

Try DimOS

Paste this into Claude Code, Cursor or Codex. It installs DimOS and plays back a recorded robot session.

Install DimOS from https://github.com/dimensionalOS/dimos and run the Go2 replay demo.

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

Run command	What it does
dimos --replay run unitree-go2	Quadruped navigation replay — SLAM, costmap, A* planning
dimos --replay --replay-db go2_bigoffice run unitree-go2-memory	Quadruped temporal memory replay
dimos --simulation run unitree-go2-agentic	Quadruped agentic + MCP server in simulation
dimos --simulation run unitree-g1-sim	Humanoid in MuJoCo simulation
dimos --replay run drone-basic	Drone video + telemetry replay
dimos --replay run drone-agentic	Drone + LLM agent with flight skills (replay)
dimos run demo-camera	Webcam demo — no hardware needed
dimos run keyboard-teleop-xarm7	Keyboard teleop with mock xArm7 (requires dimos[manipulation] extra)
dimos --simulation run unitree-go2-agentic-ollama	Quadruped agentic with local LLM (requires Ollama + ollama serve)

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.

Blueprint	Notes
teleop-hosted-go2-transport	Browser teleop — drive + camera + minimap + click-to-nav (recommended)
teleop-hosted-go2-multicam	Adds a second RealSense, operator-selectable, mux'd into one video track

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.coordination.module_coordinator import ModuleCoordinator
from dimos.core.core import rpc
from dimos.core.module import Module
from dimos.core.stream import In, Out
from dimos.msgs.geometry_msgs.Twist import Twist
from dimos.msgs.sensor_msgs.Image 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__":
    ModuleCoordinator.build(
        autoconnect(
            RobotConnection.blueprint(),
            Listener.blueprint(),
        )
    ).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.coordination.module_coordinator import ModuleCoordinator
from dimos.core.transport_factory import make_transport
from dimos.msgs.sensor_msgs.Image import Image
from dimos.robot.unitree.go2.connection import GO2Connection
from dimos.agents.agent import Agent
from dimos.agents.mcp.mcp_server import McpServer
from dimos.agents.skills.observe_skill import ObserveSkill

blueprint = autoconnect(
    GO2Connection.blueprint(),
    ObserveSkill.blueprint(),
    McpServer.blueprint(),
    Agent.blueprint(),
).transports({("color_image", Image): make_transport("go2/color_image", Image)})

# Run the blueprint
if __name__ == "__main__":
    ModuleCoordinator.build(blueprint).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