v0.1: Robot-use agents now write code, move smoothly, and reach 40% on RoboDojo

Yuanbo Yang, Junda Chen, Quanquan Peng, Yulun Wu, Shaoxiong Duan, Hao ZhangUC San Diego

ORA v0.1: Robot-use agents now write code, move smoothly, and reach 40% on RoboDojo

TL;DR

ORA is an open harness: a language model operates a robot with cameras and tools, and no robot training[1]. v0.1 with the open-weight DeepSeek-V4.1-Flash[2] solves 39.9% of RoboDojo[3] zero-shot, up from 5.2% in October's preview[4, 5].

  1. Write code.The model writes Python against the same robot tools; one turn carries 3.6 robot actions instead of 1.1.
  2. Move smoothly.Every move is planned around what the depth cameras see; moves stopped by a collision fall from 14.1% to 7.0% on RoboDojo.
  3. Work across open models.In code mode on 39 RoboDojo tasks, six open models solve from 48.7% (DeepSeek) down to 5.1% (Nemotron).
  4. Cold-start post-training.On RoboLab-120, Qwen3.8-27B solves 5.4% alone, 52.5% inside ORA, and 61.9% with PEAR's training on top[6].
ORA v0.1 in 90 seconds. The button on the video turns the sound on.

Overview

How ORA works, what v0.1 solves, and six solved episodes you can inspect.

ORA is a robot-use agent[1]: it brings the loop of computer-use agents[7, 8, 9] to robots, as a line of recent systems does[10, 11, 12, 13, 14, 15, 16, 17, 18]. The model asks for an action; the harness, with its manual, tools and context, carries it out on the robot and returns what happened; the model decides again. Language models drove robots zero-shot before these agents[19, 20]; ORA's loop is built on Pi[21].

The agent loop, around a robot

Language modelplans, grounds, decides
HarnessManualrules, body card, task, tool manual
ToolsLookMeasureAct
Contextrecent turns in full, older turns as decisions and lessons
trust boundaryRobotbehind the trust boundary, with a success check the model never sees

Tool calls. Each turn the model sends one tool call; the harness runs it and one result comes back before the model decides again.

Code mode. Each turn the model writes one program, which calls the same tools from a persistent workspace, up to 12 robot motions admitted one at a time, before one result comes back.

What one turn carriestool callsprograms
Robot actions per acting turn1.103.62
Reasoning per action, characters33.4k12.7k
One loop, two interfaces. A turn carries one tool call or one program. Numbers: DeepSeek-V4.1-Flash, 59 RoboDojo cases in each setting.

RoboDojo, zero-shot

Share of cases solved

DeepSeekleaderboard1.9%
ORA previewOctober5.2%
RPentbaselinewith its VLA5.5%
Astraleaderboard22.5%
Uni-Robot-Agentbaseline27.8%
ORA v0.139.9%

We run the baselines and ORA v0.1 on DeepSeek-V4.1-Flash. Successes after the benchmark's step limit count.

How successes are counted

Across four benchmarks

Same model, run by us, % solved

RoboDojo

Uni-Robot-Agent27.8ORA, October5.2ORA v0.139.9

RoboLab

Uni-Robot-Agent62.3ORA, Octobernot run in OctoberORA v0.178.3

RoboTwin

RPent71.1ORA, October71.5ORA v0.179.6

LIBERO-Pro

RPent*92.2ORA, October81.4ORA v0.187.5

*RPent there runs a policy trained on LIBERO and an explored memory. October's LIBERO-Pro ran on other seeds; RoboLab was not run in October.

The numbers in full

What one turn carries

One call per turn against one program per turn

tool callsprograms

Robot actionsper acting turn

tool calls1.10
programs3.62

Reasoningper action, characters

tool calls33.4k
programs12.7k

DeepSeek-V4.1-Flash, 59 RoboDojo cases in each setting.

Code mode

Moves stopped by a collision

Share of moves, %; lower is better

before the motion stackv0.1

RoboDojo44 cases7.014.1
RoboTwin25 cases6.818.4

Other parts of the harness changed between the two sets of runs too.

Smooth motion

Open models in v0.1

RoboDojo, 39 tasks, share of cases solved

tool callsprograms, a hue per maker

DeepSeekV4.1-Flash48.7%
Qwen3.8-Flash-Next35.9%
Inkling2-Small21.8%
MuseSpark Open16.7%
Qwen3.8-27B15.4%
Nemotron3.5-Super-VL5.1%

Four layouts per task for DeepSeek, two for the others.

Analysis across models

A harness and training, on one model

Qwen3.8-27B on RoboLab-120, % of episodes solved, scored as PEAR scores

PEAR's paperPEAR's paper, trainedour runour run, PEAR-trained

5.4%
37.3%
52.5%
61.9%
releasedno harness
trainedno harness
releasedin ORA
trainedin ORA
releasedno harness5.4%
trainedno harness37.3%
releasedin ORA52.5%
trainedin ORA61.9%

The model nobody trained, inside the harness, is ahead of the trained model without one; the trained model inside the harness is ahead of both.

Harness and model

ORA v0.1 in six charts. Zero-shot throughout. Other systems: Uni-Robot-Agent[11], RPent[12] and RoboDojo's leaderboard[22, 23]. Other benchmarks: RoboTwin[24], LIBERO-Pro[25], RoboLab[26]. The trained model is PEAR's[6]. Click a card for its section.

