Blog

A step-by-step account of one human-gated DAgger round on an SO-100 arm: run the policy and record it, take over when it goes wrong, file the run as a correction, compose a mixed dataset, and continue training from a checkpoint. Includes the keyboard and slider takeover path for people without a leader arm, and the four mistakes that make a round worthless.

The intervention rate - intervention frames divided by the frames of the run - is the cheapest honest progress signal a human-gated DAgger loop has. This article defines it so that two people compute the same value, shows how to log it, and works through the four ways it misleads you: operator habituation, a drifting evaluation setup, training only on corrections, and a human who corrects differently on Tuesday than on Monday.

Plain DAgger asks a human to label states while the robot is still driving. On real hardware that is unsafe and it produces poor labels. The gated variants replace blind labelling with a gate someone has to hold: the human in HG-DAgger, a safety classifier in SafeDAgger, an ensemble's disagreement in EnsembleDAgger, a budgeted novelty-and-risk estimate in ThriftyDAgger. This article compares them by who owns the gate, what signal opens it, and what each one costs — and why the human-gated form is the one that survives contact with a real arm.

Behavior cloning fits a policy on the expert's state distribution and is then deployed on its own. The gap between those two distributions is why a policy that looks fine in validation walks off the table on step 300. This is the theory chapter of our DAgger series: where the quadratic error term comes from, what dataset aggregation changes, what the no-regret proof assumes, and which part of the bill the human expert still has to pay.

Cuts, playback speed, retries and hidden teleoperation all change what a robot demo proves. How to read one critically, with the trial counts real papers report.

Running a semester robotics course on the SO-100 arm: cost per seat from the published bill of materials, a 14-week plan, five exercises that teach, and the honest limits.

An STS3215 at 7.4 V makes about 1.6 N.m. That is not what decides whether CE marking applies. Placing on the market and putting into service are, and here is where the line falls.

Who is responsible when a remotely driven robot arm breaks something: the config defaults, contract clauses, insurance exclusions and session records to settle before an operator connects.

A 110 euro SO-100 will never pipette to ISO 8655. It will shuttle plates, feed instruments and sort tubes. Where the line runs, with measured numbers from both sides.

How to build the record, train, evaluate, deploy, retrain loop for an SO-100 arm: real LeRobot commands, DAgger-style failure collection, and what to automate first.

A published SO-100 pick-and-place cycle runs 9.7 seconds, about 370 attempts an hour. Here is how that compares to 400-600 for a human picker and 1,200 for a piece-picking cell.

A published SO-100 pick-and-place cycle runs 9.7 seconds, about 370 attempts an hour. Here is how that compares to 400-600 for a human picker and 1,200 for a piece-picking cell.

Published zero-shot success rates measure narrower things than they sound like. What BC-Z, RT-2 and Open X-Embodiment actually held out, and how to test your own policy.

A policy that works in daylight and fails at night has three separate problems: the camera driver, the optics, and a dataset with one lighting condition. Here is which fix applies to which.

An SO-100 has no force sensor, and one encoder count is already 0.31 mm at the gripper. The real tolerance budget for insertion, and which of the five policies closes the loop fast enough.

Cloth and cable manipulation breaks the assumptions behind pick-and-place. What the published folding results actually achieved, what a single low-cost arm can do, and what it cannot.

Recording demonstrations means recording a room. What counts as personal data in a LeRobot dataset, which lawful basis fits, how to redact footage, and why publishing is one-way.

Curriculum learning promises gains from ordering examples easy to hard. In a shuffled behaviour cloning dataset that order is erased. Here is what survives, and a recording order that helps.

Which vision encoder each VLA policy actually ships with, what freezing the backbone costs in accuracy and saves in VRAM, and how to tell when the encoder is your bottleneck.

INT8 and FP8 next to the servos: what quantisation saves in memory, what it costs in success rate, which runtimes support it, and why 8-bit VLA inference is often slower than 16-bit.

A policy under occlusion does not stop, it keeps acting from proprioception. What the published ablations measured, why the wrist camera matters, and how to record for it.

What knowledge distillation does to a robot policy, which capabilities survive it, the published speedups from TinyVLA to VLA-AD, and whether it beats training the small model directly.

