GPT-6 Astra Robot Agents with 14% Higher Success Rate but 65% Fewer Tokens

PyRUA-Lean, a robot-agent framework that replaces per-step tool calling with generated Python cells, raised task success to 71.7% from 63.1% while cutting input tokens 65% (276k vs 788k), LLM calls 49% (8.7 vs 17.0) and cost 2.2x ($0.74 vs $1.63 per solved episode) on 700 simulated task instances from LIBERO-PRO, RoboTwin 2.0 and RoboCasa365, according to the reported benchmark. The framework keeps the same vision-language model, robot primitives and VLA policies, giving the agent one python(code) tool and a robo object whose methods are those primitives, so a single cell chains steps, checks results and retries locally. In a recorded placement example, one PyRUA-Lean cell written by GPT-6 Astra replaced four baseline LLM calls for placing a bowl on a plate.

PyRUA-Lean matches or exceeds tool calling’s success rate on each sub-suite and costs less on every benchmark. a Success rate on all 700 instances, tagged by task property semantic: perturbed layouts, objects, goals ; RoboTwin 2.0 split by skill from task names. b, c Input tokens and GPT-6 Astra list-price dollars per solved episode, on instances both agents solved; Avg: mean over all of them. RC365: RoboCasa365. Same planner, same primitives: code instead of tool calls Success rate 71.7%vs 63.1% with tool calling Input tokens 65% fewer276k vs 788k per solved episode LLM calls 49% fewer8.7 vs 17.0 per solved episode Cost 2.2× cheaper$0.74 vs $1.63 per solved episode 700 simulated task instances from LIBERO-PRO, RoboTwin 2.0 and RoboCasa365; tokens, calls and cost on the instances both agents solved. Stop paying one LLM call per step A robot agent built on a vision-language model usually acts through tool calling. The model picks one tool, such as move to or release; the robot runs it; the result comes back, with three camera images after every motion; and the model is called again with everything so far. Every small step costs a full LLM call, and every call reads the growing conversation again, images included. PyRUA-Lean Python for Lean Robot-Use Agents keeps the model, the robot primitives and the VLA policies, and changes only how the agent acts. The agent gets one tool, python code , and a robot object robo whose methods are those same primitives. In one LLM call it writes a cell: a few lines of Python that chain several steps, check each result, retry when a policy falls short, and compute what no tool returns. The cell runs on the robot; the agent then sees only what the cell printed and the camera images it asked for. PyRUA-Lean combines primitive composition with selective feedback. a The tool-calling agent invokes robot primitives through tool calls. Operations that depend on preceding results generally require another VLM turn, and motion calls automatically return images and state. b PyRUA-Lean instead generates Python cells that compose robot primitives with helper functions, conditional checks, and local retries. Intermediate execution stays within the runtime, while explicitly requested images and state messages are recorded and returned at cell end for replanning. c A recorded placement example illustrates both mechanisms: one PyRUA-Lean cell replaces baseline steps 14–17, reducing four LLM turns to one. One cell instead of four LLM calls This is the cell of panel c , exactly as GPT-6 Astra wrote it while placing a bowl on a plate. Tool calling needed four LLM calls for the same step: two to locate the bowl and sample its base, one to lower it and one to release it, and each move returned three camera images. The cell measures the bowl's bottom in the point cloud, lowers it to the right height, releases it only if the move arrived, and asks for an image only if the task is still not done. The three comment lines are ours; plate was found by an earlier cell. compose: compute a placement target from the scene geometry held at plate = robo.segment point= 314, 795 print 'bowl above plate', held at plate assert held at plate.found correction = np.array plate.world xyz :2 - np.array held at plate.world xyz :2 place xy = np.array robo.state .eef pos :2 + correction surface map = robo.world map bowl patch = surface map 290:365, 740:850 bowl heights = bowl patch :,:,2 bowl heights = bowl heights bowl heights 1.04 & bowl heights<1.17 bottom z = float np.quantile bowl heights, 0.02 placement z = plate.world xyz 2 + robo.state .eef pos 2 - bottom z + 0.007 print 'correction', correction, 'bottom', bottom z, 'placement z', placement z assert np.linalg.norm correction <0.07 and 0.95<placement z<1.05 compose: lower, check, and release within the cell lower = robo.move to place xy, placement z , gripper=+1, step clip=0.012, tol=0.005, max steps=100 print 'lower', lower if lower.reached and not robo.done: print 'release', robo.release print 'done', robo.done select: ask for an image only if the task is unfinished if not robo.done: robo.show 'agentview' It printed five lines and asked for no image: the bowl was on the plate and the task was done. One task, two agents The whole episode behind that example, run once with each agent on the same LIBERO-PRO task instance: “Pick the akita black bowl on the stove and place it on the plate”. Step through it one LLM call at a time: each square is one call, a filled square brought camera images back, and the outlined square solved the task. Turn on JavaScript to step through the two episodes. What the agent writes We read the code agent's cells on every benchmark, in solved and failed episodes, and counted what they do over all 11,145 cells of the 700 episodes. Four kinds of cells keep coming back, and none of them fits in one tool call. Each example is a real cell, exactly as the model wrote it. Guarded chains 19% of cells · 45% on LIBERO-PRO Several primitives in a row, each run only if the one before worked: move above the bowl, grasp with the VLA policy only if the move arrived and the task is not done, and look only if it is still not done. With tool calling, each link of the chain is an LLM call. assert bowl.found and plate.found bowl xy = np.array bowl.world xyz :2 plate xyz = np.array plate.world xyz table z = robo.back project 837,660 .world xyz 2 prepose = float bowl xy 0 ,float bowl xy 1 ,table z+0.22 approach = robo.move to prepose,gripper=robo.OPEN print 'APPROACH',approach if approach.reached and not robo.done: picked = robo.pi0 pick 'pick up the black bowl between the plate and the ramekin', max chunks=20 print 'PICK',picked print 'STATE',robo.state if not robo.done: robo.show 'agentview' robo.show 'wrist' Cell 2 · LIBERO-PRO, spatial swap, task 0, seed 0 Retries 8% of cells · 18% on RoboCasa365 atomic Where a VLA policy may stop short of the goal, the cell runs it again until the task reports success. With tool calling, every retry is a round trip that brings back three camera images. The cell reads a camera's image and point cloud as arrays and locates objects itself: a colour mask for a block, the points above a height for its top, their principal axis for its orientation, and from that the yaw of the grasp. A tool-calling agent gets only what its tools compute. mask=red& rows<92 & cols 98 & cols<165 & world ...,2 0.745 points=world mask upper=points points :,2 0.794 mean xy=np.mean upper :,:2 ,axis=0 eigenvalues,eigenvectors=np.linalg.eigh np.cov upper :,:2 .T long axis=eigenvectors :,1 if long axis 1 <0: long axis=-long axis short axis=np.array long axis 1 ,-long axis 0 projection long=upper :,:2 @long axis projection short=upper :,:2 @short axis block center=long axis np.min projection long +np.max projection long /2 +short axis np.min projection short +np.max projection short /2 print 'flat centre',block center,'long axis',long axis,'extents',np.ptp projection long ,np.ptp projection short left grasp xy=block center+0.045 long axis right grasp xy=block center-0.05 long axis yaw=math.atan2 long axis 1 ,long axis 0 q down=np.array math.cos yaw/2 /math.sqrt 2 ,-math.sin yaw/2 /math.sqrt 2 ,math.cos yaw/2 /math.sqrt 2 ,math.sin yaw/2 /math.sqrt 2 print 'grasp',left grasp xy,'receive',right grasp xy,'quat',q down safe=np.array robo.state .left.eef pos ;safe 2 =1.03 if checked move 'left',safe,quat=robo.state .left.eef quat,substeps=20 : waypoint=np.array left grasp xy 0 ,0.015,1.03 if checked move 'left',waypoint,quat=q down,substeps=25 : print robo.move to 'left', left grasp xy 0 ,left grasp xy 1 ,0.97 ,quat=q down,substeps=25 print robo.state .left robo.show 'head' Cell 5 · RoboTwin 2.0 without the VLA policy, handover block, seed 100003. checked move is a helper the agent defined in an earlier cell. Skills of its own 2% of cells define a helper · 7% reuse one The agent writes a descent that moves down in 8 mm steps and stops as soon as a step does not reach its target, stops going down, or drifts sideways, and reuses it in its next cell. Helpers like this are how it grasps without a VLA policy. python def lower guarded arm name, target tcp z : initial=robo.state .arm arm name target=np.array initial.eef pos final eef z=target tcp z-0.12 initial.approach 2 while target 2 final eef z+0.001 and not robo.done: before=robo.state .arm arm name target 2 =max final eef z,target 2 -0.008 result=robo.move to arm name,target,substeps=8 after=robo.state .arm arm name print 'descent',result.reached,tuple round v,4 for v in after.tcp pos if result.terminated or not result.planned or not result.reached or after.eef pos 2 =before.eef pos 2 -0.001 or np.linalg.norm np.array after.eef pos :2 -target :2 0.01: print 'stop',result break lower guarded 'right',0.800 robo.show 'right wrist' robo.show 'head' Cell 7 · RoboTwin 2.0, place object stand, seed 100002 It also chooses when to look: 84% of cells ask for a camera image, and 20% look only if the task is not yet done. When things go wrong Code helps most after a setback. PyRUA-Lean alone solved 96 task instances; tool calling alone solved 36. In most of the instances only code solved, both agents met the same setback, most often a VLA grasp that missed or an object that fell. Tool calling then asked the policy again, or stopped; the code agent closed the gripper itself, scripted the recovery from the same primitives, and checked each step. Two of them: The dropped moka pot LIBERO-PRO · “turn on the stove and put the moka pot on it” Both agents turned the stove on and dropped the pot. Tool calling asked the VLA policy to grasp the fallen pot four times and ended the episode. The code agent grasped it itself, fitted a plane to the points of its lid to find how it leans, turned it upright, and set its base, not the gripper, over the burner. Tool calling RPent gives up at LLM call 32PyRUA-Leansolved at LLM call 33 Simulator recordings at 10× speed. Top: the recorded camera views after the LLM calls named. Bottom: the code agent's cells, excerpts exactly as the model wrote them; “...” marks lines left out. The plane fit in call 23 raised an error NumPy's linear algebra refuses half-precision arrays ; call 24 cast the points and ran it again. The cabinet door, pulled along its arc RoboCasa365 atomic · “Open the cabinet door.” Both agents located the door's hinge. Tool calling pulled the handle a few centimeters per LLM call and was still pulling when its 40 calls ran out. The code agent took the hinge as the centre of the circle through three positions of the handle, two of which it copied from earlier outputs, and pulled along that arc in one cell, stopping if a move fell short or the grip slipped. The door opened, and a VLA call in call 34 completed the task. Tool calling RPent still pulling when its 40 LLM calls ran outPyRUA-Leansolved at LLM call 34 Simulator recordings at 15× speed. Top: the recorded camera views; bottom: the code agent's cells, excerpts exactly as the model wrote them. Results More tasks solved. Across 700 task instances, PyRUA-Lean raises the success rate from 63.1% to 71.7%, an improvement of 8.6 percentage points, or about 14% relative. It gains on every benchmark: 11.0 points on LIBERO-PRO, 9.2 on RoboTwin 2.0, 7.8 on RoboCasa365 atomic tasks and 5.0 on composite tasks. Fewer calls and tokens for the same tasks. On the instances both agents solved, PyRUA-Lean reduces mean LLM calls from 17.0 to 8.7 and input tokens from 788k to 276k, reductions of 49% and 65%. At list prices, an episode costs $0.74 instead of $1.63; the saving in dollars is smaller than in tokens, in part because caching discounts the history that tool calling sends again and again. The same success for a fraction of the tokens. Cut every recorded episode at a token budget and count what is solved by then: on LIBERO-PRO, PyRUA-Lean reaches tool calling's final success rate with 564k tokens per episode, tool calling with 3.18M. Success rate if every episode were stopped once its token consumption reached the budget on the horizontal axis. Dashed lines mark the budget at which each agent first reaches tool calling’s final success rate, with its value on the axis; the large number is their ratio. RC365: RoboCasa365. Mostly from calling the model less often. The token ratio splits into the ratio of LLM calls and the ratio of input tokens per call. On LIBERO-PRO, the 4.48× token ratio comprises 2.55× fewer calls and 1.76× fewer tokens per call. On RoboCasa365 atomic tasks, PyRUA-Lean's calls are larger on average, yet fewer calls still reduce the total. Also without VLA policies or guides. Removing the VLA policies, the operating guides or both from both agents, PyRUA-Lean keeps the higher success rate and the lower token use. Without VLA policies it reaches 68.8% on RoboTwin 2.0 against 42.8% for tool calling, composing classical primitives into approach, gripper control and state checks. More episodes solved with code Nine episodes per benchmark. Pick one to see every cell the agent wrote in it, and what each cell printed. Put the bowl on the top of the drawer Code · 5 cellsPick the akita black bowl on the ramekin and place it on the plate Code · 5 cells2×put both the cream cheese box and the butter in the basket Code · 9 cellsPick the ketchup and place it in the basket Code · 4 cellsOpen the top layer of the drawer and put the bowl inside Code · 6 cells3×Put the wine bottle on the rack Code · 8 cells2×Pick the akita black bowl in the top layer of the wooden cabinet and place it on the plate Code · 8 cells4×put the black bowl in the bottom drawer of the cabinet and close it Code · 14 cellsPick the alphabet soup and place it in the basket Code · 5 cells Open the laptop Code · 2 cellsPlace the empty cup Code · 2 cellsRotate the QR code Code · 2 cells2×Rank the blocks in RGB order Code · 7 cellsPress the stapler Code · 7 cellsHand the block from one arm to the other Code · 5 cells2×Stack three bowls Code · 7 cells2×Beat the block with the hammer Code · 7 cellsOpen the microwave Code · 5 cells Close the toaster oven door Code · 1 cellTurn on the sink faucet Code · 1 cell6×Turn on the microwave Code · 6 cells7×Move an item from the drawer to the counter Code · 8 cells4×Close the fridge Code · 4 cellsOpen the drawer Code · 1 cell2×Move an item from the counter to the stove Code · 2 cells14×Turn off the stove Code · 10 cellsNavigate the kitchen Code · 1 cell 3×Stack bowls in the cabinet Code · 1 cell4×Wash the lettuce Code · 2 cells7×Load the dishwasher Code · 6 cells3×Rinse the sink basin Code · 6 cells6×Select the cutting tool Code · 7 cells10×Portion the hot dogs Code · 13 cells12×Reheat the waffle Code · 10 cells8×Scrub the cutting board Code · 13 cells10×Pack identical lunches Code · 6 cells Simulator recordings of PyRUA-Lean episodes from the main comparison; long episodes sped up as marked. How we compared LIBERO-PRO 40 tasks × 5 seeds = 200 instances Tabletop tasks from its four perturbed suites. Franka arm; VLA policy π0.5. RoboTwin 2.0 50 tasks × 5 seeds = 250 instances Dual-arm tasks with randomized scenes. VLA policy LingBot-VLA. Kitchen tasks for a mobile manipulator. VLA policy RLDX-1. Both agents use GPT-6 Astra at high reasoning effort through the Codex CLI, with the same robot stacks, primitive implementations and VLA policies, and SAM 3 for segmentation. Each task instance runs once with each agent, under a budget of 40 LLM calls per episode 100 on the composite tasks , and each benchmark's own success check decides the outcome. The tool-calling baseline is RPent, whose robot stacks PyRUA-Lean builds on. Try it PyRUA-Lean drives the robot stacks of RPent. Install it into the Python environment of an RPent robot stack; the README covers the three robot stacks and a full episode.