Solved tasks

A tower from planks24 decisions · 85 motions · 73 s of motion

TaskBuild a tower using the wooden blocks and wooden boards.

1× · 73 s of motion
  1. 1 of 24 · cycle_supR.py
  2. 2 of 24 · place_supR.py
  3. 3 of 24 · cycle_boardL.py
  4. 4 of 24 · place_boardL.py
  5. 5 of 24 · place_boardL2.py
  6. 6 of 24 · retract_verifyL.py
  7. 7 of 24 · cycle_upperL.py
  8. 8 of 24 · cycle_upperR.py
  9. 9 of 24 · place_upperR.py
  10. 10 of 24 · cycle_boardM.py
  11. 11 of 24 · place_boardM.py
  12. 12 of 24 · fix_boardM.py
  13. 13 of 24 · place_boardM2.py
  14. 14 of 24 · relay_tan.py
  15. 15 of 24 · stage_tan.py
  16. 16 of 24 · place_boardS.py
  17. 17 of 24 · place_boardS2.py
  18. 18 of 24 · place_roof.py
  19. 19 of 24 · place_roof2.py
  20. 20 of 24 · place_roof3.py
  21. 21 of 24 · verify_tower.py
  22. 22 of 24 · roof_yaw_do.py
  23. 23 of 24 · roof_yaw_do2.py
  24. 24 of 24 · roof_place3.py
  1. move_pose
  2. move_pose
  3. set_gripper
  4. move_pose
  5. move_pose
  6. set_gripper
  7. move_pose
  8. move_pose
  9. move_pose
  10. set_gripper
  11. move_pose
  12. return_home
  13. move_pose
  14. move_pose
  15. set_gripper
  16. return_home
  17. move_pose
  18. move_pose
  19. set_gripper
  20. move_pose
  21. move_pose
  22. move_pose
  23. set_gripper
  24. return_home
  25. move_pose
  26. move_pose
  27. set_gripper
  28. move_pose
  29. move_pose
  30. move_pose
  31. set_gripper
  32. return_home
  33. move_pose
  34. move_pose
  35. set_gripper
  36. move_pose
  37. move_pose
  38. move_pose
  39. set_gripper
  40. return_home
  41. move_pose
  42. move_pose
  43. set_gripper
  44. move_pose
  45. move_pose
  46. move_pose
  47. move_pose
  48. set_gripper
  49. return_home
  50. move_pose
  51. move_pose
  52. set_gripper
  53. move_pose
  54. rotate_wrist
  55. move_pose
  56. move_pose
  57. set_gripper
  58. return_home
  59. move_pose
  60. move_pose
  61. set_gripper
  62. move_pose
  63. move_pose
  64. move_pose
  65. set_gripper
  66. return_home
  67. move_pose
  68. move_pose
  69. set_gripper
  70. move_pose
  71. rotate_wrist
  72. move_pose
  73. move_pose
  74. set_gripper
  75. return_home
  76. wait_ticks
  77. move_pose
  78. move_pose
  79. set_gripper
  80. move_pose
  81. rotate_wrist
  82. move_pose
  83. move_pose
  84. set_gripper
  85. return_home
Six tasks, solved zero-shot by DeepSeek-V4.1-Flash in ORA v0.1. The robot's own cameras at 1×, and a 3D replay of each run to turn.

1. Code mode

The same harness, as a Python library in a workspace that persists.

Code mode adds no robot capability: the cameras, the motion stack and the supervision that admits one robot command at a time are the same. What changes is the interface. Instead of one tool call per turn, the model writes Python in a persistent workspace and can run up to 12 robot motions in one decision. Programs run in a sandbox[27] with no network and reach the robot only through the same supervised tools. Programs as an agent's action have a history: language-model programs for robot control[28, 29], executable code in place of one tool call per turn[30, 31], and code mode for tool use[32, 33].

The gain over tool calls

On build_tower, the tool-call run gives up after 94 model calls with the planks still on the table; the code-mode run stacks the tower. One of its programs finds a block, measures it, grasps, lifts, places, and checks the height before it hands back. Across 59 paired RoboDojo cases a turn carries 3.62 robot actions instead of 1.10, and solved cases go from 6 to 20.

One task, two real runsTaskBuild a tower using the wooden blocks and wooden boards.
model call 94 of 94
Tool callsall the preview had
94calls50motionsnot solved
head camera · pauses cut
not solved
menu: one tool per call
Code modenew in ORA v0.1
86calls108motions38filessolved
head camera · pauses cut
solved
library: the same tools, as functions
its own tools and scripts38imported laterone-off
The same task with tool calls and with programs. One task (build tower, DeepSeek-V4.1-Flash), a model call per tick, from the runs' records. Tool calls: 94 calls, 50 motions, not solved. Code mode: 86 calls, 108 motions, 38 files written, solved after the benchmark's step limit (Appendix).

Tools written on the fly

Given a workspace, models fill it with tools of their own[34, 35]. Qwen[36] and DeepSeek build perception and geometry helpers, a median of 122 and 37 functions per episode, and import them in later turns; Qwen3.8-27B[37] writes 46, Inkling[38] 12, Muse[39] 7 and Nemotron[40] 4. More code is not more success: DeepSeek's failed episodes hold more functions than its solved ones.

Language models now make their own tools, on the fly

34,327 functions the models wrote in 727 RoboDojo episodes, code mode

Each dot is one function, a sample of 2,496, placed by how alike their source is.

