v1 3Γ—3 Β· Simulation Β· Shadow Hand Γ— 2 Β· UR10e Γ— 2

Atomic Moves, Agentic HandsRobot hands learn the moves. An agent solves the cube.

Atomic moves learned with RL, each ending in the same grip β€” whole-cube rotations included. An Opus agent solves it like a human cuber β€” recognise the pattern, recall the algorithm, rotate, play it: Cross β†’ F2L β†’ OLL β†’ PLL. No optimal solver, and under five minutes of thinking per solve.

9 / 9
random scrambles solved end to end
1 grip
every atomic move starts and ends in it
62 / 62
checkpoints passed (stickers and grip)
4.5 min
of model thinking per solve, on average β€” no optimal solver
Versions

One project, version by version

Nine random 3Γ—3 scrambles solved by two Shadow hands
v1current

The 3Γ—3, solved

Atomic moves, one grip, a CFOP agent β€” or a language model.

Read the v1 post β†’
nextin progress

Bigger cubes

Later versions take the same moves and the same grip further.

Interactive

The real simulation, in your browser

One recorded solve β€” game 1, Opus's solution (pattern recognised, algorithms looked up) with its whole-cube rotations β€” every body of it, both hands, both arms and all 26 cubies, replayed in your browser. Drag to orbit, scrub the timeline.

Loading the recording…
Drag to orbit Β· scroll to zoom Β· right-drag to pan
β€”
How it works

Look, plan, act, check β€” and always come home

Every atomic move is turn a layer + return to the standard grip. With that one contract, moves compose like building blocks.

1 Lookfull cube state(7 looks per solve) 2 Planpattern β†’ algorithmplanner or LLM agent 3 Actatomic moves, one by oneeach ends in the grip 4 Checkstickers + grip at eachstage; replan if off next stage: cross β†’ F2L 1–4 β†’ OLL β†’ PLL
β†Ί

One standard grip

Left thumb and middle finger pinch the F and B centres; the right hand owns the R layer. Every move starts and ends here, so the policies never see each other's leftovers.

⌁

Learned with RL

Each move is a reference path plus a policy that learns per-motor corrections (MuJoCo Warp + PPO). Its way back is trained on the move's real end states.

βœ“

Checked, not hoped

At every stage the executor reads all 54 stickers from the simulated cubies and compares them with the logical cube, and measures how far the hands are from the grip.

Atomic moves

Atomic moves, one contract

Turn the layer, then come home to the standard grip.

R
R'
U
U'
L
L'
D
D'
F
F'
B
B'
Nine random solves

Nine scrambles, nine solves

Random scrambles, nothing picked. Opus solved each one by pattern and library β€” one answer per stage, 2 to 7 minutes of thinking a game β€” and the hands did it, rotations and all. The clips play the turns at about 2Γ— (2–2.5Γ—), the way back to the grip at about 4–5Γ— and pauses at most 8Γ—, easing from one speed to the next (the legend in the corner gives each clip's numbers). Each recording sits next to a 3D cube replaying the same moves β€” click a card to step through it.

More clips

Chains, mirrors, a rotation, a whole solve

First person on the left, the whole robot on the right.

R U R' U', then back.

L U L' R. The left hand takes over for L.

x' rotation. The whole cube turns over in hand, back to the grip.

One random scramble, start to finish.

The agent

The agent can be a planner β€” or a language model

Swap the planner for an Opus session β€” no optimal solver, no search. It works like a speedcuber: it looks at the cube as the hands hold it, recognises the case (which F2L pair and where its pieces are, which OLL, which PLL), looks the algorithm up in a library, then rotates the cube or turns U and plays it. Recognition is the model's; the library only remembers algorithms. A whole solve takes about 4.5 minutes of thinking on average (2–7 min a game; 14.6 min before, when it worked every algorithm out in its head); the hands' own time comes on top.

4.5 min
thinking per solve, average (median 4.9) β€” was 14.6
15 s
per F2L pair (median) β€” was 135 s
36 / 36
F2L pairs right the first time
9 / 9
solved, one answer per stage (62 / 64 first time)

The hands executing Opus's solution β€” recognised and looked up, stage by stage β€” its thought for each stage on top. Solved.

Agent replay

Watch the model think its way through a solve

One CFOP stage at a time: what it sees, the case it looks up in the algorithm library (πŸ“–, with what the library answered), then the moves.

Scrambled
β€”

The πŸ’­ lines are the short note the model was asked to write for viewers with each answer β€” not a transcript of its internal reasoning. πŸ“– are its look-ups in the library (rubik/alg_lookup.py), which only stores algorithms and never reads the real cube. Timing is compressed; the numbers above are the real per-stage times and costs.