Zero-real Agent Policy (ZAP)

Frontier-style reasoning at the cost of a VLA

A robot policy has to do two hard things at once: understand what it is being asked to do in a scene it may never have seen, and turn that understanding into precise physical motion. Today's approaches tend to be good at one of these and pay for it in the other. The current landscape of robot policy models broadly falls into three groups:

1. Dedicated models that directly output robot actions (vision-language-action models, or VLAs, and world-action models, or WAMs) [1, 2, 3, 4]. These have shown promising results, but they have real downsides. Most notably, because diverse action data is scarce, they often generalize poorly to different prompt, task, scene and goal distributions. Additionally, teaching them a new task usually means collecting new demonstrations and training again.
2. Code that directly drives the robot (Code-as-a-Policy) [5, 6]. This runs quickly and reliably when the situations it will face can be anticipated when the program is written, but it struggles to handle cases outside that script, such as an unexpected failure, an unfamiliar object or an ambiguous instruction. Adapting to a new task or scene means rewriting the program.
3. Large frontier LLMs controlling the robot through tools and a harness (Large Agent-as-a-Policy) [7, 8, 9]. These inherit all the generalization, understanding and reasoning capabilities of LLMs. However, trillion-parameter models are slow and cost dollars for a task that smaller policy models, when they can do it, do in seconds and for pennies.

We propose Zero-real Agent Policy (ZAP): training a smaller LLM exclusively on simulation data, so that it keeps the reasoning and generalization advantages of frontier LLMs at the cost and speed of VLAs and WAMs.

Parity with GPT-6 Astra on real hardware

The real test of a simulation-trained policy is what happens when it meets real cameras, real lighting and real objects. We selected 10 tasks of varying complexity from the Robolab-120 task list, none of which the model trained on, and ran 3 trials each. We ran them on our bimanual YAM rig [14], two 6-DoF YAM Ultra arms, each with a parallel-jaw gripper, with the same three cameras as in simulation.

ZAP matches GPT-6 Astra running in the same harness: both succeed on 97% of trials. Both clearly outperform Astra in the Robocurve harness [8, 15] and MolmoAct2 [1], a prominent public VLA for bimanual YAM arms, as well as the base Qwen 3.6 27B we started from. The base model has the same reasoning and the same harness, but no motion training, and succeeds on only 17% of trials.

New objects, new goals

What we find most exciting is that training only on simulated pick-and-place and stacking tasks carries over to a wide range of harder real-world tasks. The same model handles objects it never saw, goals it was never given, and kinds of manipulation it never practiced.

For example, we ask the agent to place a test tube in a test tube rack. Both objects are new to it, and so is the goal. The agent works out how to pick up the tube, turns the gripper so the tube is vertical, and seats the tube in a hole. This task is particularly challenging because, at the moment of placement, the hole is completely hidden from the agent's cameras.

In this episode the model:

• Turns the tube so it points the right way, cap up.
• Brings the left arm, holding the tube, to the middle of the table, above the rack.
• Brings the right arm over the tube and descends from above, just far enough to grasp the cap but not so low that it hits the left arm.
• Closes the right gripper, then opens the left one.
• Moves the left arm out of the way.
• Lowers the tube into a hole in the rack.

We also ask the model to make the winning move in a chess position. This again requires precise manipulation of an object, in a scene it has never seen: chess pieces are small, light and top-heavy, and tip over easily if grasped badly. It also requires reasoning about the rules and strategy of chess itself, to find the one move that delivers checkmate.

None of these objects, scenes or goals appear in training, and neither does drawing, a mid-air handoff or board-game reasoning. The agent brings its understanding of the world from its own pre- and post-training; simulation only had to teach it how to move the robot. That combination is what lets simple simulated tasks translate into this range of real-world behavior.

Robolab-120 on the bimanual YAM

We also evaluate in simulation, on Robolab-120 adapted to our bimanual YAM arms. None of its 120 tasks are in our training set. Fine-tuning on mined traces raises success from the base model's 8% to 58%, and RL raises it to 74%, above both GPT-6 Astra and Opus 5.5.