drag to turn · click a dotdrag to turn · tap a dot
Try one
By model
The tools agents make for themselves. The universe: 2,496 of the 34,327 functions the four models wrote, placed by the similarity of their source[41, 42]. The toolboxes: the functions of a median episode of each model, in seven groups.

2. Smooth motion

Every move is planned around what the depth cameras see and timed inside joint limits.

Between asking for a move and seeing the next picture, the model sees nothing. In October a move was a straight run at the target, as fast as the controller would go. Arms clipped boxes, hit each other and knocked finished towers over.

swept offnot filmed on v0.1 yet

DigitsRoboDojo

The hand lets go of a digit and whips away; the digit goes with it.

hitnot filmed on v0.1 yet

A bowl by the cabinetLIBERO-Pro

Carrying a bowl out, the arm drives into the cabinet top and drops it.

knocked overnot filmed on v0.1 yet

A finished towerRoboDojo

Both arms pull away from the tower at full speed; planks and blocks burst across the table.

knocked awaynot filmed on v0.1 yet

Pack the boxRoboDojo

The arm swings into the open box and sends it 0.9 m into the far corner.

hitrefusednot filmed on v0.1 yet

Xylophone, two armsRoboDojo

Holding a mallet, the right arm swings into the left; the mallet falls to the table.

knocked awaynot filmed on v0.1 yet

Build a towerRoboDojo

A 0.12 s sweep along a plank shoots it up on end.

tippednot filmed on v0.1 yet

Push the TRoboDojo

Coming down beside the T, the gripper lifts it onto its edge.

flungrefusednot filmed on v0.1 yet

XylophoneRoboDojo

A quarter turn of the wrist whips the arm up; the mallet is gone.

Moves stopped by a collision% of moves, lower is better

beforev0.1

RoboDojo44 cases7.014.1
RoboTwin25 cases6.818.4

Other parts of the harness changed between the two sets of runs too.

Moves that went wrong, and the same request on v0.1. Each tile is one move from a run before the motion stack, at real speed. Switch to ORA v0.1 for the same request replayed from the same state.

In v0.1 every move goes through one tool, move_pose. The harness builds a 1 cm voxel map from the robot's depth cameras, plans around it with cuRobo[43], and times the path inside joint limits[44, 45]. A request that would collide, press into a surface or wind the wrist is refused before anything moves, with a named reason the model can act on. A guard stops an arm that falls behind its command.

Timed, not thrown.The same way out, paced inside each joint's limits: 0.80 s instead of 0.36 s. The digit moves 2 mm where before it flew 60 cm.

Beforethe run, as recorded

swept offhead camera · real speed

ORA v0.1same request, same state

head camera · real speed
move_poseRoboDojo · arrange largest number, layout 2 · move 22
right
position_m: [0.36, -0.43, 1]
interaction: "free_space"

and 2 more arguments

Beforewhat came back
execution_status: "reached"
failure_code: null

The hand moved 0.455 m in 0.36 s.

measured in the simulator, not seen by the model

The digit: 597 mm, turned 145°.

ORA v0.1what came back
execution_status: "reached"
motion.duration_s: 0.76
motion.speed.planned_peak_linear_m_s: 1.5583

It ran for 0.80 s.

measured in the simulator, not seen by the model

The digit: 2 mm, turned 15°.

The hand's speed m/s, measured by the controller every 4 ms

beforeORA v0.1

01232.67 m/sbefore1.55 m/sv0.10 s0.36 s0.80 s

time from the start of the move

See
Plan
Pace

Every path is timed inside each joint's speed and acceleration limits. The pace never changes the path.

Check
Guard

where the model sees itIn the call, speed; not set here, so fast, the default. In the receipt, motion.duration_s and motion.speed.planned_peak_linear_m_s.

What changed under a move. Five moves from before the motion stack, each beside the same request replayed on ORA v0.1 from the same state. What moved is measured in the simulator, which the model never sees.
move_posereworkedPut the hand at a poseabsolutedeltaworld_axeshold_current

One call is one move. The harness compiles the target, plans the path from the measured joints, runs it as one motion and answers with a receipt. In the preview a free move on RoboDojo was one inverse-kinematics solution and an interpolation between joints, with no check for collisions. Each arm gets a position (absolute, a delta, or held) and an orientation: a quaternion, a turn about an axis, held, or world_axes, which states the hand's pose as two directions, the way it approaches and the way the jaws close.

Comes back The compiled pose, the receipt (reached or not, how far from the target), the route taken and the speed the plan reached.

move_pose({"targets": {"left": {
 "approach_world": [0, 0, -1],
 "interaction": "free_space",
 "jaw_line_world": [0, 1, 0],
 "orientation_mode": "world_axes",
 "position_m": [-0.29, -0.14, 0.97],
 "position_mode": "absolute"}}})
→ left arm 0.1 mm / 0.0° from target, reached, TCP moved 218 mm

Recorded: arrange largest number, layout 0, tool calls, decision 1

interactionSay what kind of move it is; the harness picks the pathfree_spaceprecisioncontact_approach

free_space: a collision-free path planned around what the cameras see now and the other arm, a held object moving with the hand. precision: the straight line of the hand when the whole change is within 50 mm and 15 degrees, a planned path otherwise. contact_approach: straight when it is short; when it is longer, a planned path to a point just short of contact, a stop, then the straight line for the last 40 mm. The model states a physical intent and never names a controller.