How a continuous joint trajectory becomes tokens a transformer can predict. 256-bin discretization, the FAST DCT plus BPE scheme, real defaults, and what each choice costs.

One GPU, several robot arms, one policy. What batching really costs in measured milliseconds, how the queue turns into jitter on each arm, and where the ceiling actually sits.

GR00T N1.5 is non-commercial and N1.7 is not. Pi0.5's Apache repo ships a Gemma licence. SmolVLA declares none. What each robot policy licence permits, verified at source.

What a VLA policy really receives from your cameras: the resize, crop, colour transform, lossy codec and sampling clock between an SO-100 webcam and the model, with the real defaults.

Episode length only means something next to chunk size. What the LeRobot defaults do, why k/T predicts trouble, and how much supervision padding quietly removes.

Bolting an arm onto a mobile base adds three action dimensions, swaps position control for velocity control and breaks table-top policies. What that costs, and how to fix it.

A second camera on an SO-100 costs USB bandwidth, vision tokens, inference latency and a full re-record. Published ablations on when it pays for itself and when it does not.

How many rollouts a robot benchmark really needs, how to randomise starting conditions reproducibly, what to freeze between policies, and how to report a success rate someone can check.

An honest seven-day schedule for a first SO-100 or SO-101 build: print, motor ids, assembly, calibration, teleoperation, recording, training, rollout, and where each day loses people.

How the task string in a LeRobot dataset reaches a VLA model, how phrasing changes what the arm does, and exactly what breaks when training and inference instructions drift apart.

What an MCP server really gives an agent controlling a robot arm: the tool surface, why annotations are only hints, where the confirmation gate belongs, and what stays local.

Speech recognition turns audio into the same string that --task already carries. Here is how to build the pipeline with Whisper, and why a one-instruction dataset makes it useless.

How to pin a LeRobot dataset to an immutable commit: Hugging Face revisions, meta/info.json, content hashes, and the dataset pointer every checkpoint needs.

The Feetech STS3215 is tested to 100,000 cycles at one fifth of stall torque. What that means for a recording rig, which joint dies first, and the registers that warn you.

ROS 2 and LeRobot solve different problems and overlap in one small interface. What each is for, the bridges that exist in 2026, and how to connect them.

Which SO-100 MJCF to start from, why the two published models disagree by 20x on gain, how their torque limits came from the 12 V datasheet, and where a sim policy stops.

A policy that nails pick and place collapses at step seven. The compounding-error arithmetic behind it, and the two ways out: a planner above a language-conditioned actor, or longer demonstrations.

Work out whether a VLA policy fits on a GPU before you rent it: bytes per parameter, optimizer state, activation memory, and the batch size that falls out of the arithmetic.

A finished checkpoint does not move a servo. The real file paths, the config keys that must match, the three deployment stacks and the errors that eat a day.

DROID standardised the robot at 13 institutions and let the scenes vary. Here is what the LeRobot merge really enforces, what it silently accepts, and how to plan a multi-site recording fleet.

Clean demonstrations teach one path and no way back. What the recovery-data papers measured, and how to record failure and correction on an SO-100 with LeRobot 0.6.1.

How rollouts get scored without a human in the room: simulator predicates, VLM judges and their real false positive rate, and why two published success rates almost never compare.

A DIGIT costs 355 USD, an AnySkin fingertip 128, a magnetic skin under 30. None of the five trainable policies has a touch input. Here is how tactile data gets in anyway.

RT-1 turned 130,000 teleoperation demonstrations into a 35M transformer that ran at 3 Hz. Its action tokenisation, real success rates, and what still holds in 2026.

GELLO's bill of materials is under 300 USD, an SO-101 leader adds about 108 USD to a follower arm. What each design buys you, and how the leader you pick changes your data.

Every open VLA policy you can fine-tune today takes RGB, state and language. What RGB-only policies learn about geometry, when a depth camera earns its price, and what it costs.

Wiring, calibrating and recording two SO-100 arms as one 12-channel system in lerobot 0.6.2, and which of the five trainable policies accept the doubled action vector unchanged.

ALOHA put four arms in a cage for under 20,000 USD and hit 96 percent on slotting a battery from 50 demonstrations. What the second arm buys, and what it costs you in data.

