Small Skills, Composed: Tiny Robot Networks That Chain Into Tasks
Two 5,400-parameter networks, a simulated SO-101 arm, and 400 out of 400 four-step tasks
Most of the attention in robot learning goes to big models: one policy, billions of parameters, trained to do everything from pixels and language. I wanted to test the opposite idea. Can very small networks learn single robot skills well enough that you can chain them into longer tasks, and put the task structure in the chaining instead of inside one model?
I ran the experiment on a simulated SO-101, the low-cost open-source arm from the LeRobot community. Here is what I measured, what it does not show yet, and where I’m taking it next.
The setup
Two skills, each a tiny network:
| Skill | Network | Parameters | Training demos |
|---|---|---|---|
| grasp | 12→64→64→6 MLP | 5,382 | 160 |
| place | 13→64→64→6 MLP | 5,446 | 240 |
Both are trained by behavior cloning from a scripted inverse-kinematics expert. The input is the six joint angles, the target position, and which phase of the motion the skill is in. The output is six joint targets at 30 Hz. The same place network handles putting a cube on a pad and stacking it on the other cube.
One important simplification: the skills read the exact object positions from the simulator. There is no camera yet.
Each skill also checks its own preconditions before moving. Grasp needs an empty gripper and a reachable cube. Place needs the cube in hand and a stable support. That turns out to matter, as you’ll see below.
Single skills
I retrained each skill from scratch with three different random seeds and tested every version on 200 starting positions it had never seen.
Every version succeeded 200 out of 200 times, for grasping, pad placement and stacking. The 95% lower bound is 98.1%. Retraining with the original seed reproduces the shipped weights bit for bit.
Chaining them
Here is the part I care about. Sorting both cubes onto pads takes four skill calls:
grasp red → place on green pad → grasp blue → place on yellow pad
Each skill starts from wherever the previous one left the arm and the scene, which is exactly where chained systems usually break. I ran it on 400 new starting layouts, covering both pad assignments and both orders.
| Measure | Result |
|---|---|
| Whole task (4 skills) | 400/400 |
| Skill 1 → skill 4, each position in the chain | 400/400 at every step |
| All grasps / all places | 800/800 / 800/800 |
Reliability did not drop from the first skill to the fourth. At this scale, chaining cost nothing I could measure.
Only the two learned networks drive the arm in this video. The scripted expert that generated their training data is not used.
The planner detour
Before this, I spent a lot of time on the layer that decides which skill to run: fine-tuned small language models, quantization, a decision encoder. The lesson surprised me. A fixed script, grasp then place then check, completed every task whose goal it understood correctly. Every end-to-end failure came from misreading the instruction, never from executing the skills.
Across 2,340 episodes driven by different planners, the skills ran 2,184 times with zero physical failures. The planners also sent 32 impossible requests, like grasping a cube already sitting on a pad, and the skills refused every one through their own checks. Small skills that protect themselves make the whole system easier to trust.
What this does not show
I want to be precise about the limits:
- It’s simulation only, with exact object positions. No camera, no sensor noise, no real robot yet.
- It covers two skills and one object type, and the cubes start inside a narrow region.
- Chains go up to four skills. Longer chains are where small errors would start to add up.
- There’s no result on a standard benchmark yet.
Where this sits
This isn’t a new idea in the literature, and the context is worth knowing. MINERVA showed this month that a 0.54M-parameter policy can reach 95% on the LIBERO benchmark, but as one monolithic network that mostly memorizes its tasks. AtomicVLA splits tasks into atomic skills, but inside a model of 3 to 5 billion parameters. Plan-Seq-Learn composes small local policies with a planner.
What I haven’t seen yet is tiny, separately trained skills composed explicitly on a standard benchmark. So the claim I want to test next isn’t “small models can solve tasks”. It’s that skills trained once can solve new combinations they were never shown. A monolithic network can’t do that by design.
Next
Two steps:
- Longer SO-101 tasks: three-cube towers, swapping cubes through a free spot, sorting by color, with success measured at every position in the chain.
- A composition test on LIBERO. Train the atomic skills from its 90 short tasks, then solve its 10 long tasks by chaining them, without a single demonstration of those long tasks.
What I take from this
The interesting question in robot learning isn’t only how big the model is. It’s where the structure of a task lives. If it lives in how skills are combined, each skill can stay small, fast and checkable, and adding a new task becomes a new combination rather than a new training run.
The code, the numbers and the reproduction scripts are open: github.com/elharchaoui/arm-101.