Comes back motion.route says which path ran: a planned one, a straight line, or the two in stages.

move_pose({
 "slow_approaching": true,
 "speed": "normal",
 "targets": {"left": {
  "interaction": "precision",
  "orientation_mode": "hold_current",
  "position_m": [-0.12671, -0.06119, 0.9316],
  "position_mode": "absolute"}}})
→ left arm 0.1 mm / 0.0° from target, reached, TCP moved 43 mm

Recorded: arrange largest number, layout 0, tool calls, decision 7

speednewSet the pace, never the pathfastnormalcarefulslow_approachingspeed_m_s

fast, the default: each joint at up to 4 rad/s. normal: about 0.3 m/s at the hand, for moves while holding something. careful: about 0.1 m/s, for the last centimetres of an approach or a placing. slow_approaching slows only the last 2 cm of a move. speed_m_s gives a top speed directly. Every plan is timed inside the joints' speed and acceleration limits.

Comes back The caps that applied and the top speed the planned path reaches under them.

move_pose({
 "expect_contact": true,
 "speed": "careful",
 "targets": {"right": {
  "approach_world": [0, 1, 0],
  "interaction": "contact_approach",
  "jaw_line_world": [-1, 0, 0],
  "orientation_mode": "world_axes",
  "position_m": [0.066, -0.122, 0.8516],
  "position_mode": "absolute"}}})
→ right arm 1.9 mm / 0.4° from target, reached: arm not settled, TCP moved 49 mm

Recorded: insert tubes, layout 0, tool calls, decision 20

dry_runnewLook at a move before making ittrue

Nothing moves and nothing is spent. The planned path is drawn on the camera images that see it, with its start and end, and the answer gives, per arm, how far the hand travels and turns, how high the path rises above its ends, and the least clearance between the jaws and what the depth images show, with where that is. The same call on the same observation then runs exactly the path shown. Every moving call takes it.

Comes back A picture and the numbers of the plan. It predicts no contact and nothing after the first contact.

pl = tools.move_pose(targets=tgt(p, it), dry_run=True)
print("dry", name, "feasible", pl.feasible, "code", pl.failure_code, "|", pl.summary[:160])
if not pl.feasible:
    handoff("approach path not feasible", stage=name, code=pl.failure_code, summary=pl.summary)
→ dry grasp feasible True code None | left: 19 native actions, hand travels 0.289 m and turns 2 deg, rises 43 mm above its higher end at 42% of the path, least clearance 2 mm at 74% of the path, ent

Recorded: pour by language, layout 3, code mode, decision 1, step grasp.py lines 27 to 30

reach_checknewAsk whether the arm can hold a pose, without movingposesinteraction

A read-only question to the planner, in programs: for up to 16 poses of one arm at once, whether each can be reached, by which route, and how far its joints stay from their limits. A program uses it to choose among grasps or to check a whole pick and place before the first motion.

Comes back Per pose: reachable, a reason when it is not, the route, and the margin to the nearest joint limit in degrees.

res = query("reach_check", arm=arm, poses=poses)
→ reach unc-red grasp: True None margin=17.638704
→ reach unc-red lift: False ik_failed margin=None

Recorded: cover blocks, layout 5, code mode, decision 8, cycle.py lines 28 to 28

expect_contactnewMean to touchtrue

For a move that is meant to push, press or move an object. It follows the straight line the whole way, at any length and speed, and the guard that stops an arm as soon as it meets resistance stands down; the hard limit on how far the arm may fall behind its command stays.

Comes back The receipt as for any move; a stop on such a move says that it was stopped despite expecting contact.

move_pose({
 "expect_contact": true,
 "slow_approaching": true,
 "speed": "normal",
 "targets": {"left": {
  "interaction": "contact_approach",
  "orientation_mode": "hold_current",
  "position_m": [0.0496, -0.1785, 0.874],
  "position_mode": "absolute"}}})
→ left arm 1.4 mm / 0.2° from target, reached, TCP moved 4.8 mm

Recorded: play Xylophone, layout 1, tool calls, decision 69

the receiptreworkedWhat comes back: reached, stopped, or refused with a reasonreachednot_reachedrefused

A move that ran ends reached, or not_reached with what stopped it and how far along its path it was. A move the planner will not make is refused before anything moves, with a named reason, such as goal_unreachable, goal_in_collision, goal_below_support, path_blocked, inter_arm_collision or paced_path_wrist_unwind, and where it can, with something that would work. In a program a refusal is an exception, ToolRefused, that the program can catch and branch on.

Comes back The reason by name, and the measured state; nothing is executed on a refusal.

move_pose({
 "slow_approaching": true,
 "speed": "normal",
 "targets": {"right": {
  "interaction": "precision",
  "orientation_mode": "hold_current",
  "position_m": [0.0418, -0.0612, 0.928],
  "position_mode": "absolute"}}})
→ right arm 14 mm / 0.9° from target, not reached: controller tracking error, TCP moved 58 mm

Recorded: arrange largest number, layout 0, tool calls, decision 49

robot.ToolRefused: move_pose: no joint configuration reaches this pose even with nothing in the way; with the fingertips at the same point, an approach tilted 30 degrees plans: (0.15, 0.48, -0.87) in world coordinates instead of (0.00, 0.00, -1.00); the other arm does not reach this pose with nothing in the way; nothing was executed
→ refused: goal_unreachable

