Cerulion open-sources ROS 2-compatible robot runtime with run recording and failure replay

What Cerulion is

Cerulion, a robotics startup from Y Combinator's Summer 2024 batch, has open-sourced its robot runtime and introduced it on Hacker News on November 13. According to the project's README on GitHub, the runtime is built to let AI agents operate real robots within safety limits the robot itself enforces, and the company frames it as an operating layer for physical AI systems.

The README leads with three properties: ROS 2 compatibility, a zero-copy design for moving data between nodes, and built-in run recording with failure replay. A robot's processing graph runs as one process per node, and the project says this split happens without any change to the graph definition file.

Recording and verified replay

The workflow the project showcases is record-then-verify. Running a graph with recording enabled produces an MCAP file. Replaying that file while re-simulating all nodes, with a verification flag, compares the outputs nodes would produce now against what the recording captured. Unchanged code yields a passing verdict; the README demonstrates the failure path by editing a sample safety controller so its clear-path speed drops from 0.3 to 0.25, after which verification reports a divergence and exits nonzero.

Because the verdict is an exit code, the team positions it as a CI gate: behavior changes in robot code get flagged for review before they reach a physical machine. The README also says the runtime ships with tooling that lets agents debug recorded failures on their own.

Platforms, ROS 2 support and installation

Prebuilt binaries cover Linux on x86_64 and ARM64 (glibc 2.31 or newer, Ubuntu 20.04 onward) and macOS on both Intel and Apple Silicon. Building custom nodes requires Rust 1.95 or newer plus a C toolchain, and nodes load through a compiler-independent interface, so the toolchain used for a node need not match the one that built the CLI.

ROS 2 integration depends on the platform. The Linux packages bundle an rmw implementation for ROS 2 Jazzy, used by the runtime's ros2 run and launch commands; macOS gets none because ROS 2 Jazzy itself has no macOS builds. For the ROS 2 Lyrical distribution, per-release tarballs are published for both Linux architectures and tested in CI.

Installation is offered through a shell script, Homebrew, an APT repository for Debian and Ubuntu, or cargo from crates.io and source. The current release is 2.0.0, with documented migration steps for workspaces created under 1.0.

Accounts and remote access

Every Cerulion command runs under a free account, which the project says is used for robot pairing; sign-in happens once per machine and commands keep working offline afterward. By default a recorded run is readable from any computer signed in to the same account, with no addresses or flags to configure, and a --network off switch confines a run to the local machine. Two components, one on the operator's side and one on the robot, handle remote connections. The README even includes a ready-made prompt for coding agents such as Claude Code or Codex to run the quickstart in a terminal.

Why it matters

Reproducing a failure on a physical robot is notoriously hard, because the bug may depend on sensor timing and environmental conditions that cannot be recreated on demand. A runtime that records every run and can replay it against new code turns that problem into something closer to conventional software testing: divergence becomes an exit code, and behavior changes can be reviewed before they reach hardware. ROS 2 compatibility lowers the adoption barrier for the existing robotics ecosystem, and per-node process isolation paired with zero-copy transport speaks to real performance concerns in robot software.

The pairing of an open-source runtime with mandatory accounts and cross-machine access also signals the business model: an open core, with pairing and remote reach as the hosted surface. How well replay verification holds up outside the synthetic obstacle-avoidance demo, with real sensors and real timing jitter, will determine whether Cerulion earns a place in production robot stacks.