LeRobot, Isaac-GR00T, openpi and Open X-Embodiment: who publishes what, which licence really covers the weights, and how the four projects connect on a real robot arm.

Joint limits, torque caps, per-step motion caps and a stop you can reach. What LeRobot enforces on an SO-100, what the Feetech firmware catches, and what nobody enforces.

How robot policy servers work in practice: ZeroMQ vs gRPC vs WebSocket, measured serialisation and payload costs, message framing limits, and the queue arithmetic that keeps the arm moving.

A 30 Hz control loop gives you 33.3 ms per tick. Where those milliseconds go on an SO-100, what action chunking really buys, and the measured point where the arm starts to hesitate.

What to look for in a robot teleoperator, how long training really takes, and the measurable ways operator skill shows up in a LeRobot dataset. With real numbers.

A demo is one rollout. Turning it into a number you can defend takes fixed resets, enough attempts, failure codes and a confidence interval. Here is the full protocol.

We counted 72,393 public LeRobot datasets and sampled 700 of them. What actually drives the value of robot demonstration data, and why episode count tells you almost nothing.

Which vision-language-action policies fit on a 24 GB RTX 4090 at inference, measured latency per action step, what quantisation really buys, and which models stay out of reach.

Real numbers for a working manipulation setup: a $229.88 SO-101 bill of materials, what cameras and a host machine cost, GPU rental at 1 to 12 USD a run, and where small budgets leak first.

LIBERO, SimplerEnv and Meta-World numbers appear in every VLA paper. What each one measures, why two 97 percent scores are not comparable, and what they miss about your arm.

Every fix for CUDA out of memory in VLA fine-tuning, in the order to try them, with real Isaac-GR00T and lerobot flags and which levers quietly change the policy you get.

Real GPU rates, real trainer defaults, and the five places a robot training budget leaks: oversized models, demo step counts, dead datasets, forgotten instances, and reruns.

How chunked policies actually run on a robot: queue depth, chunk_size_threshold, inference delay, and what happens when a new action chunk lands mid-motion.

LeRobot 0.6.1 gives robotics teams a dataset format, a plugin bus and 22 policies. It does not give you curation, fleet ops or API stability. What that costs, and who is actually shipping on it.

What recording robot demonstrations for other people actually pays in 2026, who buys the data, how many episodes per hour you can really deliver, and where the business breaks.

Seeds, nondeterminism and run-to-run variance in VLA fine-tuning: what lerobot and Isaac-GR00T really seed, what a seed cannot fix, and how many rollouts a comparison needs.

An arm in one room, an operator in another, a GPU somewhere else. What published remote deployments measured, the bandwidth and latency you need, and what it costs.

A five-gate review workflow for LeRobot demonstration data: what to check, in what order, and what to automate. Cheap metadata checks first, human review last, with runnable commands.

Open-loop evaluation scores predicted actions against recorded ones. Closed-loop evaluation runs the policy on the robot. Which to run when, with real commands, defaults and rollout-count statistics.

Dataset statistics define the map between robot units and the model input space. Change the action representation without regenerating them and the loss still falls while the arm does nothing.

Adding GPUs to a VLA fine-tune changes batch size, learning rate and step count in ways the flags hide. What GR00T and LeRobot really do, and the distributed failures that cost a day.

A step is not a unit of progress. How to turn published step counts for GR00T, SmolVLA, ACT and Pi0.5 into passes over your own dataset, and when to stop the run.

Your trainer prints a falling loss and saves ten checkpoints. None of that says which one to deploy. What open-loop error, held-out episodes and rollout counts really tell you.

Hardware per seat, shift structure, quality gates and real throughput for a 2 to 5 operator robot data team. Why robomimic's 300-demo six-operator dataset lost to its 200-demo single-operator one.

Learned world models and video prediction as a route to robot control: the three published routes, the real latency and VRAM numbers, and how far each is from a real arm.

A checkpoint is four artifacts pretending to be one. Real file listings from LeRobot, GR00T and Pi0.5 checkpoints, and the eight reasons copying one between machines fails.

Robotics has no LAION-5B and no Common Crawl. What the largest robot datasets actually contain, why they stay small, and how many episodes one arm and one task really need.