Recorded: cover blocks, layout 5, code mode, decision 9

recover_pose · return_homenewUndo a move, or start overarms

recover_pose backs an arm out the way it came, one of its last five moves per call, along the path it measured on the way in. return_home takes an arm straight back to the joints it started the episode in, by a planned path, keeping the grippers as they are.

Comes back A receipt, as for any move.

recover_pose({"arms": ["left"]})
→ left arm 0.1 mm / 0.0° from target, reached, TCP moved 68 mm

Recorded: arrange largest number, layout 0, tool calls, decision 12

return_home({"arms": ["left"]})
→ left arm 0.0 mm / 0.0° from target, reached, TCP moved 450 mm

Recorded: arrange largest number, layout 0, tool calls, decision 26

What the model moves the robot with. Open a row. The names are the same as tool calls and in Python; each example is a recorded call.

On matched cases, moves stopped by a collision fall from 14.1% to 7.0% on RoboDojo and from 18.4% to 6.8% on RoboTwin[24]. Light contact is not solved: about one move in ten still shifts an object by 5 mm or more.

3. Analysis across models

Six open models, the same prompt, tools and budgets, 39 RoboDojo tasks.

In code mode DeepSeek-V4.1-Flash solves 44.9% of these cases (48.7% over four layouts) and Qwen3.8-Flash-Next 35.9%; few of their programs fail (10% and 13%). Inkling-2-Small[38] solves 21.8% with programs of nine lines. Muse Spark Open (16.7%), Qwen3.8-27B (15.4%) and Nemotron-3.5-Super-VL (5.1%) lose about a third of their programs to a crash; for Muse and Nemotron it is mostly a refused call they did not catch. More reasoning is not what separates them: Qwen3.8-27B reasons the most, a median of 3,390 tokens per call against DeepSeek's 2,083. The open models were served with vLLM[46] and SGLang[47].

Across open models

Code mode, share of RoboDojo cases solved, 39 tasks

DeepSeekV4.1-Flash48.7%
Qwen3.8-Flash-Next35.9%
Inkling2-Small21.8%
MuseSpark Open16.7%
Qwen3.8-27B15.4%
Nemotron3.5-Super-VL5.1%

Four layouts per task for DeepSeek, two for the others.

  • DeepSeek-V4.1-Flash: with programs 35 of 78 cases solved, a median of 2,083 reasoning tokens per model call, programs of 35 lines (median), 10% of programs fail.
  • Qwen3.8-Flash-Next: with programs 28 of 78 cases solved, a median of 1,072 reasoning tokens per model call, programs of 40 lines (median), 13% of programs fail.
  • Inkling-2-Small: with programs 17 of 78 cases solved, a median of 1,000 reasoning tokens per model call, programs of 9 lines (median), 21% of programs fail.
  • Muse Spark Open: with programs 13 of 78 cases solved, a median of 341 reasoning tokens per model call, programs of 24 lines (median), 32% of programs fail.
  • Qwen3.8-27B: with programs 12 of 78 cases solved, a median of 3,390 reasoning tokens per model call, programs of 41 lines (median), 31% of programs fail.
  • Nemotron-3.5-Super-VL: with programs 4 of 78 cases solved, a median of 180 reasoning tokens per model call, programs of 17 lines (median), 39% of programs fail.
Six open models in the same harness. RoboDojo, 39 tasks, two layouts each, with programs and with tool calls; every case in the views is quoted from the runs as recorded.

The traces are open: 3,557 episodes from seven models on five benchmarks, with everything each model was given and everything it wrote, are on Hugging Face.

Across the six, the RoboDojo result lines up with public scores for agentic coding far more than with those for visual reasoning.

Robot use against public benchmarks

Across the six models, r runs from 0.38 to 1.00 on evaluations where the model acts and from −0.21 to 0.45 on those where it answers questions; it is 0.84 on the Intelligence Index, a composite of nine evaluations.

The model acts agentic evaluations

RoboDojo cases solved, %r = 1.00
0204060

The model answers question sets

RoboDojo cases solved, %r = 0.45
0204060
RoboDojo against public benchmarks, six models. Up, the share of RoboDojo cases a model solves in ORA in code mode; across, its score as Artificial Analysis measured it[48], at different reasoning settings. Six points make a fragile r; after a panel of Uni-Robot-Agent[11].

4. Harness and model

What a harness adds, and what training adds on top of it.

Training a reasoning model to use robots[6, 49, 50] or a vision-language-action model[51] changes the model; a harness changes what the model is given. PEAR trains Qwen3.8-27B[37] with reinforcement learning in simulation to drive a robot with no tools. We ran the base model and PEAR's released checkpoint[52] inside ORA and scored them the way PEAR does.

On RoboLab-120[26] the base model goes from 5.4% alone to 52.5% inside ORA, ahead of the trained model alone (37.3%). The trained model inside ORA reaches 61.9%. RoboDojo's long-horizon tasks stay at 0% either way.

One model, with and without training, with and without a harness

No training: 5.4 becomes 52.5 in ORA. PEAR's training adds on top: 61.9.

All 120 tasks

Qwen3.8-27B on RoboLab-120, share of episodes solved, %

Qwen3.8-27Bno harness, PEAR's paper

5.4

PEAR-trainedno harness, PEAR's paper

37.3

Qwen3.8-27Bin ORA, our run

52.5

PEAR-trainedin ORA, our run

61.9

By task difficulty

