Claude Opus 5.5 Writes Robot Programs That Succeed in 221 of 240 Real-World Trials
On this page 7 sections
TL;DR
ACE-CaP-0, a robotics preprint posted Nov 12 by ACE Robotics with collaborators at Hong Kong Polytechnic, Zhejiang University and Nanyang Technological University, has Claude Opus 5.5 write the control programs for a real dual-arm robot, then freezes them. Across eight manipulation tasks, the frozen programs ran 240 physical evaluation trials and succeeded in 221, a rate of 92.1%, with no human and no model in the loop. Development burned 0.75 to 2.14 million output tokens per task, plus at most ten human-assisted scene resets.
What runs the robot
The work sits in the Code as Policies lineage: a coding agent writes a program that decides the actions, and the program keeps running after the agent logs off. The ACE-CaP-0 recipe hands the agent a task instruction, three camera feeds and a robot toolbox, then lets it loop: write code, run it on the physical robot, read the result, revise. The code specifies action sequences, geometric computations, motion parameters and gripper commands.
Two kinds of help arrive only when the agent asks. Demonstrations on Request: a person physically guides the arms, and the agent receives video, recorded trajectories and the joint poses at critical moments. Simulation on Demand: the agent picks a task segment, mirrors that state in a digital twin and tests candidate revisions in parallel, then carries the conclusion back to the real robot.
The station is two Agilex PIPER X arms with three Orbbec DaBai DC1 cameras, one top-down and two at the wrists. The eight tasks span alignment, multi-object handling and bimanual coordination: inserting a charger, inserting a flower, uncapping a bottle, nesting cups, packing bread, packing shoes, plating chicken and reorienting a parcel.
The scoreboard
Each program was frozen and then run 30 times, separate from development. Charger insertion went 30 for 30, chicken plating took 29 of 30, and bread packing, at 25 of 30, was the only task below 90%. Mean execution times run from 0.97 minutes for parcel reorientation to 2.27 minutes for shoe packing, and six of the eight tasks average under two minutes.
The paper ran no live-model comparison group, so there is no measured claim that frozen code beats a model in the loop on speed. The framing is a resource trade: repeated model calls stretch task completion time, while a frozen program amortizes the reasoning to zero at execution.
Ask for the demo, rent the sim
Before the eight tasks, the team ran a six-condition study on charger insertion, one development run per condition, all with the same foundation model. The guidance comparison is blunt: text advice alone produced a frozen program at 60% final success, video of a human doing the task got 73.3%, and a kinesthetic demonstration of the robot itself got 86.7%. Demonstrations also cut development time and output tokens.
Timing mattered as much as form. Handing the same guidance over upfront produced 53.3% success in 7.2 hours and 1.16 million output tokens. Letting the agent ask when stuck produced 86.7% in 3.7 hours and 0.73 million. Help the agent requests lands attached to a question it already has.
After three failed insertions, the agent sent its operator a multiple-choice question, options A through D, about how a human pushes a plug past the point where the gripper stalls at about two newtons. The answer, push in deep before releasing, ended up cited in a code docstring with the operator's timestamp. Robot debugging has reached the multiple-choice stage.
Simulation produced the study's sharpest failure and its best score. A demonstrate-then-simulate-then-transfer pipeline scored zero: the twin's clean renders lacked the real sensor's close-range blind regions, and the transferred program failed at its first grasp. It also burned the most output tokens of any condition, 1.86 million. Simulation called on demand inside real-world development reached 100% in 2.6 hours, against 86.7% in 3.7 hours for real-only work, at a token cost of 1.09 million against 0.73 million.
Why this matters if you never touch a robot
The trade generalizes past robotics: pay for the model during development, then ship an artifact that runs without it. Think of the agent as a consultant who writes the runbook and flies home; the runbook works the night shift, and you can audit every line of it. Here the artifact is readable code whose docstrings cite their sources, which is more than most fine-tuned networks can say.
Software builders run a version of this loop every time an agent writes a script that replaces a conversation. Same trade, milder physics: the robot's loop is slower, its feedback is noisier, and a wrong move bends hardware. Two rules survived contact here and port cleanly: give help when the agent asks for it, and use simulation to answer specific questions while the real system stays in the loop.
Read the small print
This is a preprint, and the authors flag its edges themselves. Each development condition was a single run on a single task, so the 30-trial scores measure the program, and, in their words, "consistency across independent development runs remains to be established." There is no live-model comparison group, reuse under new conditions is untested, and humans were present throughout development, guiding arms and answering questions. The ten-reset budget also excludes resets spent collecting demonstrations. One platform, one team, self-reported scores.
Key Takeaways
- ACE-CaP-0, posted to arXiv Nov 12 by ACE Robotics with Hong Kong Polytechnic, Zhejiang University and NTU collaborators, had Claude Opus 5.5 develop robot manipulation programs on a dual-arm Agilex PIPER X station.
- The eight frozen programs ran 240 physical evaluation trials with no human or model in the loop and succeeded 221 times, 92.1%, spanning alignment, multi-object handling and bimanual tasks.
- Charger insertion went 30 for 30 and chicken plating 29 of 30; bread packing at 25 of 30 was the only task under 90%. Mean execution times run 0.97 to 2.27 minutes.
- In the guidance study, robot demonstrations on request beat text-only advice (86.7% versus 60% final success), and on-request timing beat upfront handouts (86.7% versus 53.3%) while cutting development from 7.2 to 3.7 hours.
- Simulation on demand reached 100% success in 2.6 hours; a demonstrate-then-simulate-then-transfer pipeline scored 0% because the digital twin lacked the real sensor's close-range blind regions.
- Caveats: one development run per condition, one platform, no live-model comparison, reuse untested in new conditions; development cost 0.75 to 2.14 million output tokens per task and at most ten assisted resets.
Sources: ACE-CaP-0, arXiv 2611.16872, arXiv full text, ACE-CaP-0 project page, ACE Robotics, EconoTimes, Nov 15, 2026, CryptoSlate, Nov 15, 2026