Which simulators contain an SO-100, what domain randomization really costs in compute, and how large the sim-to-real gap measures in published paired evaluations.

How the spot GPU market prices an A100 or H100 by the hour, when your instance gets paused, what a fine-tuning run really costs, and how to stop paying for an idle card.

The training loss of a robot policy is a surrogate, not a score. What each curve shape means, why there is often no validation set, and the four shapes that mean stop the run.

The SO-100 gripper is one revolute joint with 110 degrees of travel and a torque cap written into the servo. What that means for grasping, compliance and what a policy can learn.

Camera pose and object placement destroy a trained policy. Backgrounds and distractors barely dent it. The measured ranking from the published ablations, and a factor grid you can run on an SO-100.

The SO-100 has five arm joints plus a gripper. Measured from the official URDF: what it can reach and orient, which tasks are impossible rather than hard, and how to design around it.

The SO-101 servo gauge has a 24.700 mm pocket for a 24.7 mm servo. Zero designed clearance. What material, layer height, infill and slicer compensation actually decide.

What actually fits on a Jetson Orin, what TensorRT does to GR00T N1.7 on it, and the measured throughput you get. With the memory numbers that decide it first.

How one model drives many robots: embodiment tags, shared action spaces, per-robot heads, and honest numbers on what actually transfers between arms and what does not.

Two cameras and an action stream never sample the same instant. What LeRobot really records, why the timestamp column hides the skew, and how to measure it before 50 episodes.

What 7.4 V actually means on a Feetech STS3215 bus, how a sagging rail shows up in servo registers and recorded episodes, and how to size a supply that does not brown out.

Almost every manipulation policy that works today is behaviour cloning. Here is the proven flaw in that, what reinforcement learning still wins on real hardware, and the hybrid people run.

A measured breakdown of remote robot arm latency: what capture, encoding, transport, the jitter buffer and display each cost, and the delay at which an arm stops feeling connected.

LeKiwi puts an SO-100 class arm on a three-wheel holonomic base. What the extra base dimensions do to the action vector, and what really changes when you record and train.

A falling loss curve does not mean a working arm. The six checks that separate plumbing, normalisation, camera identity, distribution shift and chunk timing, in the order they cost you.

A vision-language-action model turns camera frames, a joint-state vector and one sentence into a chunk of joint commands. What goes in, what comes out, and where it breaks.

Serial bridge chips, udev rules, unbind and rebind, and the triage order that separates a driver problem from a dead servo on an SO-100 class arm in five minutes.

What a Raspberry Pi really does well in a robot: USB topology for the servo bus and cameras, power and encoder limits, and why the policy belongs on a GPU somewhere else.

What to log while a robot policy runs: achieved action rate, per-joint deltas, camera frame age, action queue depth and servo load, plus the early signs of a run about to fail.

Build and configure a Koch v1.1 arm: XL330 and XL430 servos, the 5 V and 12 V rails, the LeRobot koch_follower commands, and why the dataset is identical to an SO-100.

Calibration on a Feetech STS3215 writes three integers per joint into servo EEPROM. What they mean, why a bad one silently ruins your episodes, and six checks that catch it.

Where a robot policy should run, measured honestly: per-model control periods, what a round trip really adds, and which manipulation tasks survive it.

Resolution, frame rate, exposure control and the USB bandwidth ceiling that breaks the third camera. What actually matters when picking webcams for a LeRobot recording rig.

DROID, BridgeData V2 and Open X-Embodiment convert to 7-D end-effector actions on 6 and 7-DoF arms. An SO-100 takes 6 joint positions. What transfers, what does not, what to do instead.

Simulation can multiply a handful of demonstrations into thousands. Here is what the published numbers really say, where the sim-to-real gap bites, and what still has to be recorded.

TinyVLA and SmolVLA put a working VLA under 1 B parameters. Real numbers from both papers, the lerobot defaults, measured latency, and what a run costs on a 24 GB card.

Leader arm ergonomics, episode pacing, resets between episodes and what operator fatigue does to a LeRobot dataset. Real lerobot-record flags, real defaults, real numbers.

SO-100 against SO-101: the leader gear ratios, the joint 3 wiring fix, the real bill of materials in four currencies, and why LeRobot treats both arms as one class.