trained, no harnessas released, in ORAtrained, in ORA

Simple128 episodes in ORA

44.661.768.0

Moderate78 episodes in ORA

35.847.464.9

Complex34 episodes in ORA

13.229.432.4

120 tasks. No harness: PEAR's paper, 10 episodes per task. In ORA: 2 episodes per task, 240 and 239 episodes.

No training: 0.08 becomes 10.0 in ORA. PEAR's training adds on top: 15.8.

All 54 settings

Qwen3.8-27B on RoboDojo, mean of five capability dimensions, %

Qwen3.8-27Bno harness, PEAR's paper

0.08

PEAR-trainedno harness, PEAR's paper

5.5

Qwen3.8-27Bin ORA, our run

10.0

PEAR-trainedin ORA, our run

15.8

By capability

as released, in ORAtrained, in ORA

Generalization

6.26.2

Precision

06.2

Long-horizon

00

Memory

25.041.7

Open-ended

18.825.0

54 settings. No harness: PEAR's paper, 10 episodes per setting. In ORA: 2 episodes per setting, the same 106 episodes for both models.

A harness and training, on the same model. Qwen3.8-27B as released and as trained by PEAR[6], without a harness (PEAR's numbers) and inside ORA (our runs), scored as PEAR scores: within the benchmark's step limit. We ran 2 episodes per task, PEAR 10.

ORA is open source. To run it, go to the repository.

References

  1. 1Isola (2026). Robot-Use Agents.
  2. 2DeepSeek (2026). DeepSeek-V4.1-Flash-1017.
  3. 3Chen et al. (2026). RoboDojo: A Unified Sim-and-Real Benchmark for Comprehensive Evaluation of Generalist Robot Manipulation Policies.
  4. 4Yang et al. (2026). ORA: Open Robot-Use Agents Zero-Shot Solve Robot Tasks for $0.35.
  5. 5Yang et al. (2026). ORA: Open Robot-Use Agents.
  6. 6Tang et al. (2026). Training Reasoning Models in Simulation to Natively Use Real Robots.
  7. 7OpenAI (2025). Computer-Using Agent.
  8. 8Anthropic (2024). Introducing computer use, a new Claude 3.5 Sonnet, and Claude 3.5 Haiku.
  9. 9Xie et al. (2024). OSWorld: Benchmarking Multimodal Agents for Open-Ended Tasks in Real Computer Environments.
  10. 10Chu et al. (2026). OpenRUA: Robot-Use Agents Are Zero-Shot Visuomotor Policies.
  11. 11Yuan et al. (2026). Democratizing Robot-Use Agents: A Unified Harness with Open Models.
  12. 12Zhang et al. (2026). Harness VLA: Steering Frozen VLAs into Reliable Manipulation Primitives via Memory-Guided Agents.
  13. 13Si et al. (2026). Fewer Tokens, Better Action: GPT-6 Astra Robot Agents with 14% Higher Success Rate but 65% Fewer Tokens.
  14. 14Huang et al. (2026). Scaling Online Exploration for Robot Agents.
  15. 15Lu et al. (2026). ASPIRE: Agentic /Skills Discovery for Robotics.
  16. 16Yang et al. (2026). Astranomy: An Empirical Study of GPT-6 Astra as a Native Robot Policy.
  17. 17OpenRoboKit (2026). RoboSkills: A minimal set of agent workflows and tools for robotics.
  18. 18StellarEdge AI Technical Team (2026). Auriga Technical Report: A Task-Agnostic Agent Harness for Zero-Shot Embodied Manipulation.
  19. 19Ahn et al. (2022). Do As I Can, Not As I Say: Grounding Language in Robotic Affordances.
  20. 20Huang et al. (2023). VoxPoser: Composable 3D Value Maps for Robotic Manipulation with Language Models.
  21. 21Earendil Works (2025). Pi.
  22. 22RoboDojo Team (2026). RoboDojo Sim Leaderboard, Agent Track.
  23. 23Zhang et al. (2026). An Unexpected Robot Policy: Early Evaluations of GPT-6 Astra on RoboDojo and Beyond.
  24. 24Chen et al. (2025). RoboTwin 2.0: A Scalable Data Generator and Benchmark with Strong Domain Randomization for Robust Bimanual Robotic Manipulation.
  25. 25Zhou et al. (2025). LIBERO-PRO: Towards Robust and Fair Evaluation of Vision-Language-Action Models Beyond Memorization.
  26. 26Yang et al. (2026). RoboLab: A High-Fidelity Simulation Benchmark for Analysis of Task Generalist Policies.
  27. 27Containers (2016). Bubblewrap: low-level unprivileged sandboxing tool.
  28. 28Liang et al. (2022). Code as Policies: Language Model Programs for Embodied Control.
  29. 29Fu et al. (2026). CaP-X: A Framework for Benchmarking and Improving Coding Agents for Robot Manipulation.
  30. 30Yao et al. (2023). ReAct: Synergizing Reasoning and Acting in Language Models.
  31. 31Wang et al. (2024). Executable Code Actions Elicit Better LLM Agents.
  32. 32Varda and Pai (2025). Code Mode: the better way to use MCP.
  33. 33Anthropic (2025). Code execution with MCP: Building more efficient agents.
  34. 34Wang et al. (2023). Voyager: An Open-Ended Embodied Agent with Large Language Models.
  35. 35Cai et al. (2023). Large Language Models as Tool Makers.
  36. 36Qwen Team (2026). Qwen3.8-Flash-Next.
  37. 37Qwen Team (2026). Qwen3.8-27B.
  38. 38Thinking Machines Lab (2026). Inkling-2-Small.
  39. 39Meta (2026). Muse-Spark-Open-816B-A42B.
  40. 40NVIDIA (2026). NVIDIA-Nemotron-3.5-Super-VL-120B-A12B-BF16.
  41. 41Reimers and Gurevych (2019). Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks.
  42. 42van der Maaten and Hinton (2008). Visualizing Data using t-SNE.
  43. 43Sundaralingam et al. (2023). cuRobo: Parallelized Collision-Free Minimum-Jerk Robot Motion Generation.
  44. 44Pham and Pham (2018). A New Approach to Time-Optimal Path Parameterization Based on Reachability Analysis.
  45. 45Berscheid and Kröger (2021). Jerk-limited Real-time Trajectory Generation with Arbitrary Target States.
  46. 46Kwon et al. (2023). Efficient Memory Management for Large Language Model Serving with PagedAttention.
  47. 47Zheng et al. (2023). SGLang: Efficient Execution of Structured Language Model Programs.
  48. 48Artificial Analysis (2026). Artificial Analysis Intelligence Index.
  49. 49Liu et al. (2026). AgenticRoboRL: Bringing Coding-Agent Post-Training to Agentic Robotics.
  50. 50Fan et al. (2026). CaPtain: A Pipeline for Post-Training Code-as-Policy Robot Agents.
  51. 51Black et al. (2025). π0.5: a Vision-Language-Action Model with Open-World Generalization.
  52. 52MIT HAN Lab (2026). Qwen3.8-27B-PEAR.
  53. 53OpenRUA Team (2026). Behind the RoboDojo Boom: Revisiting Embodied Evaluation of Robot-Use Agents.
  54. 54Zhao et al. (2023). Learning Fine-Grained Bimanual Manipulation with Low-Cost Hardware.
  55. 55Haddadin et al. (2022). The Franka Emika Robot: A Reference Platform for Robotics Research and Education.
  56. 56Khazatsky et al. (2024). DROID: A Large-Scale In-The-Wild Robot Manipulation Dataset.
  57. 57OpenAI (2026). GPT-6 Astra: A new generation of intelligence.
  58. 58Mittal et al. (2025). Isaac Lab: A GPU-Accelerated Simulation Framework for Multi-Modal Robot Learning.
  59. 59Xiang et al. (2020). SAPIEN: A SimulAted Part-based Interactive ENvironment.
  60. 60Zhu et al. (2020). robosuite: A Modular Simulation Framework and Benchmark for Robot Learning.
  61. 61Liu et al. (2023). LIBERO: Benchmarking Knowledge Transfer for Lifelong Robot Learning.
  62. 62Carion et al. (2026). SAM 3: Segment Anything with Concepts.
  63. 63Sundermeyer et al. (2021). Contact-GraspNet: Efficient 6-DoF Grasp Generation in Cluttered Scenes.

Citation

To cite this post:

@misc{ora2026v01,
  title        = {{ORA} v0.1: Robot-Use Agents Now Write Code, Move Smoothly, and Reach 40\% on {RoboDojo}},
  author       = {Yuanbo Yang and Junda Chen and Quanquan Peng and Yulun Wu and Shaoxiong Duan and Hao Zhang},
  year         = {2026},
  month        = nov,
  howpublished = {FastRUA Blog},
  url          = {https://fastrua.ai/blog/2026-11-code-mode/}
}

Appendix

How successes are counted

RoboLab[26] and RoboDojo[3] limit the simulator steps of an episode. ORA records the benchmark's verdict at the limit and lets the episode go on; this post counts a success reached later too, except in section 4, which follows PEAR[6] and counts only successes within the limit. RoboTwin[24] and LIBERO-Pro[25] end an episode at their limit.

Comparison All successes Within the step limit
RoboDojo, 198 cases ORA v0.1 79 (39.9%) 21 (10.6%)
Uni-Robot-Agent 55 (27.8%) 32 (16.2%)
RoboLab, 300 cases ORA v0.1 235 (78.3%) 200 (66.7%)
Uni-Robot-Agent 187 (62.3%) 179 (59.7%)
RoboLab, 500 cases ORA v0.1 79.2% 67.0%
RoboTwin, 235 cases RPent 167 (71.1%) 151 (64.3%)
Paired experiment, 59 cases tool calls 6 2
programs 20 5
Open models: DeepSeek, 156 cases tool calls 58 36
programs 76 30
Qwen, 78 cases tool calls 29 17
programs 28 7
Inkling-2-Small, 78 cases tool calls 12 6
programs 17 6
Muse, 78 cases tool calls 9 6
programs 13 8
Qwen3.8-27B, 78 cases tool calls 10 6
programs 12 5
Nemotron, 78 cases tool calls 3 3
programs 4 2

Within the limit Uni-Robot-Agent[11] solves more RoboDojo cases than ORA, and for DeepSeek and both Qwen models tool calls solve more than programs. RoboDojo's leaderboard[22] counts within the limit only, so 10.6% is the number nearest to it. We count later successes because the limits were set for policies that act at a fixed control rate[53], and a late success passes the benchmark's own check. Uni-Robot-Agent ran with its own limit of 3 hours per episode, ORA with 6.

The numbers in full

ORA v0.1 with DeepSeek-V4.1-Flash, zero-shot, every success counted:

Benchmark Robot Cases Programs Tool calls
RoboTwin 2.0, clean to randomized two-arm ALOHA[54] 235 79.6% (187) 80.4%
LIBERO-Pro Franka Panda[55] 800 87.5% (700) 85.4%
RoboLab, 100 of its 120 tasks DROID[56] Franka 500 79.2% (396)
RoboDojo two-arm ARX X5 198 39.9% (79)

Baselines, run by us on the same cases: Uni-Robot-Agent[11] solves 55 of 198 on RoboDojo and 187 of 300 on RoboLab; RPent[12] solves 167 of 235 on RoboTwin, 738 of 800 on LIBERO-Pro with its LIBERO VLA[51] and explored memory, and 11 of 200 on RoboDojo with its VLA. On RoboDojo's leaderboard[22, 23], read on 16 November 2026, GPT-6-Astra[57] scores 22.48% and DeepSeek V4.1 Flash 1.92%.

The motion stack

Under every planned move, on every simulator[58, 59, 60]:

Stage What it does
Collision world Rebuilt for each request from the robot's own depth cameras only (RoboDojo: the head and both wrists; RoboTwin: four cameras; LIBERO[61]: two), as 1 cm voxels. The robot's own body is removed; the start pose and a box around the hand at the goal are cleared; a held object moves with the hand; space no camera sees counts as free. A goal that puts a fingertip more than 1 cm below the surface under it is refused before planning.
Path cuRobo[43] plans from the measured joints, with the other arm as an obstacle where it stands. The path is checked a second time against the scene without the clearing at the goal.
Wrist Along the path the hand may turn at most 45 degrees more than between its two ends; beyond that the move is refused (paced_path_wrist_unwind). With empty jaws the same grasp turned a half-turn about the approach is tried as well.
Timing TOPP-RA[44], then Ruckig[45]. fast: each joint at up to 4 rad/s and 40 rad/s². normal: 0.3 m/s and 60 degrees/s at the hand. careful: 0.1 m/s and 20 degrees/s. slow_approaching: the last 2 cm at careful.
Contact A move into contact is a straight line when it is within 50 mm and 15 degrees; a longer one is planned to a point short of contact and is straight for its last 40 mm. With expect_contact the whole move is straight. The guard that stops a blocked arm reads how far the joints fall behind their commands; there is no force sensing.
Refusal Nothing moves and nothing is spent. The model is told one of goal_unreachable, goal_in_collision, goal_below_support, start_in_collision, path_blocked, paced_path_wrist_unwind, paced_path_unreachable, self_collision, table_collision, inter_arm_collision, contact_path_blocked, paced_motion_budget or invalid_motion_arguments.

Cost, and every model call by call

A model call is not cheaper in ORA than in Uni-Robot-Agent[11]: a median of 190k input tokens against 133k on RoboDojo. An episode is, because code mode makes about eight times fewer calls (a median of 58 against 462).

  • Model calls per episode, median: Uni-Robot-Agent 462, ORA 58.
  • Input tokens per call, median: 133k and 190k.
  • Input tokens per solved case: 211.9M and 31.5M.
  • Context resets per episode: 5.0 and 0.0.
What a context costs. ORA and Uni-Robot-Agent[11] (URA) with DeepSeek-V4.1-Flash on the same cases, run by us. Input tokens are totals, cached or not.
DeepSeekV4.1-FlashQwen3.8-Flash-NextInkling2-SmallMuseSpark OpenQwen3.8-27BNemotron3.5-Super-VL
Episodes
Casesone episode each78layouts 3 and 478layouts 3 and 478layouts 3 and 478layouts 3 and 478layouts 3 and 478layouts 3 and 4
Solvedshare of cases45%36%22%17%15%5%
Thinking, per model call
Reasoning tokensmedian; quartiles and 90th percentile2.1k800 to 4.6k, p90 8.4k1.1k139 to 3.2k, p90 6.3k1.0k272 to 2.5k, p90 4.9k341163 to 642, p90 1.1k3.4k542 to 8.4k, p90 16.4k18040 to 767, p90 2.8k
Calls with no reasoningshare of model calls2.8%0%0%0%0%0%
What a decision carries
Model calls per decisiontotal calls over total decisions2.83.93.22.13.13.1
Robot actions per acting turnmean3.94.22.13.93.01.6
Acting turns with several actionsshare73%68%41%66%61%28%
The programs
Lines per programmedian; quartiles3523 to 544020 to 7296 to 152414 to 394123 to 661712 to 26
Programs that end in an errorshare of programs10%12%21%32%31%39%
Robot tool calls
Moves refusedshare of motion calls, before anything moves5%5%16%9%6%26%
Calls not accepted, by reasonshare of all robot tool calls3%5%10%37%6%19%
Context and length
Input per model callthousand tokens; median over episodes187k95k98k91k106k85k
Model calls per episodemedian5814613688104139
Decisions per episodemedian183140373340
How episodes end
Endingshare of cases45%36%22%17%15%5%

Not accepted:move refusedbad argumentsper-program limitother

Ending:solvedgave upout of budgetended by a failed check

Every model, call by call. The episodes of section 3, each row on one scale for both settings. A decision counts against the episode's budget and an acting turn moved the robot; a refused move was turned down by the planner, and an episode runs out of budget on decisions, model calls, six hours or the context window.