Profile
Back to NewsBack
GitHub Trending 6 min
Reader Mode
dimensionalOS/dimos: Dimensional is the agentic operating system for physical space. Command humanoids, quadrupeds, drones, and other hardware platforms in natural language and build multi-agent systems that work seamlessly with physical input (camer

dimensionalOS/dimos: Dimensional is the agentic operating system for physical space. Command humanoids, quadrupeds, drones, and other hardware platforms in natural language and build multi-agent systems that work seamlessly with physical input (camer

9 hours ago

banner_bordered_trimmed

The Agentive Operating System for Physical Space

Discord</a> Stars</a> Forks</a> Contributors</a> Docs</a> !Nix !NixOS !CUDA Docker</a>

dimensionalOS%2Fdimos | Trendshift

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 Perception

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
Agents Spatial Memory

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

🟩 stable 🟨 beta 🟧 alpha 🟥 experimental

[!IMPORTANT]
🤖 Direct your favorite Agent (OpenClaw, Claude Code, etc.) to AGENTS.md and our CLI and MCP interfaces to start building powerful Dimensional applications.

Installation

Guided installation (recommended)

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

``sh skip 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:

> 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:

bash

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
bash

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
bash

Control a real robot (Unitree quadruped over WebRTC)

export 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.

bash 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:
bash # Robot dials out to the broker with your API key TRANSPORTS__BROKER__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.

py skip 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.

py skip 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

Demos

<img src="assets/readme/dimos_demo.gif" alt="DimOS Demo" width="100%">

Development

Develop on DimOS

sh skip 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:

Chat with me