Hobby & open sourceRuns today
SO-100 / SO-ARM100
TheRobotStudio / LeRobot (Hugging Face)
5 DoF + gripper
Our reference arm. Low-cost, open source, recorded as a leader and follower pair.
Image: TheRobotStudio · Apache-2.0 · edited
Desktop App & CLI
Your arm. Your machine.Your data.
The client detects your arm and cameras automatically and guides you through recording, review, and upload - straight into LeRobot format. Custom tasks, camera setups, and arm configurations included. No Python, no terminal, no tinkering weekend.
- Free
- macOS, Windows, Linux
- 2 min
- to your first recording
- Local
- Your data stays with you
- 0
- lines of Python needed
Recording · Desktop clientSample data
camera_25 · wristcamera_17 · frontTask: sponge into the box REC 00:20
Episode#007LeRobot v2.1
SO-100 · /dev/ttyACM0stored locally
Why a client
Recording is the easy part. Everything around it is not.
Most teams with a robot arm lose their first weekend not to the arm, but to the tooling around it.
The LeRobot format is well documented. What eats time is everything before the first Parquet file: finding the serial port, camera indices that change after every reboot, calibrating both arms, keeping the record loop from crashing at episode 14 because one thread fell behind. None of that is research. It is plumbing, redone on every machine and by every newcomer.
The desktop client takes over that plumbing. It scans the serial bus and finds the arm on its port, opens every USB-UVC camera it can see and shows the feeds side by side before you record a single frame. Calibration is a guided pass over all joints, stored on your machine, so leader and follower move together immediately.
From there the client runs the loop every good dataset needs: describe the task, reset the scene, record one episode, review it, keep or discard it, repeat. When you have enough episodes, you upload the dataset to train on a rented GPU or sell it on the marketplace. Until you press upload, every byte stays on your disk.
The recording view
What you see while recording
This is the client's Manual Control view: camera feeds with latency and quality, the joint sliders for shoulder_pan, shoulder_lift, elbow_flex, wrist_flex, wrist_roll and gripper, the leader-follower switch and the record button that writes straight into the active dataset. Try it - the panel is interactive.
Manual ControlSample data
camera_25LatencyQuality73%LIVEGrid
camera_25Double-click zooms · drag pans1×
Leader-Follower Mode
Move the leader robot manually and the follower will mirror its movements.
Leader
Follower
Recording
Dataset
+ New
Recording runs on Leader → Followerarm
primary camera_17wrist camera_25camera_18camera_20camera_24
Five steps, one loop
The client guides you through every round - that is how datasets are made that actually move models forward.
01
Task
Describe the task - it goes into every episode as a language annotation.
02
Reset
Set up the scene, place objects. The client shows you both camera feeds.
03
Record
Demonstrate with the leader arm. Joint angles and images run in sync.
04
Review
Watch every episode, sort out weak ones - quality over quantity.
05
Upload
Only when you are ready: upload and train. Until then, everything stays local.
Who records with the client
Four typical setups, from a single hobby arm to a pilot project with its own data policy.
A lab with two SO-101 arms and rotating students
Every semester a new group inherits the arms and the half-working record script. With the client the setup is the same on every laptop: install, plug in, calibrate once, record. The task text goes into every episode as a language annotation, so datasets from different students stay comparable and can be merged for a shared ACT or SmolVLA baseline.
The lab keeps raw data on its own machines and uploads only the datasets that are meant for training or publication.
- Typical task
- Pick and place with three object classes, front camera plus wrist camera
- Dataset
- 150 to 300 episodes per task, 30 fps, LeRobot v2.1
- What comes out
- A reproducible baseline every student can train against
Under the hood
How a recording turns into a LeRobot dataset
No hidden format. Every episode is a Parquet table plus one MP4 per camera, exactly as lerobot expects it.
When you start an episode, the client reads the follower arm's six joint positions and the leader arm's commands at 30 Hz and writes them as observation.state and action into a Parquet table. Each camera feed is encoded into its own MP4 with matching timestamps. The task text becomes the language annotation SmolVLA, Pi0.5 and GR00T train on.
After each episode the review step plays the recording back with all camera views. You keep it or discard it, and only kept episodes end up in the dataset, so a weak demonstration never reaches training. The folder follows LeRobot v2.1 with meta, data and videos directories and opens in any lerobot script or the Hugging Face viewer without conversion.
Upload is a separate, explicit step. The client archives the dataset and sends it to the platform's S3 bucket under your account, where it shows up in the dashboard with an episode preview. From there you start a training run or list it on the marketplace. The local copy stays where it is.
- observation.state and action for shoulder_pan, shoulder_lift, elbow_flex, wrist_flex, wrist_roll, gripper
- One MP4 per camera, timestamps aligned to the joint samples
- Task text stored per episode as language annotation
- Folder layout meta/, data/, videos/ as in lerobot v2.1
Hardware and format
What the client supports today. More arms are added on request, see the carousel below.
- Arms
- SO-100 / SO-101, Koch v1.1, WidowX-250
- Serial connection, detected automatically, for example on /dev/ttyACM0.
- Cameras
- USB-UVC, up to 5 at once
- One usually on the wrist. Feeds shown side by side before recording.
- Operating systems
- macOS, Windows, Linux
- Apple Silicon and Intel builds, Windows x64, Linux AppImage and .deb.
- Dataset format
- LeRobot v2.1, Parquet + MP4
- Readable by lerobot scripts and the Hugging Face dataset viewer without conversion.
- Sample rate
- 30 fps
- Joint states, actions and video frames share one timeline.
- Recording method
- Leader-follower
- Move the leader, the follower mirrors it. Sliders and keyboard also work.
- Storage
- Local, on your machine
- Nothing leaves the disk until you upload a dataset yourself.
- Upload
- Platform S3 bucket, per account
- Explicit step. The dataset then appears in the dashboard with preview.
- Recorded signals
- 6 joints, actions, language annotation
- shoulder_pan, shoulder_lift, elbow_flex, wrist_flex, wrist_roll, gripper.
Free client. Install it, plug in your arm, record the first episode tonight.
Record your first datasetLeRobot scripts by hand vs. the client
Both produce the same format. The difference is how many evenings it takes to get there.
| Step | lerobot scripts by hand | AY-Robots client |
|---|---|---|
| Setup | Python environment, lerobot checkout, driver packages, robot config file written by hand | One download or one curl line, no Python required |
| Camera setup | Find camera indices, edit them into the config, repeat after every reboot | Cameras are detected and shown side by side, assignment saved per setup |
| Calibration | Command-line pass per arm, results in a JSON you have to keep track of | Guided pass in the app or `ay-robots calibrate`, stored on your machine |
| Recording loop | Fixed episode count and timing per script run, restart on every error | Task, reset, record, review, upload as one loop, keep or discard each episode |
| Review | Open the MP4 files afterwards, delete episodes by hand and fix the index | Playback of all cameras right after the episode, keep or discard with one click |
| Sources of error | Wrong port, swapped cameras, stale calibration, dropped frames noticed at training time | Port and cameras are shown before recording, calibration state is visible in the app |
| Upload and training | Push to a hub by hand, set up a GPU machine, install training stack | Upload from the client, start ACT, SmolVLA, Pi0.5 or GR00T training in the dashboard |
The client writes standard LeRobot v2.1. If you already have lerobot scripts, they keep working on the same folders.
Simulator
Practice in the simulator first
The same SO-100 and control column, in your browser. Get used to leader-follower motion and recording before you touch the real arm.
Manual Control - SO-100 SimulationSample data
camera_frontFPS--SIM
Keyboard
Hover the scene, then WASD drives base and shoulder, Q/E the elbow, R/F the wrist, T/G rolls it and space closes the gripper. The keys light up as you press them - or hold them here with the mouse.
Recording
Every move in the sim can be stored as an episode, exactly like on the real arm.
Dataset
+ New
Recording runs on SO-100 (Sim)
camera_frontcamera_topcamera_sidecamera_gripper
0 episodes recorded
Prefer the terminal? One command.
The CLI installs with one line and also runs as an MCP server - Claude, ChatGPT, and other agents can operate your arm directly.
View the MCP integrationay-robots CLI
$ curl -fsSL ay-robots.com/install.sh | sh
→ Arm detected: SO-100 on /dev/ttyACM0
→ Cameras: 2 found
$ ay record --task "Cube into the box"
→ Episode 001 … saved (LeRobot v2.1)
The client is also an MCP server
Once installed, the CLI can run as an MCP server. Claude, ChatGPT, Cursor and other agents then see your arm as a set of tools: drive it, start a recording, export a dataset. Every command still goes through the same client on your machine, so the arm never talks to anything you did not install.
Claudedrive_arm()
GPTChatGPTstart_recording()
Cursor / Grokexport_lerobot()
GitHub Copilotreport_bug()
AY-RobotsMCP server
SO-100 - your arm
Quality
What makes a good dataset
A model is only as consistent as its demonstrations. These points decide whether training is worth the GPU minutes.
For a single, well-defined task like a cube into a box, 50 clean episodes are enough for a first ACT policy, and 150 to 300 make it stable. Language-conditioned models like SmolVLA or GR00T benefit from several hundred episodes across a few task variations. A dataset of 80 careful episodes usually beats one of 300 rushed ones.
Variation is where most first datasets fall short. If the cube always sits in the same spot, the model learns that spot, not the task. Move the object between episodes, rotate it, change the box position, vary the lighting. Reset discipline is the other half: start every episode from the same home pose so the first frames are comparable.
A wrist camera makes a difference for grasping because it shows gripper and object at close range. The task text is the language annotation the model trains on: write it like you would ask a person, identical within one task. Use the review step: an episode where the grasp slipped teaches the model exactly that, deleting it costs ten seconds.
- 50 clean episodes for a first test, 150 to 300 for stability
- Change object position and orientation on every reset
- Vary lighting and background too, not just the object
- Wrist camera plus at least one front camera
- One task text per task, written like an instruction to a person
- Keep the episodes where the grasp slipped, delete only broken recordings
Dataset uploaded? Start a training run on a rented GPU, billed by the minute.
See cloud trainingSupported Robot Arms
From hobby kits to industrial arms. The label on each card shows what runs with AY-Robots today and what we connect on request.
Industry & researchIntegration on request
Franka Emika Panda
Franka Emika
7 DoF855 mm3 kg
Torque-controlled research arm that appears in many published manipulation datasets.
Image: Ims · CC BY-SA 4.0 · edited
Hobby & open sourceRuns today
SO-101 / SO-ARM101
TheRobotStudio / LeRobot (Hugging Face)
5 DoF + gripper
Successor to the SO-100 with a revised wrist. Same servos, same workflow.
Image: TheRobotStudio · Apache-2.0
Industry & researchIntegration on request
KUKA LBR iiwa
KUKA
7 DoF
Sensitive lightweight robot with seven axes, available with 7 or 14 kg payload.
Image: Xavier Caré / Wikimedia Commons · CC BY-SA 4.0 · edited
Hobby & open sourceData compatible
Koch v1.1
LeRobot (Hugging Face)
5 DoF + gripper
Open-source arm with Dynamixel servos. Its LeRobot datasets train like SO-100 data.
Image: Jess Moss · Apache-2.0 · edited
Industry & researchIntegration on request
Universal Robots UR16e
Universal Robots
6 DoF900 mm16 kg
Collaborative robot from the UR e-Series for heavy payloads.
Image: Auledas · CC BY-SA 4.0 · edited
Hobby & open sourceIntegration on request
OpenArm
Enactic (Open Source)
7 DoF + gripper633 mm
Open-source humanoid arm with seven axes, usually built as a two-arm pair.
Image: Enactic · Apache-2.0 · edited
Industry & researchIntegration on request
FANUC LR Mate 200iD
FANUC
6 DoF717 mm7 kg
Compact six-axis industrial robot for handling small parts.
Image: BorbaZal · CC BY-SA 4.0 · edited
Hobby & open sourceIntegration on request
Dobot Magician
Dobot
4 DoF320 mm0.5 kg
Desktop arm for classrooms and maker labs.
Image: Giacomo Alessandroni · CC BY-SA 4.0 · edited
Industry & researchIntegration on request
ABB YuMi (IRB 14000)
ABB
2 × 7 DoF559 mm0.5 kg
Dual-arm collaborative robot for small-part assembly.
Image: Stilfehler · CC BY-SA 4.0 · edited
Hobby & open sourceIntegration on request
MeArm
Phenoptix / Mime Industries
Laser-cut acrylic kit with hobby servos, a classic first robot arm.
Image: Phenoptix · CC BY-SA 3.0
Questions about the client
No. The desktop client is a standalone application for macOS, Windows and Linux and brings everything it needs. The CLI installs with one curl line. If you already use lerobot, that is fine: the client writes standard LeRobot v2.1 folders your scripts can read directly.
Related on AY-Robots
Teleoperation
Remote operators drive your arm and record demonstration data around the clock.
Read moreCloud training
Fine-tune GR00T, Pi0.5, SmolVLA or ACT on a rented GPU, billed by the minute.
Read moreCloud inference
Serve a checkpoint in the cloud and watch a real arm run it in your browser.
Read moreSimulator
Real teleop demos become varied simulation episodes, checked automatically and exported in LeRobot format.
Read moreStart recording tonight
Load the client, connect your arm, record your first episode - faster than any README.