Skip to content

Changelog

1.0.0

One Robot object drives any robot, in simulation or on real hardware, through six contracts; bash acceptance/all.sh proves it against real backends and prints what it verified. Package: strands_robots, about twenty thousand executable lines on seven layers that only import downward.

In

  • Robot(name, mode="sim"|"real"|"twin", port=..., driver=...): one class for sim and real, owning exactly one Driver; observe, act (validate, finite, clamp, lease), preflight, is_connected asked of the wire, close with torque off.
  • Six contracts in core/contracts.py: RobotLike, Driver, SimEngine, Transport (Protocols), Policy, Recorder (ABCs). UnitFrame with preflight refusing a DOF change or a cartesian to joint gap before motion.
  • Registry: robots.json rows only for usable robots (asset, driver or lerobot type), joint frames per row, max_step per row; policies.json with seven providers; the factories (make_driver, make_sim, make_policy, make_transport) as the dependency-inversion seam.
  • Drivers: thirteen native wires, each protocol.py (pure functions over bytes) plus driver.py: Feetech (SO-100/101, LeKiwi, HopeJr, Open Duck), Dynamixel (Koch, ALOHA, ViperX, WidowX, Trossen), Unitree G1 and Go2 (DDS), Franka FCI, UR RTDE, Robotiq, Booster T1, Crazyflie, EarthRover, Microduck robotd, Reachy Mini daemon, Yahboom M3 Pro; the lerobot driver for every other lerobot robot type; ServoBusTwin giving Feetech and Dynamixel mode="twin" against the MuJoCo model.
  • Simulation: MujocoEngine first-class (reset, step, render, contacts, objects, headless EGL); Isaac and Newton behind the same SimEngine; one noise model, one mp4 writer.
  • Policies: lerobot_local (every architecture lerobot ships), groot service client, cosmos3, mock, rl (gymnasium env over SimEngine, algorithms from stable-baselines3), microduck ONNX, wbc ONNX (gait=True); one RTC implementation, one quaternion helper.
  • App: PolicyRunner with RTC, teleop, DatasetRecorder writing lerobot-format datasets for sim and real with a receipt from save() and a tombstone after it, replay, skills (move_to, set_gripper, look_at), Lease (one writer per arm).
  • Mesh: Zenoh and loopback transports, presence, state, correlated RPC, per-robot command allowlist with bounds, HMAC envelopes with a replay window, signed append-only audit chain, one fleet e-stop with lockout cleared by STRANDS_MESH_OVERRIDE_CODE.
  • Tools: fourteen (list_robots observe move preflight list_policies run_policy record_episode dataset_info mesh_fleet mesh_ask camera_list camera_snap mhs_fleet mhs_invoke), mode="sim" and dry_run=True by default, confirm=True for real motion, strands HITL on hardware motion; the strands-robots CLI over the same functions, doctor generated from the extras.
  • MHS: every Robot mounts as a Model Hardware Standard device (app.mhs.mount_robot): manifest derived from the registry row, validators refuse out-of-range before dispatch, execute_op runs the PolicyRunner, one e-stop shared with the mesh, broker loss lowers estop to 1; STRANDS_MESH_BACKEND=mhs carries the mesh over the same broker.
  • Dashboard: fleet, cameras over WebSocket, run, record, replay, e-stop, WebAuthn passkeys, confirm: true on every write.
  • Acceptance: ten scripts and all.sh printing == v1.0 ACCEPTANCE GREEN (n real / m skipped) ==.
  • Docs: about thirty pages; contracts, robot and policy cards, the coverage matrix, the tool reference and the configuration page generated from the source at build.
  • Containers: base, so101, g1, microduck images for amd64 and arm64.

Out, and what replaces it

left replacement
moveit2, curobo planners implement Policy when someone needs one; no contract kept warm
kimodo, protomotions not owned here; a text-to-motion chain belongs upstream
remote, lerobot_async providers lerobot's own async_inference
GR00T 1.5 / 1.6 / 1.7 in-process loaders lerobot_local serves GR00T N1.7; groot stays as the service client
IoT Core transport and provisioning Zenoh router across networks
bridge transport, camera offload, mesh/input.py, mesh/sensors.py drivers own their cameras; the mesh carries state
ROS mobile-base robots in the mesh drivers/ros/graph.py (rosbridge) and the Yahboom driver
lerobot_record subprocess writer DatasetRecorder for sim and real alike
three noise models, three mp4 writers, four quaternion helpers, two RTC blocks one of each
benchmarks, terrain curricula, live scene recompilation, run_multi_policy features that grow back on a stable engine
motion primitives per backend, ik.py app/skills.py over the contract
76 tool functions (13 G1, 14 Reachy forwards) 14 tools over RobotLike
Device Connect none; the mesh is the fleet path
~40 registry rows with no asset, driver or lerobot type none; a row exists only if it is usable
tests/ with mocked backends the acceptance suite against real backends
107 doc pages about 30, generated where they can be