DimOS: Vibe-Code Any Robot With Claude, OpenClaw, or Ollama

For most of AI history, “embodied AI” meant a research lab with a seven-figure hardware budget and a team of robotics PhDs. The gap between the software world — where you can spin up an agent in 10 minutes — and the physical world has been enormous.

DimOS just closed a significant chunk of that gap.

Dimensional open-sourced their robot operating system this week: a Python framework that controls humanoids, quadrupeds, drones, and robotic arms from a single codebase. No ROS. No custom firmware per robot. And crucially: MCP built in from day one, so the same agents you use to browse the web or write code can now drive physical hardware.

Their README is refreshingly direct about it:

“Direct your favorite Agent (OpenClaw, Claude Code, etc.) to AGENTS.md and our CLI and MCP interfaces to start building powerful Dimensional applications.”

What Hardware You Can Actually Control

DimOS uses a traffic-light system. Here’s the current state:

Status	Hardware
🟩 Stable	Unitree Go2 Pro/Air (quadruped)
🟨 Beta	Unitree G1 (humanoid), xArm, AgileX Piper (arms)
🟧 Alpha	MAVLink drones, DJI Mavic
🟥 Experimental	Unitree B1 (larger quadruped)

This is pre-release beta — verify the hardware matrix on GitHub before purchasing anything specifically for DimOS.

Getting Started Without Any Hardware

The fastest path to DimOS is simulation. You need nothing but a laptop:

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

# Python environment
uv venv --python "3.12"
source .venv/bin/activate
uv pip install 'dimos[base,unitree]'

# Replay a real recorded quadruped session (downloads ~75MB dataset)
dimos --replay run unitree-go2

That replays a recorded Unitree Go2 session — SLAM, costmap, A* path planning — showing you exactly how the robot navigated a real space.

For full MuJoCo simulation:

uv pip install 'dimos[base,unitree,sim]'

dimos --simulation run unitree-go2        # quadruped
dimos --simulation run unitree-g1-sim     # humanoid
dimos --replay run drone-agentic          # drone + LLM agent replay

When you have a real robot:

export ROBOT_IP=<YOUR_ROBOT_IP>
dimos run unitree-go2

Same code. Different flag.

The MCP Layer: Controlling a Robot Like a Software API

This is the genuinely new thing. DimOS exposes an MCP server that maps robot capabilities to callable tools. Once running, any MCP-compatible agent drives the robot.

# Start the MCP-enabled quadruped in simulation
dimos --simulation run unitree-go2-agentic-mcp --daemon

# Check status
dimos status

# See what tools are available
dimos mcp list-tools
# → relative_move, rotate, explore_room, take_photo, stop, ...

# Call a skill directly
dimos mcp call relative_move --arg forward=0.5

# Or send natural language
dimos agent-send "explore the room and come back"

Now open Claude Code, Cursor, or OpenClaw and point them at the MCP endpoint. The robot’s skills appear as tools. You type:

move forward 1 meter, then turn left 90 degrees and take a photo

The agent decomposes that into skill calls. The robot executes them. In simulation first, then identically on real hardware.

Using OpenClaw or a Local LLM

For OpenClaw users, the setup is clean: run DimOS with MCP, add the endpoint to your OpenClaw config, and your existing agent gains physical capabilities alongside its digital ones.

For fully local/offline operation:

# Requires Ollama running with a model pulled
ollama serve &
ollama pull llama3.2

dimos --simulation run unitree-go2-agentic-ollama

Any Ollama model becomes the robot’s reasoning layer. Llama 3.2 works for basic navigation and pick-and-place. For complex multi-step autonomy you’d want something larger — but the option is there for air-gapped or privacy-sensitive deployments.

What the Code Actually Looks Like

DimOS uses a Module system — subsystems communicating via typed message streams. A minimal movement example:

from dimos.core.module import Module
from dimos.core.stream import Out
from dimos.msgs.geometry_msgs import Twist
import time

class MoveForward(Module):
    cmd_vel: Out[Twist]

    def run(self):
        for _ in range(10):
            self.cmd_vel.send(Twist(linear_x=0.3))  # move forward
            time.sleep(0.1)
        self.cmd_vel.send(Twist())  # stop

Modules subscribe to sensor streams (camera, lidar, IMU) and publish to actuator streams (velocity commands, joint angles). The framework wires everything together. This pattern works whether you’re writing a simple teleop controller or a full SLAM + navigation + vision pipeline.

What’s Included Out of the Box

Perception:

• Camera streams, LIDAR processing
• VLM integration (ask “what do you see?”)
• Object detection and 3D projection

Navigation:

• SLAM (simultaneous localization and mapping)
• Dynamic obstacle avoidance
• A* route planning
• Autonomous exploration

Memory:

• Spatio-temporal RAG — the robot remembers where things are
• Dynamic object localization and permanence (“go find the kitchen”)

Agent interface:

• MCP server (Claude, OpenClaw, Cursor)
• Ollama support (local LLMs)
• CLI for direct skill calling

What DimOS Is and Isn’t

It is:

• A unified Python SDK across robot platforms — write once, target multiple hardware types
• Agent-native with MCP built in from day one
• A practical entry point for developers who’ve been locked out of robotics by ROS complexity
• Useful without any hardware — simulation works fully

It isn’t:

• Production-ready (explicitly pre-release beta)
• A ROS replacement for deep research (it has a ROSWatch bridge if you need compatibility)
• Fully hardware-agnostic yet — the stable support list is short

The Bigger Picture

MCP standardized how AI agents talk to software APIs — one protocol, any tool. DimOS is applying the same idea to physical hardware. One protocol, any robot.

Yann LeCun’s $1B bet at AMI Labs is that future AI needs to understand the physical world through learned world models, not token prediction. DimOS is a more pragmatic answer to the same problem: give current agents a body and a standardized way to operate it, and see what they can do now.

The NemoClaw stack at GTC 2026 showed the enterprise agent layer hardening fast. DimOS is the open-source version of that happening at the physical layer — and it’s already citing OpenClaw by name as a first-class integration target.

If you have access to a Unitree Go2 or just want to try it in simulation, the install is one command and the sim works out of the box. The MCP-to-robot path is genuinely accessible.

---

DimOS is open-source at github.com/dimensionalOS/dimos. Pre-release beta — verify hardware support before purchasing.