Model Inference

Use Model Inference to load a trained policy and test it in simulation mode before moving the real robot. It also supports TensorRT conversion for faster inference and provides both Async and Sync action request modes.

Cyclo Brain System Architecture

Cyclo Brain runs policy backends as separate Docker containers. The UI sends inference commands to the selected backend, the backend loads the model and computes action chunks, and Cyclo Brain publishes robot commands only when Real Robot Deploy is selected.

Cyclo Brain System Architecture

Cyclo Brain separates command handling, model inference, open-source policy backends, and robot I/O into distinct runtime areas. The diagram below shows the system blocks first; detailed data flow is summarized after the diagram.

external commandengine request / action_listsensor / state readrobot command publishopen-source backend

Host

Command SourceUI / OrchestratorStandalone CLI argssame command shape

InferenceCommandLOAD / START / PAUSERESUME / STOP / UNLOADexternal service

Policy Container: <backend>_server

Main Runtime

main-runtimeServiceHandlercommand entry

main-runtimeSessionStateruntime gate

main-runtimeInferenceRequesterone GET_ACTION at a timetimeout + seq_id stale guard

main-runtimeActionChunkProcessorbuffer + optional match / RTCinterpolate / blend / smooth

main-runtimeControlLoopself-running tick

main-runtimeRobotClientcommand output

Engine Process

engine-processEngineWorkerhosts internal EngineCommand serviceusing Zenoh ROS2 SDK

engine-processBackend InferenceEnginemodel-specific implementationbehind stable contract

Policy LoadPreprocessPredictOptional Optimize

engine-processRobotClientobservation only

Open-source backend islandLeRobotGR00TFuture model

Robot

Sensors / StateObservation inputcamera, joints, base state

Command TopicsCommand outputcmd_vel, trajectory, etc.

service callEngineCommandaction_listprocessed actionsone action / ticksensor / state readobservation to inferencecommand outbackend contract12345

1. UI/CLI command enters Main. The command reaches main-runtime through the external service.
2. Main requests Engine action. InferenceRequester sends one EngineCommand at a time.
3. Engine reads Robot observation. The engine-side RobotClient reads camera, joint, and base state.
4. Engine returns action_list. The backend policy loads the model, preprocesses observations, predicts, and optionally optimizes.
5. Main buffers/processes/publishes. ActionChunkProcessor can turn 16 actions into a 100 Hz buffer, and ControlLoop publishes one action per tick.

Source of truth: Cyclo Brain runtime structure. When runtime shape changes, update this diagram with it.

Part	Role
UI / Orchestrator	Sends model load, start, stop, and configuration commands.
main-runtime	Owns inference session state, action buffering, and robot command publishing.
engine-process	Loads the policy model and computes action chunks from robot observations.
Robot	Receives commands only when real robot deployment is enabled.

Inference Page

warning

Before running inference on the real robot, stop the teleoperation node or any leader-follower bringup used during data recording. Teleoperation and model inference should not command the robot at the same time.

Then launch the robot follower bringup from AI Worker Follower Bringup for Inference before using Real Robot Deploy.

Inference Workflow

Use 3D Sim Deploy first to run one action chunk from the current robot state in simulation. This helps check whether the first policy motion is normal before sending commands to the real robot.

Inference Settings

Policy Docker Image

When the selected policy Docker image has not been downloaded yet, the backend panel shows Image missing. Click Pull to download the policy Docker image that matches the selected model.

Pre-built ACT and GR00T policy Docker images are supported only on Blackwell-based amd64 or arm64 environments. If the host environment is not supported, use a compatible machine or prepare a policy backend image that matches the target hardware.

Deploy Target

Target	Behavior
3D Sim Deploy	Runs one action chunk from the current robot state in simulation and blocks physical robot commands. Use it to check whether the first policy motion is normal.
Real Robot Deploy	Sends policy actions to the physical robot. Keep the robot workspace clear before starting.

Action Request

Mode	Use when
Async	Requests the next action chunk asynchronously while the control loop continues. This mode is not recommended when inference takes a long time.
Sync	Waits for the policy response before continuing. Use this when inference timing should be handled synchronously.

Inference Hz sets the model action generation rate. Control Hz sets the robot command publish rate.

LeRobot Inference

LeRobot inference supports multiple policy families, including ACT, Diffusion, SmolVLA, XVLA, Pi0, and Pi0.5.

Use this panel when the selected model belongs to the LeRobot group. The main input is Policy Path. If the selected policy uses language conditioning, also enter Task Instruction.

For LeRobot checkpoints, select the exported pretrained_model directory:

/workspace/model/lerobot/<run_name>/checkpoints/<step>/pretrained_model

GR00T N1.7 Inference

GR00T N1.7 uses a task instruction and can optionally use TensorRT acceleration.

Use this panel for GR00T N1.7 checkpoints. GR00T uses Task Instruction as part of the inference input, so enter the task instruction before starting inference. Enable TensorRT only when using a TensorRT engine for the selected checkpoint.

For GR00T checkpoints, select the checkpoint folder:

/workspace/model/groot/<run_name>/checkpoint-<step>

Docker Backend Control

After selecting a model, the matching Docker backend control appears in the right panel.

Button	Behavior
ON	Creates or starts the matching policy container.
Restart	Restarts the policy container after model-load failures or stale runtime state.
OFF	Stops the policy container.

If Start is disabled, check the backend status first. Common causes are Policy Docker is off, Not created, Warming up, Main Down, or Engine Down.