Servo ids, horn angle, cable routing and the 7.4 V rule: the SO-100 build errors nobody catches on the bench, and how each one turns into a dataset that trains a bad policy.

RDT-1B is a 1.2B diffusion transformer for bimanual manipulation. Its 128-dim unified action space, the real fine-tuning commands, hardware needs and honest limits.

How to publish a LeRobot dataset properly: what is really in the repo, the dataset card fields that decide reproducibility, licence choice, and the version tag that moves under you.

Pi0 and Pi0.5 share a backbone and an action expert. What changed is the gradient path, the tokeniser and the data mixture. Here is the diff, and what you actually get.

OpenVLA is 7B parameters with a contested weights licence. What LoRA fine-tuning really costs in VRAM, why its 7-DoF action space fights an SO-100, and what to run instead.

Octo is a 27M or 93M transformer policy trained on 800k Open X-Embodiment trajectories. Its diffusion action head, how it refits to new sensors and action spaces, and where it stands now.

Training one policy on several tasks: how the LeRobot task field works, what task balance does to sampling, and the cases where a single-task ACT still beats a multi-task VLA.

LoRA against full fine-tuning for VLA policies: what really trains in each case, how much VRAM each needs, the measured OpenVLA gap, and whether it matters on a single-task SO-100 arm.

LeRobot v3.0 packs many episodes per file and moved metadata to Parquet. Which trainer accepts which version, both conversion directions, and what happens to your stats.

How task descriptions become training signal: the GR00T annotation key, LeRobot task metadata, what a good instruction looks like, and the 22 to 52 pp a rephrase costs.

How many episodes a robot policy really needs: the trainer floors, what RT-1, BC-Z, robomimic and the data scaling laws measured, and two cheap runs that tell you if more will help.

What actually changed between GR00T N1.5 and N1.7: the Cosmos-Reason2 backbone swap, relative actions, why old checkpoints will not load, dataset compatibility, and when to stay.

Flow matching and diffusion train the same network with different targets. The objective, the samplers as lerobot ships them, the real step counts, and why fewer steps does not mean lower latency.

Audit a LeRobot dataset before you rent a GPU: find frozen video frames, swapped camera streams, joints clamped at a calibrated limit, and image-to-action timing skew.

How Diffusion Policy denoises an action sequence instead of regressing one action: receding horizon control, the Ta trade-off, lerobot defaults, and the real inference cost.

Who owns robot demonstration data, what licences DROID, Open X-Embodiment and BridgeData V2 actually carry, and the checks that decide whether your policy can ship commercially.

Colour jitter and small random crops help manipulation policies. Flips, rotations and large shifts can break them, because the action label is tied to the image geometry.

How NVIDIA Cosmos Reason works as a high-level planner above a low-level robot policy, why GR00T N1.7 using it as a backbone is a different thing, and where the split breaks.

CogACT hangs a diffusion transformer action head off a 7B VLM. The real SimplerEnv ablations, the 16-A100 training bill, and where the same split shows up in GR00T and Pi0.5.

Where to put cameras when recording LeRobot datasets on an SO-100: what overhead, front and wrist views each let a policy learn, the measured cost of dropping the wrist camera, and the traps.

Action chunking cuts compounding error by predicting a block of actions and executing part of it. What chunk_size and n_action_steps really do, and how to tune them.

Your robot machine has no GPU. Put the GR00T policy server on a rented cloud GPU, stream action chunks to the arm, and learn exactly what the network costs you.

Train an Action Chunking Transformer from scratch on an SO-100 with lerobot: the act config, chunk_size and n_action_steps, the 100000 step schedule, 20 ms inference.

GR00T N1.7, Pi0.5, SmolVLA, ACT or GR00T N1.5? A decision table matched to real situations, with the published benchmark numbers, latency, cost per run and licences behind each choice.

Real spot-market GPU prices, how long each of the five policies runs, what the arm and the demonstrations cost, and the four places the money quietly disappears.

Record a usable LeRobot dataset with an SO-100: calibration, leader-follower teleoperation, the real lerobot-record flags and defaults, camera setup, episode counts, and the defects that ruin a run.

