Why
Two years ago the answer to "how do I get into robotics" was a robot, and it cost more than a car. Then a $100 arm and an open imitation-learning library removed that. The next answer was an ecosystem — adopt the stack, take the workflow — and an open training loop that installs in one line removed that too. What is left is genuinely a choice rather than a barrier, which is why it now needs a decision rule instead of a shopping list.
The four options cluster around the same price and answer completely different questions. A $399 Jetson Orin Nano Super and a $299 Reachy Mini look like competitors and are not: one buys 67 TOPS of edge compute you attach cameras and servos to, learning ROS 2 plumbing and edge inference; the other buys an expressive desktop body with a Python SDK that runs out of the box, learning the human-in-the-loop interaction loop. A $100-130 SO-101 arm buys manipulation — the full record-demonstrations, train-a-policy, replay-autonomously cycle. A rented cloud GPU buys the model itself, since GR00T N1.7-3B needs 16GB+ VRAM and the Jetson's 8GB cannot run it natively. The price similarity is a coincidence and treating it as a comparison is the most common way to buy the wrong thing.
The deeper split is pipeline versus loop, and it is the one worth thinking about longest. Isaac and LeRobot together fold four stages — collect, train, evaluate, deploy — into one workflow. That is genuinely valuable and comes with a commitment: you take the stack. MuJoCo Playground on MJX is the opposite end — one install line, one GPU, a policy training in minutes. Neither is better. Isaac and LeRobot answer how does robotics ship; Playground answers *how does a reinforcement-learning loop actually turn* — an agent, a reward, a policy improving, and the specific disappointment of watching it improve at the wrong thing. That second experience is not learnable by reading, and it is thirty minutes of compute away.
Where Playground's speed comes from is worth understanding because it generalises past robotics. The usual bottleneck is not the maths — it is the round trip between CPU physics and GPU learning, paid every step. MJX runs simulation and rendering on the GPU, so the trip disappears and hours become minutes. Most real speedups have that shape: not a faster component, but a boundary removed. The cost is a JAX lock-in, and if that ecosystem is unfamiliar the learning curve is the actual price of admission rather than a footnote.
The limits belong in the card rather than in a footnote. Zero-shot sim-to-real is a stated target, not a guarantee — transfer to hardware stays its own problem no matter how fast the loop runs. The Jetson AGX Thor dev kit ($3,499-5,499) is the real-time inference target NVIDIA designs GR00T for, and it is a late-stage purchase, not a starting point. And the thing actually worth taking away from an evening is not a trained policy — those are cheap now — but reward shaping: watching an agent optimise exactly what you asked for rather than what you meant. That failure has a texture no write-up conveys, and it is the same failure mode agentic-intent-veto describes on-chain — a spend cap constrains the amount, not the purchase; a reward function constrains the score, not the intent.
How it works
The four entries, and the question each one answers
| Entry | Cost | What you actually buy | The question it answers | Binds you to |
|---|---|---|---|---|
| Rented cloud GPU + GR00T | ~$0.3-0.7/hr | The foundation model itself — N1.7-3B needs 16GB+ VRAM | What does a humanoid foundation model do? | NVIDIA stack |
| LeRobot + SO-101 arm | $100-130 a kit, $220-260 leader+follower | Manipulation — record, train, replay | How does imitation learning close a loop? | Hugging Face ecosystem |
| Reachy Mini | $299 | A body — motorised, Python SDK out of the box | How does a human-in-the-loop interaction feel? | Pollen / HF SDK |
| Jetson Orin Nano Super | $399 | Compute — 67 TOPS, you attach everything | How does edge inference actually deploy? | JetPack, Isaac ROS |
| MuJoCo Playground (MJX) | Free + one GPU | A training loop — minutes to a policy | How does an RL loop actually turn? | JAX |
The $299 and $399 rows are the trap. They are not two prices for one thing — one is a body without compute, the other is compute without a body. Reachy Mini needs a host machine for heavy inference; the Jetson's 8GB shared memory cannot run GR00T natively. Neither is a complete system on its own.
Pipeline versus loop
| Isaac + LeRobot | MuJoCo Playground (MJX) | |
|---|---|---|
| What it is | Collect, train, evaluate, deploy as one workflow | The training loop alone |
| Commitment | Adopt the ecosystem | pip install, one GPU |
| Answers | How does robotics ship? | How does an RL loop actually turn? |
| First result | After setup | Minutes |
| Sim-to-real | Documented hardware path | Zero-shot is the target, not a guarantee |
Why MJX is fast, and why the lesson generalises
| Step | Conventional | MJX |
|---|---|---|
| Physics | CPU | GPU |
| Rendering | Mixed | GPU |
| Learning | GPU | GPU |
| Per-step cost | A round trip across the boundary | No boundary to cross |
Most large speedups are a removed boundary, not a faster component. The way to find them is to ask which line in the loop crosses a hardware or process edge every iteration.
The staging that avoids wasted money
- Simulation first — Isaac Lab (open source, headless-capable) or LeRobot against Hub datasets. No purchase, and it is where most of the learning is.
- One arm second — the SO-101 is a weekend project including assembly: 3D-printed frame plus six STS3215 servos, leader arm moved by hand to record demonstrations, ACT policy fine-tuned so the follower reproduces the motion.
- A body or a board third, once you know which of the two questions you care about.
- Jetson AGX Thor last ($3,499-5,499), and only if real-time on-device inference is the actual goal. Mobility hardware — Unitree Go2 Air $1,600 / Pro $2,800 — sits later still.
LeRobot is the connective tissue across all of this: it bills itself as the transformers of robotics, holding a dataset standard (LeRobotDataset), pretrained policies (ACT, Diffusion Policy, π0, the GR00T-N family) and the training/eval scripts in one package. NVIDIA's July 2026 integration of GR00T 1.7 into LeRobot is why the $100 arm and the foundation model are one path rather than two.
What to take away from an evening, whichever entry you pick
Not a trained policy. The reward-shaping experience — an agent optimising exactly what you asked for rather than what you meant — and, for the hardware entries, how few lines separate "load dataset" from "trained policy" once the dataset format is standardised, and what a robot episode (observation images, joint states, actions) looks like next to the text-token datasets an LLM developer already knows.
A fourth door: download the policy instead of training one (2026-08-28)
The three routes above all start from learning a policy. openpi (π0 · π0-FAST · π0.5) starts from one that already exists — a vision-language-action model pretrained on a reported ten-thousand-plus hours of manipulation data, taking camera frames plus a natural-language instruction and emitting a continuous action trajectory. The pretrain/finetune split that reorganised the LLM world has arrived in robotics, and it changes the entry cost more than any of the three above.
Two details decide whether it is actually reachable:
| Detail | Why it matters |
|---|---|
| A flow-matching action head on a vision-language backbone | actions are generated as a continuous trajectory rather than classified step by step, which is why the motion comes out physically smooth |
| Original is JAX, with a PyTorch port shipped through LeRobot | this is the practical difference from the simulator route, where JAX is not optional |
Put the three routes and this one side by side and the stack has three floors — data and deployment, training, and the model. An eight-year backend developer is hired on the first and third; the middle floor is the researcher's. This is the cheapest door of the three, because the fine-tuning instincts carried over from LLM work — dataset format, LoRA, evaluation harness — transfer almost unchanged. The thirty-minute version is to open the π0 page and read only the tensor shapes: how many images, what instruction, how many action dimensions.
The number to compute before buying an arm (2026-09-08)
The SO-101 route above records demonstrations — and the honest entry cost of that physical cell is not the ~$100 arm, it is the time to collect enough demonstrations to fine-tune one policy. Hugging Face's LeRobot ships the SO-100/SO-101 reference hardware (3D-printed parts plus off-the-shelf servos) with assembly, calibration, and leader-follower teleop-collection scripts, so the bottleneck moves from money to human repetition. The figure that decides 'hobby or project' is the wall-clock time for ~50 demonstrations of one target task: at 2 minutes each that is under two hours; at 10 minutes each it is a full working day. Compute that for your actual task before buying, and treat the low repeatability of budget servos as a ceiling on task difficulty — simulation (MuJoCo/MJX) is enough to learn the loop, so buy the arm only when measuring the sim-to-real gap is itself the goal.
Review clarification
The safe learning default is the one others have already run (2026-09-11)
Put MuJoCo/MJX next to newer engines like Genesis (which leads on speed claims) and LeRobot (which owns the data format), and MuJoCo is still the safest square to learn on — not because it is fastest, but because it is reproducible: others have run the same scene, so when you get stuck there is an answer. The real cost of a new project is not speed; it is having no one to ask when you are stuck. So the reflex 'pick the fastest new thing' is backwards for a learning tool — community and reproducibility beat a benchmark, because the bottleneck while learning is unblocking, not throughput.
Measure it: can you bring your target task up in a MuJoCo example within 30 minutes? If not, the problem is the task definition, not the tool. Reach for something else on purpose: Isaac Lab for large-scale RL, LeRobot for a data-collection loop; keep Genesis as the 'try it for fun' box, not the default you learn on.