Quickstart

Sign in

Go to platform.menlo.ai and sign in with Google.

Create a virtual robot

Click Add robot → Add virtual robot.

Click Create robot. Your robot appears in the robot list.

Launch the simulator

Click Start Robot to launch the simulator

Send commands

There are two ways to control the robot:

Manual control — keyboard

Direct teleop. Each keypress fires one movement command immediately.

Agent control — push-to-talk

Hold Shift to activate the microphone. Speak a command in natural language — the agent hears you, reasons about it, moves the robot, and speaks back a confirmation.

Example: say "move forward" → the robot walks forward and the agent replies "okay, walking forward."

The agent joins the session automatically when the robot starts — no extra setup needed.

View telemetry

The robot settings page shows live telemetry updating at ~10 Hz:

• Joints — position, velocity, and current per joint, grouped by anatomy
• Logs — timestamped events with severity
• Subsystem Health — FW Link, Speaker, Camera, Mic, BLE Radio, Cloud (physical robot only — Platform UI support coming soon)

See the Telemetry guide for the full breakdown.

Get an API key

Sign in at platform.menlo.ai, then go to Account → API Keys.

Click Create API key, give it a name, and copy the key.

Install the CLI

sh -c "$(curl -fsSL https://raw.githubusercontent.com/menloresearch/cli/release/install.sh)"

Verify the install:

menlo --version

Initialize

menlo init

The wizard will prompt for your API key and let you select a default robot. Skip robot selection for now — you'll set it after creating one.

Create a virtual robot

Please head over to platform.menlo.ai and click on the "+" button to "Add virtual robot".

Add Name and Description accordingly, then click "Create robot"

After the robot is created, you can click "Start robot" and wait for the robot to be iniated fully, before going to the next step.

You should be able to see the view of the robot if the sim starts successfully.

Set your default robot

To pick interactively:

menlo robot connect

Or to set directly through robot-id:

menlo robot connect <robot-id>

Remember to pick the robot that you are currently starting in your browser and not the inactive one and not the inactive one.

Check status & join a session

To check a robot status including its name, id, model and type:

menlo robot status

To get the robot connection endpoint and the verification token:

menlo robot session

It will return you the following:

Connection Endpoint:
xxx

Agent Token:
xxx

Debug View:
xxx

You can use the information above to connect directly to the robot and communicate to our robot through the Asimov API defined here

Here is a sample code on how to connect to the robot in simulation and send it a command:

import asyncio
import time
from livekit import rtc
from edge.generated.edge_cloud_pb2 import CloudCommand, VelocityCommand, EdgeTelemetry

CONNECTION_ENDPOINT = "your-endpoint"
AGENT_TOKEN = "your-token"

async def main():
    room = rtc.Room()
    await room.connect(CONNECTION_ENDPOINT, AGENT_TOKEN)

    # --- Receive telemetry ---
    async def read_telemetry(track):
        stream = track.subscribe()
        async for frame in stream:
            t = EdgeTelemetry.FromString(frame.payload)
            print("Telemetry:", t.fw_mode)

    @room.on("data_track_published")
    def on_data_track(track):
        asyncio.create_task(read_telemetry(track))

    # --- Send ONE velocity command ---
    cmd = CloudCommand(
        timestamp_us=int(time.time() * 1e6),
        sequence=1,
        velocity=VelocityCommand(vx=0.5, vy=0, vyaw=0),
    )

    await room.local_participant.publish_data(
        cmd.SerializeToString(),
        topic="commands",
        reliable=True,
    )

    # keep process alive to receive telemetry
    await asyncio.sleep(10)

if __name__ == "__main__":
    asyncio.run(main())

You should be able to see a steady stream of telemetry from the robot in the simulation and the robot will also start walking forward after running the script.

Send commands

Alternatively, you can also test control directly through our CLI as follow:

menlo robot action <one-of-the-valid-commands-below>

Valid commands: forward, backward, left, right, turn-left, turn-right, stop.