Introducing roz: Open-Source AI-Powered Robot Control

What if an AI agent could write a robot controller, verify it in simulation, and deploy it to real hardware — all within safety bounds that you define?

That's roz.

roz — the robotics claw

roz is an open-source platform for AI-powered robot control. It treats LLM agents as first-class robot programmers: agents write WASM controllers, deploy them to edge hardware, and operate within a layered safety system that you configure.

It's written in Rust (edition 2024), unsafe is denied workspace-wide, and it's available today as a research preview.

The Problem

Robotics development has two worlds that don't talk to each other.

On one side: traditional robotics engineers writing C++ control loops, cross-compiling for ARM targets, debugging on hardware with JTAG probes. Deterministic, reliable, slow to iterate.

On the other side: AI agents that can reason about tasks, plan multi-step actions, and adapt to novel situations. Flexible, intelligent, but dangerous near actuators.

roz bridges these worlds. An AI agent reasons about what the robot should do. roz ensures it can only do it safely.

How It Works

The core pipeline is straightforward:

Agent receives a task — "pick up the red block" or "survey the north quadrant at 10m altitude"
Agent writes a WASM controller — targeting the robot's channel interface (joint positions, velocities, or efforts)
Controller loads into the Copper-rs runtime — executing on the edge device at up to 1kHz, sandboxed in WASM
Safety constitution constrains behavior — four tiers of rules the agent cannot override
Heartbeat monitoring watches everything — if the agent stops responding, the safety daemon triggers an e-stop

What You Can Build

Manipulator arms — UR5 and compatible 6-DOF arms. Position, velocity, and effort control modes. The agent can write controllers that move joints, follow trajectories, or respond to force feedback.

Drones — PX4-based quadcopters. The agent handles arming, takeoff, mode transitions, and velocity commands through a MAVLink bridge. Tested end-to-end in Gazebo SITL simulation.

Multi-agent teams are supported natively. Agents can delegate spatial regions to other agents, coordinate on shared tasks, and hand off control — all through NATS messaging.

Architecture

Edge — Copper-rs runtime for deterministic control loops. WASM sandbox isolates agent-generated controllers. Zenoh for low-latency local communication. This runs on the robot.

Cloud — NATS for messaging. Restate for durable task orchestration. PostgreSQL with row-level security for multi-tenant isolation. This runs on your infrastructure.

You can self-host the entire stack with Docker Compose, or use Roz Cloud for managed infrastructure.

Safety First

Safety in roz isn't a feature — it's the architecture.

Constitution — A tiered system prompt that constrains agent behavior. Tier 1 (safety-critical) rules can never be overridden, not by users, not by the agent itself.

WASM sandboxing — Controllers run in a sandbox with no filesystem, network, or system call access. Only sensor reads and actuator writes through a narrow host function interface.

Heartbeat watchdog — If the agent stops responding, the safety daemon triggers an e-stop. No heartbeat, no movement.

Hardware e-stop — Physical emergency stop integration. All actuator commands are zeroed and the system enters a safe state requiring manual recovery.

At the language level: unsafe is denied across the entire workspace. This is a safety-critical robotics platform. There are no exceptions.

Getting Started

roz is a research preview. Getting it running requires some setup — this is not a one-click install.

Prerequisites:

Rust toolchain (1.92+) with the wasm32-unknown-unknown target
Docker for running PostgreSQL, NATS, and Restate (self-hosted mode)
A simulation environment (Gazebo) or real robot hardware
An LLM API key (Anthropic, OpenAI, or a local model via Ollama)

Install the CLI:

cargo install --git https://github.com/Bedrock-Dynamics/roz-oss roz-cli

For self-hosted mode, you'll also need to spin up the backend services via Docker Compose. For cloud mode, you can skip infrastructure setup and connect directly to Roz Cloud.

See the full installation and quickstart guides in the docs for step-by-step instructions.

Full documentation: bedrockdynamics.studio/docs/roz

What's Next

roz is a research preview. The core pipeline works end-to-end — from agent reasoning through WASM compilation to real hardware actuation — but we're still hardening for production use.

On the roadmap: vision integration for spatial reasoning, fleet management for multi-robot coordination, sim-to-real transfer for validated controllers, and more robot platforms including Nav2 mobile robots and ArduPilot vehicles.

We're building roz in the open because robotics needs better foundations. If you're working on autonomous systems, we'd love your feedback and contributions.

GitHub: github.com/Bedrock-Dynamics/roz-oss

Docs: bedrockdynamics.studio/docs/roz