Daily AI Paper

Imagine a robot that can both understand what you want and physically carry it out. That sounds obvious, but in practice those are two very different problems. One is semantic reasoning: figuring out the task from language, scene context, and maybe a messy real-world setup. The other is motor control: turning that understanding into precise arm and gripper movements that actually work on hardware. Most robot systems are good at one side or the other, and the gap between them is where a lot of failures happen. This paper is about closing that gap without using any real robot training data. The authors introduce Zero-real Agent Policy, or ZAP, a recipe for taking a pretrained vision-language model and teaching it to control a robot entirely in simulation. The key idea is simple but powerful: let pretraining supply the “what,” meaning world understanding and reasoning, and let simulation teach the “how,” meaning motion control. At test time, the same model is then used on real hardware, on new goals, new objects, and even a new robot embodiment. To understand why this matters, it helps to look at the current landscape. One major family of robot policies are end-to-end vision-language-action models, or VLAs, and related world-action models. These are trained directly on robot action data, so they can learn both language understanding and motion in one network. The drawback is that robot action data is expensive and limited, so these models often stay tied to the training distribution. They may understand the instruction in a broad sense, but fail when the object changes, the scene is unfamiliar, or the task requires a new combination of skills. A second family is code-based robot control, where a language model writes a program that calls perception and control tools. That can be very effective when the environment is predictable and the program can anticipate the needed steps. But if something unexpected happens, or the instruction is ambiguous, the code can become brittle. And changing tasks often means rewriting the program. A third trend is to use very large frontier language models as robot agents through a tool harness. These models bring strong reasoning and flexibility, but they are not explicitly trained to move a robot, and they are expensive and slow for an actual control loop. So the paper’s motivation is to get the best of both worlds: the reasoning of a pretrained language model, and the motion skill of a robot policy, without paying the data or inference cost of frontier-scale systems. ZAP starts from Qwen 3.6 27B, a pretrained vision-language model. The model already knows a lot about the world, language, and scene reasoning. The authors then teach it how to move a robot in simulation using two stages. First, supervised fine-tuning on successful rollouts. Then reinforcement learning, specifically GRPO, on a set of simulated manipulation tasks. Importantly, neither stage uses real-world robot demonstrations. The only training signal comes from simulation. The architecture is built around a simple tool harness shared between simulation and hardware. ZAP controls two 6-DoF YAM arms with parallel-jaw grippers. Instead of outputting joint angles or prepackaged motion primitives, it commands absolute end-effector poses and gripper openings. The interaction is framed as a conversation. The model first writes a plan and identifies objects to locate from camera views. Then it repeatedly issues tool calls to perceive, plan, and act until the task is done. There are five tools in the harness. Two are for motion: move_to, which sets a full end-effector pose for one or both arms, and set_gripper, which opens or closes the grippers. The other three are for managing the episode: change_query updates what the perception system should look for, update_todo keeps a short plan visible to the model across turns, and done ends the episode. There are no grasp macros, no hardcoded pick-and-place primitives, and no scripted motion chunks. Every approach, grasp, lift, transfer, and release is composed by the model itself through these basic actions. Perception is handled by a background system that uses segmentation and depth. The model names the objects it wants to inspect, the harness segments them in the camera stream, and then combines those masks with calibrated depth cameras to estimate object centroids, height, and principal axes. This happens continuously and asynchronously, so the model can steer perception by changing its query and receive updated annotated views and measurements. Training motion happens entirely in simulation, in Isaac Sim, with simulated YAM arms and calibrated cameras. The authors created 40 simulated tasks that cover everyday manipulation skills: grasping and lifting, single- and multi-object pick and place, stacking, and reorientation. These tasks are intentionally simple and do not require heavy reasoning. That matters because the point is not to teach the model language or abstract planning from scratch. The point is to see whether motion skill learned on simple simulated tasks can combine with pretrained reasoning to solve unseen real tasks. The reinforcement learning stage uses dense rewards rather than just success or failure. That is important because binary reward can be too sparse, especially when the model starts out failing almost everything. Instead, the paper uses a reward ladder that gives partial credit for partial progress. In a pick-and-place task, for example, approaching the object earns some reward, grasping earns more, lifting earns more still, and moving toward the goal adds additional credit. Completing the task gives a much larger reward than partial progress, and there is also a small penalty for taking too many turns. The authors emphasize that final success must dominate partial reward, or the model may learn to settle for halfway solutions. They also harden the success checker against reward hacking. For instance, the goal must hold for at least half a second. And invalid motion proposals, or turns where the model fails to make a valid tool call, are penalized. The paper notes that these penalties substantially reduce certain error rates compared with earlier runs. Before reinforcement learning, the authors need successful traces for supervised fine-tuning. Rather than relying on a human teacher or a large external model, they mine the model’s own successful rollouts. They begin with a short GRPO warm-up, oversample harder tasks, and collect the successful trajectories that emerge. This is a kind of self-distillation loop: as the policy improves, it generates better examples for itself. For tasks that still never succeed, they add a prefix-tree search over partial episodes. The simulator is reset to the deterministic start state, the stored actions up to a node are replayed, the model context is restored, and then the search samples a continuation. A best-first strategy favors high reward and less-explored nodes, while failing branches are pruned. This finds successful traces for tasks that ordinary sampling could not solve, and those traces are added to the fine-tuning data. So what happens when they evaluate it? In simulation on the bimanual YAM setup, the base model starts very low. Supervised fine-tuning raises success substantially, and reinforcement learning raises it further. The authors report that motion learned on the 40 simple simulated tasks transfers to new objects and new tasks in RoboLab-120, and that the base Qwen model, despite understanding the scene and goal in its internal reasoning, lacks the ability to choose the right grasp orientation, approach correctly, and translate 3D perception into motion commands. In other words, the reasoning was already there; the missing piece was actionable motor skill. The real test is hardware. They recreate 10 tasks from the RoboLab-120 task list on a real bimanual robot rig, using the same camera layout as in simulation, and run three trials per task. They compare against GPT-6 Astra in their harness, GPT-6 Astra in a different harness, MolmoAct2, and the base Qwen model. ZAP matches GPT-6 Astra in the same harness. It also clearly outperforms the base model, which has the same reasoning but no motion training. The paper highlights an important contrast with the VLA baseline. MolmoAct2 sometimes follows the meaning of the instruction but still fails on the actual manipulation. That is a subtle but important point: understanding the task is not enough if the robot cannot execute the motion robustly. ZAP’s advantage is that it learns motion as a separate capability while preserving the language and reasoning strengths of the pretrained model. The authors also emphasize efficiency. ZAP runs about three times faster and costs about one-seventeenth as much as GPT-6 Astra in their harness. That matters because a practical robot policy has to be not just capable, but usable in real time. Perhaps the most striking results are the generalization demonstrations. The model handles tasks that were not in its robot training data at all: seating a test tube in a rack, choosing a different hole when prompted, handing a test tube between arms in mid-air, drawing an X on a tic-tac-toe board, and playing chess. These are not just variations of the training tasks; they involve new objects, new goals, new manipulation strategies, and in some cases new kinds of reasoning. The point is not that the model has memorized those behaviors, but that it can compose pretrained understanding with learned motion in novel ways. They also test transfer to a new embodiment: a single-arm Franka robot. Without retraining, ZAP reaches 55.9% on RoboLab-120, outperforming the leading VLA/WAM baseline by 4.9 percentage points. That suggests the learned policy is not overfit to one exact robot body, though the paper is careful to frame this as transfer on a specific benchmark rather than universal embodiment invariance. There are still limitations to keep in mind. The simulated training tasks are deliberately simple, so the paper is not claiming that simulation alone solves all robot manipulation. The dense reward ladder is manually designed, which means the method still depends on task-specific reward shaping. The harness is also carefully engineered, with calibrated cameras, segmentation, depth estimation, validation checks, and a particular action interface. That engineering matters, and it may not be trivial to reproduce in every setting. And although the model generalizes impressively, the paper’s evidence is still centered on the tasks and embodiments they evaluate. The broader takeaway is that a robot agent does not necessarily need to learn everything from robot demonstrations. If you start with a strong pretrained model that already knows how to interpret language and scenes, then simulation can teach the missing motor control skill surprisingly well. ZAP shows that a smallish off-the-shelf vision-language model can become a capable robot policy through a minimal tool harness, self-generated training traces, and reinforcement learning in simulation. The result is a system that is more flexible than a fixed skill library, more specialized than a frontier generalist, and, at least on these benchmarks, strong enough to transfer to real robots and new embodiments without ever seeing real robot training data.