With the same harness, the base Qwen model fails on almost every task. Looking at its thinking, it clearly understands the scene and the goal. What it lacks is the ability to move the robot: it picks the wrong grasp orientation and height, approaches objects badly, and struggles to turn 3D perception into motion commands. Training adds exactly this missing skill.

A new robot for free

We then take the same checkpoint, trained only on two YAM arms, and run it on a single-arm Franka. From the agent's point of view, only the system prompt describing the robot changes; the harness stays exactly the same. The Franka differs from the YAM in most of the ways that matter to a policy that outputs joint angles or action chunks: one arm instead of two, seven joints instead of six, a different gripper, different reach and different cameras.

Our model is unaffected by these differences, because it commands end-effector poses and the harness handles the joints. On Robolab-120 it reaches 56%, ahead of Lakeside and FLUX 3 Action [18], the leading VLA and WAM policies on the current leaderboard [19]. What the model learned in simulation is not a mapping tied to the YAM arms, but how to move a gripper through space to get an object where it needs to go.

The model acts only through tools

ZAP acts only through tools. It sees camera images and the robot's measured state, then commands absolute end-effector poses and gripper openings. A motion controller turns each pose into joint commands and reports back. Everything robot-specific (joints, cameras, workspace limits) lives in a declarative description, so the same harness runs on the simulated YAM, the real YAM and a Franka it never trained on.

The harness has five tools. There are no grasp macros or approach primitives. In earlier versions, such macros raised success on the objects they were designed around but got in the way on everything else.

The harness above works very well with frontier models like GPT-6 Astra. But it demands knowing how to translate physical-world understanding into actual motion control, which is difficult for off-the-shelf smaller models. On our real rig, base Qwen 3.6 27B succeeded on only 17% of trials. Below we describe how we closed that gap. We never introduce any real-world action or teleoperation data; all learning is performed in simulation.

We found it crucial that completing the task is rewarded far more than any intermediate step. Otherwise the model can settle for reliably collecting partial credit instead of finishing. Credit is judged on the final state of the scene, and multi-object tasks scale each object's reward so the total stays in the same range as a single-object task. The success checker is hardened against reward hacking, for example by requiring that the goal hold for at least half a second.

Where it still slips

The model is not perfect on these new tasks, and its failures are informative. Below are two examples where it gets most of a task right but fails on one part of it.

In the second, the model must sort fruit into bins by color: orange on the left, yellow in the middle, red on the right. It reasons correctly about color, location and manipulation, and moves most of the fruit to the right place. However, it misses the last remaining red fruit in the left bin, possibly because of the bin's shadow.

Several choices in this report came from trying the obvious thing first. These are the ones we would most want to know about if we were starting again.

• Grasp macros. Relative moves and approach primitives raised the floor but capped the ceiling. We removed them and let the model plan each phase.
• Euler angles and quaternions. Side grasps sit near the Euler singularity, so small errors looked large. Slot yaw, tilt and tilt direction fixed this.
• Binary reward. On tasks with no successes, pass/fail gives no signal. The dense reward ladder does.
• Overhead depth on the real rig. In the real world, depth from the height of the overhead camera is often not accurate enough, and the policy would falsely rely on these perception coordinates. We found that simply turning off overhead depth allowed the policy to focus on the wrist-camera perception measurements. Surprisingly, the policy had no issue adjusting to this, even though in simulation it had reliable depth from all three cameras.

A model trained only on simple simulated pick-and-place tasks carries over to harder real-world manipulation and reasoning tasks it never saw. The recipe is straightforward: a base VLM already brings reasoning and world understanding, so training only has to teach it how to move a robot.

@misc{pikus2026zap,
  title  = {Pretraining Knows What, Simulation Teaches How: Compositional Generalization in a Sim-Trained Robot Agent},
  author = {Pikus, Benjamin and Saunders, Daniel and Mironenco, Mircea and
            Mohammadi, Salman and Mathew, Mathew and Zhu, Sirou and Makkar, Divya and
            Huang, Xuhua and Li, Qinbo and Narasimhaswamy, Supreeth and
            Cen, Siyuan and Xu, Dejia and Buch, Shyamal and Neff, Thomas},
  year   = {2026},
  eprint = {2610.35817},
  archivePrefix = {arXiv},
  note   = {Luma AI}
}