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.
Atomic moves, one grip, a CFOP agent β or a language model.
Read the v1 post βLater versions take the same moves and the same grip further.
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.
Every atomic move is turn a layer + return to the standard grip. With that one contract, moves compose like building blocks.
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.
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.
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.
Turn the layer, then come home to the standard grip.
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.
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.
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.
The hands executing Opus's solution β recognised and looked up, stage by stage β its thought for each stage on top. Solved.
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.
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.