SmolVLA is a 450 M parameter VLA that fine-tunes on a single 24 GB card. Real lerobot 0.6.1 commands, the actual defaults, the traps that cost a day, and what a run costs.

Fine-tune Pi0.5, the flow-matching VLA from Physical Intelligence, on your own robot data. Real commands for openpi and lerobot pi05, dataset format traps, VRAM and latency limits.

A tested walkthrough for fine-tuning NVIDIA GR00T N1.7 on an SO-100 LeRobot dataset: real flags, modality.json, the v2.1 requirement, what a run costs, and the traps.

What a robot teleoperator actually does hour to hour, the habits that make demonstrations trainable, the hardware and skills you need, and the pay figures that can be sourced.

Behaviour cloning errors compound quadratically in the episode length. DAgger and HG-DAgger fix that by training on the states your policy actually visits. Here is the loop on an SO-100.

Discover expert strategies for collecting high-quality VLA training data to enhance robot manipulation tasks. Learn about teleoperation methods, data augmentation, benchmarks, and scalable approaches to optimize AI models for robotics.

Discover everything you need to know about the SO-100 Robot Arm, from initial setup and teleoperation techniques to advanced AI training using VLA models. This comprehensive guide is perfect for robotics researchers, AI engineers, and operators looking to optimize their workflows and achieve scalable robot deployment.

Discover how NVIDIA's Isaac Lab revolutionizes multi-modal robot learning through GPU-accelerated simulations, enabling faster AI training, scalable deployment, and optimized ROI for robotics researchers and companies.

Discover how Isaac Gym revolutionizes robot learning with GPU-native physics simulation, enabling thousands of parallel environments for rapid reinforcement learning, VLA models training, and efficient AI robot teleoperation. Explore benchmarks, integration with PyTorch, and real-world applications that bridge the sim-to-real gap.

Discover how RoboTurk revolutionizes robot learning by crowdsourcing high-quality data through remote teleoperation, enabling scalable datasets for AI models in robotics. Explore its impact on imitation learning, VLA models, and ROI for robotics companies.

Explore how BC-Z revolutionizes robotic imitation learning by enabling zero-shot task generalization through scaled demonstration data. Discover scaling laws, VLA models, teleoperation best practices, and ROI benefits for robotics companies and AI engineers.

Discover how the DROID Dataset, a large-scale robot manipulation dataset, is transforming AI training for robots with over 76,000 demonstrations from real-world environments. Learn about its impact on VLA models, benchmarks, and scalable data collection methods for robotics companies.

Explore how BridgeData V2 provides low-cost robot data at scale, enhancing imitation learning methods and offline reinforcement learning. Discover key benchmarks, VLA models in robotics, and efficient robot teleoperation workflows for AI training data collection.

Discover how Open X-Embodiment, a collaborative dataset spanning over 20 robot embodiments, is transforming robot learning. Learn about RT-X models, cross-embodiment generalization, and practical strategies for robotics companies to boost ROI through efficient data collection and teleoperation.

Discover how Pi-Zero's flow-matching technique, combined with VLM initialization, is transforming generalist robot policies for dexterous control. Learn about its advantages over traditional methods, efficiency in AI training data for robotics, and implications for scalable robot deployment in industries.

Discover how Google's RT-2 Vision-Language-Action Model revolutionizes robot control by transferring web knowledge to physical actions. Learn about its architecture, training methods, emergent capabilities, and implications for robotics companies and operators, including integration with teleoperation for efficient AI training.

Explore how Vision-Language-Action (VLA) models are revolutionizing robot learning by integrating vision, language, and action for smarter, more efficient robotics. Discover architectures, training methods, benchmarks, and ROI for deployment in this comprehensive guide.

Discover how Google's RT-2 Vision-Language-Action (VLA) model is reshaping robot learning by integrating visual data, natural language, and real-time actions. This innovative AI technology enhances data collection for teleoperators and boosts efficiency in robotics applications. Explore its potential impact on the future of AI-driven robots at AY-Robots.

Discover how Google DeepMind's RT-2 model revolutionizes AI robotics by emphasizing the critical role of high-quality training data over advanced algorithms. This article breaks down the experiments that demonstrate why effective data collection is essential for real-world robot performance. Learn how platforms like AY-Robots can help bridge the gap in training data for future innovations.