Skip to content
Artwork for RoboPapers
TechnologyScience

RoboPapers

Chris Paxton and Michael Cho

Chris Paxton & Michael Cho geek out over robotic papers with paper authors.

robopapers.substack.com
Play
  • 20 episodes
  • Avg 56 min
  • English
  • Friday · 39 min

    Ep#113: MolmoBOT: Large-Scale Simulation Enables Zero-Shot Manipulation

    Using simulation to teach robots would unblock the massive scale of robotics data that seems to be missing right now. The issue is usually sim-to-real transfer; MolmoBOT aims to solve this with sufficient diversity of simulation data, so that no real data is necessary for robot deployment. It has a few parts: MolmoBot-Engine produces diverse pick-and-place demonstrations across many different simulated environments; MolmoBot-Data is a dataset of 1.7 million expert trajectories for item manipulation and pick-and-place tasks; and they train a number of VLA policies which can achieve strong performance on real-world pick-and-place tasks with zero real robot data. Rose Hendrix, Snehal Jauhri, Abhay Deshpande, and Maya Guru join us to give us the details. To learn more, watch RoboPapers episode 113 with Chris Paxton and Ruijie He! Abstract A prevailing view in robot learning is that simulation alone is not enough; effective sim-to-real transfer is widely believed to require at least some real-world data collection or task-specific fine-tuning to bridge the gap between simulated and physical environments. We challenge that assumption. With sufficiently large-scale and diverse simulated synthetic training data, we show that zero-shot transfer to the real world is not only possible, but effective for both static and mobile manipulation. We introduce MolmoBot-Engine, a fully open-source pipeline for procedural data generation across robots, tasks, and diverse simulated environments in MolmoSpaces. With it, we release MolmoBot-Data, a dataset of 1.7 million expert trajectories for articulated object manipulation and pick-and-place tasks. We train three policy classes: MolmoBot (a Molmo2-based VLM with a flow-matching action head), MolmoBot-Pi0 (replicating the π₀ architecture for controlled comparison), and MolmoBot-SPOC (a lightweight policy for edge deployment). Without any real-world fine-tuning, our policies achieve zero-shot transfer to unseen objects and environments, reaching 79.2% success rate on real-world tabletop pick-and-place, outperforming π₀.₅ at 39.2%. Learn More Project Page: https://allenai.github.io/MolmoBot/ ArXiV PDF: https://arxiv.org/pdf/2603.16861 Transcript Produced by ChatGPT and Riverside. Introducing MolmoBot Chris Paxton: Hey everybody, and welcome to another episode of RoboPapers. Today we’re excited to have the team behind the MolmoBot paper here to talk about their work. Would you like to introduce yourselves? Rose Hendrix: I’m Rose Hendrix. Until recently, I was a research scientist at AI2, and now I’m at a startup. Abhay Deshpande: I’m Abhay Deshpande. I conducted this work while I was a predoctoral researcher at AI2, and now I’m a PhD student at Princeton University. Maya Guru: I’m Maya Guru. I’m currently a predoctoral researcher at AI2, and I’m looking for PhD positions for this fall. Chris Paxton: Awesome. Would you like to get started and tell us a little about what you’ve been working on? Rose, maybe you can share your screen? Abhay Deshpande: I’ll pull it up. Rose Hendrix: Thanks, Abhay. On a previous episode of RoboPapers, the MolmoSpaces team came on to talk about their work, which is closely related to this. MolmoSpaces is about scaling synthetic environments and evaluation. MolmoBot is about cashing out that potential: scaling synthetic data generation, then training policies on that data to achieve zero-shot sim-to-real transfer for manipulation. MolmoBot is a data engine and a family of policies. We show that the policies transfer in large-scale simulation evaluations and in the real world, both for tabletop pick-and-place and for mobile manipulation on the RB-Y1 platform. That includes opening doors, drawers, and cabinets, as well as object manipulation and pick-and-place. Generating synthetic robot data at scale Abhay Deshpande: As Rose mentioned, we have this large framework, MolmoSpaces, for synthetic data and large-scale simulation. Within that, we built MolmoBot-Engine, a data engine for generating extremely diverse, large-scale datasets. The basic idea is to roll out heuristic demonstrators in these environments, then apply very aggressive randomization: camera extrinsics and intrinsics, textures, lighting, colors, and all sorts of other things. You keep rolling that out and scaling with compute, and you get high-throughput, large-scale data. For a concrete example, you sample an arbitrary scene from MolmoSpaces. There are more than 100,000 scenes available. Then you sample a workspace, choose an object for a pick-and-place operation, place a receptacle for the object, and put the robot in the workspace. From there, we randomize lighting, the robot’s initial configuration, inertial and frictional parameters, and other aspects of the scene. Then we roll out a scripted demonstrator. Since we have access to privileged information in simulation, a fairly simple heuristic policy can perform well under a wide variety of conditions. Of course, there are so many things we could randomize: textures, lighting, robot configurations, camera poses, task instructions, templates, and much more. How do we decide which ones matter? What we found is that a good philosophy is basically: yes. If you can randomize it, you generally should. That extreme diversity goes a long way toward making policies robust in the real world. We generate several different modalities. By default, we have two external cameras and a wrist camera. Since we’re using the DROID setup, we replicate those cameras in simulation: ZED 2 cameras for the external views and a ZED Mini for the wrist camera. We also have a randomized GoPro view. The GoPro has a very wide field of view and significant fisheye distortion. We apply post-processing to warp the rectified image so it looks like what the real GoPro would produce. In addition to RGB and depth, we save the camera intrinsics, since we’re randomizing them. We also save task-relevant object keypoints, which lets us compute visibility heuristics or do image-space reasoning downstream. For actions, we save all of the action representations rather than prescribing just one. That way, people using MolmoBot-Data can support a wide variety of downstream applications. We also save proprioception, joint positions and velocities, end-effector poses and twists, and other task-relevant privileged state: the demonstrator’s current phase, contact forces and points, grasps, door states, and so on. Finally, we label everything with rewards, success indicators, scene metadata, task prompts, and language referring expressions. Chris Paxton: One question: all these grasps and door states you’re talking about—where do those come from? Are those heuristics? Abhay Deshpande: Generally, they’re derived from the scripted heuristics or read directly from simulation. A door state might just be a joint angle, which we can access directly. The same goes for contact points and forces. Others, like rewards and success, are based on predicates: conditions that need to evaluate to true for us to say the task succeeded. Rose Hendrix: This was also motivated by the fact that knowing what the demonstrator is trying to do can be a useful training signal. That’s a strength of synthetic data. If you’re collecting human teleoperation demonstrations, it isn’t necessarily possible to extract that kind of nuanced information about what the operator intended at any given moment. RJ He: Was all the data scripted, or were there other sources? Abhay Deshpande: It was all scripted. We found that fairly simple heuristic policies go a long way. We have around 1.7 million demonstrations, and they’re all generated with scripted policies. By randomizing enough dimensions, you get surprisingly far. You can see in the data distribution that the scripted motions sometimes look a bit robotic—which, of course, is fitting for a robot. But we didn’t encounter major downstream problems, and the policies performed well in the real world. It might become more of an issue when co-training with datasets that have different action distributions. There is interesting ongoing work on making synthetic data match human action distributions, but that wasn’t something we focused on here. Rose Hendrix: And just to be clear: all of our policies are trained strictly on synthetic data. There’s no human data, teleoperation data, or real-world robot data involved in their training. Abhay Deshpande: Altogether, we have 1.7 million demonstrations across more than 94,000 environments, 11,000 object assets, and 9,000 receptacles, totaling around 5,700 hours of data. That makes it one of the largest open robotic datasets available, and the nice thing is that you can scale compute to generate it. In terms of hours, that puts us well ahead of datasets like DROID, Open X-Embodiment, and RoboCasa365. Where we really stand out is environment diversity. By building on MolmoSpaces and its indoor environments, we get more than 94,000 unique environments—far more than most other datasets provide. The policy architectures and evaluations Maya Guru: We trained three different model classes. All take visual information and proprioception as inputs: our flagship MolmoBot model, MolmoBot-SPOC, and MolmoBot-Pi0. All three achieve zero-shot transfer to the real world and generalize to new environments, though at different performance levels. For MolmoBot and MolmoBot-SPOC, the inputs include external and wrist cameras for the Franka, or head and wrist cameras for the RB-Y1, along with a language task instruction, proprioception, and optional point conditioning. For example, if we want the robot to open a specific drawer, we can point to that drawer and instruct it to open it. Our flagship MolmoBot architecture uses the Molmo2 vision-language model with an action expert. MolmoBot-SPOC is adapted from previous work and uses a lightweight transformer. One reason to offer that architecture is that it makes reinforcement-learning fine-tuning more accessible. We also trained MolmoBot-Pi0, using the π₀ architecture, from scratch on our synthetic data, without real-robot data. That serves as a comparison to isolate the value of our data. We know the architecture works with real-world training data, so how far can it get with only our synthetic dataset? For real-world evaluation, we prioritized different environments and a range of objects and tasks, including pick-and-place with a Franka robot. MolmoBot outperformed the π₀ baselines, including MolmoBot-Pi0. The results are a strong signal both that our data can transfer to the real world and that the architecture of our flagship VLA matters. We also evaluated against several baselines in simulation using the MolmoSpaces benchmarks. These tasks have been verified using scripted policies, so we know they’re feasible in simulation. MolmoBot outperformed the other VLAs there as well. Rose Hendrix: The modularity of MolmoBot-Engine let us extend the data generation to a range of tasks and validate performance in simulation against state-of-the-art baselines. We included picking, pick-and-place, placing next to another object, and color-conditioned placement. For the color task, for example, we used two otherwise identical receptacles to test whether a policy would follow the instruction for the correct color. Overall, MolmoBot outperformed the baselines in both simulation and the real world. We also ran ablations of different parts of data generation and policy training. We made special pick-only datasets with a maximum budget of 50,000 trajectories and evaluated the resulting policies in simulation and in the real world. For dataset size, the result wasn’t surprising: more data was better. The number of object classes was more interesting. Adding classes helped, but performance was still surprisingly good when we trained on just 25 object classes and evaluated on a mixture of seen and unseen classes. It wasn’t simply the case that the model performed well on seen classes and poorly on unseen ones. The environment ablation was perhaps even more interesting. I think the lesson was that we didn’t go far enough toward removing diversity. Even with only 50 houses, you can have hundreds of visually distinct placements, and the cameras were still randomized. We designed those ablations based on our previous work with mobile policies, and I suspect the result might not hold for mobile policies. That’s something to investigate further. My guess is that fully randomized cameras, together with a powerful visual backbone, are doing a lot of the heavy lifting in these object and environment ablations. We also ablated the action representation. Absolute joint positions and joint deltas performed similarly in simulation, but absolute joint positions transferred better to the real world. There are other ablations in the paper, too, but one reason we wanted to build the engine was to make tightly controlled experiments like these possible. Each point on these curves represents a separately generated, purpose-built dataset. Robustness demonstrations and limitations Rose Hendrix: Snehal, can you talk about the qualitative results? Snehal Jauhri: Sure. Here are a few tabletop demonstrations with the Franka DROID setup. One we’re especially happy with shows Abhay moving a standing desk up and down while the robot performs a task. The policy immediately adapts to the table height because training included so much variation in table heights. It never saw an episode where the table height changed dynamically, but because it saw so many different static heights during training, it adapts as the height changes. Another demonstration shows a dramatic camera-view change. Abhay picks up one of the ZED cameras and changes the angle completely, and again the policy adapts. What’s also interesting is that there are two bowls, one brown and one black. Initially, the policy can see only one of them. It begins moving toward the black bowl with the banana because the brown bowl is out of frame. When the other bowl comes into view, it changes course and moves toward the brown bowl specified in the instruction. We didn’t actually plan that demonstration, if I’m remembering correctly. It was something we noticed during testing. We also have a mobile manipulation demonstration on the RB-Y1, using two wrist cameras and a head camera. It hasn’t seen this exact door in simulation, but the learned behavior transfers: it reaches for the handle and coordinates the motion of its base with the arm as it opens the door. Rose Hendrix: There are some important limitations. First, the tasks are quasi-static and prehensile. That rules out a huge range of things we’d ultimately want robots to do. But our goal was to establish a proof of concept for synthetic data at scale, and then expand toward more complex behaviors. Second, we only handle rigid, non-deformable objects. Plenty of real-world objects we’d like robots to manipulate are deformable. Finally, the policies we trained use only RGB and proprioception. We observed some failure modes that seem pretty clearly attributable to the lack of depth information. We saved depth in the dataset we released; we just didn’t train on it. We expect using it could reduce some of those failures, and that’s worth exploring. Chris Paxton: Did you use stereo RGB, or just monocular views? Rose Hendrix: Not calibrated stereo. We did experiment with multiview policies—two external cameras and a wrist camera, for example—but not a calibrated stereo setup. The big next step is task diversity. We’d especially like to cover non-prehensile manipulation and multifingered dexterity. There’s exciting work at AI2 and elsewhere on training state-based RL policies and then rolling them out as expert demonstrators to generate synthetic data. That’s a promising direction and something Maya is working on now. Simulation itself is also improving. Researchers are developing more efficient ways to simulate deformable objects, for example, and every improvement to simulation can feed back into synthetic data generation. I think force- and tactile-aware policies are particularly interesting for synthetic data. That information can potentially be much more accessible in simulation, and I think it’s clearly part of where the field is going. We’ve open-sourced everything: the data, policies, training code, engine—the whole stack. We’re excited to see what people build on top of it. This was a very large project with a lot of collaborators, so thanks to everyone who contributed. How should simulation and real-world data fit together? Chris Paxton: Thank you for the presentation. I have a few follow-up questions. Let’s start at a high level. Most work in this space, especially on VLAs, is trained predominantly on real-world data. You’re one of the few teams that’s publicly all-in on sim-to-real. How do you feel about that approach in hindsight? What role do you think real-world data and simulation should each play? It’s a very open-ended question. Rose Hendrix: There might be a diversity of opinions on the team. I’ll let Abhay, Maya, and Snehal go first. Abhay Deshpande: I don’t think the two approaches are mutually exclusive. They’re different tools for solving similar problems. Simulation can give you a huge diversity of situations that would be expensive, intractable, or unsafe to collect in the real world. If you want to train on counterfactuals, high-speed interactions, or dangerous situations, you might be able to instrument those in the real world, but simulation could be safer and cheaper. At the same time, real-world data collected on your robot, in your domain, for your task, is probably always going to be the gold standard. You could imagine combining it with synthetic data to get the last mile of generalization, or to push reliability toward the level you really need. Chris Paxton: One follow-up on that. You mentioned dangerous situations as a reason to use simulation, but whenever I see somebody doing something crazy and dangerous with a robot—say, using π₀.₅ to operate a backhoe—it always seems to be in the real world. Why is that? Abhay Deshpande: That’s a great point. Maybe there’s some selection bias. Right now, you might only be able to do that in the real world, because simulating a backhoe could be a huge pain in the ass. So maybe it’s an argument that dangerous tasks should be trained in simulation, not necessarily that they currently are. That’s partly a limitation of what we can simulate. And because so much of the field is pursuing real-world data collection anyway, those demonstrations tend to happen in the real world. Chris Paxton: That makes sense. Maya? Maya Guru: I agree with a lot of Abhay’s points, especially that real-world data can be useful for the last mile or for the tail end of tasks that are difficult to simulate—tasks where building a simulation might be more effort than it’s worth. But simulation gives you broad coverage across a lot of environments, and it’s easy to scale. Rose and I have also talked about how zero-shot sim-to-real transfer is a particularly interesting research problem. How can we get something trained only on simulated data to work in the real world? That’s a different challenge from training on real data in essentially the same distribution as the environment where you intend to deploy it. Snehal Jauhri: There’s this data-pyramid argument. At the bottom of the pyramid is internet data: general knowledge of the world, how things look, and so on. At the top is a relatively small amount of real-world robot data. In the middle is simulation. Simulation isn’t going to be internet-scale, but it can be much larger than real-world robot datasets while still providing useful, in-domain experience. It helps shape the policy toward the behaviors you ultimately want, and then you can use real-world fine-tuning. There will be tasks where you can collect enough real data that you may not need the middle layer. And there will be tasks where direct sim-to-real transfer already works well, like quadruped locomotion, so you might not need much of the top layer. But for a lot of tasks, a mixture of the two will probably work well. Chris Paxton: I’m curious about the middle layer of that pyramid. Which part of the robotics problem do you think is best solved in simulation? Snehal Jauhri: I think policy shaping is a good fit. Consider trying to learn mobile manipulation from scratch entirely in the real world. It’s doable, but quite expensive. Even when collecting real data, we spend a lot of effort teaching relatively simple behaviors. Much of that could happen in simulation. Our results suggest that the basics really should be learned in simulation, as long as you can figure out the domain randomization needed to make them transfer. That’s broadly what we’re doing in this work: pushing domain randomization far enough to get direct real-world transfer. Rose Hendrix: I’ve thought a lot about this, and I have a metaphor. Bear with me for a moment. Think of robot data collection as a food system. You have teleoperation and simulation. Teleoperation is like foraging, and simulation and synthetic data are like agriculture. When you’re foraging, you can find extremely high-quality things—fancy mushrooms and all sorts of things that we don’t know how to grow at scale. They’re highly valued, and it’s well worth your time to collect them. Foraging isn’t going away. But agriculture is the technology that helped unlock human civilization. We learned irrigation and crop rotation, and we kept getting better at it. Agriculture has a technological learning curve. Foraging doesn’t have that same kind of learning curve. I think we’re still very early in synthetic data, but what’s compelling is that it’s something we can improve year after year. Teleoperation, in comparison, can look a little like a vending machine: you put money in, and data comes out. Obviously, people are working very hard on improving teleoperation, and I don’t mean to denigrate that work. But synthetic data is a technology that can compound as we improve the process of producing it. That’s why I think it’s so worth working on. RJ He: Building on that analogy, which dimensions of data still belong in the foraging category? What isn’t easy for simulation to recreate, where you still need teleoperation? And which dimensions have more or less been cracked, so you can exploit the agricultural advantages of simulation at scale? Rose Hendrix: There’s still a lot that simulation isn’t good at. Deformable objects are probably the biggest class of things where the technology isn’t there yet. Also, if you want extremely high reliability—five nines, say—there’s still a role for on-hardware teleoperation and final fine-tuning data. That’s the garnish. But I think most of the food pyramid could potentially be generated rather than collected. Abhay Deshpande: There are so many different axes of diversity. The obvious one is scale: how many episodes or frames you have. But then there’s the diversity of environments, camera positions, camera poses, and so on. I think simulation is particularly good at camera diversity, as we show here. MolmoBot has very strong camera generalization. When you post-train policies on DROID, they tend to fit very closely to those left- and right-shoulder camera views, and performance drops as you move to different camera positions. You don’t see that as much with MolmoBot, because camera randomization is such an easy knob to turn in simulation. A weaker axis is task diversity. Every new task requires implementing a new demonstrator, testing it, tweaking it, and making sure the throughput is good. That demands much more human effort than randomizing camera poses or textures. That’s a real limitation of MolmoBot as released, and it’s something people are working on. In the real world, a teleoperator can often change tasks just by deciding to do something different, on the same robot with the same cameras and environment. That flexibility is a valuable advantage of teleoperation, and it’s something synthetic data needs to catch up on. Chris Paxton: That makes sense. One last question along these lines. Your group previously worked on MolmoAct and MolmoAct 2, which involved a lot of real-world data. Have you thought about combining that work with MolmoBot? Do you think the real-world data or those ideas would add something here? Rose Hendrix: Definitely. One of the main things MolmoAct and MolmoAct 2 explored was reasoning, and almost a kind of test-time scaling. One of the great things about synthetic data is how much additional training signal it can provide for that kind of reasoning. In MolmoAct, there was an entire process for tracking points on objects over time. In simulation, you can get that basically for free: render the segmentation mask and save it. You could also expose the demonstrator phase or the current end-effector goal—what the robot is trying to reach at that moment. There are all sorts of additional signals that could help. I think combining those ideas with synthetic data is a very promising direction. Why does the Molmo2 backbone matter? RJ He: Let’s talk a little more about the architecture. Comparing MolmoBot with your implementation of π₀ on the same data, what do you think made MolmoBot perform so much better? Maya Guru: I think one factor is Molmo2’s ability to reason about space. It’s a strong backbone for the kinds of generalization we’re looking for, such as localizing objects. The MolmoBot-Pi0 comparison also shows the value of our data. We’re taking an architecture that we already know can perform well in the real world, training it with only synthetic data, and showing that it can still transfer. That’s a compelling result about the data itself. But I do think the strength of Molmo2 contributes to the difference in performance between the architectures. Rose Hendrix: MolmoAct 2 and MolmoBot use very similar base architectures, with some minor modifications. And from a close look at MolmoBot-Pi0 versus MolmoBot with the Molmo2 backbone, I think the backbone is probably a significant part of the difference. It’s roughly another billion parameters, and we’re testing generalization, which I suspect is coming in large part from the backbone. Abhay Deshpande: I’d love to understand how much of that generalization comes from the backbone. We’ve seen impressive demonstrations on objects the policy hadn’t seen before. The semantic understanding and referring expressions presumably draw on the VLM’s pretraining. It would be interesting to tease apart how we can best leverage that pretraining. For example, there are training techniques used in models like π₀.₅ where auxiliary objectives help preserve VLM capabilities, and flow-matching losses aren’t backpropagated through the VLM weights in the same way. We didn’t do those things. If you tried to use our fine-tuned backbone for autoregressive text decoding, I’m not sure you’d get anything useful. Yet we still preserve some of that VLM understanding: the robot recognizes objects and referring expressions it never encountered in the synthetic robot data. That might explain a lot of the gap between MolmoBot-Pi0 and MolmoBot. Molmo2 is a newer, larger VLM with stronger representations. Rose Hendrix: To be clear, we don’t have an ablation that conclusively shows the backbone is responsible. That’s our interpretation, not something we’ve isolated experimentally. Future work! Chris Paxton: Could you add enough objects to the synthetic dataset that you no longer needed a pretrained VLM backbone for generalization? You’d think one big advantage of simulation is that you can, at least in principle, throw an enormous number of objects into the training data. Maya Guru: The SPOC results speak to that a little. MolmoBot-SPOC is a lightweight transformer with a text encoder and a vision encoder, but not a VLM backbone. We don’t see the same level of generalization, in either simulation or the real world. It still does reasonable things. On the pick-and-place benchmark, I think its success rate was somewhere in the 50-percent range. So I wouldn’t say these capabilities depend entirely on the VLM backbone. But some of the generalization appears to be closely tied to it. Chris Paxton: But that’s also a smaller architecture, presumably trained with fewer FLOPs. It could be that enough data or diversity in simulation would solve the problem. Do you think there’s a fundamental limitation of the data, or could you train your way out of it? Abhay Deshpande: The controlled experiment would be to randomly initialize the same VLM architecture and then train it on a huge amount of synthetic robot data. That’s probably the only way to settle it. We can’t say conclusively from these comparisons. In principle, if the evaluation distribution is sufficiently similar to the training distribution, you might expect enough robot data to be sufficient. We see something like that with large behavior models that don’t necessarily use a pretrained VLM backbone but still show impressive performance and generalization. Maybe VLMs are a way to bootstrap from the robot data you have, rather than a fundamentally necessary ingredient. Rose Hendrix: I have a caveat. I think we rely on the backbone’s visual understanding to bridge the sim-to-real gap. I’m not sure our transfer would be as good without a powerful visual backbone. In previous projects, we’ve been able to get nice sim-to-real transfer without a language model, but not necessarily without a strong vision model such as SigLIP. Without one, policies can be much more sensitive to rendering differences. So that’s the nuance: enough synthetic diversity may keep a pretrained backbone from collapsing onto a narrow set of objects, while the backbone itself helps with sim-to-real transfer. I suspect we need that visual representation. Again, that’s an opinion; we don’t have the ablation to prove it. Abhay Deshpande: One important training detail is that we froze our visual backbones. As Rose said, pretrained vision representations are really good now. We’ve also seen in work that evaluates real-world-trained policies in simulation that they can behave reasonably well despite the differences in rendering. Those pretrained visual representations are probably doing a lot of the heavy lifting in both directions. Even if you show the model a strangely rendered potato, it still knows it’s a potato. That means we may not need to invest so much effort in perfect photorealism. Scripted demonstrations and action diversity RJ He: It would be interesting to understand exactly which ingredients help bridge the sim-to-real gap, and why these approaches work as well as they do now. On the data side, you focused almost entirely on scripted demonstrations. Do you think you lose anything by relying on scripted data instead of collecting, say, DAgger data or other forms of expert correction? Abhay Deshpande: One limitation of scripted data is that you’re prescribing a particular way to accomplish a task. You have a state machine, and you roll out that state machine. You can randomize things inside it—add action noise, perturb waypoints, randomly choose grasps—but you’re still following basically the same high-level strategy. A human, especially across multiple operators, might complete the same task in completely different ways: different strategies, speeds, or approaches. I don’t think that’s an unsolvable problem. There’s a lot we can do to increase the diversity of our demonstrators, and there’s interesting work on making synthetic demonstrations look more like human demonstrations. Improving the action distributions of scripted demonstrators is a promising research direction. Research directions and closing thoughts Chris Paxton: Any last questions, RJ? Otherwise we can wrap up with our usual final question: is there any recent work you’d like to give a shout-out to? A paper or demo that you thought was particularly cool? Abhay Deshpande: One thing that’s been on everyone’s mind is the impressive ability of frontier AI models to do robotics-related tasks. What does that mean for the field, and how can we use those models in our research? In particular, how can we use them for simulation? That’s something I’ve been thinking about a lot lately. Maya Guru: Similarly, I think we’re all still processing how impressive GPT-6 is. One thing I’m especially interested in is agentic robotics. How can we use these models to help robots acquire new capabilities? How can robots deploy those capabilities in the real world, almost like calling tools? I’m very interested in how that relates to task diversity: learning new tasks, and then being able to invoke them. Snehal Jauhri: I’m interested in scaling this approach further. We used a large number of household environments, but they’re still one particular flavor of household environment. There’s been good work on generating indoor 3D environments using agents and agentic pipelines. Work like SceneSmith, for example, has shown promising results in taking procedural generation much further. What could we do with ten or a hundred times more environments, and more diversity? One of the nice things about simulation is that we can scale the data and investigate scaling laws. I’m very interested in indoor scene generation and where that goes next. Rose Hendrix: I’ll cheat and pick two things. First, in synthetic data and simulation, I’m excited by work coming out of Jeannette Bohg’s lab, including SimToolReal and Play2Perfect. I think dexterous manipulation is where we ultimately need to go, and it’s extraordinarily difficult to teleoperate dexterous hands. You can map motions from humans, but that isn’t exactly the same thing, particularly when you have different kinds of dexterous manipulators: three-fingered hands, tools such as chopsticks, and so on. Teleoperation becomes very challenging. State-based RL gives us a way to explore not just how to imitate human behavior, but how to get superhuman performance from expert demonstrators. If the demonstrators are trained with RL, there’s no reason they couldn’t become better than humans at certain tasks. I think that’s a very exciting direction. Second, I’m interested in what Snehal mentioned: generating scenes much more freely. A major limitation of our current data is how hard it is to generate environments for long-horizon, compositional tasks. Imagine training a robot to respond to, “I just got home; put all my groceries away.” You need a lot of specific assets, arranged in appropriate ways: a refrigerator with multiple compartments, different groceries, storage locations, and so on. It’s difficult to procedurally generate a huge range of coherent scenes that support tasks like that. Agentic scene generation might unlock this. We could build much more varied environments specifically suited for complex, long-horizon tasks. That’s another line of work I’m really excited about. Chris Paxton: We actually already had the SimToolReal team on the podcast, for what it’s worth. But yes, I hope to see a lot more interesting work in agentic robotics. RJ He: One more question. We’ve talked a lot today about deformable objects as a challenge simulation hasn’t cracked. Do you think agentic methods could help solve that, and if so, how? Rose Hendrix: The thing about deformables is that we can simulate them. We’ve all seen animated movies. You can simulate almost anything—it just takes a long time. The problem is efficiency. The simulation can be too slow to use for large-scale data generation, and certainly too slow to learn from efficiently with RL. I think agentic approaches will help in the way they’re helping many other areas: making the development process faster and better. If people focus on this problem and use modern coding tools to improve the simulators, the technology will get better. It’s a rising-tide-lifts-all-boats effect. The problem isn’t that deformable simulation is impossible. It’s that it’s slow, and slow is something we can work on. RJ He: That makes sense. And it fits the larger theme of the discussion: betting on simulation means you can keep reinvesting in better tools, improving the technology and everything you can build on top of it. It’s exciting to see that approach paying off. Chris Paxton: Absolutely. There’s a ton of potential in simulation, and I’m excited to see where this goes. Thank you all for coming on. Rose Hendrix: Thank you so much for having us. Abhay Deshpande: Thanks for having us. Snehal Jauhri: Thank you. Maya Guru: Thanks. Bye! This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit robopapers.substack.com

  • Thursday · 1 hr 2 min

    Ep#112: SlipSense and Touch2Trace

    Touch is crucial for humans when they want to perform precise tasks to a high degree of reliability, and yet robots almost universally use vision — they’re often completely blind to this whole modality. Two works from Tong Jian, Tao Yu, Saleh Nabi, and Matteo Grimaldi show us how important this sense is. In SlipSense, they look at how to detect objects slipping in grippers using a compact multimodal tactile sensor, which generalizes across unseen objects and to different robots. They then talk about how tactile sensing can be used to enable high real-world performance with a challenging cable-tracing task, where a cable must be fed through the hand with a repeated pinch-and-curl motion. To learn more, watch Episode 112 of RoboPapers today, with Michael Cho and Ruijie He! SlipSense Abstract Slip detection is fundamental to dexterous manipulation, yet existing systems often lack precise characterization of detection latency and cross-platform generalization. We present SlipSense, a multimodal tactile slip-detection framework built on TacV5, a compact sensor integrating a 32×32 piezoresistive array operating at 240 Hz and a 3-axis MEMS accelerometer operating at 8 kHz. The piezoresistive array captures spatial pressure distributions, while the accelerometer captures friction-induced vibrations, providing complementary slip cues. The framework performs modality-specific encoding, intra-sensor fusion, and cross-modal attention with causal temporal prediction at 240 Hz. Experiments on a dataset of 1.4 million frames spanning 37 objects demonstrate the complementarity of the two modalities. SlipSense achieves 96.7% Macro F1 with a false-positive rate below 1.6%, detecting 76% of slip events within 23.1 ms. When trained solely on UMI data, SlipSense generalizes zero-shot to a Tesollo dexterous hand, transferring across unseen objects, distinct sensor units, and robotic platforms without retraining. Touch2Trace Abstract Dexterous manipulation of deformable objects demands continuous fingertip-level regulation of pressure, friction, and incipient slip. We study one of the most challenging cases: dexterous cable tracing, feeding a cable through the hand with repeated pinch-and-curl motions of the thumb and index finger. We introduce Touch2Trace, a tactile-driven imitation-learning system for this task, and provide, to our knowledge, the first systematic real-world characterization of how encoder pretraining, control rate, temporal context, and spatial resolution each shape policy performance. The winning learning recipe combines a tactile encoder pretrained for a custom 32 x 32 piezoresistive sensor (TacV5) via self-supervised learning with a lightweight transformer policy trained on teleoperated demonstrations via behavior cloning, deployed at 60 Hz on a Tesollo DG-5F hand. Tactile feedback without vision or explicit cable-state estimation significantly improves tracing performance versus a proprioception-only baseline: from 0.2 cm to 20.1 cm mean distance and 0% to 93% success rate, with zero-shot transfer to unseen cables and routing conditions. The results quantify the influence of key parameters in tactile-driven systems for reliable dexterous deformable object manipulation. Learn More SlipSense Project Page: https://tjian-ai.github.io/corl26-slipsense/ SlipSense on ArXiV: https://arxiv.org/abs/2609.15910 Touch2Trace on Project Page: https://grmmtt.github.io/corl26-touch2trace/ Touch2Trace on ArXiV: https://arxiv.org/abs/2609.15921 Transcript Introduction Michael Cho: Hello, everyone. Welcome to another episode of RoboPapers. Today we’re really happy to have the crew from Analog Devices, the Dexterous AI Group: Tao Yu, Tong Jian, Saleh, and Matteo. They’re coauthors of two papers that they’ll walk us through. One is Touch2Trace: Tactile-Driven Imitation Learning for Dexterous Cable Tracing, and the other is SlipSense: Multimodal Tactile Learning for Low-Latency and Generalized Slip Detection. Thank you so much for coming, guys. Maybe we can start with everyone introducing themselves, and then go through the papers. Tao, do you want to start? Tao Yu: Yeah, great. Thanks. My name is Tao Yu. I lead the DexAI team, short for Dexterous AI Group, at Analog Devices. The team was set up about two years ago, and our mission is to unlock humanoid dexterity. That’s how we started looking into tactile sensing, which we believe is one of the missing pieces in dexterous manipulation. With me are the other team members. Maybe Tom can go next. Tong Jian: Yeah, I’m Tom. I’ve been with the DexAI team for two years, working on applied machine learning and, more recently, robot learning. Saleh: Matteo, do you want to go next? Matteo Grimaldi: Hello, everyone. I’m Matteo. I’ve been working with the DexAI team for two years now, mostly on robot learning. Saleh: And I’m Saleh. I also joined Dexterous AI about two years ago. When I met Tao, we were still prototyping a lot of things on the sensor side. The two works you’ll see today are the result of a lot of interesting internal research, both on the hardware side and on the algorithm side. Tao Yu: I also want to add that I personally believe this isn’t just a hardware problem or an algorithm problem. It’s a combination of both. One question we’ll touch on in these papers is what hardware capabilities can unlock learning, and vice versa: what can learning tell us about the hardware requirements? We believe the path forward is a loop: create new hardware, integrate it with a robot, train a model, demonstrate whether the new hardware capability improves performance, and then use what we’ve learned to design the next generation of hardware. Michael Cho: Very cool. I’m really looking forward to these two papers. Which one do you want to start with? Tong Jian: Maybe we can start with SlipSense. Let me share my screen. Michael Cho: Okay, cool. SlipSense: Detecting Slip Quickly and Reliably Tong Jian: Can you see the screen? Great. We’ll be talking about two works accepted at CoRL 2026, both built on our TacV5 tactile sensor. They demonstrate tasks where vision alone isn’t enough. I’ll begin with SlipSense, and Matteo will follow with Touch2Trace. As the title suggests, SlipSense studies slip detection. When an object starts to slip from a robot gripper or fingers, we want a model that can detect it quickly and reliably. Slip detection has a long history. Researchers have been working on it for decades, and the core problem is well understood. But two things remain relatively underexplored. The first is detection latency. A lot of prior work reports accuracy without really characterizing latency. To emphasize, detection latency is not the same as inference speed. It’s the time between when slip actually begins—the slip onset—and when the model first detects it. That’s the interval between these two lines on the plot. A model might run in two milliseconds, but if it needs 100 milliseconds of evidence to make a correct prediction, that’s still 100 milliseconds of detection latency. By the time the model detects slip, the object may already be gone. That’s why we care so much about detection latency. It depends both on the sensor’s capabilities and on the model’s capabilities. RJ He: Can I jump in here? This might be a naive question, but it sounds like you’re saying that different materials and different objects can actually produce different slip-detection latencies. Is that correct? Tong Jian: Yes. It depends on many things: the material, the object, the actual slip speed, how quickly the sensor can capture the relevant slip features, and how quickly the model can interpret those features and make the correct detection. All of those things matter. There’s not just one dominant factor. RJ He: I see. And my assumption is that this is a learned detector, not just a property of the sensor? Tong Jian: Yes, exactly. It’s learned. And that brings us to another important aspect: detection latency naturally trades off against false alarms. It’s a sensitivity-versus-specificity trade-off. If you want to detect slip faster, you may make more mistakes and trigger more false alarms. Prior work rarely evaluates that trade-off directly, and that’s where we started. Before going into the details, let’s look at some demos. Here, SlipSense is running in real time on UMI parallel-jaw grippers. The orange component on the fingertip in all three videos is our TacV5 sensor. It’s a multimodal tactile sensor developed by our team. It measures normal force using a piezoresistive array, as well as high-frequency vibrations using an accelerometer sampled at 8 kHz. This sensor wasn’t originally designed for slip detection. It’s a general-purpose tactile sensor, but we found that it works very well for this task. In all three videos, you can see the model’s predictions updating live. In the left video, when the operator pulls on the object, SlipSense detects the slip almost immediately. In the middle video, it can also detect rotational slip. Michael Cho: I’m curious: physically, where exactly is the three-axis accelerometer? You have this TacV5 device with a 32-by-32 array of taxels. Is the accelerometer at a particular taxel, or somewhere else? I imagine the position would affect the vibrations it senses. Tao Yu: The module is really like a fingertip. The sensor array is on the surface, but inside there’s a PCB that reads out the sensor, and the accelerometer is on that same PCB. Michael Cho: I see. So somewhere inside the module. Tao Yu: Exactly, and rigidly coupled to the surface. Michael Cho: When you’re measuring vibration, you’re using all three axes of the accelerometer? Tong Jian: Yes. We use X, Y, and Z, and we also try to compensate for gravity and motion-induced acceleration so that we can focus on friction-induced vibrations, which are the slip features we’re interested in. Tao Yu: Just to add some background on why we did this research: a lot of the questions we get when talking about our piezoresistive tactile sensor are about its limitations. One drawback of a piezoresistive array is that it only directly measures normal force. People ask, “How do you measure 3D force? How do you measure shear force?” Magnetic, vision-based, and capacitive tactile sensors can offer those capabilities. My next question is always, “Why do you need shear force?” And often the answer is, “I want to detect slip.” We believed that, with a learning-based model, we could do that without directly measuring shear force. That’s why we built SlipSense: to show that we can reliably detect slip even without shear-force measurements. Tong Jian: To summarize the numbers: with SlipSense and the TacV5 sensor together, we achieve both accurate and fast detection. Seventy-six percent of slip events are detected within about 23 milliseconds. That’s fast enough to support downstream tasks, such as slip prevention. We also show that the model, trained entirely on data collected with the UMI gripper, transfers zero-shot to the Tesollo dexterous hand. There’s no retraining and no fine-tuning required for slip detection on the new platform. Achieving this is really a system-level effort across three pillars: the sensor, the data, and the model. The sensor modalities provide the slip features. Precise labels let us train a supervised model. And the model architecture helps address the latency trade-off and generalization. You need all three pieces. RJ He: Just to make sure I understand: when you say zero-shot transfer, that’s specifically for slip detection, right? You’re not claiming transfer of some broader manipulation capability? Tong Jian: Exactly. Just slip detection. That’s important to clarify. The TacV5 Sensor and Tactile Hardware Tong Jian: We’ve already discussed the sensor a little, but I’ll give some more detail. TacV5 is a compact multimodal tactile sensor that packs multiple sensing modalities into a fingertip. For slip detection, we use two of them: a 32-by-32 piezoresistive array running at 240 Hz, with about 1.55 taxels per square millimeter, and an accelerometer running at 8 kHz. The two modalities respond to slip through different physical mechanisms. The piezoresistive array captures pressure redistribution, while the accelerometer captures friction-induced vibrations. The sensor can be integrated across different platforms. Here it’s on the UMI gripper, and here it is on three fingers of the Tesollo hand. RJ He: Since we’re talking about the sensor, maybe we could take a step back. Some of our audience may not know much about tactile sensing. They know that there are different options—piezoresistive, piezoelectric, capacitive, vision-based, and so on. Could you describe the landscape and explain why you chose piezoresistive sensing? Tao Yu: I don’t think we have a plot ready, but I can talk through it. First, there’s an important distinction between piezoresistive and piezoelectric sensing. The latter can also be used as a vibration sensor. We started with piezoresistive sensing because it has two big advantages. The first is scalability. We can make the sensor very large or very small, and we can make the sensing elements quite dense. In fact, this isn’t the densest array we could make. We could make it much denser, but that introduces other challenges, like how to read out so many taxels. It’s also flexible, so it can conform to different surfaces without too much difficulty. There are downsides, of course: temperature drift, other nonidealities, and the fact that it only measures normal force directly. The second advantage is manufacturability. We’re using an existing kind of reel-to-reel manufacturing process. We’ve developed our own custom version of it, but fundamentally it’s a process that can scale. For those two reasons, we think piezoresistive sensing has a lot of potential for commercialization and widespread adoption. We’re also working on solutions to address some of the limitations of the sensing technology itself. Other popular approaches include vision-based tactile sensing. Sharpa’s recent developments, for example, and the papers around the sensors on their Wave hand have attracted a lot of interest. Vision-based tactile sensing has real advantages, including high resolution and the ability to capture fine-grained features. But those sensors are generally bulkier than ours and more expensive. At this point, it’s hard to say whether the field will converge on one sensing technology, or whether we’ll end up with two or more approaches. It’s a little like autonomous driving, where there are still different camps around sensing. RJ He: Awesome. Thank you, I appreciate that overview. Michael Cho: One last question on that. These two papers involve mounting sensors on robotic grippers or a Tesollo hand. But suppose someone wanted to collect human data, using tactile gloves. Am I right that piezoresistive sensing is particularly well suited to that? I imagine vision-based tactile sensing would be much harder to put into a glove. Tao Yu: Yes, the vision-based systems are bulkier. I really like how flexible the piezoresistive sensor is, and that’s a good point. We’re also working on tactile gloves. That’s one of our important next steps, and hopefully you’ll see some new work in the coming months. By the way, if anyone in the audience is coming to IROS, we’ll be demonstrating the next version of this sensor. It will look nicer than this one, with the bare sensor exposed on the surface. RJ He: This episode probably won’t come out before IROS, unfortunately! Saleh: One thing I’d add is that, beyond the hardware capabilities, piezoresistive sensing has another interesting advantage: ease of simulation. We discussed this recently with a university collaborator. Some other tactile sensing technologies, including magnetic and vision-based ones, give you measurements that aren’t directly force readings. With piezoresistive sensing, the relationship to contact force can make it easier to bridge the gap between simulation and reality. That’s useful if you want to build sim-to-real pipelines. Michael Cho: Do you think that’s because piezoresistive sensing is limited to normal force, so it’s relatively straightforward to simulate? Is that the reason? Saleh: There are efforts to add shear-force simulation as well. You’re right that simulating shear force is an interesting challenge in its own right, but researchers are working on it. I think that’s becoming more tractable. SlipSense: Data Collection, Architecture, and Results Tong Jian: Let’s move on to data collection. This is a supervised learning problem with three labels: no contact, contact without slip, and slip. We can’t use episode-level labels, because the transition to slip can happen so quickly. Instead, we label at the level of individual piezoresistive frames. The sensor runs at 240 Hz, so that’s 240 labels per second. The most important labels are near transitions—especially the transition from contact without slip to slip. Those are the moments we need the model to predict correctly. To generate labels, we use a motorized test stand. There’s a crosshead that moves vertically. The object is clamped at one end, and the other end is held against the sensor. When the crosshead moves, it causes the object to slip across the sensor. We read the crosshead position to identify when motion starts, and use that as the slip-onset label. There’s one constraint here: during data collection, the objects need to be effectively nonstretchable, or else the crosshead motion wouldn’t precisely correspond to slip at the sensor. But this constraint only applies to collecting labeled training data; it isn’t a restriction on the inference model. We collected about 1.4 million frames across 37 objects, including cables, connectors, different materials, and tools. We used 28 objects for training and held out the other nine for testing. The model combines convolutional encoders with attention. Its inputs are the piezoresistive array and the accelerometer, along with a short history of observations. We predict the contact state at the latest piezoresistive frame, because this is a real-time detector. Slip may have happened at some point in the history, but we care about the state right now. The history provides context. We use modality-specific encoders: a convolution-based encoder for the piezoresistive maps, and a spectrogram-based encoder for the accelerometer signal. We first convert the accelerometer data into a log-mel spectrogram, then encode it with an audio-spectrogram-based transformer. We also perform pooling across sensors, which makes the architecture agnostic to how many sensors are present. Whether you have one finger, two fingers, or five, the model can handle the inputs. Then we use cross-attention to let the model learn relationships between spatial pressure and vibration. We compared cross-attention to simpler concatenation and late-fusion approaches and found that cross-attention worked best. Finally, a prediction head produces the frame-level contact label. The whole system runs at 240 Hz. The biggest finding, I think, is that the two modalities are not just useful individually; they’re crucially complementary. Looking at our evaluation results, a piezoresistive-only model gets a macro F1 score of roughly 82%. An accelerometer-only model gets roughly 81%. But when we fuse the two, performance rises to around 95% on that comparison. Why? Their failure modes are different. In this first example, the operator repeatedly grasps and releases an object, without any real slip. The piezoresistive-only model can confuse pressure redistribution during grasping with slip and generate false alarms. The accelerometer-only model is sensitive to vibrations, including vibrations caused by moving the gripper even when there’s no friction-induced sliding at the contact surface. So it can make its own mistakes. When we combine them, the pressure array helps confirm contact, and the accelerometer helps identify relative motion at the surface. The two signals compensate for each other’s failure modes, producing a much more robust prediction. RJ He: I was wondering whether you could do an ablation using just the accelerometer, without the tactile pressure array, to isolate the value of the tactile sensor itself. Tong Jian: Yes, that’s exactly the accelerometer-only row in this table. There’s no piezoresistive input. As you can see, it confuses some of those other vibrations with friction-induced slip and makes mistakes. RJ He: I see. Sorry, I missed that. Michael Cho: I’m curious about the observation history in the architecture. How far back does it look? How many frames do you use? Tong Jian: We did an ablation study on the history length. We varied it from six piezoresistive frames up to 144 frames. To our surprise, performance largely saturates at around 60 frames, or 250 milliseconds. After that, accuracy still improves slightly, but not much. I’d expect that number to depend partly on slip speed. If the slipping happens faster, a shorter observation history may be enough. We also study history length in Touch2Trace, and Matteo will discuss that in more detail. Another interesting finding is how much spatial resolution matters. Our default is a 32-by-32 array, but we also tested lower resolutions: 8-by-8 and 16-by-16. The improvements were almost monotonic, from around 83% at 8-by-8 up to around 96% at 32-by-32 in that experiment. Higher resolution captures finer contact patterns that coarser arrays may miss entirely. We may not have hit the ceiling yet. RJ He: It should eventually taper off, though, right? You can’t get that much closer to 100%. Tong Jian: Probably. RJ He: Could you actually build and test a denser sensor? Tao mentioned that was possible. Tao Yu: It’s totally possible. We just haven’t built one denser than the current version yet. SlipSense: Transfer Across Robots and Sensor Units Tong Jian: The last result I want to share is the transfer from UMI to the Tesollo hand. This is perhaps our most surprising result. We train exclusively on data collected with UMI and then deploy the model on the Tesollo hand, which is a very different platform. Despite that, the model still performs reasonably well and detects slip effectively. The video on the left shows SlipSense running on the Tesollo hand. I think two things make this transfer possible. First, the sensor and model work together to learn signatures of slip at the contact surface: the pressure distribution and the friction-induced vibration. Those signatures are intrinsic to the physics of sliding contact, rather than being tied to a particular robot. But the transfer does introduce noise. For example, the Tesollo hand has direct joint actuation, which changes the contact stiffness and produces different vibration signatures in the accelerometer. Those weren’t present in our UMI training data. We address this with accelerometer augmentation, which turns out to be critical. We have an ablation in the paper: without this augmentation, transfer performance drops significantly. On the right, we’ve also added a simple slip-prevention behavior on top of the detector. When SlipSense detects slip, the fingers squeeze to prevent the object from falling. It’s rule-based, but it works pretty well. To wrap up, SlipSense is a joint effort across sensing, data collection, and learning. We have high-density, high-frequency piezoresistive measurements and accelerometer signals; a system for obtaining precise labels; and a model using cross-modal attention and augmentation. Together, they give us a low-latency, accurate, generalizable slip detector. SlipSense is the first capability we’ve demonstrated with TacV5. Matteo will now talk about Touch2Trace, which uses the same sensor for a downstream dexterous manipulation task learned through imitation learning. Matteo Grimaldi: Thank you. Let me share my screen. Michael Cho: While Matteo sets up, I have one more hardware question. Am I right that TacV5 also has a MEMS microphone? Tao Yu: Yes. It’s actually an overprovisioned design, because we weren’t sure which sensors would be most useful. For vibration, we included an acoustic MEMS microphone, a bone-conduction microphone, and an accelerometer. In this study, we only showed the accelerometer, but we’ve heard about other use cases where people would like to use the acoustic microphone to detect particular events. Michael Cho: That’s really interesting. It might complement the accelerometer because it gives you a different signal and frequency profile. Even with an 8 kHz accelerometer, audio is still a different measurement. Tao Yu: Exactly. RJ He: On that note, we’ve been talking about transfer across robots. How transferable are these models across different types of tactile sensors, or even different sensors within the piezoresistive category? One of the challenges with tactile sensing is that, unlike vision, we haven’t converged on a mature sensing technology that everybody uses for data collection. There’s a chicken-and-egg problem: which sensors should people build datasets around, and how do you reuse data collected with different ones? Does your model architecture help with that transfer? Tong Jian: I can start from the experimental side, and Tao can discuss the sensor side. In SlipSense, our data collection spanned four months, which gives us some experience with drift and aging. The UMI and Tesollo experiments also used different physical TacV5 units. So it’s not just cross-platform transfer; it’s also transfer between sensor units. Performance was still pretty good, so we’re not particularly worried about unit-to-unit variation in these experiments. Tao Yu: I think it’s a very good observation. Even within one sensing technology, we’re still exploring how best to represent the data. Right now, we essentially treat the two-dimensional tactile array like an image, as you can see in the paper. But I’m not convinced that’s the right—or the best—representation. Force has a spatial distribution. If you mount the same sensing technology on different embodiments, like a gripper and a finger, or a larger and smaller finger, their 2D arrays could look the same while representing physically different contacts. We’re still trying to understand how best to account for that. At the end of the day, these sensors are designed to be used by a model. As the technology matures and becomes more widely adopted, I think we’ll understand the representation we want, and then design sensors—using the same or different technologies—to produce data compatible with it. RJ He: That’s interesting. In a previous episode, some researchers working on depth were making the argument that image-like representations are beneficial because you can take advantage of learned visual encoders. It will be interesting to see how that trade-off plays out in tactile sensing. Saleh: One quick comment before we move on: I think the community is increasingly recognizing that there are different tactile sensing technologies, different data formats, and different kinds of information. Recognizing that problem is the first step toward solving it. Hopefully we’ll find ways to unify those representations and make tactile sensing a first-class modality. RJ He: Absolutely. All right, let’s let Matteo get to his presentation. Touch2Trace: Dexterous Cable Tracing Without Vision Matteo Grimaldi: Thank you. We’d now like to talk about another paper from this year: Touch2Trace: Tactile-Driven Imitation Learning for Dexterous Cable Tracing. It’s easiest to start with the video so you can understand the task. Cable tracing is a challenging problem in dexterous manipulation. Here, a robotic hand repeatedly performs pinch-and-curl motions to feed a cable through its fingers. It has to do that over and over again. This is difficult for several reasons. First, a cable is a deformable linear object, so it has complex dynamics. Second, we’re doing the task with a multi-degree-of-freedom robotic hand, which hasn’t been explored as much for this particular problem. And third, we don’t use vision. The policy has access only to tactile sensing and proprioception. You can imagine it as a person trying to trace a cable without looking at it. Our central research question is whether we can learn to perform this task without vision or explicit estimation of the cable’s state. Let’s start with the system. We use a Tesollo DG-5F hand, equipped with our TacV5 sensors on the fingertips. For this work, we control eight degrees of freedom across the first three fingers. We also use MANUS MetaGloves for teleoperation, which I’ll explain in a moment. For evaluation, we use an external rotary encoder to measure how far the cable has been traced. That measurement is completely separate from the policy; the robot isn’t using the encoder as input. Data collection is based on teleoperation. Even when a human operator is controlling the robot, the task is quite difficult. In the video, you can see the operator moving their hands with the MANUS gloves and the robot trying to reproduce those movements. We collected just ten minutes of demonstration data, and from that we trained an imitation-learning policy. The policy observes proprioception and tactile sensing. Proprioception captures the eight controlled degrees of freedom. For tactile sensing, we use the pressure maps from the thumb and index fingertips. Those go through a pretrained tactile encoder. We then combine the encoded tactile information with proprioception and train a policy to predict eight-dimensional joint targets. Here you can see the tactile maps during the three main phases of the motion: opening, pinching, and curling. The activation patterns are different in each phase. As Tong mentioned, each fingertip has a 32-by-32 piezoresistive array. That tactile information, combined with proprioception, is enough to learn cable tracing without vision. The central result is shown in this plot. With tactile sensing and proprioception, the policy traces about 20 centimeters of cable, compared with essentially no progress using proprioception alone. The horizontal axis is time, and the vertical axis is distance traced. The videos make the difference particularly clear. With proprioception alone, the hand has no feedback about where the cable is or how it’s moving. It cannot effectively trace the cable. With tactile sensing, it can perform the repeated pinch-and-curl action and keep the cable moving through its fingers. RJ He: I noticed you have another slide about zero-shot transfer to different cables. What kinds of cables and wires does this model work with? And where does it break? Is the important factor diameter, material, weight, flexibility, or something else? Matteo Grimaldi: That’s a good question. We did study generalization, although of course we only tested a subset of the cables that are out there. We trained on one cable, the USB cable shown on the left, and then tested zero-shot on other cables and configurations. You can see that the tracing distance and success rate change across those conditions. Material makes a difference, particularly how deformable or rigid the cable is. Training on more diverse cables would probably make the policy more robust. But we deliberately trained on just one to see how much transfer we could get, especially with only ten minutes of demonstrations. We also chose a cable that was relatively easy to manipulate during teleoperation. Even teleoperating the task was challenging. So there’s definitely a lot of room to improve this result with more data. Michael Cho: Just to clarify, you didn’t use the accelerometer for this work, right? It’s the tactile pressure maps and proprioception? Matteo Grimaldi: Correct. We only used the tactile array and proprioception. Adding the accelerometer is a possible future extension. RJ He: Going back to the range of cables, even theoretically, where do you expect tactile-only control to break down? For example, a very springy cable might be much more difficult to handle. Matteo Grimaldi: I think a large difference in the required grip force between training and deployment could be a problem. Material and stiffness matter, as does how soft the cable is. Diameter also matters. The diameters in our experiments aren’t dramatically different. If you tried a very thin cable, that could be quite difficult, especially because the Tesollo fingertips are larger than human fingertips. The relationship between the finger size and cable diameter becomes important. Those are limitations of the current study. We’d like to extend the range of conditions, especially with more data. Deformable linear objects have become a popular research area in recent years, and there’s still a lot to explore. Saleh: I want to add some context about why we isolated tactile sensing from vision here. We actually have some results using vision as well, but focusing on tactile-only control gave us a way to understand which properties of tactile sensing matter for policy learning. In many visuotactile manipulation papers, vision is so dominant that adding tactile sensing might take success from, say, 70% to 75%. That’s useful, but it doesn’t necessarily tell you which tactile parameters made the difference. We wanted to study that directly. So we investigated things like the tactile observation history, the sensing and control frequency, and other properties of the tactile input. That gave us a clearer picture of what we need from tactile sensing before combining it with vision. There’s another difference from some previous approaches. A lot of work uses tactile measurements to estimate an object’s pose and then feeds that estimate into model-predictive control or some other model-based controller. Here, we learn end to end, from tactile signals directly to actions. We compared that approach with low-dimensional intermediate representations, and the end-to-end model performed better in our experiments. The idea is that a learned policy can take advantage of information in the raw tactile signal that might otherwise be discarded when you compress everything down to an estimated pose. Tao Yu: I’d also add a significant failure mode. Sometimes the cable moves outside the reachable workspace of the fingers. The hand has many degrees of freedom, but we’re only controlling eight here, and there are physical limits to what the fingers can reach. A stiffer cable, for example, might bend away until it’s outside the hand’s reach. That’s one reason Saleh is looking at combining vision and touch: visual feedback can detect those larger unexpected changes and help the robot recover. Saleh: Exactly. In this demonstration, I’m perturbing the cable from side to side, but I’m not pulling it out of the fingers’ workspace. The policy can bring it back toward the center between the fingers, which is an interesting stabilizing behavior. That wasn’t explicitly programmed; it seems to have come from the demonstrations. Another thing worth noticing is the role of the middle finger. The thumb and index do much of the tracing, but the middle finger also moves up and down to adjust the cable’s height. We didn’t handcraft that either. It came from the human demonstration data. And the skill of the demonstrator matters. I tried teleoperating this task myself and wasn’t nearly as good at it! The person who provided the demonstrations was very dexterous, and I think that made a difference. What Makes a Good Tactile Learning Recipe? Matteo Grimaldi: Yes, exactly. We wanted to demonstrate that cable tracing could be done with tactile sensing and proprioception alone, but we also wanted to understand why it works and which design choices matter most. We studied four aspects of the system: encoder pretraining, control frequency, temporal context, and spatial resolution. The numbers we found aren’t a universal recipe for every robot, task, and sensor. But they offer a way to think systematically about designing tactile-learning systems. Let’s look at spatial resolution first. Just as Tong found for SlipSense, increasing the tactile resolution from 8-by-8 toward 32-by-32 improved performance substantially. The plot shows both the success rate at ten centimeters and the distance traced, and both increased with higher resolution. We also varied the control frequency, looking at 15, 30, and 60 Hz. Higher frequency improved performance in our experiments. Temporal context is more interesting, because there’s a trade-off. In our experiments, 15 stacked frames at 60 Hz, or about 250 milliseconds of history, worked best. Increasing the context to 20 frames, about 333 milliseconds, actually reduced performance. So there’s an optimal region for the amount of context, rather than simply ‘more history is better.’ For another task or hardware platform, the optimum might be different. Tong Jian: I want to jump in on that temporal-context result. It’s a remarkable coincidence: for SlipSense, we also found that performance started to saturate around 250 milliseconds of context. For cable tracing, 15 frames at 60 Hz gave the best result. We need to explore whether there’s a deeper reason for that similarity. Michael Cho: I was wondering about that, especially because the second task uses imitation learning from human teleoperation. Could the 250 milliseconds have something to do with the human operator’s reaction time to visual feedback? A very good operator might still be reacting on roughly that timescale. Of course, SlipSense doesn’t involve a human in the same way. There, the physical slip event could be caused by gravity or something else. So perhaps the similarity is a coincidence, but it’s an interesting question. Saleh: That’s a good point. We’re also exploring reinforcement learning, where the policy can learn through trial and error rather than relying only on human demonstrations. Some of these events happen so fast that it may make sense to let the learning algorithm discover responses that are difficult for a human to demonstrate. I also want to emphasize the 60 Hz policy rate. A lot of robot-learning work runs policies at 5, 15, or 30 Hz, partly because those rates are natural when you’re relying on cameras. The sensing modality often ends up dictating the policy frequency. But a tactile sensor provides very fast temporal information. If we design algorithms that can use it, we can get fast, reactive corrections that would be difficult to obtain from vision alone. We were trying to push in that direction with this paper, and it’s an important area for future work. Matteo Grimaldi: Exactly. We tested several policy models and control frequencies. The best performer for this task was a transformer-based policy with a Gaussian mixture model (GMM) head. It’s small and fast enough to operate at 60 Hz, which seems to be important here. We also tried diffusion policies. The diffusion-policy models performed worse than the transformer with a GMM head in these experiments. We’re not saying diffusion policies are generally worse. The point is that for a task requiring very fast, compact control, there can be a significant trade-off between model expressiveness and execution speed. In the appendix, we also include results with vision. We collected another dataset with a camera operating at a lower frequency, around 20 Hz, and showed that vision and tactile sensing can be complementary. The purpose of this paper, though, was to characterize tactile-specific design choices. The other important aspect is pretraining the tactile encoder. With such a small demonstration dataset—just ten minutes—we found it helpful to keep the pretrained encoder frozen during policy learning. Fine-tuning the encoder didn’t improve our results and could easily reduce performance. That suggests that encoder fine-tuning is delicate when you have very little policy-training data. So the full recipe we arrived at combines decisions about tactile representation and pretraining with control frequency, context length, and spatial resolution. Again, this is a recipe for cable tracing on our system, not a prescription for all tactile manipulation tasks. But we believe studying these axes can help other groups design better tactile policies, and we’ve seen related patterns in some other tasks as well. Where Tactile Robot Learning Goes Next Michael Cho: Thank you, Matteo. To bring the two papers together, Tao, how do you see SlipSense and Touch2Trace fitting into the broader direction of the Dexterous AI Group? Tao Yu: I would say these two papers are just the beginning of the journey. They grew out of our curiosity about what new hardware can bring to robot learning. We’ve been doing relatively isolated experiments to understand what the sensor enables. But I think a truly disruptive solution will involve something more like reflexes. Think about how a human grasps a cable. It may start to slip, or I may want to manipulate it. I don’t need to consciously think about every movement. My hands just respond. These behaviors are integrated and almost instinctive. How do we build learning-based systems with those kinds of capabilities? We need multimodal sensing with high spatial and temporal resolution, and architectures that combine those signals. Vision should play a role, too, but without slowing down the fast tactile reactions. There is interesting work along these lines, such as T-Rex, which is starting to think about tactile sensing differently from vision and develop architectures for foundational reactive manipulation capabilities. But how well these systems work will depend on both algorithms and hardware. That’s why we believe in iteratively designing sensors, integrating them with robots, training models, and using the results to inform the next hardware design. RJ He: I’ll add one more question. These are really nice, in-depth studies of specific capabilities like slip detection and cable tracing. But how soon do we get to a more general foundation-model approach for tactile sensing—a single model that supports lots of different tasks? Tao Yu: Right. And I don’t think that should replace a vision-language-action model or a world-action model. It should complement those systems. A hierarchical architecture seems like a natural direction. The question is: what belongs at the lowest level of that hierarchy? Michael Cho: That’s a great way to put it. I personally really like this line of tactile research. I don’t know if you know this, but we were helping organize a robotic origami competition with the Sharpa team. Part of the reason I helped start it is that I really like origami myself. Last year, we invited a grandmaster from the Japanese origami association to CoRL for a demonstration—a kind of human benchmark. I stood there for ten minutes watching this man, probably in his sixties or seventies, making paper cranes while talking to people. He wasn’t even looking at the paper most of the time. His hands were just working. That really struck me. So much of what he was doing seemed to rely on touch. And origami involves lots of occlusion: even when you’re looking, the important contacts aren’t necessarily visible. For very fast reactions, you also can’t depend on vision alone. That’s why I like seeing papers that deliberately remove vision and explore tactile sensing as a modality in its own right. It’s also great to see a hardware-centric research approach, because the sensing hardware matters so much when you’re operating at these control frequencies. Saleh: Origami is also a good example because paper is deformable. That makes the dynamics much more complicated, which connects it to the cable work. Michael Cho: Absolutely. I don’t think you’re going to solve robotic origami reliably with vision alone. You need touch. Papers and Research Worth Following Michael Cho: To wrap up, we always ask our guests this: have you come across any interesting papers recently that you’d like to give a shout-out to? They don’t have to be about tactile sensing—anything in robotics is fine. Matteo Grimaldi: One that comes to mind is the recent NVIDIA work on Sonic. We discussed it in our journal club, and the video was very impressive. Tao Yu: We’ve actually been doing journal clubs internally, so there are quite a few. Maybe Tom, Saleh, and Matteo can each mention some of the work we’ve been looking at. Tong Jian: I’ve also been looking at Robot TDT, particularly its approach to long-term memory. I thought that was really interesting. Saleh: I’d like to mention some work from Yun Zhu Li’s group at Columbia University. They have a series of interesting tactile-sensing and simulation papers, including 3D-ViTac, VT-Refine, and Touch in the Wild, which also used UMI. More recently, there has been work on interactive world simulation. Those are all exciting directions. I’m also interested in the papers we haven’t seen yet: how to use tactile information efficiently in foundation models. T-Rex is interesting in that regard, but I think there are still many approaches to explore. If language provides instructions for robots, and images are the language of vision, you might say that contact is the language of physics. That’s where tactile sensing becomes a first-class modality. For physical AI and dexterous manipulation, I think tactile sensing is essential, and the community is increasingly recognizing that. I’m excited to see how researchers integrate tactile information into foundation models. Data is another problem, though. There’s a real bottleneck in collecting tactile data at scale. We have some ideas about that, and I expect we’ll see more research on it. Tao Yu: Speaking of data, Michael, you mentioned human egocentric data earlier. I think that’s one of the most scalable paths for collecting manipulation data. I recently came across the MINT paper, which I believe was a collaboration involving UJI and a university. That work is interesting because egocentric data processing and annotation pipelines still aren’t very standardized. Every company or research group seems to have its own approach. Understanding what makes human egocentric data useful for robot learning is going to be crucial. Michael Cho: Hopefully we’ll get some of those authors on RoboPapers soon. Thank you all again for coming on the podcast. I found both papers really interesting, especially the way hardware, data, and model architecture are all treated as central parts of the solution. It sounds like you have a lot of follow-up work in progress, and we’re looking forward to seeing it. Please come back and join us again. Tao Yu: Thanks for having us. Saleh: Thank you. Matteo Grimaldi: Thank you very much. Bye-bye. Tong Jian: Thank you. RJ He: Thanks so much, everyone. Michael Cho: Thanks for coming on. See you in the next one. Bye! This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit robopapers.substack.com

  • October 9 · 53 min

    Ep#111: SOLE-R1: Video-Language Reasoning as the Sole Reward for On-Robot Reinforcement Learning

    Reinforcement learning is often seen as key to achieving scalable, highly reliable real-world robot performance, yet it requires good reward functions that can supervise the wide range of tasks that need to be performed. The obvious thing to try would be a large vision-language model (VLM), but these models often fail under common real-world conditions like partial observability and occlusion. As a solution Philip Schroeder and Thomas Weng propose SOLE-R1, a video-language reasoning model trained to serve as a reward signal for online RL. Given real video, SOLE-R1 will reason over input video frames, generates reasoning traces, and predicts a reward signal. This allows online RL from random initialization on new manipulation tasks. To learn more, watch Episode 111 of RoboPapers, with Michael Cho and Jiafei Duan! Abstract Vision-language models (VLMs) have shown impressive capabilities across diverse tasks, motivating efforts to leverage these models to supervise robot learning. However, when used as evaluators in reinforcement learning (RL), today's strongest models often fail under partial observability and distribution shift, enabling policies to exploit perceptual errors rather than solve the task. We introduce SOLE-R1 (Self-Observing LEarner), a video-language reasoning model explicitly designed to serve as the sole reward signal for online RL. Given only raw video observations and a natural-language goal, SOLE-R1 performs per-timestep spatiotemporal chain-of-thought (CoT) reasoning and produces dense estimates of task progress that can be used directly as rewards. To train SOLE-R1, we develop a large-scale video trajectory and reasoning synthesis pipeline that generates temporally grounded CoT traces aligned with continuous progress supervision. This data is combined with foundational spatial and multi-frame temporal reasoning, and used to train the model with a hybrid framework that couples supervised fine-tuning with RL from verifiable rewards. Across four different simulation environments and a real-robot setting, SOLE-R1 enables zero-shot online RL from random initialization: robots learn previously unseen manipulation tasks without ground-truth rewards, success indicators, demonstrations, or task-specific tuning. SOLE-R1 succeeds on 24 unseen tasks and substantially outperforms strong vision-language rewarders, including Robometer, RoboReward, ReWiND, GPT-5, and Gemini-3-Pro, while exhibiting markedly greater robustness to reward hacking. We release all models, data, code, and demos at the anonymous page: this https URL Learn More Project page: https://philip-mit.github.io/sole-r1/ ArXiV: https://arxiv.org/abs/2603.28730 Transcript Transcripts are automatically generated by Riverside and are lightly edited by ChatGPT. Michael Cho [00:06] Hello guys, welcome to another episode of RoboPapers. Today we are really happy to have Philip Schroeder and Thomas Weng, two of the co-authors of this paper, SOLE-R1: Video-Language Reasoning as the Sole Reward for On-Robot Reinforcement Learning. Thank you so much for making the time, guys. Maybe as a start, Philip, you can share a bit about yourself and then Thomas. Philip Schroeder [00:27] Yeah, so my name is Philip. I’m a final-year PhD student at MIT in computer science. My work has mainly focused on improving the reasoning capabilities of language and vision-language models in challenging embodied settings. And over the last couple years, my work has mainly focused on reward reasoning over video, which is what we do for this paper. Thomas Weng [00:55] Cool. I’m Thomas. I’m a research scientist at RAInstitute. And more recently my work has been focusing on the pieces required to achieve like post-training and deployment for robotics. So reward modeling is one piece of that. On-robot reinforcement learning where you have data from deployment is also a piece of that. But that’s what I do. Michael Cho [01:22] All right, great to have both of you on. Yeah, maybe Philip you can take us through. Philip Schroeder [01:27] Yeah, yeah. Okay. So the goal of this paper was to develop a vision-language model that has strong enough reward reasoning that we can train policies from scratch through online reinforcement learning. So the model we developed is called SOLE-R1. And we show that it can serve as the sole reward signal for learning over 20 different unseen manipulation tasks through online RL. And I guess the motivating problem for this paper was that if you use just general vision-language models or VLM-based reward models that have recently come out, you get this reward hacking behavior when you try to train a policy from scratch using the predicted rewards. So here, the task is to open the drawer, and you can see that these VLM-based reward models give very high rewards just for the policy fiddling with the drawer and just slightly opening it. And then here’s another example with the Pick Cube task in RoboSuite. Again, you see that the policy is getting these very high rewards by just finding these odd camerangles and positions that trick the VLM into thinking the task is being accomplished without actually doing the task. And you can see here the SOLE-R1 predicted rewards are plotted here in blue, and the ground-truth rewards are plotted in red. And you can see that solar SOLE-R1. Much more robust to this type of reward hacking. And you kind of think of this paper as a recipe for how to train a reward model that is robust to reward hacking. And there’s kind of two major components to this that differentiate our work from prior work and really help with this reward hacking robustness. And I can quickly mention those and then go over them in more detail later. So the first is our training data mixture. We do I think three unique things with our training data mixture. One is that we include a lot of general spatial reasoning data. And a lot of this data is new. It came out with NeurIPS 2025 and ICLR 2026 papers. So at the time of this work it was data sets that were just released. So it includes just general spatial re spatial reasoning data SSR chain-of-thought And some robotics data sets, some recent one called From Seeing to Doing, and some very famous ones like Embody chain-of-thought and Robo2VLM. And we combine this with data that forces the model to reason over multiple images within the same space, capturing different moments in time. So this includes general spatial reasoning data or spatiotemporal reasoning data spot the diff and robot-specific video data that we generate and then. Also curate from Open X-Embodiment. And our video data includes failure datand I think much more failure data than prior work because we generate a lot of it ourselves in RoboCasa. So that’s one big thing. And then another big thing is that we annotate the time each time step of the videos with dense progress values and dense chain-of-thought reasoning traces to help the model explicitly reason about progress with these failure trajectories or suboptimal trajectories. And then we mix this with these artificial failure data from Open X So that’s the training data mixture. And then another novel thing we do is have the model do this chain-of-thought reasoning at each time step of the video. And this has been shown to significantly improve language model performance and visual language model performance. So and we show ablations where it helps significantly. So the models con it at each time step is reasoning about what’s changing over time between the current and previous time step and predicting a dense progress value. Relative to the previous progress value that it predicted at the last time step. And then we do a lot of experiments that I can that I can show. But let me know if you have any questions so far. I can go over in more detail the both how we generate our training datand then how we train this chain-of-thought reasoning over video. Jiafei Duan [05:56] Can you let me yeah. Yeah, I’m gonna go ahead. Yeah, no, you go ahead. Michael Cho [05:56] Yeah, let’s go over the training data. Sorry, Jiafei. No, I was gonnask about the training data. I mean it’s a nontrivial amount of training data. It’s curious how you get that, like the dense annotation. Jiafei whether that’s your question. Philip Schroeder [06:10] Yeah, so we w most of the novel data we’re generating is in sim. So we’re leveraging the ground-truth simulator state at each moment. And I have some slides for sh walking through that and I can I can show that next. Jiafei if you have a question, I can answer that before I show that. Jiafei Duan [06:26] Yeah, so maybe like I’m curious about the reward hacking, right? So you showed the first example, where I guess it’s like it’s non-trivial in the sense whereby you are trying to showcase a task where it looks like it’s grasping, but when the from a different angle it might look slightly different. Is that my understanding? Okay. So is it a perception problem or like do you think it’s like the a result of perception that leads to reward hacking or you know? Philip Schroeder [06:31] Yeah. Yes. Yeah, so it Jiafei Duan [06:55] or what do you think is the you know, how do we quantify this? Yeah. Philip Schroeder [06:59] Yeah, so it’s definitely a perceptual failure. Where the policy is just finding out-of-distribution visual input by just ‘cause it has so many degrees of freedom with moving the camera into any position. And since we’re already a little bit out-of-distribution with this task setup because there’s probably not a lot of rope like the robotics data inside video data inside the training data for these visual language models. But especially when you give the policy this opportunity to optimize against the VLM’s sense of progress. And it’s always easier to just find these weird camerangles than it is to just do the task. It’s always easier to get these false positive states than to get the true positive. Jiafei Duan [07:41] I see. I see. Maybe my question would be like humans also have this, right? Like in the sense whereby it’s like you know, if you look at things from a certain angle, you have an illusion that, you know, certain things has been done correctly, or it might not be the case. Like, is this like is this a would you say this like something that you have to fix to ensure that you know you are able to train a real model that is, you know, able to really accurately sort of predict progress regardless of this kind of, you know, camera positioning? Yeah. Philip Schroeder [08:15] Yeah, I mean, I think, for example, this time step right here, we want models that can look at this. I think any I think almost any human that watches this video will see clearly that the robot is not picking it up. And to the extent that we want our models to have this human-like reasoning capability visually, I think we want to fix this problem. If that’s I don’t I don’t know. I mean, there might be ways of using the model that help it help it avoid these scenarios. Like for example, we start with a randomly initialized policy, so we give it like this full capability to explore and explothese weaknesses in the model. But I think I don’t know if that answers your question, but I think fundamental I think this something fundamental to the model. It’s not just some long tail of tiny narrow failure cases. It’s there are very obvious examples where it’s hallucinating success when it’s given the full opportunity to recognize that success is not being achieved. Does that answer your question? I don’t know if I’ve answered your question. Jiafei Duan [09:24] Yeah, yeah. Yeah, no, yeah, I get it, yeah, yeah. Thanks. Thomas Weng [09:28] I think to add on to that, it’s also the fact that we’re in this like pretty difficult regime of reinforcement learning, like specifically online RL, where we are acting as kind of the sole reward signal for this model. And in that situation, if you have any kinds of false positives then the policy will learn to exploit that pretty quickly. So that’s part of it. But I think in general with any kind of Jiafei Duan [09:41] Mm. Thomas Weng [09:58] reward harness if you don’t address these issues of like overestimation or overconfidence, then you can quickly run into some pretty bad scenarios. Jiafei Duan [10:07] I see, I see. Yeah. I guess maybe the reason I wasking this that I’ve been also thinking a lot about reward modeling from norm like visual perception. Like if you add in a tactile sensor or you add in some kind of force feedback, then you could easily tell for sure that the robot is not touching the cube or that it’s not grasping. So then you might not be able to see, but the other signal could inform you of the, you know, progress of the of the reward that’s tracking. So I’m just saying that, you know, in no like thinking forward, you know, w would this be like is vision the only thing that o that we sort of rely on or do we look at other modalities that, you know, potentially the way that reward hacking could look like could also be different given the kind of census that you give. Yeah. Philip Schroeder [10:50] yeah, it’s a great point. I we considered at the beginning of this work whether we should just have like one scalar value representing the contact the gripper is making with the different objects it’s trying to pick up or manipulate. And I agree that there are a lot of scenarios where that would help. I think the policy would still, I think, find ways of just triggering that sensor and still not doing the task. It would make the so I think it would make the reward hacking job harder for the policy. But I think it would like for example here, you could see that even if it’s like it could start to grip the cube here and trigger some sort of sensor that’s as if it’s picking it up, but just never lift it off the table. But you’re right, it does make the reward hacking harder. The more the more Jiafei Duan [11:21] Mm. Mm. Makes sense, yeah. Philip Schroeder [11:46] The more datand the and there’s other things you do with reward hacking as well. Like for example, you can change the you can constantly change the camerangle. Like for example, the external camerangle here, you can constantly flip sides of the table or orient it differently. So the could so the policy never knows what external camera view the VLM is watching it from. So it can’t it can’t like re find reliable paths to exploiting any visual shortcoming of the VLM. Jiafei Duan [12:14] Mm. Philip Schroeder [12:14] And it’s like we do that, for example, with the ManiSkill setup. It was all really the only way we could get things to work. We had a flip between alternating sides of the of the table. But yeah, so I think yeah, any extra information or changing information or sources of information will make it harder to do the reward hacking. But fundamentally, I mean like if you if you get an image and a human can watch or get a video and a human can watch it and say, okay, clearly not success here. Jiafei Duan [12:23] Hm. Philip Schroeder [12:42] And but the VLMs reliably predict success. I think we want to solve that problem from the visual side. If as long as humans can do it from the visual side, I guess. I g I guess that’s the bar. Jiafei Duan [12:53] Makes yeah, yeah. Makes sense. Thomas Weng [12:56] I think I mean vision alone is I mean we have like all the bootstrapped like capabilities off of VLMs to be able to use vision. But I also kind of think that if we had other proprioception or perceptual information that could be used to prevent reward hacking, I don’t think we’re necessarily opposed to that. It’s just that you know, if you have a tactile sensor that does help you prevent reward hacking, then that’s great. But it does need to probably vision will still be part of this picture. Philip Schroeder [13:32] Yeah, and a nice part about vision is it’s agnostic to the embodiment. And you can also like integrate by manual, et cetera. So it you don’t have to like retrain it on a new set of joints or two versus one arm or it or any other changes you make. So that does make it a little bit more general. And if you a lot I think a lot of people might not want to have to send extra sensor. I don’t know, it depends on what the data is, but It’s nice being able to just send videos if you have like a big data set of videos. So yeah. But To answer Michael’s question, I can walk through the data generation in more detail. And see if you guys have any questions about the actual steps that we take. Okay, so again, this our overview of our training data mixture that I showed earlier. We have this general spatial reasoning data where the model’s just reasoning over single image and Producing this chain-of-thought reasoning along with final answers to questions that talk about spatial relationships. And then we add these robotics data sets, like I mentioned. And then we also have this data that requires the model to reason over multiple images or multiple time steps of a video representing the same space at different moments in time. So we have this general data from spot the diff, and then our curated data from both RoboCasand Open X-Embodiment. And I will walk through how we generate the non-expert trajectories inside RoboCasa now, along with the dense progress estimates and the per time step chain-of-thought. Okay, so I think most of us are familiar with this the source of our data, which is RoboCasa. I think most of us are familiar with it. It’s great resource from UT Austin, and I think they have updated versions of this now, but we’re using just the original RoboCasa where they release thousands of demonstrations, of expert demonstrations of many different manipulation tasks inside randomized kitchen scenes that they generate. And the demonstrations, although there’s multiple robots shown here, the demonstrations are all provided with the Franca. And so here’s some examples. So these are the single-stage tasks or the atomic tasks. that they that they categorize. And so it ranges from picking up and placing things to opening and closing drawers to turning on the stove to turning on the sink. And then here are some multi-stage tasks like picking up cans and putting them inside the pantry and then taking the coffee mug outside the cabinet and putting inside the coffee machine and pressing the start button. Okay, so RoboCasa provides a this great resource of diverse Expert demonstrations across many different manipulation tasks. And the question is, how do we get the non-expert trajectories from these expert trajectories? So the task example I’ll show here is picking up the salt shaker, and the expert states are shown in blue. So we get non-expert trajectories by inserting random actions inside these trajectories and then recovering and then we can still recover to the expert trajectory through just linear state interpolation between the deviate the final deviated state and a future expert state. And you have to be a little bit careful with how you do this so you don’t get like floating objects or the gripper moving through the cabinet. But if you’re careful you can generate pretty realistic suboptimal trajectories or just total failures by injecting these deviations. And because we know the simulator state at each moment, we can measure the distance between the robot and different goal states throughout the trajectory. So here we would measure the distance between the gripper and the salt shaker at each time step. And when we do that, we can get these very reliable progress estimates that we use to ultimately train our vision-language model. And then in addition to These progress estimates, we have all of this ground-truth information that we can translate into just natural language statements about the about each time step. And we leverage this to generate chain-of-thought reasoning traces that are explaining kind of why the progress is what it is at each time step. And the final training data looks something like this. So these are two videos from the actual training mixture. We change the resolution a lot and we rotate the camera on the wrist to help just build robustness of our model. And we change the lighting, et cetera. But you can see the progress values that are plotted on the right. And the tasks here are just to pick up this object and put it in the cabinet. I think the one on the top fails to pick it up, and the one on the bottom picks it up but then fails to place it. And you can see the chain-of-thought reasoning traces we generate. So that the I’ll play this back again one more time. So the chain-of-thought reasoning traces come from just pure templated language mixed with templated language that we enrich with VLMs that see the time steps and see the templated language and then just add more characterization of the scene of the movements Without deviating from the ground-truth information that’s in the templated language. So I think this probably the most important thing that leads to our model performance is generating these suboptimal trajectories with very good progress estimates and then the reliable chain-of-thought reasoning. So definitely let me know if you have any questions about this, and I’m happy to go back to any previous slides. Michael Cho [19:40] Yeah, Philip, I’m curious, like I guess there’s a concept of memory here, right? Like, you know, how ha have you done an application studies or like h how many frames or how often do you take the frames? Is it like when is it too much for the VLM? Yeah. When you do this CoT. Mm. Philip Schroeder [19:58] Yeah, so yeah, I that’s a great question. So we have a very simple solution to this, which is we just our all the tasks that we care about are short enough that we just include the first, previous, and current time steps in the context window of our VLM. And that makes it really fast for inference and our inference scales cost scales linearly with the video length because of that. But I think you can play with this a lot. You could do some sort of dynamic frame pruning or dynamic like dropout of frames depending on what the structure of the task. Or you can just try to concatenate like 10 plus frames to get a bigger picture of what’s going on if you have longer horizon tasks. I think our framework’s pretty agnostic to this. We just chose, I think pretty simple like three frame three time step framework because our we know our tasks aren’t very long. And we show in the mod so the model gets a total of six frames because it gets three time steps and then two camera views. So it’s getting the wrist and the external view. But yeah I think memory is a really important thing and I think The easiest solution is just increasing the number of frames you include in the context. It’ll slow down the model, but there’s other ways to speed it up. Michael Cho [21:30] Got it. Yeah. And am I right that in a way, you know, your templated text here is in a way capturing like the memory. It’s just in text form. As you cycle through Philip Schroeder [21:42] Yeah, I mean Yeah, so I think most of the template language or most of the yeah, most of the chain-of-thought language is talking about the previous time step relative to the current time step. And it can infer a lot about the trajectory just based on the or I based on these time steps. And then it’s also it also sees the very first time step of the trajectory, so it sees the starting position of the robot. But yeah, in some sense I think you could leverage if you didn’t want to can ca continue to just concatenate frames which are expensive. You could somehow be summarizing along the way in text and just keeping that in context. But our model doesn’t see the chain-of-thought reasoning from the previous time step. It only sees the progress predicted the previous time step. So all of this text that it’s generating at each time step is essentially forgotten at the next one. But I think there’s probably a way to leverage the text that it’s generating along the way. To serve as a some form of memory that’s far more compressed than trying to just concatenate a lot of frames together. Michael Cho [22:55] Got it. Yeah. I’m also actually also curious, I don’t know whether this the right time to ask. It’s for let’s say slightly longer horizon tasks where maybe the way to get to the final outcome is you need to do a little bit of detour. You know, it could be one of those like okay, you it you have to do a little bit of detour. So I wonder how ha have you have you done those kind of tasks where and then how does it square with the task progress? Philip Schroeder [23:14] Yeah, yeah. Yeah, Michael Cho [23:26] You know, maybe temporary it’s the only way to solve the final task is you need to do a big detour in yeah. Philip Schroeder [23:32] Yes. Yeah, so yes, this a common problem, especially when the tasks get more complicated. You can’t always just use like Cartesian distance as a progress proxy because you’re right. Sometimes you have to avoid obstacles and you have to temporarily deviate from going to the target location in order to avoid some midway collision. And there are so I essentially just handle that by hand in our data generation. Like I know all these like edge cases where there’s a pick and place task in RoboCasa where it has to maybe like work around the sink or it has to go from below the cabinet to the top of it, but it temporarily has to move away from the final target position. And I just flatten out the progress values at those points, but this a very like hand-engineered solution that doesn’t scale. So I think if you just allowed that type of imperfection in the progress values, the VLM would probably still perform well because it’s still going to get points as soon as the object gets closer to the target position after avoiding the obstacle. But it might really affect policy learning where the because the policies getting penalized for avoiding a collision with some middle thing, it never really learns to get out of that and place low place the actual object. Yeah, so I mean I guess I think this why, yeah, I think ultimately we want a VLM to be able to reason about okay, you want to include videos where there are examples of having to avoid an obstacle. and the VLM would be reasoning about, it’s moving further from the target position, but obviously it’s trying to avoid this obstacle, so reward should go up. You want that. I mean, you want this human-like rational reasoning. But I don’t, yeah. For our data, I just hand I hand engineer solutions to all these specific cases where this might happen. And that was good enough because it’s a small enough task set, but yeah, it’s a really important problem. Thomas Weng [25:52] I guess specifically for our data, we looking at the datand the simulator like information coming out of RoboCasa, I think we borrowed some from our previous work of ROVER, where were using essentially like the Cartesian distance information in like 3D geometry to try to determine our task progress indications. And so Jiafei Duan [25:52] Right. Thomas Weng [26:19] For the scale that were working at, like it was fine to kind of go in and make sure that those were not a problem. But if you didn’t use that kind of ground-truth metric of the Cartesian distance, then you wouldn’t necessarily have these have to deal with this like artifact. Now it does mean maybe you have to do some more intense reasoning or like maybe you start using some kind of motion planning or collision optimization in order to pre process your data. And I think that’s what Philip is getting at when he’s saying like, you know, right now we basically are dealing with the fact that we know our heuristic is Cartesian distance between like the object’s current location and the goal location and things like that. But ultimately we can move away from that kind of heuristic. Jiafei Duan [27:11] I have a question. I think more high level and philosophical. So I think like one thing, you know, we start to realize with all these frontier companies that companies that who really trains pretty good, like you know, I mean ChatGPT, you know, version of ChatGPT tends to do RL better. And smaller models like those companies that do smaller models struggles a lot with this because there’s a missing component where you’re not able to have user feedback. Okay, you’re not able to have that kind of Michael Cho [27:12] Yeah, makes sense. Yep. Jiafei Duan [27:41] real-time val viable reward in that sense. And you guys are generating this trajectory or discount reward using simulation. I think robot meter does differently. Like what do you think is the most ideal scenario to get some of this annotation? Will it be like if you have a massive deployment of real-world robots and you know consistent evaluation and people are able to sort of collect evaluation rollouts, get it labeled pretty well, get all the human verifiable you know, reward out of that. That would be like the perfect scenario to be used to train a reward model. Like do you guys see that as the way, or do you see like scanning up simulation or the robot meter approach? Yeah. Red philosophy can you do the paper, just a r yeah Philip Schroeder [28:25] Yeah it’s Yeah, it’s a good question. And we also include Open X-Embodiment data to mix in with this. And we’d use the RoboMeter approach of just shuffling frames and using time step as a proxy for progress with the like creating essentially these artificial failure data. But yeah, so I mean I think one of the questions you asked during the RoboMeter episode was do you need any robot datat all to train a perfect reward model? Or a human-level reward prediction model. And the answer to that question might be no. If you just get a good enough sense of the physical world through other means, I think you could do good enough zero-shot reward prediction better than any model we have so far. And I think maybe, I don’t know, maybe GPT-6 Astra. Is almost there. And who knows how much robot data they have in their training, but probab they probably don’t have data this and it probably does very good job of generalizable progress prediction. But yeah I think to answer your but to answer your question I think the more reliable path I mean so yes we might not need robot datat all. That I mean that could be long term the actual final outcome. But in the near term I think The brute force approach of just scaling up real-world data collection and then just getting human annotators to label videos with very reliable progress values. I think and I and you don’t need nearly as many videos to train a good reward model as you do to train a good policy. So it I think this actually is feasible. And as long as you get a diverse enough task and set of trajectories that represent true failures, I think that brute force approach could actually work. Work in the near term and produce either a human level or a superhuman level reward prediction model. Michael Cho [30:36] Yeah, I actually like on a side note we just did an episode a couple of days ago with guys from Empire. I don’t know whether you guys yeah, so and they during the episode they updated the whole thing with Astrand obviously Astra is phenomenal. And so I suppose the closer you can get like some of these like just like huge foundational model that can help you with reset, then you can actually have really truly explore a lot of play and then just get the reward that way. They actually just ask I think us ChatGPT to figure out what’s the reward. And then remove the human in the loop. It was quite crazy. Yeah. Philip Schroeder [31:21] Yeah, I think yeah, so you’re right. I think ultimately we will no matter how good Astra gets, we will always want to distill a smaller model that is less expensive and just more suitable for as a final form model for robotics. And I think the question then becomes how do you do this distillation? And I think in some ways this our paper is showing how you can do distillation in a way that builds robustness to reward hacking. So it would be nice to maybe use Astra but still integrate this authentic failure datand other data that you find and annotate it with Astra’s reasoning traces and then distill from that. Because I think in the long term I think I mean I’m sure OpenAI will work on creating faster, cheaper versions of Astra’s with Astra level reasoning and provide an API that can maybe be used for robotics. But at least in its current version, it’s just too expensive, too slow. Michael Cho [32:17] Yeah. Mm. Mm. Philip Schroeder [32:27] to be a realistic I think for deployed robots or online learning of that requires like fifty thousand plus rollouts to train a model or a fleet of models. So but yeah I mean I think Yeah, I think Astra is definitely a step up of I and I wish we could have included Astra in the baselines for this. We definitely would have if were doing this today. But it’s amazing how big of a step up it is relative to the previous models. Michael Cho [33:01] I’m curious like you know, d this failure trajectory that you guys like generate, like how what is the proportion relative like ‘cause in theory you can generate like le almost like an unlimited amount of failure trajectories so called. Like how much do you go into it or do you just maybe from every successful you only have one failure or like you have like one hundred other failure trajectories? Philip Schroeder [33:26] Yeah, so we’re lim we’re only limited well I mean unless we want to do extra work, we’re initially limited by the number of tasks settings that RoboCasa release. So we so RoboCasa initially released a little over 20 different manipulation tasks. And had I think 3,000 trajectory, expert trajectories per task. And the vast majority of those are generated with MimicGen starting from a source data set of human teleoperated examples. And then we generate, I think, a total of 40,000 videos from RoboCasacross these different tasks. But yes, I mean one version of this could be to just use Astra. Michael Cho [33:43] Well just. Philip Schroeder [34:11] to generate diverse sim environments. And then you might have to manually collect demonstrations inside those environments or use Astra to collect demonstrations potentially in those environments. And then generate the failure data off of those expert trajectories. So there’s a lot of creativity potentially in the space to really scale up the diversity of the in the in the in the number of sim environments you create. But yeah, we kind of just stuck with the with the constraints of the original source data RoboCasa provided, which gave us about 40,000 videos. And then we take about 200,000 videos from the Open X-Embodiment data set. So we have about a quarter million robot videos in our training mixture and total and all of them have these dense chain-of-thought reasoning traces and dense progress estimates. Michael Cho [35:03] Got it. But b but the I still wanna get a sense of the scale of the so called failure trajectory that you guys so w it’s it Philip Schroeder [35:11] So I guess what do you mean by so the failure almost all of the tr so I think about ninety percent of the RoboCasa trajectories, which is so about thirty five thousand, thirty-six thousand are all suboptimal trajectories. Does that answer your question? Michael Cho [35:29] I see. Okay. I so is something like s something like w ‘cause I mean you made the point earlier that di this failure trajectory really helped, right? So I that’s why I wanna get a sense of what is the relative scale to the so-called ‘cause you start what with like the successful tele op trajectory first, right? And then you guys generate some so called suboptimal trajectory. I’m you know, so I’m just curious how many of Philip Schroeder [35:51] Yes. Michael Cho [35:59] those suboptimal so called failure, maybe not entire failure, but suboptimal trajectories that you that you manage to do. Philip Schroeder [36:07] Yeah, so for the vast majority of the RoboCasa trajectories, we’re not actually including the expert trajectory inside the training data. We’re just converting that into a suboptimal trajectory. And that’s about ninety percent of them. So we could we maintain about five thousand out of the forty thousand trajectories as the true expert trajectories. And then the rest are these different levels of deviation from that trajectory. So ranging all the way from like it just barely doesn’t accomplish the task to it doesn’t even approach the object, for example. And it just outputs random actions. This I yeah, I okay, gotcha. Michael Cho [36:21] Mm. Mm. Got it. Yeah. Yeah. Thomas Weng [36:49] I guess kind of returning to the high level like questions. There’s this question of like, do you only need like a data flywheel of real data that is maybe suboptimal from human teleoperation or from policy deployments on robots that are like getting not perfect success rates? Or do you actually want something like a simulator where you can extract certain features of ground-truth and use those to like I don’t know set up a template like what we have here of like making sure we know what the ground-truth state is now or maybe with the memory that we had in the past, et cetera, et cetera. Or is it just that you only need kind of real-world datand are you inducing more problems by taking on this like all the complications of trying to Create a simulator for individual tasks. I think in this work we definitely make good use of simulation. And it is possible that like bigger and better models in the future will be able to help us create better real-to-sim or digital twin type situations. That’s getting really popular in the field now as well. So yeah, I think it’s kind of I just wanted to flag that as like an open question. Like, We’re finding cooler and cooler and more effective uses of simulators. But is it necessary or do you actually want a data flywheel from robots interacting in the real-world and being deployed? Yeah. I think in either case, this paper is really contributing kind of again the recipe of how to avoid reward hacking so that you can get reasonably good pr task progress estimates that are better distilled than say just Directly querying some large model. Philip Schroeder [38:43] Yeah, I mean, I think the most obvious answer would be you would want both. And they do complement each other nicely. Like for example, with our data, you could you could say that the sim data has lower task diversity, but high trajectory diversity by showing these f different failure types. And then the Open X-Embodiment data has much higher task diversity, but much lower trajectory diversity. And then when you combine them, you get kind of the best of both worlds. I think so I think unless we get to a point where sim is indistinguishable from the real-world graphics or visuals, I think we’re always gonna benefit from the diversity you get from real-world. Even though how pa even though it’s extremely painful to collect the real-world data relative to sim. But yeah, it’s a good I think question. Okay, I can go on to show the training of the reasoning. If unless you guys have more questions about the let me know if you have any more questions about the training data generation. Okay. Okay, so and just briefly to close on this, we mix up this RoboCasa data generation with the Open X-Embodiment data that I mentioned. And yeah, just like RoboMeter, we’re doing this artificial failure generation with shuffling the frames and then using time step as a proxy. But this just really like playing the video forward and backward for the model and pretending like that’s a failure day trajectory. And we know that’s not really reflective of true failure behavior. But yeah, okay. So that’s an overview of our training data mixture. So with this tr with this with this training data, we train the model to do this chain-of-thought reasoning at each time step, where the input of the model is just the task description and the video. And at each time step, it’s doing this reasoning about what’s changing over time between the previous and current time step. And then it outputs this progress value relative to the previous progress value that it predicted. And this progress value is directly used as a reward during online RL for learning different manipulation tasks. And to train this reason, we have this two-stage approach, which is becoming quite common, especially after the DeepSeek paper in early 2025, where we first do supervised fine-tuning, which is just the standard cross-entropy loss with next token prediction, with that’s common with language models, and then we follow that up with a Reinforcement learning stage where we’re training the model to specifically predict these progress values. So the loss for the supervised fine-tuning is dominated by the tokens inside the thinking trace, and only a small part of the signal is actually coming from the final answer. And then reinforcement learning is kind of the opposite, where all the tokens inside the reasoning trace are rewarded and are rewarded entirely based on. How close the answer, the final answer is to the ground-truth answer. So they complement each other nicely. So the model builds good space good spatiotemporal chain-of-thought during SFT, and then it leverages this good chain-of-thought to get increasingly better rewards during RL for predicting the progress values that are in the training data. And for our model, SFT takes about a week, and then RL takes another couple of days. So just to give you a sense of how long it’s taking to train on all this data. Okay. So we test on we evaluate on about on forty total tasks, and we include a real-world tabletop setting along with four different sim environments. And for our main results, like I like I mentioned, we’re starting from a randomly initialized policy. So and so all the tasks are quite simple. And I think I think Most people who have tried starting from randomly initialized policies know that it can be even hard to learn from the ground-truth reward, even very simple tasks. So eventually, like I think future versions of this work would scale up task complexity. And we do some higher complexity tasks with a pre-trained VLA, which we’ve done in more recent experiments. But all our main experiments are super simple, single-step tasks, pretty much. But there’s tremendous diversity. in the actual task setting and even the embodiment in some cases and camerangles, et cetera. And are we don’t do any fine-tuning of our model, of our reward model on any demonstrations of the tasks. We don’t use any sparse rewards from the simulator state. There’s it’s all zero-shot and the behavior is totally emergent from the reasoning of the VLM. So that’s the nice part about stripping everything away is that it’s the purest way of testing. Arguably the purest way of testing the reasoning capabilities of your VLM because there’s no supplemental aids to compensate for any weaknesses that it has. Okay, so this a bar chart showing the success rates across the 40 tasks, across the five different settings. SOLE-R1 is shown in red. The we include all of the VLM-based reward models as baselines, including RoboMeter, RoboReward, Top Reward, and then some other reward models like Rewind, VLAC, Live. And the strongest baselines are just the general purpose VLMs like GPT-5 and Gemini. And SOLE-R1 accomplishes at least 50% success rate on 24 of the 40 tasks. The strongest baseline, which is GPT-5, gets over 50% success rate on seven tasks. So there’s a significant gap here between what SOLE-R1 is accomplishing and the baselines, which is really nice to see. Do you guys have let me know if you have any questions about this plot. I can move on to the next figure. Okay. Michael Cho [45:26] Yeah, I’m trying to eyeball the tasks, yeah. Looks like across the board, like you guys beat everyone. Yeah. Jiafei Duan [45:30] I’m trying to I’m trying to read the performance it’s because there’s too much bar here. Okay. Michael Cho [45:39] No, but I it’s if I’m not wrong, like basically every single task, like s so our one is just beating everyone. Just say i is there any task that is not even the case. The door open is surprisingly really, really low though, like for everyone. It’s it door open? Mm-hmm. Philip Schroeder [45:55] Yeah. Yeah. So in Meta-World, yeah. Yeah. It’s cause you have to yeah, you have to I think the door looks a little bit weird. It doesn’t look like a standard I can show I think it’s this I don’t know if you can see my mouse? It’s this scene right here. It’s a weird looking door and I think the VLMs don’t recognize that this the handle. And that’s what you have to get the gripper in to then pull it open. Michael Cho [46:12] Mm-hmm. Yep. Mm-hmm. Mm. Philip Schroeder [46:24] so I think that’s the it’s just so Meta-World it just looks weird. I think it confuses the VLMs very frequently. And I think I don’t know, I these experiments were super expensive to run. I think we spent like something like five to ten thousand dollars on API cost for OpenAI alone just to get these just to get these results for RL the RL runs. Michael Cho [46:25] it’s okay. Mm-hmm. Yeah. Mm-hmm. Philip Schroeder [46:54] Gemini is much cheaper. And the and the runs take like five days a piece, because the APIs are very slow. ‘cause we have to send every single episode that the agent collects to OpenAI and then getting it densely annotated with GPT. So it’s a little bit insane to do this. But we really want it to have I think these open Th these general purpose VLMs as baselines ‘cause I think they are probably the strongest baselines for this type of zero-shot reasoning. Michael Cho [47:32] Yeah. Actually these labs should pay you, man. You’re helping them benchmark things. So very interesting. Mm-hmm. Mm-hmm. Philip Schroeder [47:35] Yeah, I wonder how much I don’t know if they do any of this stuff internally. But it would be interesting if they did. Okay. So we dig a little bit deeper into the results by plotting the what we call the true success versus the perceived success of each task. And the true success here is the average ground-truth reward that the policy achieves on the task. Michael Cho [47:47] Okay. Philip Schroeder [48:05] And the perceived success is the average predicted reward that the VLM predicts for the task. And this bottom right quadrant is what we call these reward hacking failures, where the policy is getting the model Yeah. So yeah, the policy is getting the model to think that the task is being accomplished and predict high rewards, but without actually doing the task. Michael Cho [48:19] Mm. False positive. Philip Schroeder [48:34] And this the same task setup that I was showing earlier where the policy is just finding these weird camerangles in RoboSuite. And we provide more examples like this across different tasks in the appendix of paper. And we see that I think the major models that are susceptible here are the general VLMs, which is Gemini and GPT, and then you see some yellow dots here for RoboMeter. And then a lot of reward models just fall in this bottom left quadrant, where which we call these signal limited failures, where the policy is failing at the task, but the VLM is at least aware that it’s failing. It but it’s not able to predict rewards that are shaped well enough to get the policy to actually learn the task. So we it’s a little bit less clear what’s happening here than what’s happening here. Michael Cho [49:19] Mm-hmm. Philip Schroeder [49:31] But we just generally categorize these as signal limited failures where the p the VLM’s just not providing a strong enough signal for the policy to learn the task. And then we do some ablation. So this the same figure that I was showing just before. But now instead of plotting the different baselines, we plot the different ablations of SOLE-R1. So if we remove the non-expert videos or we remove the general spatial reasoning data from the data mixture, we see this movement towards the bottom right quadrant where we get more of these reward hacking failures. And then if you remove the reasoning that happens before the final progress prediction, it doesn’t move the results towards reward hacking, but it but it does move things closer to the lower left quadrant of these signal limited failures. So it’d be nice. I think potentially I if you really scale up the data, maybe the thinking becomes less and less critical. And you potentially could achieve a larger scale of data if you didn’t have to worry about generating the chain-of-thought reasoning traces. But at least with our scale of data, there’s a significant benefit to ha including these chain-of-thought reasoning traces in the training data mixture, as opposed to just having the progress estimates without the reasoning beforehand. Michael Cho [50:55] Mm. Thomas Weng [50:56] I guess to Michael’s earlier question about how important was the suboptimal data, the yellow plot kinda gives an indication of like what happens if you only use success or successful expert trajectories. Michael Cho [51:04] Mm. Philip Schroeder [51:10] Yes. And for those Michael Cho [51:12] Yeah, it’s always my hunch that sorry, yep. Philip Schroeder [51:15] Yeah, you’re good. Michael Cho [51:17] Yeah, I was gonna say like it was it was always my hunch, like once these you know, whatever AI policies you know, once they are beyond like let’s say something like a level two autonomy, usually they learn a lot more just from like failures, you know. So instead of showing them more success, it’s showing what fails, it’s like they learn better from negative examples. I it’s just a general hunch up. Mm-hmm. Philip Schroeder [51:37] Yeah. Yeah, and I think you don’t need that many of many failures. We could have done a different experiment where we just slowly increase the amount of failure data. Cause I think there are diminishing gains you’re gonna get from that. I think after a certain set, a the model just kind of just starts to get the point. And I think so you think you could have a large corpus of expert trajectories and then just do a little bit of extra Work to get some non-expert trajectories and it will work almost just as well. And for these yellow dots, just to clarify, we’re still including these artificial failure data where you just shuffle the video frames. So the model’s not learning to just monotonically predict increasing rewards. It still does see increasing and decreasing progress estimates during training. It’s just all these artificial examples where you’re just reversing the video essentially. That is common for Thomas Weng [52:40] Not the like suboptimal deviation data, right? Philip Schroeder [52:44] Yeah, it’s not actually changing the trajectories. It’s just playing the video back for back backwards and forwards essentially for the just to pretend like it’s the robot’s actually deviating from what you expect for the expert trajectory. Okay. And then lastly, we do this kind of scaling law experiment where if you just Subset our data to gradually increase the number of tasks you include in the training data for the reward model. You see these dramatic jumps in the number of unseen tasks you can solve through online RL. So this the different pods show the different levels of success of success you get with these different number of tasks. So I guess the idea is if you were to put the work into scale up your training data to hundreds of tasks potentially on the x-axis, maybe that gets you up to a very meaningful number of tasks you can learn now through reinforcement learning. So in some sense you get if you learn one extra task during the reward prediction training, you get more than one potentially task that you can learn now through RL. It just I think The vision-language models just generalize way better with progress prediction than we see with VLAs or other action models predicting actual actions instead of just rewards. Okay. And then finally, I think this are will be results we add to the paper after went through the NeurIPS reviews and did more experiments. We In addition, so our original results, we start with the randomly initialized policy. Here we just start from a strong pre-trained VLA and we show that you can use the SOLE-R1 rewards to get close to close to a hundred percent success rate or average a ninety-eight percent success rate on these more complicated tasks that involve multiple steps, multiple objects, and these are all LIBERO tasks that we’re familiar with. So still Sims tasks, but this just to show that you don’t That the model still works even if you start from a much more competent policy. And this a more realistic setting for doing RL than starting from random. And it’s much more sample efficient and you can do tasks that are much more useful by starting from the s the stronger base policy. Okay. So I think that’s it for the slides. Let me know if you guys have any questions. But yeah, I think Overall, the like I said, the biggest things that differentiate this from RoboMeter and other VLM based reward models are is that the authentic failure or the failure data that we include in the RoboCasa data generation and then this chain-of-thought reasoning that we trained with the two stage approach of supervised fine-tuning and RL with verifiable rewards. Thomas Weng [56:01] I think to emphasize that last point, because we didn’t really talk about it. I mean we basically took the training recipe directly from like what was working from the world of like large models and GPTs and applied it in a kind of robotics setting of using chain-of-thought reasoning and using like reinforcement learning with verifiable rewards. And that seemed to work really well for us for this with our particular data mixture. Yeah. Michael Cho [56:36] Very cool. What would be sorry. Jiafei. Jiafei Duan [56:37] Maybe I guess maybe like the question is yeah. So I guess maybe what would be next, right? ‘Cause like, you know, I taking the as what you just say, as what Thomas just said, like taking the recipe from what it works in the in the world of LMs and GPT, you know, then does it mean to that we need to have a GPT equivalent model to make this thing really useful, or sort of like ca capitalize on its hundred percent capability? Like is that the next thing that we actually need? Philip Schroeder [57:08] Yeah, I mean, I think okay, so I think it can be a combination of just purely distilling from the spatial reasoning capabilities of Astrand future models. But then also leveraging things like sim creation, dynamic sim creation to use the advances in graphics and because I mean sim is particularly useful for training reward models because it doesn’t care about the physics. And the graphics are so good and they’re g only getting better, that you can get a long way with sim. So I think a combination of those two things can get to near perfect reward. I think we’re super close to reward models that are pretty perfect. I think I wouldn’t say the same about pol like actual robot policies, but the existing VLMs have This incredible image captioning abilities, and it’s just a matter of translating that into this video native reasoning that is very sensitive to these incremental changes over time. But yeah, it’s definitely within reach, especially being able to distill from Astra. Thomas Weng [58:26] I think kind of coming back to what you said earlier, Jiafei about multimodality, like there’s definitely possibly something left on the table there if we don’t really look into other forms of robot proprioception or somehow distilling that or not distilling, I guess having some kind of access to that as part of this like reasoning chain. Of course you could have an external viewer, someone who just says whether a task succeeds or not. But maybe f when you’re introspecting and trying to determine if you’ll you as the agent have succeeded or not, being able to use multimodal information ideally without having to fully retrain everything, you know, what does that look like? I mean maybe as a first pass that’s what you do, but yeah, what does it look like to take say like raw tactile signals and actually reason about maybe you have things that are summarizing what’s going on with tactile sensing or force feedback. But then at some point that needs to come back to your reward models in order to determine, like use that as part of the computation to determine whether you’ve succeeded at a task or not, or where you are in a task. Michael Cho [59:45] Yeah, I just to echo what you were saying earlier as well, Thomas, like I think the real-to-sim thing, it’s gonna be a big unlock. I think f you for the longest time like simulation it’s just it’s just hard to create the actual assets that kind of reflect reality. But if real-to-sim start to really scale, then you get the benefit of simulation while you have scenarios that actually is based on reality. I think that’s gonna be huge. Yeah. Thomas Weng [01:00:12] Yeah. Yeah, and there it seems like there’s a lot more you could do with that. Like once you have that simulator, right? Michael Cho [01:00:20] Hmm. Yeah, I mean you get all the ground-truth. I mean, yeah, the you can you can do all sorts of like counterexamples or counterfactual like you guys did here. Alright, very cool. Yeah, I guess you know maybe just to wrap things up we always end with a l like a typical last question. Are there any other papers that you guys came across recently you want to give a shout out for? Doesn’t have to be, you know, reward, it could be anything robotics related. Philip Schroeder [01:00:51] Yeah, I mean so yeah, there I think there’s very obvious ones that we’ve already talked about the baselines. I mean RoboMeter was a great contribution to this area. I think they I think have some philosophical differences with us where they have a way of training the training the dense reward prediction without actually explicitly having to label progress values for non-expert trajectories. And we do the opposite. We just brute force label dense progress values for these non-expert trajectories. But yeah so it’s it methodologically it was very good contribution, I think, and it scales better than our method potentially if you don’t have to do the dense progress prediction. And then also there’s RoboReward, obviously, and Of course all of Jason Baugh’s early work with GVL and Live. So there’s a I’d say it’s a pretty short history, I guess, because it only goes back around like five, ten years, but there’s a there’s a long big family of reward model papers that this building on top of. But I don’t know, Thomas, do you have other papers that you would want to mention? Thomas Weng [01:02:08] I guess this I guess this my own opinion and not like a Ray sponsored thing. But I mean for my own opinion I think some of the Play-to-Perfect stuff is really cool for like dexterous manipulation. And I feel like there’s a lot more that’s gonna be coming in that space. I’m kind of curious of how large scale simulation of like dexterous manipulation really scales because I think to your point about assets, like maybe we will get better and better assets with better geometry and friction properties that are enough to do some interesting transfer. And the current level of like procedural generation is sufficient for achieving that. And if that’s the case, is that kind of bridging the gap between kind of large scale RL training and deployment in the real-world. But that’s very different from I mean, and then I guess the questions there are like, you know, a lot of this work that we’ve done on progress estimation, task estimation is with these like parallel-jaw grippers. And does anything significant really change when you have dexterous hands? Because you know, from the one hand they’re maybe closer to human hands, so there’s a bit of Michael Cho [01:03:30] Mm. Thomas Weng [01:03:36] nice like retargeting that you might be able to get just by saying, this a hand, but it’s a robot. But then on the other hand, you have more occlusion potentially. A lot of things involving hands. The things you really care about are the things that are like very finicky and require a lot of like fiddling and maybe you’re doing a lot more feeling than you are of like a visual result. Maybe it’s like you fiddle with it and then once you’re done you let go and you can see that it’s completed. Well then during that whole fiddly part, you know, is it just kind of pending in terms of task progress. I’d love to see something along those lines, but I don’t know if really in terms of reward papers there’s anything that’s like close to that. But yeah, I think that’s what I’d have to say. Philip Schroeder [01:04:19] Yeah, there’s a new simulator, I think call it’s I don’t know I guess I don’t know how new it is, but it’s superdex. I don’t know if you guys have heard of it. It’s built for this dexterous manipulation with human hands, et cetera. So it’s it looks like a big it has like a lot of soft objects, strings, etc. So it’s kind it’s definitely a step up I think for trying to simulate highly dexterous tasks and could be really good for training reward models. Michael Cho [01:04:36] Yeah. Mm. I see. Yeah, I’m looking at it now. From Meta, I think. Cool. Philip Schroeder [01:04:55] Yes. Michael Cho [01:04:58] it looks cool. Awesome. Philip Schroeder [01:05:01] Yeah, it’s really cool, yeah. Michael Cho [01:05:05] Alright. Yeah, I well thank you so much, Philip and Thomas for coming on. Really appreciate the time. Yeah, I guess until your next paper, yeah, we’ll see you again. Thomas Weng [01:05:17] Yeah, thank you so much. This so fun. Philip Schroeder [01:05:19] Yeah, thank you so much for having us on. Yeah, it was a lot of fun and I really love all the episodes you’re producing, so keep it up, please. Michael Cho [01:05:20] Yeah. Yeah. yeah, yeah. Thanks for listening. Okay. Yeah, we w we’ll try our best, yeah. Okay, cool. All right, see you guys. Philip Schroeder [01:05:33] Yeah. Thomas Weng [01:05:33] Thank you. Michael Cho [01:05:34] Thanks, Thomas. Bye. Thanks, Philip. Yep. Thomas Weng [01:05:36] Thank you. This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit robopapers.substack.com

  • October 7 · 53 min

    Ep#110: ENPIRE: Agentic Robot PolicySelf-Improvement in the Real World

    In many fields, automated research has become increasingly plausible with the improving capabilities of frontier language models, and the field robotics may be no exception. In ENPIRE, Wenli Xiao, Jia Xie, and Tonghe Zhang build a harness framework that captures physical feedback and allows for automated robotics research, minimizing human effort while training policies that achieve a 99% success rate on challenging, dexterous tasks like organizing a pin box or fastening a zip tie. Learn more in Episode 110 of RoboPapers, with Michael Cho, Chris Paxton, and Ruijie He! Abstract Achieving dexterous robotic manipulation in the real world heavily relies on human supervision and algorithm engineering, which becomes a central bottleneck in the pursuit of general physical intelligence. Although emerging coding agents can generate code to automate algorithm search, their successes remain largely confined in digital environments. We conjecture that the missing abstraction to automate robotics research is a repeatable feedback loop for real-world policy improvement: reset the scene, execute a policy, verify the outcome, and refine the next iteration. To bridge this gap, we introduce ENPIRE, a harness framework for coding agents that instantiates this physical feedback routine with four core modules: an Environment module (EN) for automatic reset and verification, a Policy Improvement module (PI) that launches policy refinement, a Rollout module (R) to evaluate policies with one or multiple physical robots operating in parallel, and an Evolution module (E) in which coding agents analyze logs, consult literature, improve training infrastructure and algorithm code to address failure modes. This closed-loop system transforms real-world manipulation learning into a controllable optimization procedure, minimizing human effort while allowing fair ablations across training recipe and agent variants. Powered by ENPIRE, frontier coding agents can autonomously train a policy to achieve a 99% success rate on challenging, dexterous manipulation tasks, such as organizing a pin box, fastening a zip tie, and tool use, a process that further accelerates when we dispatch an agent team on a robot fleet. Our results suggest a practical and scalable path toward deploying coding agents to autonomously advancing robotics in the physical world. Learn More Project Page: ArXiV: https://arxiv.org/abs/2606.19980 Transcript Michael Cho (00:06.088)Hello everyone, welcome to another episode of RoboPapers. Today we’re super happy to have Wenli, Jia Xie and Tonghe. They are three of the co-authors of this paper called ENPIRE: Agentic Robot Policy Self-Improvement in the Real World. Thank you so much for coming to the pod. Maybe as a start three of you can share a little bit about yourself first and then you guys can go through the paper. Wenli Xiao (00:30.821)Okay, I’ll get started. Sorry. So my name is Wenli. I’m a final-year PhD at CMU, advised by Professor Guanya Shi. Previously I did two-year internship at NVIDIA GEAR Lab with Jim Fan and Yuke Zhu. And later I joined Physical Intelligence as intern. Yeah, I did a bunch of VLA training, post-training, real-world RL and agentic stuff and now I’m mainly doing pretraining, studying the science of training and data. Yeah. Michael Cho (01:14.488)Yeah, I think just yeah. Jia Xie (01:16.463)Okay, sure. Yeah. Hi everyone. My name is Jia and I’m a master’s student at CMU, advised by Guanya. Of course we’re labmates. And I’ve interned at xDof as a research intern over the summer. And I’ve been working on some agent stuff and the extent stuff lately. So yeah, thanks for having us. Tonghe Zhang (01:43.739)Okay. Hi, my name is Tonghe. I’m also a master’s student at Professor Guanya Shi’s lab. I was doing internship at Amazon this summer and previously I’ve been working on reinforcement learning. And thank you guys for inviting us. Michael Cho (02:01.15)Alright, perfect. Great to have you guys. Yeah, Wenli, I know you have a slide, maybe you can go through with us. Wenli Xiao (02:08.228)Okay, yeah. So yeah, today the main topic is to introduce our paper, but as we all know, recently there’s a major breakthrough in AGI and that affects robotics, that is GPT-6 Astra. There are a lot of demos from Twitter that shows people apply this model to do different tasks. That related to robotics, like real-to-sim, sim-to-real, in-context learning, and code-as-policy. And we are very excited and we are kind of a little bit frustrating and also wondering how well robotics been solved. But we will leave the discussion to later section. And because even before the GPT-6 Astra Already witnessed a huge improvement of coding agent this year because we felt like coding agent is a biggest thing in AI this year because starting from February or last year’s December we see like a lot of a lot very good coding agent like Opus and Codex. They can do a lot of stuff like starting from front-end to Back-end and build a lot of great applications. And actually, people have been trying to use these models in robotics every time there’s a breakthrough in AI. And for this year there’s a CaP-X project, which we apply the and benchmark the state-of-the-art LLM model and VLM model to Try to solve and hill-climb on the robotic simulation benchmarks and it did pretty well in simulation. And we also tried to use coding agent to just solve the very challenging manipulation benchmark. This is a very classical task which would you need to manipulate a dot to push a T-shaped object until you perfectly matches the target. Wenli Xiao (04:31.492)And this was really challenging and people find a solution or people didn’t find a solution until diffusion policy. But now we just prompt the coding agent out of the box. This is actually Codex. We prompted to write a heuristic policy with no neural network training to achieve a hundred percent success rate. It just try and try and eventually it can like Write very good heuristic b policy. And this applies to different coding agents like Codex Claude Code and Kimi from Moonshot. This was very exciting to me. And actually during the past two years there are many impressive works about applying coding agent for robotics. So here I just like briefly divide them into three categories, like VLA plus harness, so you can achieve great performance that can be better than either VLA or code-as-policy itself. And there’s of course Code-as-Policy, which people apply coding agent to try and practice in simulation so they can learn some skills and later apply to the real-world. Real world robotics. And there’s also physical autoresearch, which is the ENPIRE work that we are gonna discuss today. So the major difference between the first two categories and the physical autoresearch is even all of them applied the method in the real-world. For the first two part of first two categories, they need tons of human effort. So if we summarize the procedure of the researchers do these projects, it’s like they apply coding agent to write code and do some practice in simulation and also with some guidance of human, it develops some impressive skills. And then the researchers, PhD students, deploy the policy in the real-world and watch the results. Jia Xie (06:54.974)Okay. Wenli Xiao (06:55.682)And maybe for the first trial it doesn’t work, or even the robot just do nonsense. And then the student just describes what happened and type in the terminal, and then the coding agent fix it and do another trial error and apply and suddenly it works, and then can submit paper. So in this process we observe that humans are a major bottleneck. Because we become the agent’s actuators and sensors. Yeah, because the observation was from like six months ago, now with GPT 6 extra, maybe we don’t need to be the sensors of the robot. GPT can like if you set up a webcam in a third-person view, maybe GPT can observe that the policy doesn’t work. But six months ago we didn’t have such good GPT and we have GPT 5.5 and we still wanna see how much it can do. So here is an example, we assemble the robot arm used some DaMiao motors because we are too lazy. We didn’t want to implement the firmware and we didn’t wanna implement the low-level control. So We just plug in the USB-CAN to the computer that has Claude Code installed and we prompt it to implement the impedance controller for the arm and try it by itself. And with great expectation and the Claude just like just think and write, think and write, and after five minutes it finished. And here’s the result. Michael Cho (08:50.424)Gosh. Ouch. Wenli Xiao (08:51.676)Yeah. And we were w glad we muted this video. Yeah, we were screaming about it. Yeah, and then we took another night to redo the 3D printing and assemble the arm again. Yeah. Chris Paxton (08:54.443)Did that break the robot? Is it? Yeah. Michael Cho (09:03.74)My Michael Cho (09:13.212)Well, you guys were very brave, man. RJ He (09:13.527)I think you’re particularly making Chris sad, given his background. Wenli Xiao (09:16.732)Yeah. So well it’s a little bit frustrating, but because autoresearch works so well in simulation that it works and your capacity to make a Twitter post. And there’s a lost also a lot of great applications of applying autoresearch in sim and digital world. So we started to think Michael Cho (09:20.366)Ouch, ouch. Wenli Xiao (09:43.857)What’s different between autoresearch in sim versus in the physical world? And we think that’s because in simulation or in sandbox you can do reset for infinitely many times. You have a verifiable reward, you can heal climate. And of course there’s a sandbox, you won’t break anything. But that may not be true because maybe with A S I it can jailbreak the sandbox. But for robotics, we don’t even have this harness or sandbox in the real-world. So that’s the motivation of the entire project. So for this project we wanna take a wild step and see like what’s the minimum setup we can do to let AGI or coding agent to actually do research in the physical world. Wenli Xiao (10:44.112)So like for this project, way b yeah. Chris Paxton (10:47.937)Sorry, can I ask maybe this is maybe you’ll get to this later, but why can’t I just ask it to reset itself? You were saying like things like resetting and safety and all this are part of the problem that keeps you from doing it in the real-world, but like I don’t know, I’m prompting it. Why can’t I prompt it to do all those things? Wenli Xiao (10:55.974)Uhhuh. Wenli Xiao (11:01.52)Yeah, yeah. I and actually that’s a idea. B because so I if you if you’re gonna hear climb on something, you really wish the signal is correct and the environment is safe. And so I believe at some at certain time if you just prompt the GPT to write a safety module and write the auto reset layer. Chris Paxton (11:09.388)Okay, we’ll get there. Wenli Xiao (11:29.294)It can do that, and we actually observed that GPT-6 can do much better than GPT-5.5. But this is just a like system design in principle. Yeah. So in principle we need auto-research environment for the agent to hill-climb on, and we need verifiable reward to Evaluate the policy or whatever the agent generates and then we can start the autoresearch loop. So wait actually let me switch to the website. Wenli Xiao (12:22.298)Okay, so here is a diagram. You can see it’s basically like two autoresearch loop interleave with each other. So for the first one, it’s like we’re human user, we prompt the agent to write an auto-reset layer. Because for GPT-5.5 it lacks spatial reasoning capability and also it lacks context of the robot. For example, it doesn’t know What does it mean to be safe for the robot? So we need a lot of human prompt and human guidance so to babysit the agent to write a reasonable auto reset r auto reset environment and to build the reward function. And after we have such environments, we just like do the run, let agent to write whatever it wants to hill-climb on the score. And Yeah, so this sounds very like now in like to make things crystal clear, we’ll let Jia to describe what did we do for all these four different tasks. So Jia, can you hand over? Jia Xie (13:38.569)Yeah, sure. Yeah, so Wenli Xiao (13:40.592)Yeah, yeah, can you share screen yourself or you need me to scroll down? Jia Xie (13:48.225)May maybe I’ll let you know when to go scroll down. So that was it? Wenli Xiao (13:54.82)Okay, okay. Okay. Jia Xie (13:59.926)Cool. So yeah, thank thanks for the overall like control to the whole paper. Yeah, as Wenli mentioned, all these modules are as we observe critical for this whole system to work. And to break it down a little bit and get into some details, the one of the most important modules here is reset. So for the task here, this is Push-T, which is the you can say the digital twin of the earlier task that Wenli showed, which in our case the agent like two, three months ago can solve it very, very easily. However, if we once we switch it over to real-world, a lot of the problems occur. So re-reset is one of the most difficult part here as and sim if you think about it, you just call the reset function. But however, in the real-world, you can of course program a lot of the like controllers and just roll it out. In a systematic way, but there are numerous edge cases that you need to very carefully engineer it so that it makes sure the whole cycle doesn’t break. Of course we can believe that Astra can have higher abilities to address these issues but still this reset By itself is a big differentiator between real and sim. So yeah, I think we can maybe show a couple of examples. Yeah, yeah. Wenli Xiao (16:00.593)Yeah, so I want to add some information. So for here the this Push-T task is like a real-world version of the simulation Push-T. And here it’s a l little bit funny because so the classic Push-T is down on Franka arm and where the you change the robot gripper with a long stick. So you can use a stick to pull the T, which is very like Much easier because there’s no occlusion, but here we use YAM arm setup. And you can see if we if we use the arm to push a T, it will block the top camera. So eventually the policy here climbed on the agent. It’s like it will push a T a little bit and then go home and use the top camera to analyze and then plan again. And so here for the reset we It stops. Wenli Xiao (17:03.536)So we basically want the robot to pick up the T and place in the same initial position, no matter where it’s located on the desk. And wait. Yeah. Wenli Xiao (17:29.052)Yeah, you can see Wenli Xiao (17:37.852)Let me let me change your website. That one this one could be faster. Wenli Xiao (17:50.855)Yeah, yeah, this is faster. So you can see no matter where place the T on the on the table, it can be reset. And we actually check the code generated by the agent. It’s it’s not as bad as I thought. It’s basically detect called CV2 to segment the red element from the top camera picture and to In order to locate the T and then do some motion planning to pick up it and place it. So it’s basically a very classic scripted policy. And for the second task is pin insertion. And this is a little bit trickier because even for the state-of-the-art Vision detection model, it’s hard to find the small object and even not even like provide a reasonable affordance, like grasp poses. So here, so we as human we guide the coding agent to do the detection in 2D space so that it only needs to worry about the xy direction. But that’s very hacky and We believe that with GPT-6 we don’t need that and But even with even with this harness or hacky way, we can achieve very impressive and robustness reset for this task. And then there’s also like we can we can have reset for the zip tie example and GPU insertion. But shamefully, that’s not very generalizable because Wenli Xiao (19:52.155)Because with motion planning, there’s a very limited pose that is feasible for both arms to operate on. So we restricted the initial range to be a little bit small, but we didn’t fix it on the table. Yeah. That’s for the reset part. And Do you guys have any questions? I’m not sure whether I describe it clearly. Wenli Xiao (20:25.51)Okay. Wenli Xiao (20:30.576)Yeah, that th that’s a that’s that’s a reset part. And then to provide clear signal to hill-climb. For the for the Push-T and Push-T pin insertion and zip tie part for and GPU insertion, it’s very easy. There’s heuristic based ways like detect the height of the object, detect the force, but for the zip tie insertion it’s a little bit tricky. Like we asked Tonghe to write a reward function. He tried about three days and couldn’t find a reasonable one. So he actually did autoresearch based on the image or human demonstration to discover the reward function. Tonghe, do you wanna talk about it? Michael Cho (21:25.774)I think you’re muted. Tonghe, I think you’re muted. RJ He (21:26.878)Yeah. Tonghe Zhang (21:28.346)Yeah, can you hear me now? Okay. So the zip-tie reward is more challenging because it relates to the form of objects that’s difficult to directly tell the size and the shape as a rigged body. So we did try a lot of ways to use simple rules to tell if it’s successful or not, but Simce it’s deformable, the same position can have different outcomes. So w what the agent essentially does is that I give it SAM detection tools. I’ll also tell you that you have multiple wrist camera views or top camera to use to consolidate your evidence to make sure that it’s really patent through the head instead of flying over the head so that it’s actually inside the knot instead of just Standing on the other side of the head. So the agent also gets some success and failure examples, which we can collect very easily. You can just plug it in, and then you will get a lot of examples by just doing some shaking of your hand and then you have lots of different camera views of what is a success. And you can also have what is a failure by just demonstrating a failure, which is way easier than teleoperating itself. So the agent has success and failure examples. It has the tools to segment the zip-tie strap and the zip-tie head. And I also tell you can use multiple camera views to make sure it’s really passimg through. So the agent starts in all the research to synthesize a function, actually series of functions, to tell if the strap is passimg through the head and how long does it pass through. And is this really intersecting with the head or it’s it’s actually not? So eventually the agent is able to hit eighty to ninety percent F1 score on the offline success or failure binary dataset that I provided. And it also knows how to accelerate this process to make the reward function very, very fast. I it reduced the time to tell from one second down to a hundred milliseconds. Tonghe Zhang (23:46.38)So that this reward system becomes real-time and also mostly reliable. Yeah, that’s how we develop this reward function. Wenli Xiao (23:53.764)Yeah, the code is just like go ahead, go ahead. Michael Cho (23:54.73)Tonghe, I’m I’m yeah, I’m curious, yeah. Yeah, actually Tonghe, I’m curious, like you know, it took you three days, you know, original human effort, you gave up, you do this autoresearch thing, and then, you know, I guess the agent figures something out. Very good F1 score. So but eventually, like when you look at the actual reward function done by this agent, like it’s is it humanly like d do you think that you could have gotten it yourself? Or it’s it’s just Is there any insight there that you th that you think it’s you couldn’t quite figure out yourself, even if you were to spend a lot more time on it? Tonghe Zhang (24:30.83)Well yes, I think the agent does make some well, surprisimgly good, modifications to what I proposed earlier. First of all, the agent knows how to use depth camera to measure the correct 3D coordinates of the zip-tie strap and also understands how to use PCA to get the major axis of the strap. So that because you know strap can’t be can’t be tall, can be can be short. But how do you tell the orientation of it? So it is PCA and it’s very, very efficient. It only costs you like tons of milliseconds to do the computation. And it also is surprisimgly good at accelerating this system. Like previously we were usimg PyTorch models and Codex or Cloud tell me that hey, actually there’s a way to get a vastly better way to build a TensorRT compilation graph from the SAM 3 model, which is Something I actually didn’t know b before he told me. And you know when I search on Hugging Face, there’s actually no such implementation for SAM 3 models yet. And I was like, okay, so can you show me how to do that? And well what it does is first it tells me that you don’t actually need 1080 pixels of the original SAM resolution. You can downcast it to like 640. And then it already saves you three times the encoding time. And then you can also do the compilation which I don’t understand at all. And the model does the compilation, it gives you a hill climb a graph telling me the F1 score is not decreasimg but the speed is getting up by you know three times. That’s something beyond my capability to make it fast. And also the agent tells me you can do some cropping before you call the SAM tool to suppress the background noise, which is I think it’s very smart. And they also hand-tune a lot of parameters like which is the best cropping ratio, what’s the best place to do the cropping. And How to ha w if SAM returns multiple candidates, how to select the best one, how to suppress the noisy, false-positive segmentation masks. The hyperparameters are tuned by the agent, which is definitely way better than me. And not to mention the acceleration part. So it’s really very astonishing that an agent at GPT-5.5 level can also do that very, very smoothly. Not to mention what Astra can do. We haven’t tried it, but Tonghe Zhang (26:55.584)I can only suppose the Astrack is gonna be way better than this. RJ He (27:00.842)Do you think that’s therefore the way to go for these reward functions now? We should not ever try any other approaches given the progress of these agents? Tonghe Zhang (27:13.998)Well, I think this in this case, segmentation and geometric relationship is enough. And the development is like taking an afternoon, then you get it’s something that’s working pretty well, although not perfect, but it’s it’s already demo level. In terms of how extensible this p system is, say I give you a random task and I tell you a brief language description of what is success. Give us some little demonstrations of a success status and a failure status. Can Astra solve everything? Well at least we tried some examples which when you can show you guys later. We also tried some new examples with Astra. Astra knows if a task is successful or not and it knows if it failed it should retry. So I suppose that inherently this is a VLM that have a general understanding of what is success means visually. So I don’t think it’s a difficulty to scale this up to thousands of tasks as long as you have the tokens. Yeah. And I also think that it’s possible that Astra can help you train a reward model if you give it the data. It can also obviously do other research to get a better like reward model architecture or training recipe. That’s also possible. Wenli Xiao (28:33.094)Yeah, but I do think not even code-as-policy. Maybe code-as-reward is could be a thing if we have like AGI level VLM. So because here we demonstrate that with limited data, say if you train an end-to-end neural network, you’ll definitely like be too conservative or too aggressive, not able to do RL on top of it. But if you write code to represent the reward. Like it’s explainable and as human we can tune some of the threshold to prevent RL exploit the reward. So I feel it’s much more efficient. So maybe like it worth a systematic study to compare this with the foundation reward model in the future. Michael Cho (29:32.064)Yeah. Yeah, fascinating. I think it’s it’s it’s incredible that we have now tools like extra. It’s you know, ‘cause like RL you know, for the longest time is like how do you even like it’s so hard to hand tune the reward, right? But now you can just okay. Figure out the reward, you know, and then maybe you get the reward out in an afternoon. Yeah. This is awesome. Okay, cool. Wenli Xiao (29:46.95)Yeah. Wenli Xiao (29:57.061)Yeah. RJ He (29:57.963)So then in that case, does that mean that, you know, your paper w was it was the main insight about doing the decomposition into these four parts of it and then just letting the agents run loose in there? Almost feels a little unsatisfying that it’s just agents in each of just it all you needed was the decomposition. Tonghe Zhang (30:15.746)Yeah. Wenli Xiao (30:23.462)Yeah. Jia Xie (30:25.318)I think this is like one possible way of harnessimg that because the model capability is not there, that you kind of need a we can say sandbox or sort of a like assistance for the model to do the self-improvement. But as the which is a trend, the model goes to do better and better, we would eventually envision a system where Tonghe Zhang (30:26.106)How Jia Xie (30:53.5)You would need minimum or even zero human effort in the whole cycle. Tonghe Zhang (31:02.254)Also it’s very important to you know build the basics of the harness because if you literally let Astra and write all the controller code, it’s gonna waste a lot of time. And there are also like safety concerns that humans should have some input at least. However a actually Astra knows a lot about safety rules than the previous models. So ENPIRE was developed like six months ago. Six months ago we started to write the first piece of code by hand and then six months later we actually don’t know how Astra can simplify the system. Probably lots of the code of fallbacks and if/else logic, we can just remove them from our Wenli Xiao (31:35.972)I don’t think it can simplify the system, you know, make it even more complex. Tonghe Zhang (31:42.04)Yeah, but probably you can find some better ways to achieve it. RJ He (31:47.659)I guess you guys have four tasks here and there are some you know, some pretty impressive tasks. But were there tasks that you all tried that you weren’t it wasn’t ready to be able to accomplish that yet or that didn’t succeed in this framework? Just wondering. Wenli Xiao (32:05.693)Yeah, so for all these four tasks, they are relatively easy to reset and easy to write reward function. I guess for like cloth folding or like how do you say origami? I it should be very hard or like use a key to open a door, like in a in a general way, like PyDate. I feel from the perspective of GPT-5.5 it’s really hard but maybe I it’ll become easy with GPT-7 or GPT-8. RJ He (32:43.798)Yeah, actually maybe if you all can expand on that a little bit. What from your experience working on this, which types of tasks work well w would work well within this framework? And which ones would? You sort of alluded to it a little bit already with you know, ones that are hard to reset, but if you can expand on that a bit more. Wenli Xiao (33:03.472)Yeah, I think because we did this from the perspective of recursive self-improvement. So eventually once we have a very good AGI model and we can use that to train skills and then we can use a train skill to reset even challenging a more challenged new skill in the future. So like you will learn like more and more complex skill. Tonghe Zhang (33:30.182)Yeah. Wenli Xiao (33:33.398)And but we do think the major bottleneck is that because here we only did things in the real-world. So if for long-horizon and task and for the task that need many steps to reset, it would be very challenging. So if you if you are doing a chemical experiment and you have some intermediate state, then it’s really hard to reset. Tonghe Zhang (34:08.206)Yeah, we’re also not directly training of super long-horizon tasks too. Yeah. Go ahead, go ahead. Chris Paxton (34:08.749)So for the for the resetting problem. Okay, but I secure it’s for the for the I just going back the resetting problem though, like I mean it can it can learn how to reset itself, right? So like I mean I understand there may be lots of steps, but like that’s is there is it just like it would take a long time to do this? What’s the okay. Just be slow. Okay. But so if you have enough robots though, all right. Wenli Xiao (34:27.974)Yeah, yeah, I it would be it would be inefficient. Yeah, it would be Chris Paxton (34:34.483)Like it’s not like it can save all the programs that it’s written and all the weights for the policies it’s learned. So fundamentally, okay. Wenli Xiao (34:41.564)Yeah. Yeah. So once we have the—wait, where is it?— Yeah, once we have this harness, we have the environment, the reward, and then it’s the same as other research in the digital world. So we start with zero success rate and give it some budget and can hill-climb to get a better performance. So here because we are conducting experiments in the real-world. Tonghe Zhang (34:58.218)Yeah. Wenli Xiao (35:11.738)We have very limited budget and also during that time we didn’t want to deal with like the communication between local machine and the cloud cluster. So we did it in a low-data, low-compute regime. So for every robot we provide with 5090 GPU desktop. So for the model training it can only be run on This 5090 and also for each iteration we only give like twenty ish minutes for it to explore and so like the final policy that trained by the system is like small policy or with limited capacity. So here we connect the system To coding agent for each of the eight robots, we log in and open a Codex session, and then we let it access the same GitHub repo so that they can do like communication between each other. And here we didn’t use a simgle agent to like control all these eight robots because there’s a huge communication delay. So we found the most efficient way During that time is to have a shared repo for them to discuss. And for each of the agents, we prompt with the same /loop, like improve the policy and don’t stop prompt. And it starts with zero and like actually we found it’s interesting that the for one of the agents at some time it’s downloaded all the Research paper from Sergey Levine’s lab to learn what is RL and to learn the design choices of reinforcement learning. Yeah, I told this to many of my friends at Sergei’s lab. They’re happy with it. Michael Cho (37:16.789)Okay, okay. Chris Paxton (37:20.611)Mm-hmm. Wenli Xiao (37:25.616)Yeah. Yeah, because they have a lot of papers about that and many of the experiments are on a like small policy. So it’s very relevant here. Yeah. And Michael Cho (37:35.051)Well. Cross agent help. RJ He (37:37.536)Well Wenli Xiao (37:42.0)Yeah. Yeah. RJ He (37:45.684)The question here is was that did that agent do better than the others after l reading all that info? Wenli Xiao (37:52.771)I guess so. I think for this exact experiment, I think it’s better than the paper. Yeah, because it was trying to use the exact same hyperparameters from the paper appendix, but like eventually it’s tweaked a little bit. And yeah, it followed paper to add BC regularization, tried different Measurements of distance like L2 norm, L1 norm, and cosime similarity, different stuff. And eventually we act I actually didn’t check the final code, but it tweaked it a little bit. And it even tweaked the BC term, tweaked the batch size. And so because usually when we want to train a policy, we want to Good base model. It actually tried to download GR00T model and π0 model, but because it’s too expensive to fine-tune them, it didn’t finish a simgle iteration after twenty in a 20 minute budget. So it for like so it gave up and just trained a small policy with like a ResNet plus a MLP. It actually even tried DINOv2, but it’s still too big for this small computer. Yeah, so this hill-climb curve is basically the optimal result under the small budget. And we think we believe that if we give more budget, like we give the whole cluster and with some simulators I it can get more like fancy methods and fancy model they can try in different cases. Yeah. Wenli Xiao (39:50.509)And another thing very interesting is so after publishing this paper, many people ask, did it really discover some super efficient reinforcement algorithm? And our answer is no, it’s it’s actually no, it’s just doing hill climbing. So the agent is trying to find a shortcut to solve the problem. So here, I have a slide. Wenli Xiao (40:35.964)Okay, yeah, so here at this step it found the it developed the compensation controller. So the idea is that because this is a pin insertion task and the height of the surface is a constant, and so that the agent figure out that once the pin just reaches the hole, it cannot move in the x and y axis. So it determined that once the height of the p of the end effector below some threshold, it will downscale the actions in the XY direction and upscale in the Z direction. So like as long as you like get in the hole a little bit, it can move very fast to reach the end and get a positive reward. And that’s a compensation controller. Michael Cho (41:37.48)Yeah, I think I mean th like trick tricks like that sounds very reasonable to a human being, but it’s probably just so painful to like state each one of them. But if you can just Yeah. Wenli Xiao (41:48.081)Yeah, yeah. But yeah. Yeah, but the thing is, imagine if you are like you have a robot farm of a thousand or ten thousand robots, and then this trick will not like have any improvements on the benchmark or on the score on average. So I th I still think it has this shortcut because we have very limited budget. Yeah. Michael Cho (42:15.638)Mm, I see. Wenli Xiao (42:18.32)Yeah, and for this system, it has another limitation is this actually a scaling law. So initially we tried only one agent to do this task and it didn’t work. So I was very mad at that time, so I actually typed in the chat box to provide some insight. But even with this We cannot succeed in a Push-T task. But once we really actually set up the eight agent collaboration system, it just suddenly works like in two hours. So we feel like large batch size and large number of rollouts actually matters. And yeah. RJ He (43:06.902)So just going back to earlier you were talking about this was all done in, you know, s low the sort of low compute regime, do you think that the performance would be different if you had relaxed that constraint? In and in what ways? Wenli Xiao (43:19.722)Yeah, I think so. Because in the very beginning it tried to fine tune π0 model or GR00T model. Yeah. Wenli Xiao (43:32.294)So we have a th like thinking experiment that’s actually every robotic startup is a is a gigantic empire system like but with a lot of human operators to con l connect the loop. Wenli Xiao (43:53.521)Yeah. Wenli Xiao (43:58.513)Yeah and here’s a video that’s one once we launch a system it’s it looks so fancy. Because you can see the robot like just autonomously practiced by themselves. Yeah. And also have like scaling law of the token usage. The more agent you launch, the more token you spend. Jia Xie (44:25.425)Wenli Xiao (44:29.21)Yeah, and also one thing to mention here is so we’re not just usimg eight coding agents to do the research. So for each computer we’re prompt it to launch agent team. So it’s like eight agent teams collaborate with each other. Yeah. So in total it may have like sixty four agents like to do the search, yeah. RJ He (44:53.504)Do you do you predefine the roles within the agent teams? Or you let that let itself define it? Okay. Wenli Xiao (44:59.6)I don’t define the role. Yeah, I don’t define it. Yeah. So one observation is initially because there are some open source coding agent harness like open code or Pi or Hermes, right? So we initially we customize the harness a little bit, as some human insight, but later we found that w we just use the simplest codex or Claude code, it will just work. RJ He (45:04.522)Do you of Wenli Xiao (45:29.732)So like I think the harness here doesn’t matter much. Yeah. Michael Cho (45:37.811)Yeah. I’m I’m curious, like you guys mentioned you guys did some like recent except experiment with Astra. How have things changed, you know, simce this paper and now with Astra. Any insights there? Wenli Xiao (45:46.872)Yeah, yeah. Okay. Yeah. Wenli Xiao (45:55.665)Yeah, so one funny thing is okay, I add your intro and Tonga will have more insights. So one funny thing I think is so normally if those foundation model companies re release a new model, Ph the research of PhD students will be scooped. So right. But here we found that with more powerful GPT-6, they actually like Fit into the like animate eliminate the biggest bottleneck of our paper. So with better model the reset will get be easier, much easier. So Empire will work better. So I think so I so that’s why I’m very excited about the GPT-6 and I’d like to try Empire on like more challenging tasks with that. RJ He (46:52.502)Well but a lot of that is because of the premise that you all have taken, which is to be almost agent first, right? In how you design your to assume that there are agents that will do a lot of the subcomponents a lot better and that actually the agents will do better w will also improve over time, right? So that’s a fundamental premise of all the work that you’re doing here. Wenli Xiao (47:00.401)Yeah, yeah. Wenli Xiao (47:15.326)Yeah, yeah, that’s true. Yeah, Tonghe also tried some interesting tasks where we can discuss. Tonghe Zhang (47:24.218)Yeah, I th I think it’s something it’s on Twitter. We have made a demonstration of usimg Astra to connect with the ENPIRE harness and the a the agent is able to do a in-context learning s that I give it a demonstration of me putting a cup on another cup, flip it 180 degrees, and then Astra is able to record the MP4, read through the frames. Jia Xie (47:28.1)Yeah, that’s Tonghe Zhang (47:53.601)Extract my motions, understand what I was doing, summarize this, and give it a new plan for how to replicate it itself. So this is me doing the experiment and then this is what Astra tells the robot arms to move. So that it can actually mimic the entire motion sequence and not just a instant. It’s actually an entire motion sequence to finish this job. And Surprisimgly, because our harness provides a good motion planner, so that the first time when Astra tries to mimic my motion, it only wants to use one arm, only the left arm. Astra tries to you know unflip one of the cup and use the same arm of the left arm and then place it on top of the closest cup because he thinks it’s the easiest way to do it. But unfortunately at that angle the left arm actually reaches a joint limit. So Jia Xie (48:29.016)Yeah. Tonghe Zhang (48:48.366)The motion planning will always fail, no matter what kind of angle or position you plan. And then Astra actually thinks that is impossible to achieve, so that he tries to select other goals. And in order to use other goals, you probably need another hand for help. So that Astra looked inside our code base and discovered that there is a handover function that we that we once left in the code base that tells you how to do a handover in general. And then Astra calls the handover function to hand the cup from the left hand to the right hand. So that let right hand have more freedom to choose the goal that you want to place the cup to. So it literally just out of the box in one in zero-shot it knows how to do the handover and also it’s very precise. There’s some adjustments to make sure the handover is safe. Yeah, there’s there’s a first trial and it notices that it’s actually not stable. Wenli Xiao (49:39.056)Yeah, there’s recover. Tonghe Zhang (49:47.159)And then it does a notch in the right hand to make sure it’s aligned and then place it down. So a power model as Astra understands the harness, understands what how to deal with motion-planning errors, how to find new ways to solve a problem, even if I didn’t actually explicitly instruct him to do it. So a stronger VLM is also able to read MP4 long videos directly so that it’s possible to unlock visual in-context learning. Which is actually a little bit difficult for previous models, which have l worse ability and video understanding. So at least from this demo we can see the Astra is more flexible, understands the harness better and exploits the harness better, and also give you better capability to do in-context learning. That’s what we have seen right now. And we are also conducting other kind of experiments, testing the boundaries of this model. Wenli Xiao (50:44.198)Yeah. Tonghe Zhang (50:44.258)And I think that this work, ENPIRE is model agnostic and that’s why the stronger the base model is, the more capability we can get out of it. Yeah, and that’s also why Astra has been com continuously surprisimg us instead of replacing this work. It only makes this work more valuable. Michael Cho (51:03.598)How do you guys think about this trade off between like, you know, having stronger and stronger you know, AGI type of models, but you can only assess from the cloud? So you take a pretty bad latency hit versus something that is that really requires closed loop, you know, high control frequency. There’s this excellent article that’s going around d yesterday, I think, from semi analysis that basically talk about this trade off, right? W do you guys have any sense, like how would that impact? Wenli Xiao (51:33.04)Yeah, I think if we only take a look at this year, that could be a problem, but if we like foresee like five years later or even like three years later, I believe like there’s a lot of engineering tricks to make the model of inference faster, like how the voice model did. Like I feel that like GPT voice too works like it’s Michael Cho (51:34.396)Okay. Wenli Xiao (52:02.023)Pretty smooth and that kind of frequency can already do a lot of like task for robotics. But if you’re talking about the extreme dexterous task like require reactive behavior to the tactile, to the force, yeah maybe we still need some like low-level system, low-level controller. Yeah, so I think maybe in short term there will be revive of sim-to-real and or even VLA, because like based on my observation, like maybe like a better GPT-6 Astra can like guide a better π0 model to do a lot of impressive tasks that we never imagined before. Yeah. RJ He (53:02.646)Do you feel like your framework needs to be the ENPIRE framework needs to be updated for these newer models or it just kinda works? Wenli Xiao (53:12.826)I think one thing we can add is simulation. Because I used to do a lot of sim-to-real for humanoid with Tairan And I also like revisited the RoboPapers podcast that Tairan and Haoru did for VIRAL and Doorman. And they mentioned the biggest bottleneck for sim-to-real at that time is like reward function, how to construct scene and task. And how to do long-horizon. And now I feel GPT6 Astra almost solved all of them. So it’s very easy to construct a new thing with this coding capability. And you can do autoresearch in sim to figure out the task and reward. So I think it’s very natural to incorporate simulation in ENPIRE framework. Maybe we can add one-line prompt. That is reconstruct this scene in simulation and do domain randomization to test your ideas. I think that’s it. Chris Paxton (54:21.059)So I mean, just to defend viral and all the work that those gu that they were doing with that, like that was they Eureka did a lot of this stuff before then, right? So like is this fundamentally has this been enabled by like would you by improvements in GPT? Yeah. Wenli Xiao (54:29.18)Uh-huh. Yeah, yeah. Wenli Xiao (54:34.266)I think it’s fun yeah, I think it’s may maybe fundamentally it’s not different, but in practice like it’s totally different because with Eureka y there’s still a lot of human like insight and restriction, but now with GPT, we just let it to rewrite everything. So it unlocks much more new capabilities. Chris Paxton (55:04.621)So it’s basically so what you’re saying is basically because like Egyptic coding works now, like this the it can close the loop that previously the human was really having to do much more of. Is that fair? Wenli Xiao (55:14.229)Yeah, yeah. Michael Cho (55:21.721)Yeah, so I guess I mean if you know, now that we have Astra and you know y we’re gonna have even like basically AGI series models, you know. GPT-6, seven, eight or whatever. I mean as you build an empire right now, it seems to me there’s almost like very little human in the loop anyway. So I’m just wondering it’s it’s is there like what would be the role of a robotic researcher engineer like in this in this loop. You know. I think I mean Tonher, you mentioned earlier just now that like if you just let Astra do the whole thing, it’s gonna waste a lot of tokens. So I get that, you know. Wenli Xiao (55:53.915)Ha. Michael Cho (56:08.647)But let’s say if you’re very well-funded lab, you know, you know, token is not a major concern. Michael Cho (56:17.917)Like sh should human just get out of the way and just let the whole thing loop? Like Tonghe Zhang (56:24.078)Well I think well, if you’re a very good robotic engineer, at least when we’re dealing with controllers, you still have a little more sense, philosophically. But in terms of optimizing a system, I don’t think you need to do that all the time on your own. But you can become sort of a product manager like giving GPT-6 your requirements, like latency requirement was the what is the minimum latency requirement you have to reach. Michael Cho (56:26.269)Where do we assert some value? Tonghe Zhang (56:54.062)Like the safety requirements and also the flexibility design of the system, y it you will more work like an advisor or a investigator instead of just the s the people implementing the details. But I think if you have a lot of experience in robotic control, you can veto some of the so-called inventions of GPT-6, although these wild ideas will gradually be become less or less, but you can help control this process and Your prior probably can lead GPT-6 to some better outcomes, but it also may stumble the model because you know human understanding may not always be optimal. So I think if you’re very experienced, at least you can accelerate this process to veto s those significantly impossible solutions. You can also give it a better guidance to consider all the factors, and some of the factors probably are beyond the reach of GPT-6. And I think that’s how we can work with the model together, to reach a maximum throughput of your system reliability and also very efficiency. Yeah. And anyways there has to be a human sitting there to you know, if something really bad happens, there has to be a human to reset the scene. Yeah. Michael Cho (58:03.06)Well, I mean mm. Yeah. Wenli Xiao (58:10.478)I respectfully disagree. I tried something like I tried to set up a third-person view webcam when like running GPT-6 to control robots. And the funny thing is so like I connected to full setup and like a Logitech webcam and when I Michael Cho (58:11.355)Yeah. Tonghe Zhang (58:15.834)Yeah, I’d like to hear your thoughts. Michael Cho (58:24.059)Mm-hmm. Michael Cho (58:37.512)Mm-hmm. Wenli Xiao (58:38.032)Get closer to the table to move the object and the robot just stopped. And I checked the thinking trace. It said, there’s a human. It’s unsafe. Stop it. And then I move away. It starts to move again. And the thinking trace is now it’s cleared. So if you it’s smarter than what we think. Michael Cho (58:56.475)Yeah. Yeah, you know, just to add on to that, right, actually, I wonder if let’s say I’m a I’m a you know, I have very good like physical intuition as a human. I’m a very good you know, contr control guy, you know, like I know how to do the controller and all this understanding. But then I operate at a human speed, right? Whereas, you know, if you have a big fleet of robots that you know, like thousands of agents like, you know How many feedback I can only attend to one feedback at one time, you know? But meanwhile there are thousands of agents talking to each other, figuring things out. I think I’m kinda slowing things down. So you know, it’s it’s not that there’s thousands of me, you know, but there are easily thousands of them, you know, if not tens of thousands, but hundreds of thousands of agents. Wenli Xiao (59:37.656)Yeah. Tonghe Zhang (59:39.736)Yeah, exactly. Michael Cho (59:51.571)I don’t know, T Tonghe, do you not agree? Like I so I agree what you say. Like, you know, I think for until we truly solve physical AGI, let’s say, you know, like we humans still have way higher physical intelligence than this specific agent. But the thing is, there you can spin up a lot more of them in parallel, especially if it’s a token budget and you have a bigger fleet of physical robots to do reset. Like me injecting myself, like how many good human robotics controllers can you go in Tonghe Zhang (01:00:11.127)Exactly. If Michael Cho (01:00:19.844)At the right time, at the right place to give this just additional insight, you know, to these agents when there are just so many of them, like you y we’re completely outnumbered. Tonghe Zhang (01:00:32.152)Sure, I think yes. What I was talking about is like if you work on that on a same simgle station. But if you’re saying that there’s one day we can scale this up to like thousands of robots and thousands of GPT-7, developing some better stuff together, I think that’s definitely humans gonna be the only burden in the system. You better remove every human being from it. Yeah, but I think humans will become more like a managerial role or become the busimess guy behind this scene. Like you can propose what’s the next goal of this month. What kind of stuff you wanna achieve. Is it a better controller? Is it a better policy? Where is it a better robot product that’s more reliable? That’s you can humans can be the guys who give it the goal. We are the guys who running the /loop or slash goal, right? That’s still be gonna be us. We gotta provide the funding, provide the robot arms, provide the product design that we wanna achieve, and then there will be a fleet of GPT-7 developing the implementations that we don’t actually care about. Wenli Xiao (01:01:04.954)Yeah. Tonghe Zhang (01:01:30.956)And then we will become the verification itself. We will test the robots on our own and we will say, Okay, this is too slow. You have to work harder to get it faster or this is this is too fast. You have to be more safe. So we’re gonna become out of the technical procedure, we’re gonna become the managerial roles, we’re gonna become the busimess roles, and I think that’s where humans should really shine. And I think that’s where humans have a say, at least for now. Yeah. Michael Cho (01:01:55.889)Hm. Yeah. So I guess so what I what I’m hearing is that you are walking back a little bit from your first statement, which is that like, you know, h humans you know, could be good engineers and we can apply our engineering knowledge at the right place at the right time. But maybe not in a case where you have literally a big fleet and a lot of tokens and in fact humans probably shouldn’t do that, the engineering part and just give very high level overview. Tonghe Zhang (01:02:21.7)Sure. I think if you compare one station, a human engineer plus GPT-7 versus GPT-7 itself, human plus GPT-7 is gonna be faster to arrive at a solution. Probably even not be the optimal one. But if you compare one human engineer and a simgle station worth is like a hundred GPT-7 with a very robust mechanical solution that don’t break arms that easily, and you run a day through the night, then Michael Cho (01:02:27.474)Mm-hmm. Tonghe Zhang (01:02:50.168)Then I can’t say that there’s anybody living on the planet that’s gonna be more smarter than a thousand or a hundred GPT-7, that’s that’s for sure. Yeah. If the engineering team can scale up and everything is very stable, I think humans should gradually step down from this engineering role. Yeah. Michael Cho (01:03:04.593)Yeah. Chris Paxton (01:03:09.859)Then what we do? Michael Cho (01:03:11.372)Mm. This is quite a sobering episode. Chris Paxton (01:03:14.071)There was this thing. So like I mean I yeah, right. I mean, so like the I like the idea of the human supervisimg it as one thing, but you know, there was this there was this thing a while back. I’m curious th about when they first saw chess called Centaur chess, where you’d have a person giving high level directions to the chess-playing engines and it would beat humans. That lasted like two years. It’s like so Do you think that’ll happen to us? Tonghe Zhang (01:03:43.363)I think it will slowly come to that moment. It may not happen tomorrow. But I think it’s there is some economic force driving this, driving this evolution because human even humans become a burden, become the guy who’s slowing down the process, then you have to g get rid of humans. If we become the bottleneck, then we have to resolve the bottleneck itself. And it’s gradually become a truth. In at least training models and deploying out robots, I think it’s human is the bottleneck. If that’s the case, there’s no reason we don’t get rid of humans. And the human will move to other positions to do other jobs where machines still can’t replace us. Say, busimess guy who would or verification stuffs or the top designers probably. Yeah. Chris Paxton (01:04:16.461)The human is the bottleneck. We’ve got to get rid of humans. This is a Michael Cho (01:04:18.138)Well Chris Paxton (01:04:21.811)Yeah. Wenli Xiao (01:04:32.166)Yeah, but I think that’s a good thing because like human has been long wishing we can have a very general and intelligent robot to help us do kinds of stuff. And now I think in also in other areas, like human is still the more creative than the AI itself. Like human can come up with better applications. So Maybe we should like as robotic engineer we are well yeah, we are truly the bottleneck of like reaching this super intelligent robot t as tool. So we should like step back and think about rethink about what’s actually important for the world. Like once we have this intelligent robot, for example, we can use it to solve the science, solve materials. Solve all the disease on Earth or explore the space. So yeah, so that’s why I’m pretty excited about the progress. Yeah. And not a although a little bit frustrating that I cannot do robotic engineer engineering anymore, but still very excited. Yeah. Michael Cho (01:05:54.298)Yeah, well anyway, yeah, it’s this has been a very fascinating episode I think. Very, very thought provoking, you know. And I’m I’m glad that we finally get you guys on, you know. I think it’s in a way it’s good that we this episode got delayed because like Astra is now out and then now you guys have even more like I mean directionally just speed up it, but it’s it’s it’s it’s the same direction that you guys have been on, you know. And kudos of you know Chris Paxton (01:06:04.014)Yeah. Chris Paxton (01:06:15.691)That’s more. Michael Cho (01:06:21.787)To you guys even attempting this like I think like half a year ago, right? When this project you got started. So yeah, really fascinating. Yeah. Anyway, I yeah, I guess, you know, to end off, like us usually we always ask the same questions. Are there any like cool papers that you guys read recently that you wanna give a shot or to? Does it have to be You know, robotic agency thing. Could be anything, you know, robotic research. Mm-hmm. Wenli Xiao (01:06:56.848)Yeah, yeah. I have one the Transformer paper. I really like it. Michael Cho (01:07:02.756)I s former chat. Wenli Xiao (01:07:05.284)It’s like co design paper from Huiha, like from [unclear]. Michael Cho (01:07:05.521)Transformers on Tonghe Zhang (01:07:11.268)How do you get rid of mechanical engineers? Michael Cho (01:07:11.995)Okay. Wenli Xiao (01:07:13.788)Exactly. Michael Cho (01:07:19.738)Yeah, that’s right. Okay, there you go. That’s an interesting paper. Yeah, I’m looking at it now. Okay, cool. How about Jan? How about you? Jia Xie (01:07:31.853)I wanna give a shout out to Reward AI for their awesome demo. That’s one of the most impressive demo I’ve seen for it’s so smooth and like all of the tasks, it seems to me it’s not even tedious for acquiring those data for training such a policy like that. And it’s very close to deployable policy to make good use in robotics. So it’s very, very impressive. Michael Cho (01:07:37.524)Yeah. Michael Cho (01:07:41.67)Mm. Michael Cho (01:08:00.773)Yeah, very, very impressive. Like it’s it’s a one X. Tonghe Zhang (01:08:00.919)Sure, I w I also vote for Reward AI. It’s it’s a it’s a it’s a great it’s a great demonstration. It also shows the what you can exploit from controllers and mechatronic design, also data collection device. There’s still a little corner where roboticists still have a value in and it’s already demonstrating how to exploit it to give you a Well yeah, I think yes. Wenli Xiao (01:08:18.076)W why do you assume they don’t use AI to do this? Michael Cho (01:08:19.033)Yeah. Michael Cho (01:08:23.834)Yeah. Tonghe Zhang (01:08:29.784)Anyways, I think it that’s another direction, beyond doing planning decision making, it’s more about real-time dexterous control and I think there’s still a lot of things to do there. Astra’s still not able to do it in real-time, so I think if we wanna still do robotics, that’s gonna be the direction. Yeah. Michael Cho (01:08:50.502)Well, thank you, thank for those like words of hope for humanity. Yeah, but anyway, like thank you so much for making the time guys. I think this is a very interesting yeah, very, very interesting episode. Right, Chris Richier. Yeah, okay, well till the next time. All right. Okay. All right, ciao. Chris Paxton (01:09:05.315)It’s really cool stuff. Thank you. Bye. Tonghe Zhang (01:09:06.821)Wenli Xiao (01:09:07.504)Okay, thank you. Yeah, thanks for having us. RJ He (01:09:09.428)Yep, absolutely. Thanks guys. Really appreciate it. Tonghe Zhang (01:09:10.126)Thank you for having us. Wenli Xiao (01:09:13.309)Okay. Okay. Bye. This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit robopapers.substack.com

  • October 5 · 48 min

    Ep#109: Enigma - Connecting 100 Robots To The Internet

    What happens if you connect a hundred AI-powered robots to the internet and just let people give them any instructions they want? Enigma founder Jonathan Jacobi joins us to talk about his experience deploying a fleet of robots on the internet, keeping them operational, and watching people truly test the generality and robustness of frontier robotics models. Watch Episode 109 of RoboPapers with Chris Paxton and Ruijie He today! Learn More Original Post on X Robots.online website (no longer active) Enigma.inc Transcript Transcript is automatically generated by Riverside and edited by ChatGPT. Chris Paxton (00:05) Hey everyone, and welcome to another episode of RoboPapers. Today we’re super excited to have Jonathan Jacobi from Enigma here to tell us about their work in foundation models and about putting a hundred robots online. So, could you introduce yourself? Jonathan Jacobi (00:19) Yeah. Thank you, Chris. Thank you, RJ. It’s a pleasure to be on RoboPapers. Big fans. A bit about Enigma: we’re a company working on foundation models for robotics, as Chris said, as well as building innovative new interfaces for robotics. How should we interact with robots? How should the interface feel to users? We’re also interested in the back-and-forth between interface work and research on the models. About a month and a half ago, we put a hundred real robots online. You could actually interact with them over the internet. They were running our models through a variety of interfaces, and you could simply ask them to do different things. So we’re here to talk about the models, the interfaces, and the experience we’ve built. Chris Paxton (01:21) Awesome. So what did people do with all these robots that you put online? Jonathan Jacobi (01:25) The basic concept was that we wanted people to feel robotics today. We all see a lot of demos. We see a lot of cherry-picked demos—some of them are cherry-picked, some of them aren’t—and we wanted people to feel that something is here right now. One of the problems is that not enough people have robots in their houses. So how do we make enough people feel that robotics is happening now, while we still have this challenge of not having enough robots deployed in the world for the average person to use? We thought quite hard about how to make that possible. One of the best ideas we came up with was: maybe we can set up a huge warehouse with a lot of robots, put our models on those robots, and let anyone online interact with them. We also got a very cool domain: robots.online. We tried to create enough different setups that one robot could be in one scenario, another robot could be in another scenario, and people would have enough flexibility to do random things that they could really feel the AI work we’ve done. They could ask the robot to do things themselves, without the logistical challenge of putting a hundred humanoids all over the world. That’s why we used tabletop robots—arms that we customized and designed ourselves, building on public open-source designs—and let people interact with them freely. Some robots were artists. People could paint. People could do pantomime. People did very unexpected things. Someone asked one of the robots holding a paintbrush to pretend that the brush was a broom. Jonathan Jacobi (03:50) So it actually swept the floor with the paintbrush. We have some very cool examples of that that we can walk through later. The concept was that, at Enigma, we focus on generalization—text, video, audio—and we have very different interfaces and input methods for our models. We wanted people to be able to experience that generalization directly and see that it’s working today. Some of the robots were artists. Some were doing chemistry experiments. We had one that could defuse a bomb. We had one that could do lightsaber-esque fighting. Not actual lightsabers. Don’t sue me. But basically, we let people do different things with different robots online. RJ He (05:01) Okay, cool. Can you describe a little more of the interface that was set up? It sounds like each one is a single manipulator fixed to a tabletop, and then the interface is a regular chat-prompt type of thing, as if you were speaking to an AI agent. Is that right? Jonathan Jacobi (05:21) Yeah. That’s a good question. We had a static manipulator. One of them was based on the SO-101 design. We took the SO-101 and said, “We want this to look really polished.” So we brought in incredibly talented industrial designers and worked with them for about a month or two. They were working full-time on designing this new version. The robot you’re seeing on the screen is an SO-101 that we customized. The colors, the enclosure, everything was custom-designed. You can see that even the cables are hidden within the robot rather than hanging around it. These were static manipulators, and each table had a different type of interface. The artist robot had a chat interface similar to an AI agent. But we wanted to make it less boring than simply asking the robot to paint or perform pantomime, so we turned it into a game. You could give it an idea and it would paint something associated with that idea, and then you had to guess what it painted. For pantomime, you could tell it to pretend that an object was something else, and the robot would mime with it. So that was one chat-based interface. Then we had other interfaces. Let me walk through some of the things we built. This is our company page. You can see more than a hundred robots here. This is part of the actual warehouse. Those are spare robots and leftover components that we built. Here’s one of the chat interfaces where people were doing pantomime. You could do drawing, pantomime, and a few other things. And here’s another interesting interface. You could tap objects directly on the screen and then ask the robot to do something with them. You could tap the green bottle and say, “Pick this up,” then tap the orange flask and say, “Pour this into this.” Jonathan Jacobi (07:45) You could say, “Throw this here,” or whatever you wanted. We wanted to introduce a new kind of interactive interface—not just text, not just teleoperation, not just audio, but something new. Our vision is that if you extrapolate this ten or a hundred steps forward, the interface almost feels like a game. It feels like you’re playing the physical world. Think about something like StarCraft. Imagine having an interface where you can control a hundred robots. You can tap, type, drag and drop, and build agents on top of that to automate entire processes. That’s where we imagine the world going. Controlling robots becomes incredibly intuitive: you can type, tap, drag, drop, maybe talk to them. Another interface was the bomb-defusing robot. You were on a mission to defuse a bomb, and while you’re trying to do it, an operator is shouting at you: “You have to defuse it faster!” So you’re under pressure while talking to and controlling the robot. People did very unexpected things with this. Someone said, “Knock on the bomb twice at the bottom.” Someone else said, “Pour the orange flask over the pink button.” The pink button wasn’t standing upright—it was lying on the table. Chris Paxton (09:45) Can I ask—what simulation is that? That actually looks pretty good. The water physics there. Jonathan Jacobi (09:50) This is the physical world. This is not simulation. Chris Paxton (09:52) That’s not simulation? Okay. Well, that makes sense. RJ He (09:54) No way. Jonathan Jacobi (09:56) Yes. Every one of these is the physical world. None of this is simulation. Chris Paxton (10:01) Right. I knew the others were real. I don’t know why that one looked like a simulation to me. Sorry for doubting you there. RJ He (10:05) Yeah, agreed. Actually, maybe that’s a good question. First, what was the main motivation for doing this whole thing? Was it about the human-robot interface, or was it about seeing what kinds of prompts and questions people would ask? And then the second question is about this simulation-versus-real-world issue. Why did you need to do it in the real world, as opposed to simulation, which might have allowed you to scale even further? Jonathan Jacobi (10:34) I can start with the last question. You guys are at the heart of robotics. You see and feel all the ups and downs: “This is going to work. This is AGI. It’s almost there. It’s not quite there.” You feel that sine wave of robotics enthusiasm. We wanted to say: guys, we think it’s amazing that robotics is accelerating this fast, but we think it’s time to stop showing only video demos and let people actually interact with it. We wanted to reach millions of people. We ended up getting around two million views and millions of robot interactions. People were going back and forth with the robots millions of times. We didn’t want the demo to just be a video. We wanted it to be something interactive. That was one of the biggest motivations. We didn’t want to do it through simulation. We didn’t want to do it through a video. We wanted to put something out there that people could actually use today. We put a hundred real robots online. The setup you’re seeing here—the thing you thought was simulation—is the real booth. And we had hundreds of robots spread around this warehouse. This was a huge operation. We had to set up air conditioning, electricity, Wi-Fi—everything. But the real motivation was to have people actually interact with robots. The second part is what we wanted to learn from it. As a company, our thesis is that we’re research-first. Most of our team is doing research on the model side. But one thing I think is incredibly important—and that was true for language models, and I think is still lacking in video models—is that the interface really matters. If you look at language models, we had GPT before we had ChatGPT. Jonathan Jacobi (12:56) The underlying technology already worked incredibly well. So why wasn’t it accessible to as many people before the chat interface? And if you think about agents, they didn’t reinvent the wheel of language models. They were riding the wave of language models working and building a new interface on top of that technology. We believe you have to think about the interface to the user and the underlying research, and you have to think about them as intertwined. What we noticed was that if you think about a new type of interface, it propagates very quickly into the research you’re doing. Suddenly you find yourself pursuing different research questions from everyone else. That was the second major reason for the launch. RJ He (13:53) That makes sense. Can you drill a little bit into what you’ve learned about interface design—whatever you’re comfortable sharing? What works? What doesn’t? And a related question for me is whether the interface is embodiment-dependent. Would the interface for a tabletop setup look similar if we moved to a humanoid or a mobile-manipulation system? And presumably it’s also task-dependent. Jonathan Jacobi (14:21) Great question. On the second question: one of our main points of view is that interfaces are going to vary. You’re not going to have the same interface for every use case. We saw that in the launch. One interface we built is something we call tap-and-type. You tap something and then type. You can say, “I want this moved here.” Being able to refer to something simply as “this” is incredibly valuable. Imagine you have a hundred different cups. You want to refer to one specific cup. Maybe it’s much easier just to tap it than to describe it in text. So I do think interfaces are going to vary. I don’t necessarily think the variation is simply because something is a tabletop robot versus a humanoid versus a mobile manipulator. I think it will vary depending on the thing you’re trying to accomplish. At the same time, I think there will be a lot of common denominators—similar features and similar behavioral characteristics across interfaces and embodiments. We’ve already seen some of our interfaces being useful for mobile manipulators that we’re now deploying—humanoid-esque kinds of robots that benefit from interfaces similar to tap-and-type. What was the first question again? RJ He (16:10) What else have you learned in terms of interfaces? What works and what doesn’t? Jonathan Jacobi (16:21) That’s still an ongoing question. We’re still working through it. But one thing we’ve learned is which kinds of interactions make more sense with something like tap-and-type, which ones make less sense, and which interfaces actually make the research easier. Let me redraw the picture a little bit. If you walked through a physical-AI lab and listened to the questions researchers were asking, you’d hear things like: “How can we make this more precise?” “How can we make this more general?” The classic questions that all of us know by heart. But when we were building this launch and trying to innovate on interfaces, we heard different kinds of questions. There’s another interesting conversation here: Who do you hire to think about interface design? We brought in game designers. If you think about gaming, game designers put enormous effort into interactivity—into what makes an interaction intuitive and compelling for users. And the questions we heard the game designers asking the researchers weren’t, “How can you make this more precise?” or “How can you make this more general?” They were asking: “Can we make this possible?” “Can you make that possible?” For example: “If I tap a few objects and type, ‘Pour this into this,’ can the robot do it?” Jonathan Jacobi (18:28) Those were moments where I felt something genuinely magical happening in the innovation process. They weren’t simply climbing a ladder of capability. They were envisioning a reality where something becomes possible and then trying to build toward that reality. That was incredibly unique. I’ve visited a lot of researchers and talked to people across many labs, but this process of starting with a particular vision and propagating it backward to the research team—and then having the research team push back on the designers—was fascinating. You had designers and researchers working together to create a new capability. I think that’s something very unique that happens when you put interfaces at the front. There were also all sorts of very specific things we learned. For example, one experience allowed you, as a human, to operate an arm using WASD controls—basically teleoperation like a game. You were fighting against another robot controlled by a model. You had a sword, it had a sword, and the robot had to react to you. One thing we immediately noticed is that if you have only one camera angle, you lose depth information. But if you have too many cameras, it becomes confusing to the user. They have to build a mental model of where everything is from multiple views, and that’s very difficult. So the question became: What can we do to make a single-camera view as intuitive as possible? We played around with camera angles. We discovered there was a particular angle—not quite a side view, not quite a top view—that gave you enough sense of depth while also making the geometry of the interaction intuitive. Jonathan Jacobi (20:53) We had to think carefully about where to position the cameras so that a human could understand the scene well enough to operate a robot remotely. That’s a tiny detail. It’s not the heart of the research, but if you’re thinking seriously about intuitive interfaces, it matters. You can’t show someone four different camera feeds and expect them to mentally say, “This is the left view, this is the right view,” while they’re trying to sword-fight with a robot. It’s just not intuitive enough. And we took lessons directly from the history of gaming. One of the designers working on this literally went and studied the history of games and how game designers had solved similar interface problems. That was incredibly interesting. I think the thing I’d want people to take away from this is that interactivity itself is an incredibly interesting research problem. Chris Paxton (22:16) What do you think is the biggest thing people do wrong with user interfaces for robots right now? Jonathan Jacobi (22:23) I think people treat them as an afterthought. They say, “We’ll get to this capability, then that capability, and then we’ll figure out the interface.” Historically, I don’t think that’s necessarily how successful technologies have developed. Chris Paxton (22:30) Yeah. That’s fair. And I definitely feel like a robot is a tool. You should be able to make it do something. That resonates pretty strongly. I wanted to go back to something you said earlier. You mentioned humanoids or semi-humanoids. Are you going to do a humanoid version of this thing? Put a hundred humanoids online next time? Drop them around a city or something? Jonathan Jacobi (23:01) Good question. Very good question, Chris. We’re still thinking about what the next step looks like and what those experiments should be. We might. We’re not sure if it’s going to be humanoids specifically, but we’re definitely thinking about what the next learning experience should be. Chris Paxton (23:26) That’s cool. Could you tell us a little bit about what these things are actually running? What’s the model that you used for all this? Jonathan Jacobi (23:34) On the model side, one of our core conclusions was that we wanted to focus on generalization. Even if you can build a table or build a GPU or whatever, that doesn’t necessarily mean you can easily transfer to new capabilities and new tasks. A lot of our research and focus has been on this specific problem. We put out a blog post about it at Enigma’s website. The problem, as we frame it, is that if you have a model that needs fine-tuning per task and per environment, it’s not really a foundation model. It’s more like a policy. And that’s fine. You just have to call the baby by its name. Our vision as a company is to get to a point where you can put a robot anywhere, in any setting, without fine-tuning, and generalize across tasks. Obviously that’s a very big vision. Zero-shotting anything and everything—getting to the physical-AGI moment—is incredibly ambitious. But what we wanted to show here was that even within environments we do know—we designed these environments—the system can still respond to essentially any request that a user gives it. We plan to release more over the next couple of months about the architecture and exactly what we do differently. But in terms of the backbone, I can say that we relied heavily on internet video data, rather than making teleoperation or egocentric robot data do all the heavy lifting. Chris Paxton (25:59) Did you collect a lot of the data yourselves? Or buy it? Or maybe that’s something we should wait for a future blog post for? RJ He (26:00) Yeah. Jonathan Jacobi (26:07) There were some small things we had to collect ourselves, but the large-scale heavy lifting came from video pre-training. And it was fascinating to do this while also having to deliver things in real time. If you’re training on a lot of video, fast inference is not trivial. This isn’t simply a video model backbone, by the way. Chris Paxton (26:20) Gotcha. Interesting. Jonathan Jacobi (26:37) I can share a little more. Getting inference fast enough and precise enough was a challenge. And in terms of data efficiency—not just time efficiency—we’ve put a lot of effort into encoders. We think there’s a lot you can do by improving what and how you encode. We released another blog post discussing some of this. We didn’t share everything, but we shared parts of it to spark ideas around how to build more data-efficient models. The reason is that we deeply believe you don’t necessarily need a gajillion hours of teleoperation data to build a model that generalizes. You can attack the problem differently. One question we’ve explored is: What if you could encode the world more efficiently and make predictions in latent space? We shared more about that in the blog. The goal is to become significantly more efficient both in the amount of data you need and in how large the models need to be at inference time. That type of research is what allows us to build a backbone that can rely on a lot of video while still operating quickly and efficiently. RJ He (28:30) When you start involving humans you have no control over with your robots, I’m sure a lot of things can go wrong. Could you talk a little about robustness and what you learned there? Both in terms of how the models needed to change, and what other harnesses or safeguards you needed around them to make sure people didn’t do silly—or terrible—things with the robots. I’m sure they tried. Jonathan Jacobi (29:00) Yeah. Humans are unpredictable. And if you think about interactive robotics, this was the largest online human-robot interaction experience of its kind that we’ve ever seen. People were actually interacting with a foundation model online, with millions of interactions, and that produced incredibly insightful data. Take tap-and-type. You can learn a lot just from how people interact with the interface. How many times do they tap something? Do they tap aggressively? Are they repeatedly tapping the same thing because they’re frustrated? These are classic product-management signals. You can also see how many times someone enters the same prompt. But people could also be very adversarial. For example, we didn’t necessarily want people to pour things all over the table, but people did. And these were actual chemicals. Real physical materials. We had real chemical reactions happening live because a human was tapping and typing and controlling the robot. The consequences were physically annoying. We had to clean them up. I’m not joking. Jonathan Jacobi (30:49) We had twenty or thirty people cleaning and resetting tables. We had monitors showing which tables were dirty and which weren’t. It was an insane operation, and we’ll talk about that too because running it was incredibly interesting—and operationally very difficult. Chris Paxton (31:08) This is one of the reasons I forgot for a moment and thought it must be simulation. Resetting this sounds like a real pain to get right. Jonathan Jacobi (31:12) Dude, it was a pain. We had servos burning out. So we had analytics tracking which servos had burned out, and we would replace the servos live. We had a huge dashboard monitoring servos. Let me share my screen and show you the blog post. This was actually insane. You can see here that we had a bunch of screens monitoring everything live. Hundreds of tables. Hundreds of live interactions happening. This was just part of the operational infrastructure. We even had a robot “repair pit stop” where you could bring in robots that weren’t working properly, screw things back in, fix them, and put them back into service. People were here 24/7. We ran shifts. Our teammates were constantly making sure everything kept operating smoothly. And the amount we learned from it was insane. As RJ asked: people were very adversarial at times. Look at this table. You can see paint everywhere. The entire table is a mess. There were even messier ones. This is a real table. Chris Paxton (33:26) I’m curious: did you get anyone actively trying to damage the robots? Trying to get them to break themselves? Jonathan Jacobi (33:31) Yeah. People broke robots. Dozens of robots broke. Chris Paxton (33:37) Dozens? Well, out of hundreds, that’s not too bad. RJ He (33:41) What? Jonathan Jacobi (33:31) Yeah. And we fixed them quickly. We had the repair stations and the operational infrastructure for it. RJ He (33:51) That’s what I’m curious about. Were you then able to bake those interactions into the model so it became more robust against adversarial behavior? Or did it mostly require classical safeguards? How did you address that part of the user interaction? Jonathan Jacobi (34:10) There were definitely some classical safeguards. Filters on the model, filters on the inputs coming in, filters on the outputs going out—the kinds of classical safeguards you’d imagine. But there were also things we could learn from. For example, you can flag sessions where a robot broke. Because we were running continuously for days, we know when these incidents happened. That means you can potentially use those flagged interactions as training data. You can say, “Okay, this is what happened,” and have the model learn from those examples. So that’s definitely interesting. But frankly, the most effective guardrails were the more classical ones. Chris Paxton (35:06) Do you think that’ll change? Do you think you’ll be able to train a better critic or something that keeps the system safe next time—if there is a next time? Hopefully there is. Jonathan Jacobi (35:13) I’m pretty confident we will. We’re still doing research on this because we have so much data from the launch. Think about it: 24/7, real people having real interactions with these robots. It’s a gold mine of user-interaction data. We’re still digging through interesting interactions and finding things where we say, “Wow, this is fascinating. Why did the model respond this way? Could we do it slightly differently?” The whole team is still digging through it. I’m pretty confident that in the next release we’ll be able to have a stronger, better-aligned model. Chris Paxton (35:56) It strikes me that one thing you have that’s pretty unique is a large dataset of people trying to break a robot. I don’t think anyone else in the world is going to have that. So that’s kind of cool. Jonathan Jacobi (36:09) That’s true. Chris Paxton (36:12) All these people talk about learning reward functions and things like that. It’s like—that’s the way to do it, right? Jonathan Jacobi (36:17) I agree. Put it in the hands of people. RJ He (36:21) Along those lines, I wonder if you can comment on the kinds of metrics the community should be thinking about beyond traditional success rates. Given the kinds of things you’ve seen—and as we think about building robots that are actually out in the world interacting with humans—what other factors do you think people aren’t thinking enough about? Jonathan Jacobi (36:50) Oof. Good question. I’d have to think deeply about it to give you a really good answer. But off the top of my head: we have some hardware experience, some software experience, and some model experience. Running an operation with a hundred robots while people on the internet are being quite adversarial really puts everything to the test. You learn what is possible and what isn’t. What breaks quickly and what doesn’t. What people actually ask robots to do. Where your imagination has drifted away from reality. Deploying this many robots gives you a tremendous number of insights into reality. And you have to iterate on those. That’s why we’re planning to do more creative things in the future and learn in more ways. But the priceless things are the tiny, unexpected details that happen in between. Maybe one prompt gets asked repeatedly and causes something to break. Let me think of an example. One interesting issue was table drift and perturbations. Very quickly, the tables drifted away from their initial state. Paint was splashed everywhere. Water moved around. The robot might clean some paint and spread colors around. The environment changed very quickly. Jonathan Jacobi (38:16) And this is one reason we’re very bullish on generalization. If you’re heavily relying on the environment staying the same—even if you assume it’s going to stay ninety percent the same—things drift surprisingly quickly. You can see it here in the backgrounds and on the tables. Look at the difference between this table and this one. This area looks black, but it’s actually a mix of all the colors that accumulated there. If your system depends heavily on the exact setting, you very quickly realize that isn’t viable. By necessity, you’re pushed toward generalization. We can’t heavily fine-tune per environment and then rely on that environment remaining fixed. You have to be robust to perturbations and environmental drift. Classical models that need a lot of adjustment per setting really struggle with this. And we also learned that you really can’t predict what people are going to ask. For example, people asked the painting robot to pretend that its brush was a broom and sweep the floor. Someone said, “Pretend the brush is a golf club and the objects on the table are golf balls. Go.” And then this happened. Jonathan Jacobi (40:27) Look at the swing. It literally swung the brush like a golf club. And that’s an annoying environmental perturbation. If you were relying on the water bowl staying in one place, that’s gone now. The bowl spills. The sponge moves. Everything changes. You have to be robust to those things. That’s why we needed generalization to make this work. Here’s another funny one. I don’t know if you’ve seen Harry Potter, but someone used the Wingardium Leviosa spell. And the robot holding the wand did this. Incredible. Absolutely incredible. “It’s LeviOsa, not LevioSA.” Chris Paxton (41:19) And a lot of this is the magic of video pre-training, right? Is that fair? That’s where it learns this stuff from? Because it has to come from somewhere. Jonathan Jacobi (41:23) Yeah. It’s not necessarily only that, but yes—it has to come from somewhere. Training on a lot of video definitely helps. But another important part was making the interaction possible through efficient inference and efficient encoding. As I said earlier, you really have to think about efficiency. You can’t wait fifteen minutes for a generation to happen. You can’t have every generation be enormously expensive at inference time. But yes, training on all kinds of video where Harry Potter appears probably helped the model understand what Wingardium Leviosa means. Chris Paxton (42:18) Could I ask you to say a couple of words about what you mean by efficiency? What makes your encoder so much more efficient? Jonathan Jacobi (42:28) Yeah. We put out a blog post about this shortly after the launch. There’s been a lot of work on encoders—from JEPA-style approaches onward—and we’ve been digging into how some of these encoders use their latent representations. For example, we discuss models like LeJEPA, LeWorldModel, and DINOv3. What we’ve shown is that these systems can become overly focused on certain types of features, and as a result they don’t necessarily use the latent space efficiently. You might have a latent representation that is much larger than you actually need to encode the information that matters. So representation learning becomes a key part of efficiency. If you can build smaller latent-space representations, then logically you can get faster inference and require less data to learn something useful. That kind of work is part of what we mean by efficiency. We also dug into regularizers and some of the problems they introduce, and we shared ideas for directions people might want to follow. We didn’t publish everything we’ve done internally. We wanted to spark more thinking around the problem. One interesting thing we show is how some of these representations can collapse. RJ He (44:56) Can you share a little about some of the ideas you’ve already discussed publicly? Jonathan Jacobi (45:05) Yeah, definitely. I’ll try to wrap it in a way that gives the intuition, because I think the intuition matters more than the details here. The basic question is: What do these encoders care about? Which features do they prioritize? There’s a very simplified picture we use to explain the encoding problem. Ideally, you’d want the representation to capture the most important characteristics of an image or environment. But in practice, if there’s a feature that’s very easy to predict, the model can allocate a huge amount of its latent space to that feature. In the blog, we describe this as something like twelve bits of information swallowing your entire latent space. A feature can be important without being the only feature that matters. So the intuition is that you want to avoid having your latent representation dominated by a small number of easy-to-predict features. If all you cared about were those features, you could use a much smaller latent space in the first place. Jonathan Jacobi (47:05) That’s the intuition we were trying to communicate in the encoder blog post. And we think there’s a lot of depth left in this research area. People will probably come up with even more interesting approaches than the ones we’ve developed internally. That’s part of why we wanted to spark more discussion around encoders. I think it’s a very important area. I hope that gives some intuition. Chris Paxton (47:39) Yeah. Super interesting. RJ He (47:45) Are there other parts of the model architecture that you think are unique and that you’re able to share? Jonathan Jacobi (47:52) I think efficiency is particularly interesting. We’re trying to learn as much as possible from as little data as possible. And there’s a connection here to our focus on intuitive interfaces. When we talk about intuitive experiences, we want the experience to be intuitive for everyone. For the end user, that might mean tapping, typing, dragging, dropping. But we also want it to be intuitive for the engineer. If an engineer has to collect hundreds of hours of data for every task, that’s not intuitive. That’s extremely difficult. That’s why we focus so heavily on this problem. Generalization is our first priority because if the base system becomes very easy to use and can already do a wide range of things, then maybe you can use reinforcement learning or human expert data to improve the final mile—similar to what happened with language models. That’s how we imagine the world evolving. You start with something intuitive that can already do a lot, and then you continue climbing the capability curve from there. RJ He (49:02) Actually, on that note: one of the key aspects of what you’re doing is that you have many different interfaces for humans to provide instructions. What does that imply for the model architecture, given that you now have more input modalities? Jonathan Jacobi (49:21) Different inputs create different constraints. By definition, that changes what you need to do. Take a very simple example: tapping an object on the screen and then writing, “I want this object moved here.” That’s a simple interface, but it opens up an entire world of possibilities on the model side. You might literally use the mouse click on an image as an input. You might try to segment things. You might do something in latent space to determine which objects have been marked. What I’m saying is that you now have more room to play. There are more approaches you can try that differ from what everyone else is doing. And when you’re trying to build a generalized model that can zero-shot many different tasks, a different interface can actually make that easier. Take the lab-assistant chemistry experiment. Some of the things we did internally were possible because we assumed the interface itself could be different. That changed the model architecture. And that has a ripple effect. It’s like a domino: change one constraint and everything downstream changes. I think that’s crucial to think about. And I really encourage researchers to challenge their axioms from time to time. Even if something seems like a cold, hard truth, pretend for a moment that it isn’t. That can lead you in very interesting directions. RJ He (51:38) I was wondering what that implies both for the representations of these multiple inputs—for instance, the taps—and for the training data. I’d imagine your internet training data doesn’t contain much data about tapping on things and giving instructions to robots. Was there anything unique you had to do on either of those fronts? Jonathan Jacobi (52:06) Yes to both. The architecture had to differ for the different interfaces. Some interfaces were more classical: text input, action output. The artist one, for example, was closer to that. We let people freely ask the robot to do pantomime, and our more classical text-input/action-output model performed quite well. For the others, let me think about how to give you the intuition without spoiling things we’re going to release soon. When you pre-train with different modalities as input—for example audio, or tapping—the tap gives you a hint about what you want to do. It’s not the full trajectory. It’s a hint about the intended object or action. You don’t necessarily want to do the classical thing of running Segment Anything first and then feeding that result into your model. There may be more useful ways to digest that information. Even though you don’t have internet pre-training data that exactly matches those inputs, if you consume that hint in the right way, it can still help model inference. I think that’s probably the best intuition I can give right now without spoiling something we’re going to show soon. And more broadly, I really believe in changing your axioms. We’re all working in broadly similar ways toward this idea of physical AGI. Changing an assumption—even if you know that assumption isn’t literally true—can lead you toward different outcomes. It’s a very useful thought experiment, and I’ve seen it lead to interesting results in other research areas too. I recommend doing it in AI research. It’s been useful for us so far. Chris Paxton (54:56) Yeah. I like that. So it’s basically a statement about the value of trying different things, even when you don’t know yet whether they’ll make sense. Jonathan Jacobi (55:05) Yeah. Chris Paxton (55:09) Good justification for basic research. Trying new ideas. Jonathan Jacobi (55:12) Yeah. Good justification for basic research. And the fact that we’ve actually seen this work in people’s hands—we’ve seen these interfaces work—gave us confidence that we can do more and innovate more aggressively around the interfaces. Chris Paxton (55:26) It’s the explore-versus-exploit tradeoff, right? If everyone is currently trying the same thing... Jonathan Jacobi (55:30) Exactly. RJ He (55:37) As we start to wrap things up, what can you share about what’s next? For people who enjoyed playing with your hundred robots, what should they expect? However much you want to tease. Jonathan Jacobi (55:52) First of all, this gave us a huge amount of learning. I want to thank everyone, and thank you guys for having me and having Enigma here. As I said, we’re big fans and listeners of both of you, so thank you. In terms of next steps, we’re working very hard on a few big deployments. We want to make things work in reality. This itself was a big deployment—more than a hundred robots—and that was a pretty big deal. Now we have a few other things that are significant in terms of creating value for partners and customers, and those projects are heavily leveraging what we learned here and the models that came out of the work leading up to this launch. So one thing to expect is actual robot deployments. On the research side, we’re also going to share more. In the next few days, we’re planning to put out more technical blog posts and more tooling for the community. For example, because we had to run an enormous number of servos at scale, we had to hack around some hardware limitations to make everything work. We’re going to put out some of the tooling we developed so the community can use it. That includes both hardcore AI research and very low-level robotics work—hardware, firmware, debugging firmware, all of those things that can be surprisingly challenging. We want to release tooling that makes it easier for people to use the models we put out in the future. So: more deployed robots, more tooling, and more research results. I hope it serves the community well. Chris Paxton (57:50) Awesome. Well, thank you for coming on. This has been really interesting. Really cool stuff. Excited to see what comes next. Jonathan Jacobi (57:59) Thank you so much. RJ He (58:00) Maybe we’ll wrap up with our standard question, which is: what papers would you recommend? It doesn’t have to be HRI, but given how unique this work is, are there any papers in the human-robot-interaction space that particularly inspired what you’re doing? Anything else is fine too. Chris Paxton (58:03) Yeah, let’s do that. Anything—HRI or elsewhere. Jonathan Jacobi (58:21) There are a few. Maybe I can send you a curated list afterward. I don’t want to name a few off the top of my head and accidentally undervalue others. Could you put the list in a Twitter thread and point people to them so they can dig in? The team and I would also happily follow up on questions. People can DM us on Twitter or reach out however they want. We’ll send you a list of our favorite HRI and research papers. And to the listeners: please feel free to reach out to us. We’re more than happy to talk. You can nerd-snipe us. We love it. RJ He (59:04) That’s an awesome idea. We’ll follow up on the list, and we definitely want to encourage that interaction in both directions. Jonathan Jacobi (59:12) Human-human interaction. Perfect. Chris, RJ, thank you so much. Chris Paxton (59:21) Yeah, thank you for coming. RJ He (59:23) Yeah, thank you. This is super cool work. Thanks so much. Jonathan Jacobi (59:23) Have a good one. Bye-bye. This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit robopapers.substack.com

  • October 1 · 51 min

    Ep#108: VLS: Steering Pretrained Robot Policies via Vision–Language Models

    Pretrained vision-language-action models for robots often fail when a task is performed in a slightly different environment. With Vision-Language Steering, you can get better generalization performance out of a frozen robot policy, by steering the sampling process of your pretrained diffusion or flow-matching policy to handle out-of-distribution changes like obstacle position or changing visual appearance. Shuo Lin and Ishneet Sukhviner Singh join us to talk about how to better generalize robot policies with no new training data. Watch Episode 108 of RoboPapers today, with Jiafei Duan and Ruijie He! Abstract Why do pretrained diffusion or flow-matching policies fail when the same task is performed near an obstacle, on a shifted support surface, or amid mild clutter? Such failures rarely reflect missing motor skills; instead, they expose a limitation of imitation learning under train–test shifts, where action generation is tightly coupled to training-specific spatial configurations and task specifications. Retraining or fine-tuning to address these failures is costly and conceptually misaligned, as the required behaviors already exist but cannot be selectively adapted at test time. We propose Vision–Language Steering (VLS), a training-free framework for inference-time adaptation of frozen generative robot policies. VLS treats adaptation as an inference-time control problem, steering the sampling process of a pretrained diffusion or flow-matching policy in response to out-of-distribution observation–language inputs without modifying policy parameters. By leveraging vision–language models to synthesize trajectory-differentiable reward functions, VLS guides denoising toward action trajectories that satisfy test-time spatial and task requirements. Learn More Project Page: https://vision-language-steering.github.io/webpage/ ArXiV: https://arxiv.org/pdf/2602.03973 Transcript Transcripts are lightly edited by ChatGPT. RJ He (00:01) Okay. Hi everyone. Welcome to another episode of Robot Papers. Today we are super excited to have with us Shuo Liu and Ishneet, who will be sharing their paper on Vision-Language Steering: Steering Pre-Trained Robot Policies via Vision-Language Models. Shuo, Ishneet, do you all want to introduce yourselves? Shuo Liu (00:29) Yes. Hi everyone. My name is Shuo Liu. For now I’m a research engineer at Cortex Robot AI and previously I graduated from University of Washington, where I was also a student researcher at Allen Institute for AI, advised by Professor Ranji Krishna and Professor Jiafei Duan, focus on robot learning from develop foundation models to deploying them into real world. RJ He (01:01) Isn’t it? Ishneet (01:02) Yeah. Hi everyone, my name is Ishneet. I work with Professor Jiafei on this paper, VLS, with Shuo. I’m currently at Menlo Research, where I also work on Asimov, and I’ll be going to Oxford for my undergrad later this year. RJ He (01:17) Super exciting. Amazing that you’re already having publications at this young age. It’s awesome. Okay, without further ado, Shuo, why don’t you take us through the paper? Shuo Liu (01:26) Okay, sure, yeah. Let me share the screen. Okay, so just make sure it’s it’s good to say right. RJ He (01:38) Yeah, it’s good. Shuo Liu (01:39) Yeah. Hi everyone. Today I want to share our work vision language theory. This work is finished when I was a master student at the University of Washington and advised by Professor Ranjik Krishna and Professor Jiafei Duan. And so today I want to introduce motivation of this work and the method we solve this problem and the experiment results and also some future works maybe could be done from this direction. So the problem is from the observation of some small front twining of the Like models like π0 or π0 Po, we found that current generative robot policies are can’t are kind of tightly coupled of the training specific configurations, so which cause some failing to decouple the reusable motor skills from the normal task constraints. Like for example, here we have some cubes on the table and if you want to stack them up to a tower with specific numbers you may call the π0.5 pre-trained value a policy to stack some cubes like if you want to stack two cubes and using the termination signal like the pushing the red button on the table it can do very well because you Because for this specific task you can fine twin the base policy a bit, like stack two cubes and push the button or stack four cubes to push the button. And but what if at test time you ask the base policy to stack three cubes? It’s never it’s never contained in the fine-tuning data set, so the base policy Shuo Liu (03:33) Can learn how to stack two cubes or stack four cubes and push the button, but it will never know how to st how to stack three cubes and push the button. This is because the training configuration we combine the language instruction and the image observation with the task two cubes and four cubes together and the polic the base policy is never contained with task specific instruction stack three cubes. So the motor skills like moving the gripper to the cube and stack it on another one and going push the red button is already included in the base policy. But at test time if you given another out of distribution scenario or out of distribution language instruction, the base policy can always fail. So we think this is from the standard imitation learning reset. So for now if we have a base policy like take π0.5 or Momo Act 2 for example, the base policy can be trained on the behavior cloning target, which means given an expert data set which contains observation, action, and the language for each index and the optimization target is to maximize the likelihood of the base policy to be to predict the next action chunk based on current observation and the absurd language instruction. So the objective is stand static and also is very distribution dependent, which means after fun training your base policy can only capture the special and semantic correlations on the training manifold if you change the observation or language at test time the base policy may confuse. This observation is clear at our daily work because if you take one pre-trained VLA policy you just don’t want to like use it in the Shuo Liu (05:53) In distribution tasks, you may change the scenario, you may change the language to the VLA. So for example, sometimes we may face observation out of distribution signal which means we may made some visual or special shift and some semantic shift which means the change of language distribution. So at that time the world may drift away from the training distribution and how we can solve it. We for now we have some two solutions. The first one is we recollect a small dataset out of distribution scenario and run another training cycle. But we need to repeat this circle for every new deployment and make the base policy useful for this specific scenario. But this is kind of misaligned with the target of we train very large VLA policy. That’s because the target is to make the base policy general generalizable but and we can using the pre-train and post-train recipe to make the skills like pick and place or open close this kind of low level skills already inside the VLA policy but we are paying the cost to relear the existing skills at test time s simply because we are not selectively adapt to the base policy at test time. So in this work we want to train we want to try another way that is steering the base policy at inference time, which means we’re taking the we’re taking the ability of generative models like photomatching or diffusion models which are Shuo Liu (07:46) Broadly used in current VLAs like the action part action expert part. We can take the advan advantag advancement of their ability to denoise iteratively. So for example the diffusion model is denoising to the target distribution from Gaussian noise and using many diff denoising steps and the flow matching are learning denoising paths to from the Gaussian points to the target distribution directly. So we can use the this the ar feature of denoising and we can add some guided guidance signals into the denoising parts to change the direction of denoising. But the challenge is can we find the right way to steer the flow matching and the diffusion policies to K and well kept their in-distribution performance. The way we can use is using the classifier guidance which means we can inject one gradient signal that push the denoising trajectory towards the out of distribution con condition, which is from the feature of diffusion policy and flow matching policy. We’re we’re not going too deep to of the mice today. But they do have this feature to be guid to be guided in the densing process. So here I want to introduce the real challenge if we can have a guidance signal to push the denoising process of these generative models, then how to make this such a guidance signal what should it to be? So in this work we introduced three requirements of this guidance signal. So firstly since the out of distribution observation and language they are structured so we need to encode the Shuo Liu (09:59) Out of distribution special and the semantic constraints into one into one like Into one feature and out one just class label because you cannot you cannot classification every new deployment based on the functioning scenario. And so we need so we are requiring two needs for the guidance signal. So first one, it should be correctly interrupt the geometry and logical structure of the out of distribution condition and secondly it should provide one dense informative gradient to the action trajectory diffusion process. So based on this tunes we designed one method to provide one very good guidance signal to answer these two questions and before we go into RJ He (10:54) Yeah. So maybe I can just jump in here. What kind of OOD conditions are you mostly concerned about? You know, in the motivat motivating example, you were talking about so you have examples with two and four blocks and then you know three is therefore out of con out of distribution. But what it you know, does this also would this also work with changing environmental conditions, you know, different lighting? Would it change with yeah, maybe you can share a little bit of which classes of Shuo Liu (10:58) Yes. Shuo Liu (11:22) Yeah. RJ He (11:23) O or D are you all primarily motivated by? Shuo Liu (11:26) Okay, . So in this in this slide I’m actually showing two videos of the rollouts of LIBERO-Pro one benchmark we are running for this paper. So for the left part is our internal liberal environment, which is kind of converged by current VLA policies because they can lower it very well to about ninety nine percent of task success rate. And we are split the out-of-distribution scenarios to two types. The first one is observation, which means the visual or special layout may change at the at test time, and the second one is semantic shift, which means you change the language instruction at test time. So for example, for observation shift we can see here on the left is original LibreO. Scenario and on the right is test time scenario. So the base policy are fun-twined on the left scenario and the test and the same layout. But LibrePro are using another layout during test time. So you can say the style and the plate, the their position has been changed. And for language instruction, which means you take the same observation which means the same RGB images with the same layout. But you use another language instruction, for example. If the training target is to push the tomato sauce into bucket, but at inference time you change the target to milk. So we typically split the out-of-distribution into these two types. Jiafei Duan (13:17) I think also like maybe just to add on, I feel that the so if you go back to the previous example about the two and four, I mean the that was the example that I told Shuo to do. Cause it’s not really like conventionally out of distribution, right? Because if you’re able to step four, means that you have essentially step three, but then it’s more of like action out of distribution where now you have to terminate earlier. And you realize most of these baseline methods have this latch on behavior. And this is a problem in imitation learning itself. So you sort of latch on onto this behavior the moment it kick starts a certain you know rollouts. So I think this is also very common in the self-driving car, you know, when they are doing imitation learning, when the moment you sort of execute a lane change, you have to commit to that lane change. So it’s it’s hard for you to actually generalize because I have never seen a time where it takes that feedback and makes some form of recovery. So this is like action-level out distribution. So I think. I think maybe like I think what show was trying to mention is that there’s many dimensions of our distribution and I think this word tries to cover every aspect of that. Yeah. Ishneet (14:23) Yeah, I think mainly we are interested in OOD cases where the underlying motor skill is still within the capability of the policy. So that means the policies has learned that sort of task. It’s not like we are getting a policy that has never learned folding clothes to suddenly fold clothes at inference time steering, but it’s more that policy has learned to stack cubes. But now if we have appearance OOD or we have viewpoint OOD or we have language OOD or we have position OOD, it should still be able to recover. And as Jiafei and Shuo mentioned, it should be able to change the action distribution and still recover and complete the task successfully. RJ He (15:00) Yep, cool. Yeah, I mean I think it probably will be a little bit of a stretch to say it covers all sorts of OOD because I think we you know, the space of possible OOD is very big. But and I don’t you know, given the kind of approach that you all are taking with sort of grounding it and stuff, I think it probably steers towards a certain types of classes. And so that yeah, wanted to sort of let you all enumerate that a bit. So that’s cool. Shuo Liu (15:25) Yeah, I think more generally, the OD is an ext extension from the expert data set we use. So maybe the observation can change a bit, or maybe the language can change a bit, or maybe the target action distribution can change, so based on the exp expert data set we use to function the well is, we may change the target or observation we want from the center of this. So it will change a bit but not too far away from what is already seen or trained on. Yeah. So yeah, so maybe I can continue to the related works part. Yeah, so here we list we list some related works by the time we write this paper and split them by some into some categories, like ITPIs and Dana Guide V GPIs and DSRL for one. So we split these related works into different categories depends on whether they need to have another training, maybe another model or the policy itself and whether they and where is the s steering signal come from and whether they are autonomous to steer the base policy, whether they have the well and reasoning ability and whether they are stage aware. So RJ He (16:56) Sorry, so all of these related works are alternatives for steering a base policy towards a broader distribution. Is that is that what you’re all comparing to? Shuo Liu (17:07) Yes, . Yes, yes. All these related works are focusing on how to how to steer the base policy into the out-of-distribution scenario we just talked about. Shuo Liu (17:25) And so compared to other works we have we have three advanta advantages. So firstly Bell is doing the regrounding not the retraining different from Dynaguide like Dynaguide need to train another latent dynamics model and VGPS need to train the Q function used from the offline rl and d DSRL is train the latent noise pol RL policy and for one need to train latent world model. So VLS is different because we make the steering signal from VLM quarry and There is no retrain needed. And also different from with VGPS and 412, because they are scoring the candid candidates and verifies the out output of the VLA policies. We use VLM to write a differentiable PyTorch reward function to the gradient to generate the gradient during the action denoising process. And also different from the DSRL and another other works to rein initial the noise or select the select the output of the VLA policies. Well S inject the gradient to action distribution trajectory denoising at every denoising step. So this can help to narrow the constraint constraints to make them reachable. So this is a comparison between the related works by the time we read this paper and after our paper released there are also some very nice stereo mentored and also introduced the stereo into world action model recently I think. Shuo Liu (19:31) So RJ He (19:31) Is there a sorry, just very high level, is there a which of these, you know, columns you think are the most significant difference between VLS and the and the signific and the previous work that Shuo Liu (19:45) Yeah, I think it’s three parts. So firstly we don’t need to train an any other thing. We don’t need to train another modular and we don’t need to train the RL for base policy or an another modular. And secondly, we get the steering signal from the ability of VLM reasoning. So We are different from others to in introduce VLM reasoning and using VLM to generate the steering signal. It’s not from re-drunk or reinitialize from the gauge noise. And secondly and thirdly we have the VLM in the loop to screen the process of task, whether it needs to be steered and was a progress of task. So we have these three different advantagements, yeah. RJ He (20:42) And I’m assuming therefore you’re it you are agnostic to what underlying VLM you’re actually using, right? Like you could swap them out with in future you could swap it out with better VLMs. Shuo Liu (20:53) Yes, we also have like ablation of the like the VLM models we use. So we use actually use different wells like for the process of grounding our recently talk is using Gemini and it’s using GPT and for the progress screen we are using Gemini. RJ He (21:21) Cool. All right. I’ll let you get to actually talk about. Jiafei Duan (21:22) VLM like GPT six, you know, could this task be just soft? Shuo Liu (21:33) Yes, by that time we use GPT-4o. Jiafei Duan (21:38) So it’s pretty far, like between GPT-4o and GBD6, it’s like not even the same generation. So do you think that will the problem of steering be solved just with better VLMs? Shuo Liu (21:52) Yeah. So here I want to introduce the full pipeline of VLS which meaning contain contains three parts. The first one is grounding, second generate and third to steer. So which is meaning to answer the question of how can we get a very good guidance signal for steering to meet these two needs. So given the we can start from the left part. Given the observation OT and language instruction, the pre-trained policy will take the robot state and initialized to generate a very raw prediction which can be used in the scene but it will have a very low success rate. So it need should be refined this raw action. So given the same observation we’re firstly doing the grounding. So where we’re using the large region model is Segment Anything Model and dyno pre-trained feature so we’re firstly using gemini to get the task specific objects and using segment anything to make task to make objects To make mask, segment mask for each object and using the dynamic to get the DINO feature for each object based on the mask and RTV pixels. So from the DINO feature, we class the DINO feature of each object into several key points based on their spatial coordinate and their dynamic. And using this kind of Shuo Liu (23:40) Using these key points we are grinding the task specific requirement into some special key points and this set this set of special key points can be used for the second stage which is well and generate the stage available function based on the based on based on the observation and language and also the k points we have for this thing. So the VLM we here we use the GPT4O will generate a series of guidance functions depends on the task progress needed. And the each guidance function will take k point set which is generated by the first stage. So it will be a special k point and also the partially denoised action sequence which is taken from the pre-trained policy denising steps. So the VLM is prompt is prompted to write this function into a PyTorch style so it could be strictly promised that the reward signal from this guidance function can be differentiable to the action sequence input. So this function will generate one guidance signal and we can get one gradient from this guidance functions and we can using the sterable ability of flow matching policies and diffusion policies to inject this gradient signal into their denoising loop. So here we take four steps to inject the signal into the denoising loop based on the raw prediction from pre-chained policy. So firstly we’re using the radius-based function which is Shuo Liu (25:37) Which is measures the diverse ability of the pre-trained prediction to give a very large area to explore and we intr introduce gradient from the reward functions using the gradient based refinement and finally we’re using resampling based on the samples itself to have a final refine prediction and then we execute the refine function and using different VLMs to screen the task progress to decide whether this stage need be steered and was with the steering s strings and also how to how to move to another the next stage. So here is a follow up of VOS. First we ground the thing and the observation and instruction into a set of key points and secondly we Query the VLM to generate a set of guidance functions based on the task requirement and second and thirdly we steer the raw prediction to refined prediction. So we can use we can take the first and the second step to meet the requirement one, because we can correctly interrupt the special and semantic requirement to set of k points to structure the out of distribution condition and we can use third part steering to meet the requirement that we need a dense and informative gradient to the partially denoise the action trajectory. And I will introduce in detail how we do the third steering part. RJ He (27:33) Cool. Yeah, this is a very interesting technique. Maybe a couple of questions first. Maybe could you share the motivation for on the grounding side of it? Why choose why use Sam Mas and the Dino features? Like what why do you think those features are the important things to be grounding on? Shuo Liu (27:54) Yes. So this step is to make the task relevant observation and instruction into structed like model that VLM can use. Because if you just give VLM an RGB image and instruction it may confuse the and output maybe output some text or maybe just re just reuse the image you gave it to. So we are using the this grounding method to make sure the observation and instruction and to ground it into a set of key points, special key points that each object may have, maybe assigned a few key points that can be used to use for description of the VLN. Ishneet (28:47) Yeah, I think we use sound for more. RJ He (28:48) Yeah, I guess for instance, you know, you’re all one of the ODD pieces are like the visual observations, right? So for instance, the background. That may or may not be really captured in the SAM mass and the dyno features. You know, i are there other groundings that you think may be maybe helpful to be more sort of more complete in the space of ODD conditions that you might be interested in? Ishneet (29:12) Hello. Shuo Liu (29:17) Yeah, I think DINO feature used here is because it well it is well trained for again the object itself, the parts I mean the different parts. So for different parts of maybe a part the pot handle and the And the part op opening part may be assigned different DINO feature and based on their special re relation and different dynam features, we can get the K-points for different useful parts for each object. And we can also get the we can also get different features from the same segment and the same mask because it’s it’s just take from the RGB image and applied for each object to split from the image and also now display the background. Ishneet (30:22) Hello? RJ He (30:27) Cool. And then maybe on the reward function, what can you give it at a high level like what is the prompt you all are asking? You know, that you put into GPD for all? Shuo Liu (30:41) Yes. So I maybe I can show some check yeah so here is here is the paper and we are showing some details of VLM reward generation so basically some instructions for the VLM to get the robot policy steering context and also we give some in-context examples like from the from the pick and place tasks and we are asking the VLM to generate the guidance functions in a in a way that use PyTorch to make sure that it’s differentiable to the input k points and we have some constraints that need to need to make the functions itself can solve can solve the guidance signal and some shape requirement and finally we ask the VLM to return a set of rule functions. Shuo Liu (32:02) And also for VLM sta for VLM stages reaching we are also using another very simple instruction to screen the task progress of the policy. Yeah. RJ He (32:02) Okay, interesting. Yeah. Shuo Liu (32:17) Yeah, so here is a prompt we use for the veil arms. RJ He (32:30) Yeah, it doesn’t seem like it has a lot of focus on the actual reward function. It seems like a there’s a lot of Dhanas that’s involved in gener in writing out that prom. But it’s interesting. Shuo Liu (32:41) Yes, because from our observation so for the very first version that VLM may generate like the real functions not in PyTorch still which means it cannot it cannot be differentiable to the action proposal and sometimes it will import another libraries from the repo but we cannot apply this because we are doing the runtime still re so i it should be generated and directly using in the pre-twin policy denoising part so we twin it literally iterate and have this final version yeah it’s also attached to the archive version at the at the final part yeah RJ He (33:36) Okay, great, thanks. Yeah. And you said you wanted to dive deeper into how the reward function gets injected to the denoising process, right? Yeah. Shuo Liu (33:44) Yes, I will introduce the play for this stair part. Maybe we can also introduce the first grounding and the reward generation part of it. So from the from the observation and the language introduction we first quarry, Gemini and second anything, then dyno for and finally the k points using the GPT to generate the real functions that are differentiable and stage a wear for the task. So here we using the reward as code not as a score so we can get the dense gradient from the these reward functions. And for stage three we want to deeply introduce processed from the initial partially denoised action proposal we use radius basis function kernel to make sure the divers of the action proposal at very early stage of denoising are very high. So it will using a pairwise representative force inside of the action proposal batch to keep each proposal keep away from each other and this can really help to make sure the denoising process not collapse into the local optimum. And so we can have a we can have a good diverse batch to start the gradient based guidance. So at the second stage we are introducing the gradient signal from the real functions we just introduced. So here we add the real gradient to the to the noise to the denoising process at every time step. So here the very dense and the differentiable signal are injected to the Shuo Liu (35:44) Denoising process and finally we’re using Feynman–Kac resampling process and to this is this is not gradient based this is resample based. So for a batch of samples it will reweight the samples based on the same reward signal from the functions and it’s kinda kind of like JNAC algorithm that copies the good examples and lower the weight of bad examples. And finally we have the refined action. So this is the process of stage three the steering from the initial raw pro prediction from the pre-trained value model to the final refined action that we can use in the scene. Yeah. RJ He (36:38) Cool. So just to make sure I understand the RBF kernel is there to try and increase the number of modes. So you get that diversity and then FK resampling is more that but once you start recognizing what are good modes and what are bad modes, that you wait further towards the good modes. Do they then kind of compete against each other a little bit because they’re Shuo Liu (36:59) Yes, yeah. RJ He (37:04) FT resembling may then lead again to a concentration towards fewer modes, you know, s hopefully the good modes, but it will lead to a smaller number of modes then. Shuo Liu (37:15) Yes, I think for n for here the refinement and resampling are using together because refinement can provide like kind of local steering. So it we are based on the gradient from the real signal for each for each sample. And the resample for here is kind of like a global mentor that can compare different samples into the same batch and select the good ones and lower the rate of bad ones. But it’s not just great weight into inside the algorithm itself it will help to improve the weight of sample the sample those action predictions that have good function reward signal score at this step but at the next step it will be another story because we are choosing from a very diverse sample port from the same batch because we are using RBF here to make sure we have a we have a very good port to select from and we doing the local requirement of each of them first and compare each other f into the batch to Select the good ones for next step denoising. Jiafei Duan (38:37) Yeah, I wanted to ask regarding the FK resampling versus to like just regularly resample you so you mentioned about the I guess like sort of like evolutional algorithm kind of approach. So like what’s the motivation behind that? Like why uses this approach specifically? Shuo Liu (38:49) Yes. Shuo Liu (38:57) I think this kind of because from the I chose this because we for action denoising we can have a batch of samples to compare and how can we how can we find the good examples from this batch. So one very classic algorithm is to using the rev revolution algorithm to compare to compare each sample’s ability of the same standard. So here we’re using the reward score here and to make sure the good ones can be sampled by higher chance for future and lowers lower the possibility of samples by ones. This is from the ability of denoising a batch of samples of the BLA models. Jiafei Duan (39:58) Got it. And my assumption is that this approach is used for image generation, like before you know, you apply it for action generation. Is that like so you do see that this actually helps quite a bit through the ablation with that case and Shuo Liu (40:13) Yes, . So Yes so yeah by the time we are exploring different mentors also inspired for from some image editing papers that using FK resampling for the image generation part image generation direction and we found that it can really help the to improve the performance of denoising samples in very quick and promising way. Yeah. RJ He (40:53) Cool. Yeah, why don’t maybe wanna make sure you have time to cover the results. Maybe you want to jump move on to that. Shuo Liu (40:59) Okay, sure. Okay, yeah. So for the experiment part, we mainly want to answer the requ research questions that first one can VLS adapt VLA models to joint observation and language shifts, and secondly does VLS provide a stronger adaptation than existing inference time steering answers? And also We want to do an ability study of what’s the contribution for each component and also whether ice can adapt the policies in the real-world deployment. So firstly we want to introduce the experiments that we did on the LIBERO-Pro and the LIBERO-Reasoning benchmark. So LIBERO-Pro is a benchmark that has a perturbation based on the original LibreO benchmark that can change the task layout and also task specific language instruction across four different seals. And LIBERO-Reasoning LIBERO-Reasoning is another benchmark that can change the visual scene change visual scene layout and also the camera viewpoints. So here is two tables relevant to the LIBERO-Pro results and the liberal LIBERO-Reasoning LIBERO-Reasoning benchmark. So we ha here we can find that compared to the base policies we use open VLA π0.5 and different environment of π0 and different Shuo Liu (42:41) Different steering method like do what you see and the π0 with vGPis here. Compared all of them VLS can get the highest score across two different liberal perturbation benchmarks. So here we want to introduce why VLA’s fail here and why VLS can success. That’s because given the very different observations and language shift the post trained policies maybe get the special reasoning and the training context together so it can doing the lazy motion like giving the kind of similar observation under different language instruction, it can it will directly mapping the observation to the action. Never consider what language used here. And VLS can do in the regrounding based on the Task inference time relevant observation and instruction pair to the 3D keypoint side and using the differentiable reward function to the action chunk. So it could be very sensitive to the inference time task configuration and improve the ability of base policies, whether it’s π0.5, π0, any flow matching based VLA expert or diffusion policy can work here. So basically the VLAs can actually learn how to use how to generate the motor skills relevant to the post training part relevant to the fine training task configuration but can very easily lose the semantics special and the special general generalized generalization and VLS can help to restore it. This is a first Shuo Liu (44:34) Research questions that we want to answer so VLIS can do adapt VLA models to joint observation and the language shift. RJ He (44:46) Would you say that a big motivation of this paper is kind of motivated by the Liberal Po setup where those are you know it’s those kind of task and position perturbations that you know LIBERO-Pro was designed for is what motivated you to sort of think about those types of O D c scenarios to solve. Shuo Liu (45:12) Yes, . So this is also from the observation that liberal is going to kind of converge by current value because recently many work can reach the success rate higher than ninety eight. So we found that One problem is that the BLA’s are functioned on the same observation and the action pair and for the inference time it will it will never change. So the BLA policies can very easily get one lazy mapping from the observation to the action. If they are not it will not consider what’s the language change or what’s the observation change. Yeah. Ishneet (45:58) Yeah, I think LIBERO-Pro was a good motivation for us because it’s a good data set where you’re able to actually do specific type of OD and test the performance of your setup. But I think the broad motivation was still that you know you have very strong pre-trained robot policies that have the motor skill and that have the capabilities in the policy, but they’re just not being utilized in the action output because if you have any observation or language context shifts, your action generation is just too it’s just tied too closely to your training time. Correlation. So I think LIBERO-Pro manifested in a way that it was a good benchmark was to actually quantify what the different OODs can materialize in and actually how to test the whole steering pipeline. But yeah, I think the main motivation still remained that the pre-trend policies are just quite brittle to OOD in general. RJ He (46:48) Yeah, no, that’s cool. And I think this technique seems like it’s quite general to expand beyond just the specific scenarios. Jiafei Duan (46:57) I have a question for show. Do you think that ‘cause the thing that you’re sort of steering I think mostly come from the action expert side of the VLAs, right? Like so do you think this will actually work for WAM, the world action model? Shuo Liu (47:13) Yes, I think recently another work is called sterile WAM is just released and I actually have not read it yet but I think for WEM if we can because it’s actually jointly denoising the feature videos and also the actions together. So we may apply this approach to the WAM models, yeah. Jiafei Duan (47:43) Got it. So it’s it’s it’s kind of applicable to also WM because of the action expert component of WM that’s pretty similar to VLA’s minus away the VLM side, which like you could in theory apply this to generic, both the world model side and also the VL VLA side. Yeah. Ishneet (48:04) Yeah, usually if WAMs have like a differentiable generative action expert, it would be quite interesting. I think there were some papers recently on WAMs where there was like a flow matching action head that decoded a continuous action chunk. There’s also one that was a lightweight action expert on it. So yeah, I think if you add steering on top of WAM, you probably have like more like more strong world representation. And then it’s also able to like iterate on the failures of its actions as well. So steering could be an interesting thing on the W A RJ He (48:36) But will say that this is this method is more limited to ones that are using an action hit like that? You know, what about say IDM type of approaches? Is this applicable or it’s probably not? Shuo Liu (48:57) Sorry, can you repeat the models like different models you just mentioned? RJ He (49:03) Sorry, so it sounds like this requ does require a model that has a action head that is kind of flow matching based. You know, what about but not all wo especially world action models are using that approach, right? Like there’s IDM and others. So do you think that would be applicable too or this is more limited to ones with flow action flow matching? Ishneet (49:24) Do you think that is available to or is it not a good job? I think steering can still be part of an IDM. As far as I understand an IDM correctly, it is differentiable end to end. So usually for us we do steering at the action generation level for VLA or maybe for world action model. We can still do the similar process for IDM, but because it’s just like a deterministic state to action decoder, you have like a video and you want to get actions from it, you can easily you can usually steer its input. So you can steer the diffusion process in the video. In the input of the IDM or maybe you steer an upstream planner rather than the IDM itself. Yeah. But I think it’s still possible with the IDM as well. RJ He (50:10) Cool. This is that’s that’s very exciting. Shuo Liu (50:14) Yeah, maybe I can introduce going to research question two, does well as provide a stronger adaptation than existing inference time theory. So here we compare to different theorem answers that are based on the same diffusion policy checkpoint on the CALVIN environment. So we compared with Spencer’s ITPS, Dana Guide, VLA pilot, and base policy diffusion and base diffusion policy itself. So we get one seven point four times improvement based on the base diffusion policy of the mobile objects and nine point six time of the base policy and we also gets a higher s score rather than other stereo mancers. So we think that’s because ITPIs need one hand picked the classifiers that need human in the loop and could very easily fail on the mobile objects and that’s because in the simulation running we are setting the K points at the first frame of ITPIs and not using the dynamically update and for Dana Guide since they are using one latent word model that using the Dino features distance to measure the to measure the reward score and inject into the action denoising process. But DINO feature is too cross for the fine special constraints like for CALVIN you may need to open the switch, open the drawers and pick up the Shuo Liu (52:04) Pick up the three cubes on the table. Only using the dano feature could make mistake because the maybe the cubes feature is too cross to describe in the whole image feature and the VLA pilot is using is using the sample quality of the i it’s depend it’s depend on the sample quality of base policy. So it’s it’s kind of irrelevant of VLS because just accept the gradient-based denoising. So they are doing the sampling and compare the different performance of each sample based on the same reward function. But they are not using the gradient signal and they are not doing the like doing the RBI process to make the samples very diverse. So if the base policy can generate a very narrow bench narrow batch of samples it will choose the best one with the highest score using the real function but will never like push it to another direction. So from the comparison of different steering methods we can find that VLS can compare cu combine the dense VLM written gradient signal and also the resampling process together to make the best for this CALVIN environment benchmark. Shuo Liu (53:47) So and also here maybe HN can introduce the Apple H part. Yeah. Yeah. Jiafei Duan (53:52) Wait, sure, I have a question about the previous one. So I mean like I understand a stronger adaptation, you know, compared to c current inference time steering approach. But is the latency better than the current approach? So like because you are steering and you are always doing this kind of like some form API cost to the VLMs, you know, then they creates latency right in the inference time. So how would that im latency compare to some of this other approach? Do you guys try that? Shuo Liu (54:22) We didn’t compare the latency across different mentors but we do have an abilation of the WS system itself. But from my experiments that dynaguide and well that could be dynamaguide could be much faster because Like for one specific scenario it will train one latent world model first and it’s very it’s very late white model and can be queried very fast. So at each so at each de denoising step it will compare the current observations DINO feature and the goal and the sorry the goal conditions DINO feature together and compute the feature distance to there’s action so it can be queried very fast and at pix is meaning human in the loop and I think BLA pilot is the closest to our messenger that’s because we are both using the remote functions reward functions generated by BLM and they are just not using the gradient based steering and so the latents the latents introduced the delay introduced can be the same level of VLA palette and ours, but both are slower than a guide. And also we have a ability of VLS system itself, the latency introduced. Jiafei Duan (55:58) Got it. Thanks. RJ He (56:01) Cool, yeah. I wanna be in I wanna be conscious of time, so maybe you can quickly touch on the ri final two research questions. Yeah. Shuo Liu (56:06) Okay, yeah. Okay, yeah, yeah. So maybe Ishneet can help to in introduce ablation part. Ishneet (56:16) Yeah, so we did ablation on each component in a system. So firstly you have like the you have the SAM and the dyno as well, which builds the geometric interface. Then you also have the VLM reward synthesis, then we did more ablation on the gradient guidance, the RBF repulsion, which maintains the diversity and also does the exploration for the steering. And then we also did ablations on Feynman category sampling. We also did ablations on adaptive guidance strength as well. And so based on all these ablations, what we realized was that the gradients guided steering is the most important. And actually when you remove that on the Calvin benchmark, then it’s not able to complete the task. And so what we realized is the programmatical rewards that the VLM generates does the heavy lifting in a system. And then Feynman–Kac resampling or the RBF is more of helping it explore and choosing the best one out of the different steering solutions. And so that helps to stabilize the steering process. And they are if you remove them or you keep them, it doesn’t make a big difference because the main thing is still the gradient guidance steering. And yeah, I think what we realized was that the gradient guidance steering is the main component that matters. And the other two are sort of inconsequential to the whole system. But if you add them to the whole system then they work. But if you r remove one of them, it doesn’t make that much of a difference. Yeah. RJ He (57:44) Sorry, just clarifying, what does it mean when you say you remove the gradients guided some part of it? Then what is the alternative when you remove that? Ishneet (57:53) So by gradient guidance steering I mean that we directly are modifying the denoising so that the trajectories move towards satisfying the reward. This is one of the main components in our paper that actually turns the reward that the VLM generates into an actual continuous signal. And we realize that if we remove this out of our pipeline and keep the others and do try to do steering, the performance drops a lot. So on Calvin we try to test this, it drops from like ninety percent to eighteen percent. So we realize that the gradient guidance part in a pipeline is actually what bends the generative trajectory towards the desired behavior. RJ He (58:32) Yeah, I mean that makes sense and in many ways I thought that is the only way that you could be influencing the action trajectories, right? I mean, if you don’t have that gradient’s guidance, you don’t have a your out your at on your enhancements don’t really have any impact. Ishneet (58:47) Yes, that is true. Shuo Liu (58:51) Yes, I think it’s also the key points that way compared to the VLA palette here because it actually an environment in environment of VLS just don’t have the gradient guidance part, so the performance showing in CALVIN we can overperform it because we are using the action specific gradient to inject to the denizing loop. Yeah. So here is which yes so it we also did real world evaluations and designs task that can measure the sterility of different RJ He (59:21) Okay, cool. Thanks. Yeah, maybe your final research question? Shuo Liu (59:38) Models whether it’s π0.5 itself or π0.5 plus VLS. So for the task for the in distribution performance, VLS can help the π0.5 checkpoint and just fun tune on several demos of the task specific data and VLS sorry VLS can help the base policy π0.5 performs better than the policy itself and for out of distribution performance. VLS can hold the success rate at the same level of in-distribution, but π0.5 can drop a bit because it’s a new observation and a new language combination at the inference time. So VLS is actually helps the base policy can be used in the out of distribution scenario. Shuo Liu (01:00:38) Yeah, so here we want to go to the conclusions that with the contribution of VLS and w with the future direction. So VLS is introducing the combination ability of VLA policies. So the pre-chrint policies can combine the motor skills they learned from the fan training process together at inference time by VLS. And we found that VLMs are very good at writing the remote functions and introduce the guided guidance signal into the denoising trajectory d denoising loop and we found that steering is actually better than selection paired with mentors like VGPS and VLM in the loop. And we also find that we also introduced that VLS is one training free and policy agnostic method that can be deployed on any flow matching or diffusion based policies, whether they are diffusion policy or VLA policies with an flow matching expert, action expert. Yeah. That’s the in the intr our introduce of our work VLS. Thank you, yeah. RJ He (01:01:57) Great. Well thanks guys. Yeah, this is a super cool technique. I think has a lot of potential. Especially bringing in the VLMs to help with writing the reward function to do the steering. So congrats on the paper. Also it sounds like you guys just got accepted to Coral, so congrats for that as well. Looking forward to seeing it at that conference. Maybe just to wrap things up, as we always ask, any papers that Shuo Liu (01:02:16) Yeah. RJ He (01:02:25) You all have come across recently, you know, whether related to steering or otherwise, that you all want to do a shout out on? Shuo Liu (01:02:32) Okay maybe I can stop sharing first. Shuo Liu (01:02:46) Sorry, can you like repeat the question? RJ He (01:02:49) Yeah, no i mean, you know, as we ask with every episode, you know, any interesting papers that you all come across recently that you want to do a shout out on. Shuo Liu (01:03:00) Yeah. Recently I think a very new trend for robot policies is called in context learning that is from the generalist one point five and skilled AI. Also previously we have the immediate like text time training. So I think it’s like new trend of how can we adapt the pre-trained policies at inference time to like fit different task specific requirements. Like if you just showing one demo of the task specific and the robot policy can just learn it. So I think it’s kind of a emergence from the very large scale of pre-trained data they have and also and also I think the tax test time training paper also introduced one very interesting mansor that introduced trainable model sorry the net networks in inside the pre-trained policy itself. So I think it’s also kind of aligned with the motivation we want to do the s this steering because we are both want to make sure the pre-trained value policies can be general generalized to the new task specific requirements. RJ He (01:04:34) Yeah, cool. Yeah, indeed. I think this space of this is a quite an interesting space together and many of these different techniques of adapting to it. Yeah, Ishneet, anything for you? Ishneet (01:04:34) Yeah, for definitely. Ishneet (01:04:45) Yeah, I think a recent paper that was very intrigued by was called Piggy and that paper was very interesting because what it does is it is it is doing like a orchestration layer and it’s orchestrating different VLAs as well as the model’s natural capabilities to do like just control the end effective pose and get it to do the task and we see this a lot with GPT-6 being released and you see it’s able to do tasks in Libro and almost solve Libro just natively. And I think that’s very interesting and how these LMs, the way they’re trained in the future as well, if they’re trained with more and more web data, they just generalize to videos and you realize all you need is really just a very good action head. And then you know it might you may not need world action models or something and maybe just scaling L LMs is the way to go, maybe. RJ He (01:05:35) Yeah, cool. Yeah, indeed, as Jafi was mentioning earlier, sort of y b methods are UI you guys that are relying on GP you know, some of these LIMs, you get to benefit for free as these LIMs get better as well. So maybe that just on its own solves the problem. Awesome. Thanks guys. Thanks for coming on our pod. And looking forward to yeah, more great works from you guys. Thanks again. Ishneet (01:06:02) Thank you so much. Jiafei Duan (01:06:03) Thank you. Bye. Shuo Liu (01:06:03) Okay. Secure is yeah. RJ He (01:06:04) All right, bye. This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit robopapers.substack.com

  • September 25 · 1 hr 2 min

    Ep#107: Do As I Do: Dexterous Manipulation Data from Everyday Human Videos

    Achieving human-like dexterity is the next frontier for robotics, and yet dexterity data is often subtly hard to scale. Real-world dexterity data, including things like finger-pose estimates, is often slightly off, making it physically invalid and hard to execute on real hardware and hard to learn from. DO AS I DO is an algorithm for reconstructing and retargeting monocular RGB videos to robot hands, outperforming the state of the art and even working from generated videos. Bhawna Paliwal, Haritheja Etukuru, Will Liang, and Mahi Shafiullah join us to tell us more. Watch Episode 107 of RoboPapers, with Chris Paxton and Jiafei Duan, now! Abstract How can we scalably generate data for robotic manipulation, especially on human-like platforms such as dexterous multi-fingered hands? Learning from human videos has recently emerged as a likely answer to this question. However, difficulties in estimating hand-object interaction and crossing the human-to-robot embodiment gap have hindered the adoption of abundant monocular RGB-only human videos as the primary source of robot manipulation data. In this work, we present DO AS I DO, an algorithm to reconstruct and retarget monocular RGB human videos to multi-fingered dexterous robotic hands. DO AS I DO reconstructs hand-object interactions from various egocentric and exocentric in-the-wild video sources. The algorithm then retargets these hand-object interaction estimates into a sequence of actions executable in the real world, yielding robot-complete manipulation data from disparate human videos. Overall, DO AS I DO outperforms previous state of the art in estimating hand-object interactions and extracting dexterous manipulation trajectories from RGB videos, as we show in experiments on datasets with ground truths and on a dataset of video clips collected online. Our experiments enable us to propose an efficacy playbook for practitioners collecting human data for manipulation. Learn More Project Page: https://do-as-i-do.com/ ArXiV: https://arxiv.org/abs/2606.19333 Github: https://github.com/malik-group/do-as-i-do Original thread on X Transcript Lightly edited for transcription errors, names, technical terminology, punctuation, and readability. Conversational phrasing is otherwise preserved. Editing done automatically with ChatGPT. Chris Paxton (00:05.479) Hey everyone, welcome to another episode of RoboPapers. Today we have some great work from Bhawna, Haritheja, Will, and Mahi: “Do as I Do: Dexterous Manipulation Data from Everyday Human Videos.” Welcome to the show, guys. Could you introduce yourselves quickly before we get started? Bhawna Paliwal (00:24.977) Yeah, hi, I’m Bhawna. I’m a PhD student here at UC Berkeley, advised by Jitendra Malik. Haritheja Etukuru (00:32.692) I’m Haritheja. I’m a second-year PhD student at Berkeley, also advised by Jitendra. William Liang (00:37.929) I’m Will. I’m also a second-year PhD student, advised by Jitendra and Pieter. Mahi Shafiullah (00:42.606) Hey everybody, I’m Mahi. I’m a postdoc currently at Berkeley, and I’m also spending some time at Amazon FAR right now. Chris Paxton (00:50.983) Awesome. Well, yeah, would you guys like to tell us a little bit about this? What have you guys been working on? Bhawna Paliwal (01:01.499) So I’ll just start with a little introduction to the paper. So mainly the motivation behind this work was how can we utilize the massive video data available on internet for training robots. And most of the prior work has been which which has involved learning from human videos, has involved co-training with robot data, which which eventually involves having like hundreds or thousands of hours of teleop data combined with, let’s say, twenty thousand hours of video. So our objective in this paper is to understand. Whether there is some intermediate representation, let’s say in in 3D, where we can extract the right kind of information from human videos and make learning from human videos much more efficient. So essentially every human video where hand-object interaction is going on turns into a separate trajectory on which you can train like a robot model. So prior work has looked into this problem mostly through by collecting their own data and maybe having like specific settings where they’re They have like specific angles and specific robot specific hands hand-object tasks available. But here we look at internet videos in general where there might be a lot of occlusion, motion blur and so on, which are not necessarily recorded for robot learning. Yeah. Chris Paxton (02:21.331) Right. Some of the videos here in the highlights look incredibly good, particularly with the dexterous hand. So how does this work? Bhawna Paliwal (02:35.113) So I think As like broadly there are like two steps. First we have reconstruction where we reconstruct the object in 3D, as shown here. And here and then we retarget it onto a robot hand, in our case the Sharpa hand. And for reconstruction, like the hardest part was object tracking. That is most of the times when we are looking into hand-object videos, the objects are mostly occluded, especially the tiny objects such as this one. There are like just fewer than a hundred pixels where the object is actually visible. And reconstructing the object becomes hard first. And secondly, tracking the object becomes even harder, even if you know the shape. So, in this work, we first we utilize like all the computer vision progress that has been made recently, especially models like SAM 3D, which can just like take a single image and give you the shape and pose of the object in that particular frame. And then we come up with our own method of how do you utilize the SAM 3D kind of methods to also track the object over time. And the motivation behind was just behind that was just this that SAM 3D has been trained on lots of images and artificially constructed images where like some particular object is blurred out or it has been hidden by some other object. And then so it knows when the how the object looks when it’s like heavily occluded. And then what we do is like we predict the shape and pose at one particular frame and then propagate it to next into like further frames. while keeping the constraint that the shape of the object should not change too much and things like that. So I let Will explain the retargeting part. Yeah. So Jiafei Duan (04:18.402) Yeah, I think I have a sorry. I have a question. Yeah, so I actually I read I read the paper quite a few times. and I find it very interesting. So what we are seeing here is an open-loop replay, is that my understanding? Right. So would that be like any limitation that you guys foresee? I mean, maybe I’m jumping ahead of time, but I’m just curious, right? Like for example, certain tasks when you are, you know, doing requires some level of precision or perception, then how will you address that? Or is it just more of the motion that matters at this point? Bhawna Paliwal (04:51.655) Yeah, so these trajectories are right now open loop and the how we foresee this should be changed into a perceptive task, which is definitely necessary, is by training taking this reference, domain randomizing the object position, and then training an RL policy, let’s say using point cloud as input. So this will involve just like since you already have the reference trajectory in simulation, you also know the object shape, and then you can like train an RL policy. The object pose is changing and let’s say like even the your environment is changing, lighting and so on, and then you can do all these kind of domain randomization tricks to kind of make it work for one object. And then once you have lots of such policies, you can probably distill it into one big model with let’s say behavior cloning. yeah. Mahi, maybe you would like to add more things. Mahi Shafiullah (05:46.155) Yeah, I mean I think one of the things that I think about when it comes to this project is really that we’re exploring how to get robot data from kind of arbitrary internet videos, right? But then like robot data is not the same as a robot policy. Imagine when you’re doing behavior cloning, you still have to do the same t thing like twenty, twenty-five, two hundred times. And that is because just a single trajectory does not really make a policy. It kind of like gives you what to do in a certain situation, but not what to do in small variations of the same situation. And you have to robustify around that trajectory somehow. multiple ways of doing this, right? Like the behavior cloning people likes to learn a map from observation to actions and the reinforcement learning people likes to train a policy that converts that from observation to action, maybe using some as reward, something as a reward. So What Rabna just described is more of an approach of like, if you wanna, you know, derive a reinforcement learning policy out of it, like a trajectory, how could he do it? But overall, I think the twenty thousand foot view that I personally take is that data is data and you want to figure out like how to make data useful. It could just be that we throw everything into a big policy where the images go in as an input and the actions, the robot actions that we’re deriving from this comes out as an output. And once you have enough scale, then that just learns the general policy for articulating a robot. So it’s pretty much open question, like how do you want to convert a robot trajectory into a robot policy? And I don’t want to like say that like a certain direct approach is better than the other. My personal bias at this point is what kind of Bhawna described, which is maybe we do some sort of sim-to-real. And especially for dexterous hands, I feel like sim-to-real is like a pretty good way to go about it. But You know, there are other papers which have kind of converted this into kind of like a two-finger gripper data and there you can actually do behavior cloning and go a long way. So that’s another viable approach, definitely. But yeah, it’s it’s a pretty important distinction to make between a robot policy and robot data, because robot data is just data and not a policy. Chris Paxton (08:05.587) So let’s yeah, let’s talk a little bit about how the about how you actually get this data out then. I guess Will, you’re gonna tell us about retargeting. William Liang (08:10.939) Yeah. So Bhawna was talking about how we get how we reconstruct the human hand and object from the video. but that’s just the human hand, so how do we get it into the actual robot hand? so retargeting has been pretty extensive extensively studied recently. this is like there’s a lot of works trying to convert human hands to robot hands. Maybe some earlier ones are trying to simply match fingertips. This is like kinematic retargeting where you don’t actually consider how the hand interacts with the object. So this allows for like collisions or like it doesn’t actually hold the object properly. But what we want is something that’s physically realistic. So there’s a more recent line of work on doing dynamics -aware retargeting, where you actually run the retargeting inside physics simulation and simulate all the contacts and collisions and forces between the hand and object. there’s like two lines of work. There’s like there’s a whole series on doing reinforcement learning. So you directly take you could directly take the reconstructed reference and then use that as a dense reward for reinforcement learning. we didn’t go that route because that would train a single policy for each task, and that might be very expensive. like take at least a few hours per trajectory. So what we did instead was sampling-based planning, or this is kind of like MPC or MPP I, where we roll out a bunch of noisy actions and then optimize the action sequence itself instead of optimizing for a policy. So yeah, there’s like a nice visualization here. We can see this is like ever every like control step is like a bunch of noisy actions that gradually converge towards a sequence that properly follows the reconstructed reference while being physically realistic. So this takes on the order of ten to twenty minutes. This is a lot cheaper than training an RL policy for each task. And then after you do this, you can directly replay on the robot, which is the first set of videos. Chris Paxton (10:17.907) Can I ask why does it take 10 to 20 minutes? Is that like I would assume that’s like very parallelizable. So let’s just throw more compute at it, it’d be faster. Okay. Yeah, makes sense. William Liang (10:23.869) Yeah. Yeah. I mean, one of the big reasons is we still need the simulator to be very precise. so if you so we’re running this within MuJoCo Warp, this is already paralleliz parallelizable. you could run it a lot faster if you like tweak the simulator setup, but in order for it to deal with like a high diversity of objects, including ones that have like very thin walls, you want the simulator to I guess run a bit slower, but be more precise in those contexts. Mahi Shafiullah (10:59.586) So here’s actually a good time to talk about a few of the intricacies of the simulator that actually matters here and things that you want to be careful about when you do this. one of the harder things when you’re kind of trying to simulate dexterous hands is that you want to represent the geometry of the hand as well as you can. Because a lot of times, for example, when you’re doing you know, kind of like a humanoid robot locomotion or you know, like quadruped locomotion. One of the things you can do is you can kind of like simplify the collision geometries a little bit so that you can simulate the whole process a lot faster, right? Because the only contact you’re making is with the ground and there is nothing else that you really have to worry too much about. So as long as you avoid self-collision and avoid as long as you avoid like catastrophic contact with the ground, you’re good. But what happens here is for example, you were trying to interact with arbitrary object. Right. And the problem here is that if you don’t simulate the hand well enough or to a high enough fidelity, what might be happening is there might be some geometric weirdness that the simulator can then take advantage of and do basically reward hacking. Right. So if you’re trying to lift up an object, let’s say this cup that I have in my hand, right? It might be that there is like a weird wedge in the fingers which just latches onto the cup that you have and the object motion is just doing just as well in simulation, it’s not gonna pass in the real world. Right. So one of the big things is that given a kind of complex geometric hand, you have to simulate that to the full fidelity, which slows down each simulation step that you can take. And the same thing you have to do for the object itself, right? Like if you have, you know, like simulated weirdness into the object, then it might be that the simulator can be exploited for the sampling process to just generate the same motion that’s not gonna transfer to the real world. so that’s kind of the balance that we have to draw and because this is kind of focusing on like mass application. We don’t want to go over every trajectory and optimize it ha hand like you know, like by hand. We try to pick kind of a conservative set of parameters, which might be a little slow but is much less exploitable compared to what could be more exploitable but much faster. this is not gonna be a problem if you’re trying to imagine like train a single policy for a single task because then you’re not bounded by the then you’re more bounded by the iteration time and not so much of like Mahi Shafiullah (13:20.895) You know, like what’s the level of decimation that you’re doing on the object convex hull? Chris Paxton (13:25.671) Presumably RL would also equally be able to exploit any issues in your model or physics, right? Yeah. Mahi Shafiullah (13:28.96) Exactly. Exactly. So that’s I guess the difference is for RL, you like train a policy, you look at it and you’re like, something’s being exploited and then you go back, edit something in, and then you run the RL policy again. Right? So the downtime that you have Exactly. Human human usually that’s kind of how the RL policy learning step works, where the human just goes and, you know, like looks at it and being like, that doesn’t look right. Chris Paxton (13:44.507) So you’re saying the human would solve it because it’s a human looking at each problem. Okay. Yeah, fair. Yeah, yeah. Mahi Shafiullah (13:54.659) But when you’re trying to do like six hundred trajectories or a thousand trajectories or million trajectories, you don’t wanna do that. Right. So you kinda wanna pick like a more conservative setting, let’s say, that still ends up with mostly success cases rather than failures. and that’s kind of the trade-off that we see here once again, because we’re trying to do it on a larger scale, rather than like a single policy. Chris Paxton (14:16.093) What does that mean on the side of the objects? So like the object models, cause I because I feel like bad object models are one of the lead things that these things often exploit, right? Mahi Shafiullah (14:25.548) Yeah. Will do you have any fun stories? William Liang (14:28.421) On the object models. So one of the tricks or one of the problems we ran into early on was for cups like the one you just showed. the walls of the cup are pretty thin. SAM 3D often generates thin walls. and that means the hand can just like ramp into the cup and tunnel through within one discretized time step. so the way you can get around this is by decreasing like having more fine-grained time steps, but also by increasing or like inflating the mesh itself. We do both of them here. Mahi Shafiullah (14:59.918) Yeah. But again it’s it’s kind of like yeah, go ahead. Yeah. Jiafei Duan (15:00.42) I have a question. So yeah, sorry. Yeah, so I think since we are also on the topic, right? So I find something really interesting after reading the paper, which is that the way success retargeting is measured is by ten centimeter means object position and zero point five radius, that’s like twenty twenty-nine degrees. So isn’t that like a huge margin to define as success? Bhawna Paliwal (15:22.705) It is a huge margin. there are two considerations. I think for first of all, this is like taken from like the past retargeting literature, so we try to keep the success definition consistent. The second one is for ours specifically we’re measuring it against the reconstructed reference. And the reconstructed reference might be off or noisy at times. So we don’t actually have like a ground-truth reference to measure proper success retargeting against. Jiafei Duan (15:30.254) Yeah. Sure, sure, yeah. Jiafei Duan (15:48.583) But what about using like contact s stability or object retention or final state as a way of measuring? ‘Cause I mean like it’s a lot of ha in hand manipulation, right, with like how you hold on to this object. So if the object drops then definitely it fails. Okay. Or like it yeah. William Liang (16:02.568) Yeah. Well I mean the object dropping would fail the current success criteria as well. I mean if it like fails the position has pretty few Jiafei Duan (16:08.2) Yeah, yeah, sure, sure, sure. But like yeah, if it’s loosely grasped yeah. But yeah. No, I I understand. I think in past literature people used the same thing, but I just find it very interesting why they chose this value. Yeah. William Liang (16:19.539) No, I think the success criteria could be a lot better because as you as you like hinted at, like this isn’t penalizing loose grasps or like there’s like there’s like some like failure examples down here where it balances the object on fingertips with like the back of the hand. And these would like unless you just look at the videos themselves, these would be counted as successes if it actually follows the reference. I think something you could do is I mean ultimately we care about whether this helps with policy training. So ultimately I guess you would measure the quality of these like success demos as like how well the policy actually does on them. otherwise you could do like some slight domain randomization to counter whatever like edge cases there are with like loose grasps. Jiafei Duan (17:03.342) Makes sense, yeah. Yeah, thank yeah, thanks, thanks. Mahi Shafiullah (17:05.164) One of the things I think yeah. I think I think one of the things I think this really like brings in is that it’s very hard to tell just from a simulation like if you’re actually following the intention of the motion itself, right? Like it’s kind of like y every every metric that you can define by hand or like by basic code is always gonna be something that is a proxy for the real motion that you’re trying to achieve. Right. Like even for example here, like you look at the knife and the knife is moving, great, but like the real goal is to cut something. The duster, like the real goal is to wipe something. The blender, the real goal is to blend something. Right? So it’s it’s all a little proxy and we’re kind of looking at it at a very like 20,000-foot view. And I think this is kind of an open problem that really requires like a lot more work. And this is something that we’ve been, you know, encountering in other projects as well, where, you know, like you want to define if a human-like action on Dexter’s hand is actually achieving the functionality that intention like initially was intended. And maybe the robot does something that kind of sort of looks like that, but is it really doing it? Jiafei Duan (18:10.394) Yeah, I totally agree. I mean like I totally agree with what Mahi was saying. I mean like also I think like the the notion of like you know being like dexterous aware requires us to identify object dynamics sorry, dynamics-aware requires us to identify object dynamics. It means that you can’t just assume that every object that you generate is having the same mass. Right. So I mean there’s a lot of these problems. System ID. Yeah. Yeah, yeah. Chris Paxton (18:10.835) So how do you Mahi Shafiullah (18:29.058) Mm-hmm. Yeah. Or like same density, I think in this case. I think that’s what we’re kind of doing here. but yeah, I mean I think I think this is a this is a pretty important problem to work on, right? Like it’s kind of like how do you look at interaction between a robot and the world and decide that if that this is actually s successfully satisfying the constraints that you want it to follow? especially automatically. Chris Paxton (18:51.155) Yeah, so I Bhawna Paliwal (18:51.283) This is probably the one component in pipeline which needs like automation as in when you start from any given video, the only human interference that you need in this pipeline is just like validating whether the final trajectory you got actually completed the task or not. And other components can potentially be scaled with like more videos as in more data and more compute. We did try asking VLMs but they weren’t good enough yet. Yeah, we didn’t say it weren’t good enough yet. Chris Paxton (19:22.899) That’s always getting better. So you try with Astra. that’s did you so I guess so you’re saying Will that one of the big goals was to produce data that’s good enough for training. So do you I guess it’s not maybe this is moving a little bit beyond the paper, but do you guys have any any signs of that? Like how much data were you guys able to generate? William Liang (19:26.835) Mm-hmm. William Liang (19:41.694) Yeah, so we generated five hundred of these like dynamically consistent trajectories. Bhawna can talk a bit more about how we train policies with them. Bhawna Paliwal (19:48) As part of this work, we tried training like some residual RL policies on top of these trajectories. One benefit of having these physically consistent trajectories is that the RL part becomes a lot easier. Like instead of h involving let’s say hours of compute, you can just do it in let’s say less than an hour, even with RL, once you have like a good enough physically consistent reference. And after that, the problem just becomes sort of like domain randomization and other things that you want to learn. Let’s say when there is an arm attached to the hand. In some of the cases, the wrist might be moving too fast compared to the acceleration limits on your arm, or compared to let’s say some Kp or Kd parameters in your hand which are not able to follow the reference or some force limits, for instance. These kind of these kind of hardware limitations can be can probably be imposed when you’re trying to learn an RL policy on top of these generated references. And then, as Mahi said, another route is to just take log. of those trajectories and try to distill them into a behavior cloning policy as and not go through a simulated route and treat each of this trajectory as like a teleop reference. Chris Paxton (21:10.781) Yeah. Jiafei Duan (21:11.078) Well does the pipeline, so like the whole going from video, you know, to the retargeting, how well does that work on like generated videos? Have you guys tried? Bhawna Paliwal (21:21.48) Yeah. So we are looking into generated videos as well and generated videos are a lot more scalable than internet videos. In fact one comparison is that if you ca if you like it takes roughly a dollar to find, let’s say, one good video through Gemini when you have to go through a lot more internet videos. And then you can also generate like a very high-resolution video in just like a dollar from a very good video model. So like cost-wise it does make sense to scale this pipeline through generated videos and then you can potentially generate lot more data and also have more control over your data. For instance, if you want to learn a particular task done in a certain way, you can just prompt your way out of generating the right kind of videos and then also get robot data corresponding to those videos. Yeah, this is like one of the examples where the video was Jiafei Duan (22:22.326) This is generated video okay. okay. Bhawna Paliwal (22:28.137) Then is what’s it? Yeah. So we just like get the segmentation mask and then at least like run the whole reconstruction pipeline through it and then we are able to just get these and object interactions and finally retarget them. Jiafei Duan (22:47.888) Do you find like a difference between egocentric versus exocentric? Like which one gives a better intrusive part? Bhawna Paliwal (22:55.017) So the If you have ex extrinsics for the camera, as in let’s say you’re recording them with Aria glasses or any other hardware in which you know how the camera is moving, then both of them are pretty equivalent in terms of quality or like the reconstructed trajectories that you can get out of them. In fact, I would say egocentric videos are slightly better because you would also have some idea of the depth. As in if like your hand is moving a certain way, it cannot be it cannot be this much far away from your eyes and like this is how much but when you are in like exocentric world there are a lot more things that can happen. For instance like random camera cuts or and so on. So if I think it does make a lot of sense to like collect egocentric data and scale like the data pipeline so that kind of videos. Haritheja Etukuru (23:56.845) So I think one thing that we found important was like we could use internet video, we can use egocentric video, we can use generated video. But there are like certain criteria that we felt like should be met if we wanted some video to be high quality and able to go through our pipeline. Like among The criteria is like you want hand and object interaction of course, but then you also want the hand and the object to be inside of the boundaries of the video. you don’t want like super heavy occlusions. So we found in a lot of the exocentric video data there was It was prone to a lot more occlusion than in like exocentric generated and internet video data. you’d also want objects to be rigid in our case because SAM 3D can only reconstruct rigid objects and it’s also easy us easier for us to simulate the rigid objects. and a lot of the exocentric data did have deformed polar articulated objects. And I think Bhawna Paliwal (24:58.201) Actually have some videos for this. I can probably share the screen and how they can walk through this. Chris Paxton (25:05.959) Great. Chris Paxton (25:10.503) Yeah, ‘cause I guess my my next question was actually going to be about like how many videos how what your accept rate for videos was, how often you could use a video. But so we’ll go. Yeah. Yeah. Haritheja Etukuru (25:16.406) Yeah. So then we Bhawna Paliwal (25:19.773) We have some numbers that highlight I can probably talk about. just yeah. Haritheja Etukuru (25:25.086) So we were curious about this ourselves. So we like took a couple thousand clips from 100 Days of Hands and yeah, we took yeah, two thousand clips from 100 Days of Hands and manually went through them just to see how many would like actually end up going through our pipeline and we found only four percent of them would. so in the end what we ended up doing was like passing thousands of clips through Gemini and filtering that way. But To break down like why some clips failed, I think we have some examples. So in a lot of these clips from like 100 Days of Hands, which is an already curated data Bhawna Paliwal (26:12.669) This is an example. how are you getting audio as well? Jiafei Duan (26:19.728) Yeah, yeah, I can hear that. Mahi Shafiullah (26:20.268) Yeah, I’m getting audio. Bhawna Paliwal (26:24.965) Natural flavor. That could mean anything. But there is no meaning. It doesn’t happen. Natural flavor. Haritheja Etukuru (26:31.722) I think we can escape and don’t play audio, just go through the slides. So in the first slide, in slide fifty eight Haritheja Etukuru (26:44.384) So like in all of these there’s like hands that are being detected in this data set. like even the thumbs up icon counts as like a hand being detected. So of course here there’s no hand like even though there’s a hand there’s no object and there’s no interaction. So that’s one thing we want to look out for. and we want there to be some meaningful task being performed as well. Haritheja Etukuru (27:10.556) And yeah, oftentimes the hand and the object can be outside of the boundaries, which is not ideal when you’re trying to reconstruct it, since works best if objects are inside the boundary. I mentioned this earlier that sometimes if the objects are fully occluded then we have trouble in reconstructing it as well. Chris Paxton (27:33.427) It’s part of the issue there just that it’s it’s still single-frame reconstruction plus tracking, right? Because presumably like you could reconstruct there is probably an ideal frame where that is visible, right? Haritheja Etukuru (27:44.586) Yeah, so we can re reconstruct it for some frames, but then when it is like going frame by frame, and so when the object is invisible and it’s completely lost, it’s hard to get it back. Bhawna Paliwal (27:51.773) Yeah. After you’ve stirred a little bit. Haritheja Etukuru (27:59.979) Yeah, and a lot of these clips on YouTube have camera cuts and camera motion, which we struggle with if we don’t have the ground-truth intrinsics. Bhawna Paliwal (28:03.358) Jamie’s a little technical. Haritheja Etukuru (28:13.14) And here are examples of camera cuts. Bhawna Paliwal (28:16.015) And then an out. Chris Paxton (28:17.597) So are these admitted videos or are these rejected videos that you’re showing us? Okay. Haritheja Etukuru (28:19.862) These are all rejected videos and these are like things that we don’t want from our videos. Chris Paxton (28:26.195) So I’m curious because like so some of this like w I think that you have this really cool video of the hammering, which is r like there is really good. But the other hand’s holding a nail. And that one looks like that wouldn’t work. Is that right? Or is that so that sounds that seems really hard because he’s holding this small object that is in yeah. Haritheja Etukuru (28:40.992) I think for this work we primarily d wanted to deal with the hand that like single hand-object interaction and didn’t really focus on the bimanual tasks and especially objects that are like super small, like a nail we didn’t bother reconstructing. So we wanted the object to be large enough, just because yeah, the smaller objects would not make it through our object tracking button. Bhawna Paliwal (29:05.001) I think around the smallest we have is like a pen. Mahi Shafiullah (29:10.306) Yeah, I think one of the things philosophically here to understand is that like hand-object interaction itself, like if if you’re c familiar with like computer vision and they’re like the very famous I think it’s John Barron whose talk is it that was like, we’re like trying to solve a bunch of fake problems and these are like the real problems. So for example, if you think about like object detection as being a fake problem and you know, like VQA being a real problem, if you subscribe to that philosophy, then you should think that like also hand-object reconstruction itself is kind of a fake problem. Right? Like the real thing that you want to understand is kind of like a human and world interaction, right? Like how’s a human interacting with the world? What are the things that are changing or what’s really like the underlying mechanism behind it? And that’s a much harder problem, I would definitely say, but that is really like the problem that we eventually want to solve. And object interaction you can think of as kind of like an intermediate checkpoint, trying to get to that. But the thing is it’s kind of like it’s like applies on one way where if you can’t solve the hand-object interaction problem, you definitely cannot solve the problem of like a human and world interaction. And so robot-world interaction is kind of a harder problem on top of that, because you need to figure out what the robot does with the world. so yeah, so that’s kind of like the way we’re thinking about it. and yeah, as you as we say, right, like on the way we make a bunch of simplifying assumptions that you just kind of have to get there. But there are some challenges that we pick, some Battles that we fight, that you know necessarily you won’t have to fight to get there. One of the things, for example, is the problem of depth. we’re assuming that you kinda have like a binocular video and you don’t really have any depth of the world. which is true if you’re trying to just scrape the internet for data, which is not true if you’re going to collect your own data. Right? So if you’re gonna go collect your own data, my recommendation would be just, you know, like instead of RGB camera, just strap on a depth camera. Maybe get a you know, iPhone Pro, like get the LiDAR. Like that itself will solve like so many of those problems, just having reliable depth because monocular depth isn’t quite there as we need it to be. So that’s one of the big issues. you know, if you’re getting an iPhone, maybe you get like camera motion for free. You don’t have to worry about like reconstructing the camera motion from SfM or something. That will get rid of another bunch of problems. If you’re collecting your own data, maybe you’re gonna be able to like frame the video in a way so that your hand doesn’t go out of frame, right? Like things like that I think Mahi Shafiullah (31:33.322) Are a lot of things that you can do via operations, which is easier than to like solve it through a research. approach, right? Like by the time you were able to like reconstruct the hand, even though it’s going out of frame, maybe you were just able to get 20 times more data by just strapping a camera on your own head. So this is really for us to understand, right? Like what are the easy problems and what are the hard problems? And when we say that like here are the problems that we see come up very often. We have run some of this analysis on you know like egocentric data sets that people are putting out open source. A lot of them still come on, right? Like for example motion blur is still there, hand Going out of frame, object going out of frame still there. you know, depth not being consistent, tracking not being consistent, all of these problems are still like largely there. So even if you had like this kind of perfect algorithms of the world, unless you’re using an algorithm that is kind of like building an inner model of the world, almost kind of like you know, like a world model with a way of extracting those latents into a simulator, then You know, like just being more conscious of what data you’re collecting is pretty much the best thing you can do. And that’s kind of the story that I want people to take away from it, which is, yeah, don’t don’t go too easy on the data collection side, right? Like be very vigilant, be very aware of it. Chris Paxton (32:54.119) So if I’m understanding so part of your argument here is that like I mean with a four percent accept rate, maybe it’s better just to collect data yourself because then you can frame everything correctly and use depth cameras or iPhones, whatever it is, and then you just don’t can circumvent a lot of the issues. Is that Mahi Shafiullah (33:09.162) Yeah, pretty much. I mean I think having more control over the data that you’re like getting through. And I think the video model itself is kind of like a pretty interesting direction there as well, right? ‘Cause you can clean up a lot of those issues by just prompting better, right? Like which kind of gives you a pretty nice out. and it’s kind of you can think of that as kind of like a video models is a distillation of all of internet videos. So that’s another direction that I think is kind of an interesting mental model to have, I must say. Chris Paxton (33:39.155) So you would say then that the like the future of this sort of set of methods then is like or if you wanted to continue this, you might use like infinite data from just from purely generated, not even do the directly used thing. Mahi Shafiullah (33:50.348) Yeah. Yeah. I mean I think I think that’s probably like the cool thing to try. Haritheja Etukuru (33:57.772) Yeah, one issue that Jiafei Duan (33:58.084) Yeah, I have a question. I think just to add on to this, right? I think it’s very interesting taken and I so totally agree, right? Like always people are like, how much human video do you actually need? I think you just need one human video for every task. Correct. So I mean I mean, I my my my understanding is that the whole idea of this paper is to demonstrate data, how you can generate data. But I wanted to ask, have you guys tried to use the data to see whether how well does that train? Mahi Shafiullah (34:25.486) So we have done some like single task policy stuff and you know, like under a reasonable control setting it’s fine. Right. I think the real question is of generalization, right? Like in the thing is you never generalize from a single example. Because a single example is very specific and you just don’t know like what are the covariates that you should care about and what are the covariates that you shouldn’t care about. So the real question is really like how do you generate data at a large enough scale so that you’re able to generalize from this? that’s still an open question. I would I would love to say more about it, but so far, right, it’s kind of like a pretty tough problem because generalization itself is really like the challenge. Here again, like the rollouts that you’re seeing, right? Like the reason why we call them rollouts and bot policies is because they don’t have like that necessary generalization. If you change the scene a little bit, then like this wouldn’t work. And that’s fine, right? Because it’s a rollout and it’s not a policy. But I think this is really like philosophically how I think about it is that it’s very mute to talk about a policy without talking about the level of generalization that you can get out of that policy. Right? Like if you have a policy that just only works in a certain space in a certain under like certain lighting conditions under certain spatial arrangements, right? Like Okay, that’s like pretty close to an open loop rollout, versus a policy that you just can like, you know, bring in your home and like run it on a robot. That’s significantly different than that. But even then it’s still a spectrum because you can find scenes where it doesn’t work. Right. And it’s not that hard to find it. You can still like mess around with things and figure out a configuration where things don’t work because the data doesn’t cover it. so yeah, so I think I think to summarize this is that there is just no magic trick, right? Like the real question is like okay, how do you scale it? Chris Paxton (36:25.683) Alright, so I I guess what’s next then? What what if you were if you were gonna continue working on this, is that is what you do? Scale it, use internet use generative video models like use WAN or Seed Dance or something, generate in generate infinite videos. Mahi Shafiullah (36:42.22) I think that’d be pretty cool. Yeah. I mean I think I think one of the things that I’ve noticed I played around with this a little bit and I think one of the biggest shortcomings that I’ve seen with this is that video models today are where language models were like two years ago. Like for I don’t know if if either of you have tried interacting with Llama 3, right? Like the base model. And like you can give it like a prompt and you can give it like some descriptions and you’ll be like, can you do this or can you tell me this? And like there is a kind of fifty fifty chance of like this doing what you want it to do versus like another fifty percent of chance is like it’s just gonna keep rambling on and do something like or like say something really weird or nonsensical or non sequitur. video models are in like that era today, right, where controllability is hard, right? Like controllability is practically the key challenge for robotics if you want to get video models to like really scale for the robotic tasks. For Things that are in domain, right? Like it’s super nice. If if you’re trying to do something common, if you’re like, yeah, you know, hammer and nail with the you know, like hammer a nail with a hammer, okay, yeah, that’s probably seen like thousands of videos of this. Okay, great. Like super nice clip comes out straight away. but then if you’re trying to do something a little bit more complicated, right? Like imagine you put that hammer in a way that’s like the handle is like facing away from you and be okay, how do I pick it up? Right. It would do something weird, like, well, the hand will go there and then, you know, it will like cover up the hammer for like one second and then it will like f pick it up and then it’s phased upside down. Right? Like something weird like that. so what I wanna say is that like they work very well in the modes that are covered and may not work as well in the modes that are not covered. With the caveat that I’m mostly talking about, like the open source models that I’ve or like open weight models that I’ve have been able to play around with. You know, like maybe Google internally has a much better model that is much more controllable. I don’t know. so that’s I think one of the things that is pretty like it’s probably gonna be one of the biggest challenge that people who want to use video models for robotics will need to figure out how to do. So that’s one. I think the second problem is kind of like the problem of like physics grounding, right? Like physics grounding could be like on a very simple or a very difficult level. let’s let’s talk about the simple level first. Like even knowing that like okay, an object Mahi Shafiullah (39:00.482) Doesn’t change size, the object doesn’t change shape, the object doesn’t, you know, like has a consistency. If you like pick up a hammer and you like rotate it around like 720 degrees, right, you’re gonna see the same thing twice. That’s kind of like an easy level physics consistency that a lot of times these video models tend to fail, in my experience, right? Like in the experiments that I’ve done for this. Another problem that I’ve seen happen quite often is really like kind of understanding the physical interactions between things, right? Let’s just say that like okay again going back to the example of a hammer, you make it like stand upright on its handle, right? And then you let go, right? And you start generating your video from there. If you generate a video like this, you’ll see like some very bizarre interaction with the ground when it drops. Right? Like it would not bounce the same way you imagine a hammer bouncing. It’s kind of like gonna have like constant velocity and it would fall and then it’d like slowly bounce and maybe roll around in a weird way. Chris Paxton (39:54.269) That’s video game physics. Yeah. Mahi Shafiullah (39:56.247) Yeah, it just it just doesn’t know physics or physical grounding very well. And this is a very simple example of like something dropping on the ground, right? Like this is not even like the hardest thing to imagine. Now imagine like the actual physical grounding that you need to do like context rich tasks, including like tas that you do with a dexterous hand. Right? Like a lot of these things just doesn’t quite have the right level of physical grounding that we have and maybe in like you know, even like the right order of magnitude. And so Right now I think you need like so for example what we do here and do as I do is we do this as a physics-grounding step, right? Like we lift the entire scene into a physical simulator and then we say that like whatever you saw in the video is a rough reference. However, you’re allowed to deviate from that video reference by a certain s number of centimeters. And that is okay as long as you’re roughly doing the same thing and it respects physics. Right? ‘Cause the physics is a hard constraint in the simulator. It’s not optional the way it is in the video model. And so I think this is a direction that I personally feel very bullish in. Exactly, right? Like I think that’s also like an open question of like how do you even for for simpler tasks, for simple atomic things like you know, pick, rotate, move, things like that, it’s pretty easy to quantify, but for something that is much harder to say, right? Like for example, hammering a nail, wiping a board, right? Like things like that are much harder to define. So I think those are the parts Chris Paxton (40:58.717) How do you quantify doing the same thing? Mahi Shafiullah (41:21.068) That I think we need to focus on more. I think video models are covering like a very important axis of imagination, right? Which is kind of figuring out what to do. But there is another axis of imagination, which is how to do it. And I think that doesn’t get covered very well, right? Like, or how do how do you ground that motion into like a physical world? That doesn’t get covered very well with a video model. And in this way, I kind of think of You know, like simulators that you see with like MuJoCo and MuJoCo Warp and Isaac Sim and Newton and everything, man, you know, like meta’s superdecks, whatever just came out and Genesis. Everything has this kind of like very nice physics grounding properties with the caveat that it cannot or you cannot just immediately lift a scene into a simulator immediately, right? And the video models on the other side has this very nice property which is you take a picture, immediately you have like lifted that world into the simulator. Right, a simulator, I’m calling a world model a simulator here, loosely speaking. and then you can like just start interacting with it. But you don’t have very good physics grounding, right? So we have kind of like these two different directions where we either have like either good physics grounding and not very good, you know, like following of the visual semantics of the world, or we have like a very good visual semantics of the world and really poor following of the physics. and You know, like eventually I think these two paths will merge and we’ll get something that is pretty close to the real world in terms of you know, like in terms of both like physical fidelity as well as the semantics and the visual nature of it. And I think that’s kind of when you can really start doing crazy things with the robots. Because when you have when you want to do something crazy with the robot, you can just roll out five hundred thousand times in your imaginations and be like, okay, this worked well, this did not work well. And then you go and fail in the real world, maybe a few times, but that is also data that can let you improve everything. So, you know, like when I think about what, you know, future robe robots, robots in the wild looks like, I think this is a direction that I find pretty promising that is pretty underexplored right now. people either bet on one or the other, but I think both of them needs to be cultivated a lot more before we can get there. Chris Paxton (43:38.843) Makes sense. Chris Paxton (43:42.365) Great. Well, I think Haritheja, you were gonna say something earlier and I think we cut you off. Was there something you wanted to add to all everything? Haritheja Etukuru (43:49.623) Yeah, I was going to add on like the path for generated videos. I think even if the generative video models get very good at prompt following one failure case we one major failure case that we find is just in the depth estimation. since we’re dealing with monocular videos, if you don’t have very accurate depth estimation, it doesn’t have to be super accurate, but you want the relative depth between the hand and the object to be sort of accurate because if the relative depth is too large then there’s not really much you can do on the reconstruction side. so the good thing with egocentric videos is that you do have ground-truth depth. So if you want to scale that way you’ll usually you have a higher probability I would say of getting hand-object reconstructions that are well aligned. Chris Paxton (44:42.547) What what kinds of videos or how how often do you think that shows up in the videos? I guess I guess that’s relatively rare still. Do you think that’d be good for sorry. Haritheja Etukuru (44:51.168) I guess if you’re referring to just failure cases in monocular adaptation, I think we find it to be pretty common. The good thing is with our spider modified retargeting, we’re able to deal with a lot of the noise in the hand-object alignment, but we still find that it’s pretty important for the initial frame for the hand-object alignment to be accurate, because we want the grasp the object to be grasped at the initial frame and after that we can sort of deal with it if the hand-object alignment isn’t perfect. but of course as like these monocular depth estimation models continue to improve, this will be less of an issue in the future. And in general, like I think our pipeline is pretty modular. So like as different components of it improve over time, our overall pipeline success rate will also improve. Chris Paxton (45:49.523) I’m curious though that video that was just playing a second ago has a deformable object. This was another thing that I wanted to ask a little bit about because like how do you like the physics because we talked a lot about the physics. You’re getting 3D models from from Sam 3D. Like how does how does to how do deformable objects fit into that? Mahi Shafiullah (46:08.75) That’s good question. I think for now what we’re doing is we’re kind of like approximating the object. So once it gets there in like a second or Bhawna can like pull up the video a little faster. let’s see. Or we can maybe scroll down, down. yeah, that one, right? The whitebreak the duster video. So we’re just kind of approximating where’s the duster? Chris Paxton (46:27.731) It was so. It was the one after this. No. Haritheja Etukuru (46:30.59) Okay. Chris Paxton (46:34.675) I don’t know. There, I think it was this one. That’s Haritheja Etukuru (46:35.948) The second one. Mahi Shafiullah (46:38.614) It’s okay. We’ll we’ll we’ll figure it out. so I think one of the yeah. there. Yes. so if you look at the object reconstruction itself, it’s actually not the deformable. You’re kind of reconstructing it as a kind of stick with the blobby bit at the end. And that’s the part that we’re kind of not focusing on too much. one of the things I think on the retargeting side that needs to be done or needs to happen more carefully is thinking not just about the objects and the kinematics and a little bit of the dynamics of the world, but also thinking a level deeper into like the forces that you’re applying with your hand and with the tools that you have with the world. Right? Because like okay, think about this as like a like different levels that you have of this. The level one problem of it is like okay, how do you grab grab hold of an object that has a certain weight and physical properties and move it through space in a certain way? And here what you’re trying to control is really like, you know, position at some Time steps, right? And that could that translates to, for example, like you know, if you discretize it at some level, like you’re trying to control the object’s like position and velocity over time. but what you really do care about is not even like objects position and velocity, but you probably do care about the forces the object is applying into the real world. But also you maybe do not care about the forces in every direction, you only care about the forces that is being applied, like straight onto the surface with the object that you have. Right? So as you start thinking about this problem, it becomes more and more complex and there are layers to it. And you can of course solve this at a different level of abstraction. What we’re showing here is really like solving the problem at the first layer of abstraction and we’re hoping that, you know, given the object is compliant itself, when you move it in a certain height above the surface, then you get the same kind of wiping behavior that you saw in this video. But it may not be true for everything, right? Like for example, for hammer like hammering in a nail. What you really do care about is like the impact that you make at the moment of contact. Right? That is not even that’s that’s pretty much like the third derivative of the position that you’re caring about, not like anything below that. And so eventually Exactly, exactly. Exactly. And so the thing that you want to really think about is how do we involve this higher order terms? Chris Paxton (48:53.095) Do need to be pretty precise for that too, actually, right? Otherwise you’re gonna hammer your wall. Mahi Shafiullah (49:03.828) Into the process and right now I want to say that this is on the verge of being possible especially given that there are you know like very good I don’t know if you’ve seen like the GPT-6 Astra release videos but one thing I was looking at and was I found it very fascinating. It created kind of like the like one of the very popular buildings in SF I’m blanking out on the name right now. It’s like the Palace of Fine Arts, exactly thank you Will so it just created like a replica of it in Blender. William Liang (49:25.619) Palace of Fine Arts. Mahi Shafiullah (49:32.118) Right, like I find it super fantastic. but the thing is you know, like this kind of large models, they they probably have a pretty good idea in the scene of like, you know, you’re seeing a little, you know, like planter and you’re looking at a bunch of books in the background and you have like you have a shelf on top, like on top of which everything s sits. You probably or like these big models probably have a pretty good idea of like what those physical parameters look like and if not exactly what they look like, what what kind of ranges would they remain in? Chris Paxton (49:35.619) Yeah. Mahi Shafiullah (50:02.061) Right, a book’s probably not a hundred kilograms. It’s probably not ten grams, right? Like it has a reasonable range that you can guess from just looking at the scene. And so one of the things I personally predict will happen and kind of become very big is really kind of this real to sim methods, which are using these agents to estimate like what the scene parameters are. just to rebuild the world in a simulator. this has traditionally been something that humans had to hand code, but I think that era is like pretty close to being done as this VLMs kind of get better. and another thing you can think about is that this could really go into kind of like this recursive improvement loop. Where you can be like, here’s the environment, here is where you are, here is a video of a human doing the same thing. Now figure out how to do the same thing. And, you know, you create a simulator, you’d like try to do this task in the simulator. When you’re certain enough, when you’re good enough, you try to do it in the real robot. And, you know, you do it in a few loops. I can totally imagine a world where that the whole process can be done reasonably automatically where you don’t really need to intervene much. just because of how good this whole process is becoming and kind of scary too, right? You’re kind of like automating grad students at the point, which is fun. but, you know, like what’s what’s what’s humanity if not just like finding more and more abstractions to automate away? Chris Paxton (51:16.147) Yeah. Chris Paxton (51:33.757) Yeah, that’ll be interesting to see. I feel like the there’s definitely like a ton of potential in like closing the loop around experiments like this. Like I was I was thinking that while you’re doing this, like the you do have a physics engine, so you can presumably estimate physics pretty well, at least for the rigid objects. Like the so should be a loop you could build that would let you do this. Makes sense. Cool. Yeah. Mahi Shafiullah (51:44.109) Mm-hmm. Yep. Yep. Mahi Shafiullah (51:52.652) Yeah, yeah. Bhawna Paliwal (51:52.86) It’s it’s also about like sometimes the physics can also help you. For instance if your reconstruction has some normal noise like your hand and object are moving this way, then you know that it ha the object has to be grasped by the hand for the object to move a certain way. And then but then there are small some small ambiguities that cannot be resolved should the object be s grasped this way or this way. And that is why you need like some human interference slash VLM interference to actually fix the reference and then get the right kind of behaviors out of it. Yeah. Chris Paxton (52:23.987) Also feels like there’s a good amount of lift that you could gain just by reasoning over multiple frames here. Because you still are like the I think that a lot of those things like lifting, like your phone example, right, Bhawna, like that seems like one that would be disambiguated if you were watching the whole video, right? There’s only so many ways I can hold it if I’m moving it. Right? Or is that okay. Bhawna Paliwal (52:41.437) Yeah. Mahi Shafiullah (52:41.602) Yeah. Yeah. Yeah. I mean I think I think it really requires kind of like a little bit more I hate to use this word and overuse this word definitely, like agenti capabilities where you can like look at multiple frames and reason that this is the same object being held and moved in different frames. This is something that I think is kind of like appearing more recently. And I’m sure like, you know, like people are training on the like this kind of data more. but I think this is critical. I think this is critical to get this kind of capabilities into the into the models and it’s happening. I think it’s pretty cool. I do wanna say though that there is like one gap which is kind of hard to close, which is one that the robot hands don’t don’t look anything like human hands, right? And s and that’s okay. Like maybe you can in paint it away, it’s fine. but the other thing is that the robot hands don’t move the same way as a human hand. And that’s one of the things that you really have to worry about a lot. let me give you a very simple example, right? Like okay, imagine I have this cup. This cup is super light. As you can see, it’s kind of like wobbling in my hand. And I can close my eyes and I can pick this cup up and it’s fine. Okay? What did I do? My hands have super high precision sensors and it’s super light compared to the sharpa hands that you’re seeing here. the sharpa hands fully made of metal. It probably has, you know, like at least five times the mass that my own hand has. And what comes with the five times of the mass, it comes with the five times the momentum. Right? So if you are trying to make the same motion, when you’re grasping the object, you are kind of transferring five times the energy or like more than five times the energy into the object. And also like if you think about conservation of momentum, like if I just hit it, it’s gonna fly away five times faster because the velocity of this object mass is the same. Right? So a lot of times just kind of like imitating the human blindly is not gonna get you there. Un like if you have a hand that is physically very different, right? If the mass is 5x, that’s not gonna get you to the same place. So you’re gonna have to adapt the behavior a little bit. the other problem is that the robot hands a lot of times are just more powerful than a human hand, right? Like for example, it can do some like crazy things like this, where this the object that I’m holding might just be super heavy, and a human could never do it, but the robot hand’s made out of metal and it does not care. Mahi Shafiullah (55:03.18) Right. So in the simulator and in the real world, it is a viable solution that makes the object move in that certain way. and the only complaint that you might have could be of two different aspects. One could be that you’re trying to do actually something that is much longer term and you’re not able to do that with that particular grasp or with that particular hand-object interaction. And the two is just purely aesthetic, right? Like yes the robot does the thing, but it looks ugly. And the thing is as humans, when we look at a robot with a humanoid hand, we expect it to do humanoid things. Right? And if it does something weirdly non-human, then it’s just off and you don’t like that robot. so both of those things kind of require injection of priors that are not purely physically describable, right? Like then you kind of have to for lack of a better word, you have to post-train your hand model to do something more human-like. And those kind of again open questions. We don’t really know what is a good way to do it. How do you even like inject this kind of human preferences into a human hand? I’ve seen some very cool work, I’m forgetting the name of it, but they’re at work which kind of create a biomechanical simulator of a human hand and restrict the robot hand to the motion that it can make w with like a biomechanical hand. And I think that’s kind of cool, right? Like restricting into the human action manifold. but Again, you know, like this the simulators they’re having like very early days, none of this is settled and how do you even like finalize this into like a real human space without having done the kind of long horizon things that we’re doing in the real world? Yeah, like I think I think it’s all like pretty open and up to research and researchers to figure out. Jiafei Duan (56:44.752) How how good is Shapahe? Mahi Shafiullah (56:47.366) That’s a good question. I think it’s pretty much the best we’ve tried so far. yeah, I t I one of the things that kinda like go you know, like isn’t quite obvious on the surface is that this whole paper would be pretty much impossible to do let’s say like three years ago. Right? Like even if you had like all the model component, if you had like vision part and everything without like a good hand, this just wouldn’t work because Jiafei Duan (56:52.408) Yeah. Mahi Shafiullah (57:13.134) Two years ago, if you look at the hands, they’re all like significantly bigger than a human hand. And that means that the retargeting step just kind of like trivially fails or does something very different. Right? the Sharpa hand, the biggest advantage that we found with this is that it’s like the shape is significantly closer to a human hand compared to previous hands that we’ve tried. because of which you can actually do human tasks in a very human-like fashion. this wouldn’t this wouldn’t work, this wouldn’t exist in like a few years ago. And in terms of things that we still would like to see, I think one of the things, be very basic things, is just like more human-like compliance, right? again this is a very heavy hand and you ha you have to make a human sized hand means you have to like really gear up the little motors that you put in your hands, which really means that now you have to make the finger and every joint basically very, very stiff. Right. but that kind of like creates a problem of if you’re trying to do something more force-aware, if you’re trying to do something that is a little bit less, you know, like position-controlled, that makes it a hard problem to solve. And so I think overall I’d say that like Sharpa’s practically like the best hand that we’ve tried and we’re very glad that we had it for this project. but overall I would say that like I don’t think this is where the humanoid hand march stops. In fact, I mean I would be very, very surprised if doesn’t like innovate very quickly and basically like creates a newer version of a hand like every three months which has like significantly better properties in every axis. Yeah. Yeah. Yeah. So so from this, like really like the takeaway for a researcher in my opinion should be that like don’t really like don’t try to like build methods that are tied to a particular hand. Chris Paxton (58:49.479) Yeah, and this new hands coming out every week, it practically, so Mahi Shafiullah (59:03.852) Which which again, like, is a side commentary on like why I think teleoperation is not gonna be a very stable solution for hands yet. Just because you’re gonna have a new hand every three months. And either you’re like collecting a lot of data and throwing it out and refreshing it every three months, or right, you’re stuck with a hand that is kind of like significantly behind state of the art. Chris Paxton (59:27.443) Okay. It feels like a lot of your questions here are someone’s gonna fix the pro someone else is gonna fix this, my like someone’s gonna build you a better hand, someone’s gonna GPT-6 Astra agents are gonna Jiafei Duan (59:29.498) I wanted to Mahi Shafiullah (59:33.88) Sorry. Mahi Shafiullah (59:38.455) It’s a it’s a good question and I think the answer to that is that you kinda have to accept the fact that the world is moving at a pace where, you know, like you’re not gonna be on top of the field at everything. So you really have to think about like what you’re the best at and do that instead of like trying to improve on every axis at the same time. so for example, like right, like there was a there was a time, you know, like during the summer where I was like, Hey, okay, the hands are great, but none of the hands have the compliance that I that I want and so like maybe I should get into like building hand hardware. Chris Paxton (59:46.931) Yeah, that’s fair. Mahi Shafiullah (01:00:08.538) Big problem with that, of course, is that I don’t speak Chinese very well or at all, right? and so I’m there are people who are much better f suited for this problem than I am. But what what I can do is make a lot of noise about the complaints that I have so that people who are building this know what kind of issues that come up. but again, like this is kind of the fun part of doing research is that we’re all in this together, right, as a community and not just kind of like You know, like and I’m and I love like doing open source research. I love being able to talk about the problems that I’m working on and problems I’m facing and why things work and why things don’t work. I think that’s really like the power of having a community with you, that you can you can talk about this, you can share feedback with others and you can get feedback from others of like, hey, I tried your thing and it works here and it doesn’t work here. but yeah, like I don’t think I don’t think anyone’s gonna get too far in isolation. I think now’s the time to collaborate. Yeah. Chris Paxton (01:01:01.843) That’s why we’re here, right? Yeah. Jeffy, did you have some question to wrap up? Jiafei Duan (01:01:08.676) Yeah. A quick question. So I think I saw this tweet recently from Jitendra, which is that you when Skill released their S1, and it was like, you know, time to use Texas hand. So I think the question I have is that you know, like the way a lot of tools are designed was designed for human hand. But that doesn’t really mean that you know human hand is the most optimum form factor. Because just because the tools are naturally designed for human hand. So I mean like if if you sort of like look a bit, I mean this is more philosophical, like you know, going forward and when you know robots sort of up. human labor, then do we want to design more efficient tools that could potentially use for parallel gripper? I mean of or you know like there should be some form of transferability between parallel grippers to dexterous hands. You know, what what’s your take on this? Mahi Shafiullah (01:01:55.576) Does anyone else want to go first? Because I’ve been speaking for a while. Bhawna Paliwal (01:02:01.162) I can go. I like generalist take, which is you don’t need to have a hand to hold the tool, your tool becomes your hand and you just have an adapter that connects it to the arm. I feel like that would be like the more robotic solution. Jiafei Duan (01:02:20.656) So you don’t you don’t agree with Jitendra’s text just hand narrative? Bhawna Paliwal (01:02:24.517) I agree in that you need a hand is the most versatile tool you have to be able to interact with any pre existing tool, but if you can design your own tool then you should design it for the robot. But of course most of the tools we have right now are not designed for the robot. So if you need a something for the robot that can interact with something humans do then then you still need a hand. Jiafei Duan (01:02:36.676) Mm. Chris Paxton (01:02:44.731) I mean, v it’s very common for industrial robots to have tool changers, for what it’s worth. Like it’s very normal. Yeah. Jiafei Duan (01:02:47.962) Yeah, exactly, yeah, yeah. Yeah, and it’s it’s a matter of how how optimized is the you know, usage of tool, right? Like if human with our hands we do this task so badly versus like if you can design a custom tool or custom gripper or whatever, then robots could efficiently do the task, then why not? Correct Yeah. But maybe I don’t know, Mahi might design his own hand, so that might change. Mahi Shafiullah (01:03:09.914) Might be fun. Yeah. I think I think in in here, right, like philosophically you also have to think about like what exactly that you’re going for, like what’s the application that you want to see it, right? Like ‘cause you can you can find this, you know, like just go on Twitter and like search for humanoid and then you can find like infinite iterations on this debate on like do we need humanoids or do we not need humanoids? And the group who likes humanoids will say that like you can put it anywhere a human goes and then they’ll just do the human thing. And the group that doesn’t like humanoids be like, but we have such special specialized robots to do such things so much faster, right? Like why use a hand-driven screwdriver if you can just use an electric screwdriver? And why use an electric screwdriver if you can just use your like mold your hand into a screwdriver? Right? And I think at the end of the day the real answer is that there is just gonna be as many robots as you see, like robot varieties as you see like dog breeds. And I really like the exact express example of dog breeds because dogs, right, are bred for human uses. Right? Like you have a different application. You’re kind of like, okay, this dog is a guard dog and this dog is a hunting dog and this dog is, you know, like a herding dog and so on and so forth. And you know, like two hundred years later you just have so many different varieties and breeds of dogs. And some dogs just only have one application, which is to be cute. Right? And they’re they’re all dogs, they’re all valid. None of them are, you know, like better than the other. They’re just like different applications. And so I don’t think there is gonna be like one robot form factor that ends up dominating over every other robot form factor. I think eventually we’re gonna have many humanoids and eventually we’re gonna have many non-humanoids and some of them are gonna be in factories and some of them are gonna be in homes and you know, like and some of them are just gonna be a low Mahi Shafiullah (01:04:52.13) Robot ball or like you know the micro duck if you guys have seen that’s also very cute and I really love that robot right it’s it’s probably like not very useful for any chore that you want to do and definitely not very useful in a factory but it’s a cute robot. And so I think overall as far as things go I think I think that’s kind of the answer that like everyone’s correct and I love everyone’s opinions on this because it’s a it’s a different way of thinking about the problem. Personally for me, I think it’s an interesting problem to think about because when you’re working on two-fingered gripper land, and I’ve done this for basically the whole of my PhD, right? Like with the little two-fingered gripper and an iPhone on top, and actually and like the shelf behind Chris, I actually saw a version of it sitting on top. Yep, right over there. Exactly. So, you know, like so I think my opinion on this is that like you can actually afford to ignore a lot of tough questions about contact. with the world when you’re thinking about a problem of like two-finger grippers that you really have to face when you’re thinking about a multi-fingered hand. And will we be using multi-fingered handed robots in 50 years? Maybe it’s just gonna be like, you know, like octopus-like tentacles and everything’s gonna be done with that. Right? But I think whatever insights that we’re gonna gain from working with robots that really make a lot of contacts with the world. Is going to transfer over to whatever robot that we end up using in whatever form factor that we end up doing. Because at the end of the day, the job of a robot is to make contact with the world, right? And I think that’s really the big problem that we’re all trying to solve. Working on hands is just a better playground for us to understand, like, okay, what really happens when you make a lot of contact with the world. Maybe it’s not application-ready, like from day one, but that’s probably also not the goal that I’m like. personally focusing on. I think my goal really is to understand what happens when you have to be precise, when you have to make contact with the world, when you really have to control the output forces of your robot into the world, and do it in like a fine way. Do it fast. Do it, you know, like in summary dexterously. I think that’s kind of the fun research problem to think about. But you know, like if you if you were to ask me like, you know, like hey, okay, like you have to maybe bring up a factory tomorrow. Mahi Shafiullah (01:07:11.372) That’s gonna do like t-shirt folding at like 90% success rate in a month. What are you gonna do? Like, yeah, like two-fingered gripper, great, fine, just do it. Chris Paxton (01:07:19.603) So you’re saying we should do five-finger hands because they’re more fun. Mahi Shafiullah (01:07:22.658) Definitely so. I think I think it’s a lot more fun because the problems are a lot harder, and you know, like the solutions are a lot less clear, I would say. And so I think I’m having a lot more fun working on this. I think it’s yeah, it’s and again, you know, like it’s i if if you don’t have like a if you don’t have a mandate of like, hey, I need to start making money within like the next three months, then I think that’s definitely what you should do. If you have a mandate on what to do, like if you have to make money within the next three months, I would definitely say like don’t do dexterous hands. It’s just Chris Paxton (01:07:35.919) It’s a good reason to setting. Mahi Shafiullah (01:07:52.502) Yeah. So it’s like nowhere near solved enough that you’re gonna be able to do that. Chris Paxton (01:07:59.464) Interesting. Any opinions from from the rest of guys? Bhawna or Haritheja? Bhawna Paliwal (01:08:07.294) Yeah, so I think I would also agree with Mahi in the sense that one, they’re more fun. Also I think that the fact that they are all multiple degrees of freedom, they all it also makes the problem more broad in the sense that whenever you have lots of joints with it which are making contact with the world all at the same time, the problem comes back to whatever problem you saw in solving the dexterous hands. So as you move from, let’s say, two-finger grippers to another form factor where you have like multiple grippers Coming out of maybe the same arm, then you are back to the same problem where you’re controlling like lots of multi like degrees of freedom, and you have like you’re making multiple contacts at the same time, you have to manage your own momentum, you have to see how the world is changing as all these multiple finger grippers are changing the world simultaneously. So the problem is basically the same. It’s just like one particular form factor of multiple finger hands, which we are trying to solve by making it human-like. Haritheja Etukuru (01:09:04.972) Yeah. I think it’s cool to have like one robot embodiment that’s able to interact with any of the o everyday objects that humans us humans interact with. and in general I just find hands to be cooler. So that’s why I’m interested in working on Chris Paxton (01:09:27.795) Well, so thanks, thanks for so usually to wrap up, we ask one last question, which is basically what’s the coolest thing you’ve seen recently? Coolest paper or like dem, whatever you’d like. so anything you’d like to give a shout out to? start with maybe maybe we can start with Will ‘cause it’s been a minute. William Liang (01:09:48.65) I think along the veins of dexterous manipulation, we haven’t seen that many we haven’t seen too much evidence of sim-to-real for stuff like Sharpa hand, but I think Tyler has a lot of good work on this. sim-to-real and I probably the second one was called. Sorry Tyler. Yes, that one. I think those are very cool. Chris Paxton (01:10:12.115) With yeah, with some tool on the paper on the podcast earlier. William Liang (01:10:19.751) I think I was thinking of like play to perfect work, but I was I would say that. apart from sim-to-real I would also like to give a shout out to like another work from Berkeley which is more on like two-finger grippers and just like the like the only open source stack, probably for teleop, which is like the ABC work recently. So that is also pretty cool. Yeah, because you can like build on top of that. Chris Paxton (01:10:44.883) Very useful for people too. Very great. Haritheja Etukuru (01:10:51.126) Think sim-to-real is promising and in this work we didn’t create any policies but there are like lots of works that are learning to make simulation training for dexterous manipulation more general and also have done sim-to-real so a couple of papers are adept adept from Nvidia and also another paper today from Stanford called Demo Mimic. I think these are both like expanding the capabilities for dexterous hands or Chris Paxton (01:11:12.603) Don’t Haritheja Etukuru (01:11:19.5) I think I think they’re in an interesting direction. Mahi Shafiullah (01:11:23.55) I’ll I’ll give two shout outs. One is for people who has a gazillion dollars and are spending it on and another for people who are, you know, like working on a modest budget like me. so the first one goes to I don’t know if you’ve guys seen the hug from I mean not not not like gazillion dollars, maybe like a bazillion. Chris Paxton (01:11:37.553) Amazon FAR is modest now? What’s sorry, they not they’re not giving you enough Mahi Shafiullah (01:11:45.772) Yeah. but yeah, so one of the things I would say is have you seen the hug paper from my old lab at NYU? it’s Human Universal Grasping, from Kevin. I think that was a pretty cool work, right? Like I think what they’re doing is using smart glasses and grasping data to learn kind of like a grasping model for arbitrary objects. Chris Paxton (01:12:05.288) I think that one will that we did record that episode of them. Actually, I think that will air before this one. So if it hasn’t heard. So yeah. Yeah, yeah. Mahi Shafiullah (01:12:10.31) Wonderful. Okay, great. So it’s kind of like a reverse shout out. That’s great. so yeah, so if if people are listening to this one I think they’ll enjoy that one as well. so I I really love that one, right? Like I think conceptually it’s super simple and really like kind of following up on the same kind of like handled or devices for data collection and transferring it into a robot embodiment. I think all of this is just fantastic ideas and we should really like, you know, double triple down on this. So that’s one. And I think the second one I already talked about a little bit, but the newer models And the ability that they have of like creating or recreating the world in code. I think I find that it’s a fantastic ability because this is kind of the ability or the direction that the world models are not covering as much or as well. I think if we need to get robots into the world, we really have to be careful about the physics. And this is to me kind of like the complementary direction of be building a world model that is general and visually introduced. interesting and simulatable. But I think once we cover both of these axes, it should be just fantastic to be able to do simulation of arbitrary scenes. Just drop a robot into a new home, have it wander around and you know like ground it into the real data eventually. So I think I think those are directions that I personally find super cool and super interesting. Chris Paxton (01:13:31.891) So that’s your shout out to OpenAI Astra if you haven’t heard of that. So Mahi Shafiullah (01:13:34.582) And also the Claude 5.1 I think the five point one model, the Fable 5.1 had like a real home scene recreation stuff. But it’s it’s funny because everyone’s kind of like working on the same ish problems. so you know that these problems are important. But I think as a roboticist as well, I just don’t wanna like handwrite simulated scenes. That’s just not a thing that we will be doing in like two like two months. Bhawna Paliwal (01:13:39.421) Baby. Bhawna Paliwal (01:13:55.457) And also I guess World Labs as well, like Mahi Shafiullah (01:14:00.406) Yeah, yeah, yeah. I think that also came out. That’s also very cool. But I think that’s kind of like falls in my head more like a like a video model but four D or like you know, like spatially camera controllable video model world. So yeah. Yeah, that’s also very cool. Chris Paxton (01:14:16.891) Very cool. Yeah. All right. Yeah. Good shout out to OpenAI and Anthropic if you haven’t heard of them. Check those out. Really cool companies. So yeah, thanks. I agree though. Yeah. All right. Awesome. Yeah, well, thank guys for coming on. I think this is fantastic work. It’s been a really interesting discussion. And I guess Geoffrey had to drop early. So but thank you. Thanks again. See you all later. Bhawna Paliwal (01:14:24.505) Okay. Mahi Shafiullah (01:14:37.848) Yeah. Bhawna Paliwal (01:14:40.083) Thank you so much for us. Thanks. Mahi Shafiullah (01:14:40.397) Yeah. Absolutely. Good seeing you again, Chris. Alright. Haritheja Etukuru (01:14:40.886) Thanks for having us. Chris Paxton (01:14:44.476) Good to see you. This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit robopapers.substack.com

  • September 23 · 53 min

    Ep#106: Flex-π: A Multi-Stream World-Action Model with Compute Flexibility

    World Action Models are becoming more popular in robotics, as they learn to predict the world jointly with learning how to act on it. However, these world predictions are usually purely based on reconstructing color images from video. This is limiting, because color is far from the most important quality for a robot moving around in the world — more important are qualities like 3D geometry and object semantics. In Flex-π, Ge Yan, Jesse Zhang, and team train a 6 billion parameter world action model to do exactly this, predicting 3D pointmaps and DINO features along with color. This results in a policy which is much more demonstration-efficient, generalizes well, and can perform complex long-horizon tasks. Learn more in Episode 106 of RoboPapers, hosted by Jiafei Duan and Ruijie He! Abstract World-action models (WAMs) predict the future to act better, but nearly all of them predict only RGB latents, trained purely for pixel reconstruction, with no explicit signal for the 3D geometry or object semantics manipulation needs. We find a surprising free lunch: the same frozen video-generation VAE that encodes RGB also encodes 3D pointmaps almost losslessly, with no pointmap-specific training at all. This lets us supervise Flex-π, a 6B-parameter WAM, on 3D geometry and object-centric DINO semantics alongside RGB, at no cost in new sensors, new pre-training, or inference latency. Every visual signal is projected into this shared latent space and denoised jointly with actions inside a Mixture-of-Transformers backbone; per-stream dropout with cross-modality forcing then lets a single trained checkpoint run on any subset of these streams, from a fast action-only mode to full joint generation. The result is a policy that is exceptionally demonstration-efficient and generalizes well, beating the strongest baselines by up to 2-7× on dexterous, precise, real-world bimanual manipulation tasks both in and out of distribution, all while running faster than π0.5. Our project website: this https URL Learn More Project Page: https://flex-pi.github.io/ ArXiV: https://flex-pi.github.io/ Thread on X Transcript Transcript edited and prepared with automated transcription and checked by GPT 6. There may still be errors. Jiafei Duan (00:04.231) Okay, sure, sure, sure. Yeah, hello everyone. Welcome to a new episode of RoboPapers. We passed our hundredth paper mark and this is, I think, 102 or 103. And and today we have like two of the returning speakers from the previous episodes, Jesse and Ge Yan, to come on and really share about their new work, Flex-π. So maybe do you guys want to Reintroduce yourself a bit more and then I think for some of the audience who never heard the previous podcast before. Yeah. Ge Yan (00:38.151) Yeah, yeah, hi Jiafei, and thanks for having us. So I’m right now like a second year PhD student who is going to enter my third year at the University of Washington. And my PhD advisor is Dieter Fox. And now I’m working also closely with TRI and Jesse. Yeah, Jesse, it’s yours. Jesse Zhang (01:01.599) Yeah, I’m a postdoc at UW and I’m advised by Dieter Fox, and Abhishek. And so I started this Ge and I worked on this project for the past how long has it been? Maybe almost a year, yeah, it’s been a while. And it’s changed quite a bit since the initial version was definitely not a WAM. so it’s been very interesting how this has turned out. Ge Yan (01:18.833) Yeah, it’s been a long time. Ge Yan (01:26.567) Yeah, great. Jiafei Duan (01:27.145) Yeah, it’s it’s been it’s been a quite a while. I mean, I remember I was still there when all the people collecting data. Ge Yan (01:35.464) Yeah. Jesse Zhang (01:35.623) Yeah, yeah. I mean, even like Phil presented on on ideas that led to this and they were very different than what it is now. Jiafei Duan (01:42.677) Yeah, yeah. Yeah. I mean I mean for audience like just context, we are from the same group, so I I know exactly what this is about. But yeah, it definitely changed. But yeah, we hope to hear from Ge exactly what Flex-π is all about. So yeah, Ge, you want to take over. Ge Yan (01:49.629) Yeah. Ge Yan (02:00.219) Okay, thank you. Okay, hello everyone. Today we’re going to introduce Flex-π, a multi-stream world-action model with compute flexibility. I think we framed it as a policy that can do one checkpoint, any observed inputs, any generated features, and the speed accuracy operating point you pick and deployment. And this work is done by me, Jinghao, Yuzhi, Lori, Minwen, Jesse, and Dieter at the University of Washington. So I think recently we’ve seen a lot of work on on WAMs. I think it starts from the trend of very good video generation model, and people start to leverage those video priors from those very large video models and use it for action prediction. And we’ve seen a lot of progress, including like Fast-WAM, LingBot-VA, DINO most recent DINOTube paper work and and a lot of others. And I think we know that the WAMs are great, but they usually only predict RGB latent and that is specifically used to for reconstruction. And the previous work like DINO or DreamZero, so they really shows us that the world modeling objective itself enables better action prediction. And I think it is quite intuitive right now, like with with so many results show its benefits. So I think in our work we kind of want to ask a question like why not predict additional and that is especially manipulation-centric visual signals. So we really want to leverage those other signals because we want to further push the world modeling objective strengths, and we want to do some very high precision and dexterous tasks, and we want to achieve better demo efficiency and generalization. So the right is a a multi-view. Ge Yan (04:02.367) RGB video shown in a YAM setup that a model do this Soft-Bag Zipping task. And so right now you can see it’s purely RGB right? And so for Flex-π we focus on like two additional signals. So for better Demo efficiency and the generalization. So one is DINO. So we know the DINO had provides very good object-centric semantics that can be very good for generalization, especially in those cloud cloud environments. And also the 3D point. I think this 3D information really provides a lot of demo efficiency, lots of model to achieve sometimes even have high performance with much less data. As as we know, there’s no like free lunch, right? as we introduce like additional signals, it can like possibly like always introduce like additional cost. So that that really comes to one problem, because the most WAMs the the inference mode is decided at training time. So like what kind of inputs the model takes and what kind of features the model needs to generate. And we know that predicting the future makes us better, but actually w when you generate those at the inference time make it pretty slow. And it’s usually we see a lot of model that joint and generate those features, it’s very hard to do real time. And especially with our additional visual signals, that makes even makes it even harder. So we we kind of like want to do like one model that can do both. they can do like action-only prediction, and then you can also predict the futures as other WAMs. And it can be decided at the deployment time. Ge Yan (06:00.741) And before introducing our exact architecture, we want to share that because we build on top of the Wan video model backbone. So this the bottom video shows after training on internet-scale videos, the Wan model, this backbone has a very good physical prior. You can see it can generate this looks reasonable like videos. Although there you can see there are still some artifacts, but it really sh it shows the model can learn like the r what waterwheel looks like a reasonable behavior, even though it’s not exactly the the right. And and one thing about the one backbone is like the VAE part. So VAE can be regarded as an encoder. So for a VLA you can have like any those image language encoder, and for these one models, we use something called a Wan 2.2 VAE. So it’s trained by you take a sequence of input videos and you have a many many convolutional networks and you compress that into latent space. So you get a more compact latent representation, and then you reconstruct RGB video from that. And that is exactly the prediction targets of most WAMs. So I think most people understand that the WAMs predict the pixels, but it’s not exactly accurate because they’re actually predicting the RGB latent. That is optimized for pixel reconstruction. And we can also call it like appearance. One thing we found out is this VAE is is actually largely pre-trained on RGB videos, but it can surprisingly transfer pretty well to pointmaps. So pointmap, you can imagine it as like the same shape as RGB, but the pointmap is for RGB that each each pixel like is RGB three channels, and for pointmap is just XYZ. So they have they share the same format. Ge Yan (08:08.372) And by normalizing, they can be within the same range. It’s just quite surprising that because this VAE can transfer it pretty well, as shown in this bottom right videos, that on the left is the ground truth, on the right is VAE reconstructed. And it’s pretty much losslessly. And this actually kind of like solves a big problem about leveraging that 3D information. Because a while ago, like when we do all the 3D learning, try to leverage those information. We all we’re always bothered by what kind of 3D encoder we should use because unlike 2D models, 3D encoding is still not mature enough. And this actually shows a very promising direction that it kind of allows to use those 2D pre-trained model applied to a 3D pointmap and it works pretty well. RJ He (09:04.802) So sorry, if you just go back. maybe the first question is is this therefore then limited to the one two point two model or does this observation apply to other backbones as well? Ge Yan (09:19.378) Yeah, that’s a great question. I think this actually comes from so actually my project. So I’m it’s not public yet, it’s called like Uniflow. So the pointmap representation is is quite good because you can actually represent this 3D as like RGB format. And so this is not only applied by like like one particular VAE. You can also try other like DINOV3 encoder and other two D model encoder, as long as it’s like with the same format and the same shape, and you can actually get very good reasonable results from that. Yeah. RJ He (09:58.166) I see. So your observation is that actually quite a few of these encoders are you know, the popular ones all sort of implicitly have that point cloud information as well. Ge Yan (10:09.146) Yeah. I think I think I think it’s more likely like by large scale pre-training the model really learns from all these priors and it can actually transfer pretty easily to geometry, even though it’s it’s never trained on that kind of data. Yeah. RJ He (10:28.365) And then maybe a second question is of course, you know, this this this opens up a huge possibility with this additional signal of of the RGB D. D do you think it applies to and I’m not sure if you could get to it, but do you think it applies to other signals as well beyond point cloud? Ge Yan (10:44.592) Yeah, that yeah that that’s correct. So it theoretically we know like because I’m yep, not sure if it’s like kinda or like a secret, but you can actually use that for tactile. So if you represent the tactile like RGB image, I think many people have done this, right? Some we call it visual tactile. So tactile you can also represent it as an image. And you can also use the Wan VAE encoder for tactile signal. So as long as as long as like you actually share the same basically similar shape and they all get they all normalize with a reasonable Range like minus one to one, then this VAE encoder can be pretty universal for different signals here. RJ He (11:35.565) That’s cool. So your your insight here is really about the representation more than the sort of modality per se. And so, you know, that could potentially even be applied to other sensor modalities like audio and maybe in future even smell or something that. Okay. Cool. Ge Yan (11:50.151) Yeah, exactly. And and I also know like some people I know they have been already starting to try using this VAE for tactile and other modality too. Yeah. Okay, I can move next. So this comes to our flex bar architecture. So the model takes RGB input with Wan VAE encoder and pointmap share the same encoder, and they are all frozen during the training. And the DINOv3 for RGB to provide the DANO semantics. And then we can get these tokens from these different modalities. And then we we input all these tokens into a Mixture-of-Transformers (MoT) structure. So MoT is like a Mixture-of-Transformers, a mixture of experts. So basically this all this RGB, pointmap, and the DINO latent, they all process into one visual transformer backbone, that is one 2.25 billion model backbone. And then we have a action expert transformer that takes these action tokens. And for for both input and output side, we for the input side we apply something called a stream presence mask so that it can decide, okay, each modality the probability of current presence in current batch. And the output generation mask controls what the action can and cannot see. So if action can if if all these three modality output are masked out, so then action sees nothing, so it’s called action-only. And if they are all generated, the action can see them all. So we call it a full generation. And of course, they can see anything in between. And the probability of all this different presence and the generation are 50%. And of of course. Ge Yan (13:44.882) for input side we did some rejection sampling to ensure that at least one modality is present so that the model can have some information about at least Jiafei Duan (13:56.436) I have a I have a question, okay. So what what what’s the decision factor between using like fusion first or fusion later? So like I think you’re using an encoder to sort of encode all these different modalities. There’s also people who have like multimodal encoders that try to fuse everything at the very beginning, then you skip using MoT. So like what what was the decision factor doing this? Ge Yan (14:21.084) D do you mean the decision for MoT or the encoder part? Jiafei Duan (14:24.479) Yeah, I mean like like you are doing MoT because you are encoding all these different modalities separately and then you have them being projected into the MoT, the the MoT architecture. But then there’s also a line of work where you know people have multimodal encoders that try to fill at an early stage rather than doing the MoT approach. So is that like reason behind choosing this way? Ge Yan (14:50.246) Yeah, it’s a point. Yeah. So MoT, why we do MoT is like the first first thing is empirically like we found out MoT is very good. Like actually there are more some more details about the MoT, like it actually We we we view MoT as like you actually to separate and integrate them together. So what I mean is like for example, like the action expert they they the interaction between action and all these modalities are not through the whole transformer. So for example, if if this transformer visual backbone have like certain layers, probably like the first like six or seven layers is each modality is specific. And then in the middle they cross attend to each other and at the end it it just attend to itself again. So this design is actually turns out to be effective. it actually envision area like in in other multimodality generation in computation not necessary in robotics and this kind of fine findings also transfer to robotics as well so MoT it essentially is a pretty efficient architecture in our side and that’s purely experiment-driven yeah. Jiafei Duan (16:02.411) Yeah. Jiafei Duan (16:08.191) Yeah. Yeah, I I I I think I understand. But I I think maybe the question is also like, is all the input modalities time-synced? Ge Yan (16:19.513) you mean the time-synceded? You mean the Jiafei Duan (16:22.357) Yeah, like are they all in the same frequency? Or are they like different? Because like people use usually people use joint multimodal encoder if everything is time-synced and they do this approach where you have input streams that’s not time-synced. That means some could be very high frequency, some could be low frequency, you know, and then they use this encoder with MoT setup. So I’m I’m curious, is the input all time-synced? Ge Yan (16:25.53) Okay. Ge Yan (16:45.146) Yeah, so a few things. So the the data we’ve trained on is 30 FPS. So the raw data is thirty fps, the action and video are 30 FPS. And We do some video action downsampling. So for for RGB video and pointmap, though the same frequency, so we downsample by four, so sample at 5 FPS. So the visual signal is slightly slower than action. And for the dynamic part there’s another context is like because this visual input they get into a Wan VAE encoder, right? So Wan VAE has a temporal downsampling by 4×. So for example if you have eight frames input and after Wan VAE, you have two latent frames. So it is a temporal downsampling process. And the DINOv3 here is at the same frequency as the latent frames. So it’s two instead of the raw eight frames. So is that clear? Jiafei Duan (17:49.415) yeah, yeah, I I see what I mean. Okay. RJ He (17:51.99) Well actually but all the inputs are basically from the same image, right? In the RGB and the pointmaps and all that. So time-syncedhronization is not really the issue here. Jesse Zhang (18:00.646) Yeah, yeah, I think Ga is referring to the outputs. So we have a separate way that we predict outputs to save on compute and and inference costs, like training and inference costs. But I think the answer is they are time-synceded, and that’s because we don’t actually need any extra modalities, right? We’re just trying to get extra priors out of the same exact RGB image that other people would train exclusively on. RJ He (18:24.716) Yeah, actually I thought your answer to Jiafei’s question was going to be something along the lines of by doing this sort of late fusion approach instead of early fusion, you have more of an opportunity of adding additional signals in future as well. rather than having it the early fusion then you sort of are constrained to what what you can do. I’m not sure if that was a consideration at all, but that I wonder if yeah. Jesse Zhang (18:48.235) It allowed us to keep everything pre-trained also. Like that’s kind of one key factor is that we don’t have to touch the weights of the Wan VAE encoder. and it because it already for free reconstructs pointmaps super well, along with like not having to touch the DINO encoder and so on. RJ He (19:07.564) Okay, that makes sense. Yeah, so so I think there are elements of of being able to reuse stuff by by taking this late-fusion approach. Cool. Ge Yan (19:16.018) Yeah. And one additional point about MoT is it’s very flexible to add other modalities. So if in the future, if we want to add more tactile and any other modalities, it’s just plug-in. So that’s another benefit about it. Okay, anyway, during this process, we’re trying to like jointly model video dental 3D and action and all then your shared latent space. And here are some visual visualization. I think one thing to notice. Here is about the video VAE latent. So as we see here, it has a lot of noise, right? So because it’s especially trained for pixel reconstruction. So the if so the VAE latent has a lot of like unnecessary details that the model tried to optimize, but it’s not useful for manipulation. So that’s also one motivation why we want to do DINO latent additionally. Okay, so given that the whole architecture, then it comes to the world modeling objective, right? Because as we add more data, it actually comes with a cost. And we can first review like the current world action models. There are there are actually a few like very common paradigms. So Fast-WAM is the video-then-IDM. So this is something like LingBot-VA and a series of other works. So the model takes observation and the the model then generates the videos. And they they and then they have like a model called an IDM, basically an inverse dynamics model to extract the actions from Ge Yan (20:59.764) So it’s basically like a two-stage process. The problem of this pipeline is it’s the slowest because it’s not end to end if we call it. And it and it also relies on the quality of the generated video. Because in many I think in robotics there are many many corner cases that it’s very hard to generate the realistic future videos. that is very accurate. So in in in order to make it work, it will need a lot of data for coverage. And th and that’s a problem about this whole pipeline. And also the reason why we eventually didn’t choose to do this kind of style. And the second paradigm is joint generation, which is like what DreamZero did. It basically like you get the past observation and it jointly generates video plus actions. So the video and action, they are all denoised at the same time, and although they can attend to each other. And this is faster because it it doesn’t have to first generate video, right? So it’s well it’s a s is it’s it’s end to end and it’s a single step. But it’s still not real time because you generated those videos and those videos use a lot of tokens at a test time. And for DreamZero it requires like 200 GB for inference, and then there’s no way to deploy it in a like model on a GPU with 15–19 GB of memory. And it’s pretty slow and not n not It’s very far away from real time. RJ He (22:43.561) What about the data data efficiency? Comparing the two? Is it also still require the same amount of you know, needing a lot of data for coverage? Ge Yan (22:52.518) I think think DreamZero, I think this kind of joint generation requires less data because because it it doesn’t require the model to really generate very good videos, right? Because that’s that’s the toughest one. And and the for gener joint generation for the action part, there are some tricks or techniques to do actually. You can in a training time you can add you can make the this generated video noise you can add some noise to these videos so that the action in the training time you you can you kind of force the model to predict action and those actions can big can generate reasonable actions even though the video is not perfect. So I think this pipeline allows generated videos not that one hundred percent good. But the Flex-πpeline it it actually requires reasonable well yeah. And okay, any question? RJ He (23:48.796) yeah the just just to draw a little bit deeper and that that’s interesting to me because I thought they both have similar video reconstruction losses and so the requirement is should be similar of needing to recreate that both the videos pretty Ge Yan (24:06.438) Yeah. Yeah, these are actually two models, right? Because for like for first one is like although people right now they can unify the forward dynamics and inverse dynamics together into one model, but But when you first predict a video, that means in many cases like for example, like if you have some partial observation. For example, if if one apple is in your bag, you want to put it a bag you want to like pull an apple out of the bag, right? But When you first observe observe it, you you have no idea what what the apple will be, right? Because you you have to take it out, then you can see what it is. So this kind of like example to show like when the model has this very partial observation and you you it has a really need to imagine what it can come out, then there’s a problem because in many cases like you c it cannot really imagine what the outcome will really be. And another example is like about the many like physical interactions. So, like if you grasp something that’s very slippery, and it there are many or you can apply a very large force to a very light object and it can have some different physical like consequence, and that’s very hard to imagine, right? So in this case, you you really need a model to actually learn like to predict actions that is not based on like perfect video generation, but to learn a kind of Uncertainty from that video predictions. Okay. Hope yeah, I hope that answers questions. Jiafei Duan (25:44.426) I have another question. So I think like so you you you mentioned about the first two approach, right? The the limb ball or I think even earlier version with like Dream Gen, they do similar stuff. And then you talk about DreamZero. you you say that you say that would you agree that there’s a correspondence between the quality of the video work with the action. So if the video generation is bad, the action is not gonna be good, correct? So maybe the question I have is that for for Flex-π, when you are generating like all these different modality, do they agree? That means does each of these modality have to be good in order for your action to be good? Or they could they disagree but yet your action could still be good. Ge Yan (26:26.042) Yeah, I think they agree. So I think it is a similar observation like DreamZero. So the video quality is correlated to the action quality. It’s just like but In the training, you actually what we did too is like in the training time we added noise to that video part. So sometimes that’s also part of the reason why we can do act we can do all this generation with four denoising steps. So that means even though even though it’s kind of noisy noisy, but the the action can still be reasonably good. And that’s one part. And another part comes down to the reason why we want to do DINO and pointmap, because because the The DINO is actually much easier to predict compared to VAE latent if we go back to this visualization. So the DINO, if we see the training curve of DINO, video, and pointmap, we will see the DINO, the loss for DINO reconstruction and pointmap reconstruction, they decrease much faster than the video VAE latent because they are easier to learn. So this also shows that even though like in some cases the video is not. Perfect, but you can still have good DINO or pointmap latent. That can actually be also good enough. Yeah. Okay. Ge Yan (27:49.809) Yeah, the the last paradigm is action-only, which is like Fast-WAM. And so the basic idea is like it’s basically the same as DreamZero, but in the training time it has a video loss for this generated videos, but it but the action actually don’t need to see those videos at all. And it’s it’s it’s more like a training encoder because at the deployment time the model only predicts the action. So it’s it’s a fastest version and it works because works pretty similarly to a VLA model which you only predicted action, but it has the lowest performance. So in our usage I we found out that like Fast-WAM is a r is really a bad as some like a very chin it has in real-world. So that’s also a problem we want to fix with all these different modalities. RJ He (28:49.386) Sorry, but doesn’t it mean action-only is really a subset of joint generation? Because it both are doing both doing training, but then action-only is only generating actions at inference, right? Ge Yan (29:06.756) Yeah. They I think I think the key part is that they are both fixed at the training time. So for example DreamZero the joint generation in the training time The action and the video are joint generated, so so is the in the inference time. The first one action-only is the similar. So the difference between the inference time is whether the whether the model should jointly generate those videos. And that can actually be quite different for these two models. Ge Yan (29:40.773) And for Flex-π is more like it’s more like a combination of both. So it’s more like it’s like one model that can do both joint generation and action-only with the presence mask and the generation mask we have shown before. And then there are some properties about this kind of design. So first thing is of course about inference mode. So because we have like multiple modality generation, so the left l left The left one is like the model can take any input and it can generate action-only. So this is one example. And on the right is full joint. So it also jointly generates RGB, DINO, 3D with action. And it can do anything in between. So besides the action, it can select any subset of RGB, DINO, and 3D. Jesse Zhang (30:33.699) One thing to add here is that this relates to Jiafei’s question from before is like, you know, you kind of need all three modalities to look reasonable, maybe, for reasonable action generation, right? well because we train with random masking of essentially both inputs and outputs. the model is sometimes forced to generate like 3D from only RGB or pointmaps from only DINO, which essentially forces it to internalize the representation here, which also again ensures that like you know you can get reasonable generations no matter what. Ge Yan (31:10.3) Yeah. Yeah, I think I think Jesse made a very important point here. So this is something we call cross-modality forcing. So that means the output and input doesn’t does doesn’t need to be the same. So here are two examples, like given RGB input and model can predict the dynamic and a 3D. And on the right model get DINO input, they can predict RGB and the 3D. So all these things are mutually predictive. So any input and any output they can be mutually predictive. And in this way, as as Jesse said, like it we can internalize these modalities into this one backbone. And in this way, we we can unify appearance, which is the RGB geometry and the semantics into one representation. And that representation can be quite adaptive to f to any input and any output. Okay, so with so with all this pipeline we then pre-train on AGIBOT World, with around 500 hours of data. So this is some visualization shown the model prediction on on some unseen part of the data. So the left one is prediction and the right one is ground truth. And these three different parts is RGB DINO and pointmap. So yeah, this is actually not not that difficult it is mainly like like a three three camera view prediction. Ge Yan (32:47.502) And I think I think one part about it is like we we found out like because AGIBOT the data released has very bad very bad depth quality, but we can use Depth Anything 3 to label this depth. And it is just a reasonable reasonable depth prediction. And and one thing to note is like in our model we don’t necessarily require metric depth. What what we mean here is like although we use a metric depth model, but because we normalize those depths or we call them pointmaps to minus one to one. So as long as it’s consistent, even though it’s not metrically accurate, then it’s fine for our model pre-training stage. And here or here is a simulation experiment. So one one one simulator we choose is RoboTwin. So we basically frame our Flex-π as one model, and you can for action-only we kind of classify it as like VLAs because it only does action prediction and And also with a full joint mode. So all this are the same model. They have different inference mode. And they and they basically beat all these other variants and WAMs that are pretty good. And I think yeah. Jiafei Duan (34:12.523) I have a I have a question. So so I think I find it very interesting because the previously the there’s a slide that you you showcase the different ways of doing this full action model, right? And then you say that Flex-π sort of is an integration, or not integration, it does both. So it does what DreamZero do, and it does what Fast-WAM does, right? So will the boundary of the performance be in between? ‘Cause in machine in machine learning we always see things, right? When someone says I have I do A and I do B, somehow often the average performance falls somewhere in between of A and B. So I I saw that there’s like fast when baseline here, but what what how would this compare to DreamZero? Ge Yan (34:55.082) yeah, so no there are two things. So one thing we can s we say like they can do action-only and you can do joint generation. It’s mainly like a deployment mode that can ch you can choose. So it’s not only because through that process the model can internali internalize different representations, learn to unify these different modalities. So it’s actually The I think the key part is not only different inference mode, it’s also the model can be adapted to any input and output. And that kind of representation really matters. And it it has shown improved performance. And for for DreamZero, because it it actually didn’t show its performance in RoboTwin right now. So we didn’t include it here. Yeah. Jiafei Duan (35:47.659) But i then if that’s the case, I saw most of the results. It seems like the full joint prediction seems to be the best. So is the one to recommend for people to use is the full joint. Ge Yan (35:54.652) Yeah, exactly. Ge Yan (35:59.345) Yeah, I think yeah, that’s a great question. I think it really depends on the use case, right? Because in I think b why we do actually only because it’s pretty fast. So I think people like fast policies, right? Because the inference speed actually allows the model to be more reactive, especially for those dexterous tasks. So if I think full joint is aimed for like a like the highest precision, the highest performance. And action-only is like for those less difficult tasks, that you i it doesn’t need like general pick-and-place, it doesn’t need that much precision and then you can use action-only. for very fast deployment. So that’s kind of like users their choice for for their different attacks. Jesse Zhang (36:49.608) And to clarify, like we’re not in between DreamZero and Fast-WAM, right? Like we’re actually ingesting and predicting far more modalities than DreamZero. so the upper bound of full joint in theory should be higher. The problem with DreamZero is actually inferencing is so slow. it’s hard to compare unless you just compare against the baselines and and benchmarks they already did themselves. RJ He (36:50.567) That’s what? Ge Yan (37:14.854) Yeah. Yeah. Jiafei Duan (37:15.177) I think yeah. RJ He (37:17.807) And if I understand correctly, y you also you don’t just have two modes, right? Of action-only and full joint. You could have anything in between as well. Right. Do you I I don’t know if you all did any analysis on which of those modes are maybe more valuable than the others, for people? Ge Yan (37:24.368) Yeah. Yeah. Ge Yan (37:36.391) Yeah, here I s yeah, we did ablation about that. So so two ablation. One is in the training time. So the training time basically to ablate whether these modalities are useful, right? They can really help the policy. So I think in training time we find that adding different modalities generally helps performance. I think it’s quite anti it’s not surprising. And for inference time comes back to your question. It’s like We do see that with more modality generation deployment time, the model gets better performance. So there are two ways, there are two things about this. So one thing is like, so you can see here we also include Fast-WAM. So Fast-WAM, you can see that it’s action-on, but it doesn’t have those modalities. So so if we compare a Flex-π actually versus Fast-WAM action-only, that means even though the generation is the same, but the but at the training time the model can learn different modalities. Then the model can still get better performance. So that’s goes to our one motivation is like to intern internalize those orientation for better policy learning. So this is one thing. Another thing is like we found out like with adding one modality model, the model gets better performance. And this actually is in like and this this plot is about a few RoboTwin tasks. And we also have ex experiment and the results in real-world, we we discover exactly the same thing that full joint always like has better performance than action-only. But but the gap between different modality addition is not that much. So that also That that’s also a very good signal. You can see here, adding the video, DINO, or a pointmap, the gap between each addition is smaller than action-only plus adding any any of those modalities. So that’s that observation shows like the model tends to unify different representations. So it actually when you add like any of this modality in the model can get a reasonable reasonably good. And when you add more and more, the model Ge Yan (39:53.189) increase the performance and the reaches the upper bound. So that’s kind of the observation we have about this inference time modality choice. RJ He (40:07.878) Then sorry, and then on the other end, in terms of the latency, with action-only versus Fast-WAM, why why is action-only faster? Is that because of some optimizations that you’re all doing or is that something in the architecture that made action-only faster than Fast-WAM? Ge Yan (40:07.931) Yeah. Ge Yan (40:26.416) Yeah, we do the very heavy optimization. I think the one core reason is like we can do few step denoising. So like Fast-WAM they can like they do 10 step denoising and for all our experiments we do four step. So that that’s naturally already a two times less denoising step, meaning two times less model forward in time. And we also do additional some engineering effort to optimize the whole network. But but I think the few step denoising is the key for that Inference here. And why I think why the model can do few-step inference without degrading the performance. I think it goes to the question like when we have this different modality, actually it helps the model to learn more efficiently. So and and the because video is so hard to optimize, so you may need a more general step. But for other modality, you don’t necessarily need to do that. And actually, this is another benefit of using different modality. Yeah. Jiafei Duan (41:35.566) yeah, good. I I I think do you have like some videos of the real-world task? ‘Cause I have like one some questions regarding I mean like do you have like videos cause these are just pictures. Okay, cool, cool yes, yeah yeah. Ge Yan (41:47.17) yeah. I know this. Jiafei Duan (41:50.486) Yeah, so I have a very interesting observation. So I read the paper quite thoroughly. so so in in in the Self-Repair Gripper task, you you guys collected 11 hours of data and then you collect a DAgger. Like, can you explain a bit about that? It’s like kind of the other task I can understand, but what why what’s what is this specific task? Ge Yan (42:11.398) Yeah, this test is the idea of Jesse. I think but it’s creative. But it’s creative to Jesse, I think. I I think it’s mainly like we want to do some long horizon task and that’s pretty required precision and that’s very Jiafei Duan (42:14.913) Jesse Jesse creates a problem for you. Jesse Zhang (42:20.301) Yeah. Sorry. Ge Yan (42:30.524) difficult to do for most policies. And so because we want to explore a boundary of this policy performance. So Self-Repair Gripper like kind of like a a very good idea to do this kind of task. And regarding the yeah, okay, go ahead. Okay. Regarding the data we used Jesse Zhang (42:43.979) Also you go. Ge Yan (42:51.364) Actually, yeah, we showed here, right? Because we have indeed like 10 hour data. So this this test really need a lot a lot of data. But but actually we’re not one 100% sure that if we need this much data to do to achieve this similar success. Like like this is mainly like the data we collect is mainly for baseline. So you if you see here, So the left is task completion, right? And the l and the right is a full task success. And π0.5 is always zero and it and the ManiFlow with all this data can achieve like one success out of twenty trials. So we are basically collecting this data based on the baseline’s performance. So because if if the data is two, it’s not this quantity, then baselines are all zero. So we we we so that’s why we choose this much data. And another observation is like even though with this much data, Pi zero five still struggles. And all this including many folds is a three policy. They struggles with this task here. Because this task involves many steps of that not a pretty difficult because for full success you have to finish the all these changes steps and that that’s what makes it fail and get zero success. Jiafei Duan (44:15.773) I see. and and and you mentioned that, you know, because it’s like just now I think you mentioned that VLA is more fast, less precise. So will world action model does better in this task? Ge Yan (44:29.392) Yeah. A few a few notions. So I think I think it also depends on pre-training, right? But in general, I think π0.5 is is far better than Fast-WAM, because Fast-WAM is like it’s action pre pre action-only prediction. We also actually test that LingBot-VA is another world action model, it’s also not good. So I s I think the reason is that it they really need a lot of data, like LingBot-VA and Fast-WAM. And that they I’m not sure about their pre-training stage, like what how many data they use compared to π0.5, but in this fine-tuning stage, it shows like they need a lot of data compared to π0.5. Yeah. Jiafei Duan (45:15.937) Got it. Jesse Zhang (45:19.06) I think one thing is like we probably don’t need the eight hundred teleop demos for any of these, even for ManiFlow to get something so. I think it’s really the DAgger demos that helped a lot with such a long horizon dexterous task, like going kind of off manifold and getting a correction. that data was really helpful. Ge Yan (45:37.168) Yeah. Yeah, I think in simulation it also kind of reflects this. So we also did some data scaling experiment. So if you had if you only have very few data, you you can see LingBot-VA is pretty low performance. And as you add add more and more data, so basically 500 demos kind of saturated the whole benchmark. And then they can get a similar performance. And and here RJ He (46:03.72) Yeah, I mean on on that sorry, on that no it seems to me like the story you’re trying to tell with the on the data versus, you know, your your outputs is that initi when you have fewer demos for your training, you really need the full joint at inference in order to get to that the delta between the two is larger. But then once you have as you increase the amount of demos, the gap narrows and you can get a you can kind of get away with an action-only inference. Is that is that sort of the conclusion we’re making there? Ge Yan (46:40.112) Sorry, ca sorry, do you mean like when we scale the data, the gap between action-only and a footrone gets closer? Is that what you say? RJ He (46:47.783) Well i it it seems like the the gap between action-only and full joint narrows as you increase with the number of demos. Right. So does is the com Ge Yan (46:55.728) Yeah, that that’s that’s also the observation we have. Yeah. Ge Yan (47:02.768) Yeah. okay, so this is the real-world experiments, like we Basically, we include π0.5, ManiFlow as a 3D policy. So one thing about ManiFlow to note here is that it is not using original point cloud. It’s also using pointmap. So it’s kind of upgraded version of ManiFlow. And Fast-WAM and the Flex-π in fact action-only and full joint here of the same model with different inference mode. And this hatched part is binary success. So we report both task completion for more granular evaluation and binary success for more. fairer comparison. And we have like three easy tasks that obviously Fast-WAM is pretty bad. And I think the ManiFlow with pointmap is slightly better than the π0.5, but they are both worse than either action mode of Flex-π. And for these two difficult tasks, we do not include Fast-WAM because it’s not competitive in these two tasks. And we see the gap is even larger on these two most difficult. tasks and and the average I think it achieves like over 2x more improvement in in terms of like task completion and success and here yeah just I show to you do you have questions RJ He (48:23.302) So RJ He (48:27.59) never, well let me finish this and then I’ll go back to the question. Ge Yan (48:33.484) yeah, this this are all the videos of sh some example. I’ve I’ve shown like to Jiafei before. And so here’s about the latency performance frontier. I think why we really care about latency is i for many times you you really need a model to be reactive. So if there are many WAMs that they claim they can have very good performance, but at the cost of very high latency and that’s not that useful in real-world. So we we kind of regard it as a very top priority for for our method. Jiafei Duan (49:15.08) I have a question. So for the latency are you measuring by per policy call? That means they are they might be at different action chunks length or are you how how are you doing it? RJ He (49:16.123) Yeah. Ge Yan (49:26.842) Here the latency is one model forward time under like under the same 5090. And and for action chunks, like we ha we have the same as Fast-WAM. So it’s like like one one prediction is around one second is like over 30 actions. Yeah. Jiafei Duan (49:50.941) I see. So for for your model it’s 32 steps, action chunk. But then Pi runs fifty. Ge Yan (49:55.227) Yeah. Ge Yan (49:58.823) Yeah. I think I think here like so pi can like at the same time they they do pretty good l longer action chunks. So one thing is like one thing is like We here we we we we mainly report the model for latency instead of like the whole the whole task completion time, right? Because as you say, like if if the model predicts longer action chunk, that means for one successful episode it can take potentially less time, right? So that’s also a very good point. And another another thing about about is like We Flex-π actually actually we also tried one version of but we didn’t include in the paper is like we try to include like three or four latent frames that correspond to forty-eight actions, forty eight actions that can be roughly matched to π0.5. And that’s also And and and in that case, if you remove because it doesn’t matter because for action-only it doesn’t matter because no matter how many frames you generated, you will still remove it at the inference time. So at in in that in in that context, it’s it’s very roughly the same as current action-only, but you can still predict f 48 to 50 actions with similar latency. Yeah, is that clear? Yeah. Okay. Jiafei Duan (51:28.479) Yeah, yeah, got it. RJ He (51:30.694) So on the performance comparison, sorry, just compare between Flex-π now and Fast-WAM, right? Because conceptually there’s they’re on a more similar spectrum of you’re only generating actions during inference, right? Is is the intuition there in terms of you know but they have because they have pretty significant difference in per in performance right between flex Flex-π action-only and and fast when is the intuition there that if you’re only going to generate actions at inference then during training you really need need the richer representation with, you know, point cloud and DINO and all of that, to to to be able to still get your good performance. Is that is that the key difference between action-only and Fast-WAM or is there something else? Ge Yan (52:15.974) Yeah, that’s true. I think I think the top reason is we have We have very good optimized representation. As you said, adding DINO and the pointmap. So I think that’s key factor one. The key factor two is like you have we have those mutually predictive, right, with this masking and dropout and the cross-modality forcing. So it kind of forces the model to learn representation that’s that’s more general and unified. And that’s really good for policy learning. So I think just two reasons I think it is a key that why even with the same action-only mode is much better than Fast-WAM. Ge Yan (53:03.046) Yeah, yeah, another thing is we also take the out-of-distribution generalization. So on this figure we show this this shallow bar is in-distribution and the and on the right is the out-of-distribution. And here we show the the negative is the minus of out-of-distribution performance versus in-distribution performance. And on this three simple tasks and we see Flex-π either action-only or full joint they show less degradation when evaluate in out-of-distribution mode. And here, and here shows the test case. So the left is the thing basic environment and the the right is unseen. So you can see that we add a lot of distractors. So it’s kind of crazy cluttered and yeah. And we also try something like Unseen plate, so unseen object. to really to really extremely test the model’s generalization capability under this environment. Ge Yan (54:13.338) And the second thing is about the demo efficiency. by dropping so this is a simpler task, Put Plate on Rack: the model puts the plate on the rack. And is we dec decrease the data from three hundred episodes to one hundred and fifty. And we observe the model performance decrease, which is a intuitive like not surprising, and we also observe π0.5 and all these baselines they decrease the performance quite a lot, while Flex-π decrease relatively less. Okay, so yeah, maybe I can s skip this video as this video as is many the motivation why we want to design this task is many because beyond the pick-and-place tasks, we want to test the the model’s capability in terms of very long horizon and the multi-step dexterous, high-precision task. Okay, yeah, this is like both task completion and for task success. basically in this kind of difficult task like even though with this kind of teleop and DAgger demos, I think what I think the point is that why baseline for performing so bad, right? I think we can take a look at the videos. So this this video shows the failure case of π0.5 on the left. So this step is that the model needs to insert that gripper into the holder. So because this gripper and the holder they they only have like like 0.5 millimeters of clearance. So the model really needs to like adjust the gripper to be aligned with this holder. Ge Yan (56:07.034) And that part is what makes π0.5 always fails. So because we see the π0.5 have 0% full success and they always fail in this step. So that’s kind of the problem here. And we I also argue that the 3D may help in this scenario because yeah it actually because the ManiFlow can actually work in this step. So that’s one observation. And the side the second observation is like about ManiFlow. So because ManiFlow is a three policy and it successfully passed the last step about inserting gripper, but it has pro but it has a limitation in the in kind of this screwing step that it always missed a few millimeters is quite close, but still not there. And out of our 20 tries it succeeded by one time. So it’s still very low performance. But Flex-π I can actually do this quite quite consistently good. I think I think the the reason is like as Jesse said before, I think the deck data really help a lot. So no many cases the initial state is not correct enough, like like on the left. The model the initial insertion is actually not not one hundred percent right, right? It’s not fully aligned. But but the model can learn to align its gripper further and then then it can succeed. And all the right is the same. I think I think this finds the most surprising ones because they actually did two retries. So so if we go as this one, so at first I think the the bit just glances over the socket. So okay this one it it it it it got it, but it’s not fully it’s not fully screwing. So it it actually retries the second time and then and then it’s fully screwing and then you put it back. Ge Yan (58:14.79) So this kind of behavior is like quite like robust and I think that that’s the key what makes you like get some a reasonable good s success for this task. RJ He (58:28.376) Yeah, but it sounds like beyond the depth sorry, beyond the DAgger data, it’s also the depth representation and the the objective that’s important in in getting the result the robust behavior, right? And that that’s I think the main point. Ge Yan (58:39.963) Yeah. Ge Yan (58:45.05) Another thing about is our model is not limited to depth input. It’s not so here is one example, like the model has no depth input, but it achieved a similar performance. So with depth input, I think the task completion is ninety-five, but without depths it’s getting ninety-one. So we we do see some degradation. But but it I think the further Actually like to showcase the model already learns the the internalized representation because even though it doesn’t have depth input, it doesn’t affect the model performance too much. It still pre it still shows this kind of precision and the recovery behavior. And yeah, I I’d like to show a few more tasks, like this one is Soft-Bag Zipping task. This one is more about dexterity, like also we tried on like a few different bags with different color. And I think this task the takeaway is it shows a similar trend as Self-Repair task but but in this time I think π0.5 and ManiFlow they’re not zero anymore so they get they get some they get some non-zero success here. And also when we deal with some unseen bags they we see that they also have like a more more significant performance drop. And this is a r this is basically a non compressor in this task. I think it’s quite funny because you we you can see the failure case of π0.5 on the on this on this task. It’s quite interesting to see because it really shows the difficulty of this for this deformable bags and it’s Ge Yan (01:00:42.32) the model I actually kind of learn for this kind of task, learn like you let this zip go and then retry, right, instead of keep f keep like for pushing for this actions. And yeah, f and another thing for this is the zipper is kind of small compared to the gripper. So the kinds of to show some dexterity like how to grasp it correctly. And if you it’s not grasping correctly, you need to retry. And this kind of this kind of behavior is like is also shown like because we in our tr you know because this is a pure BC data, so no DAgger data for this task. But in our training but in our data collection, even for human, it’s sometimes very difficult to do the task from the start to the end. So the human naturally introduced some retry behavior in the tr in the in the BC data. So that the model can still can also sh imitate this kind of behavior. But the question is the baseline seems like a π0.5 not able to fully learn this behavior very accurately. Okay, so I’m going to close. the takeaways is like training WAMs with these manipulation-centric visual signals like DINO or 3D pointmaps. It enables like both generalization and demo efficiency. And that’s crucial for real-world deployment. Ge Yan (01:02:20.792) And it’s nearly free because you don’t have to retrain any 3D encoder. And for all the for all this data, you can also use Depth Anything 3 to label those pre-trained data that don’t have depths. So it’s there is a pretty good, like nearly a free lunch for in on top of current WAMs. And the second second takeaway is with those with this kind of mutually predictable model input and future generation. the the WIMS actually learn a unified representation. So it is one representation that can represent represent appearance, geometry and the semantics. And this this brings better performance and also flexible latency budgets that you can cho you can choose based on your like deployment use case and any inference modes with different input and output. And I think the third takeaway is there’s no need to fix the world-modeling objective at training time. So you I think I think the key is like we want to internalize everything because either action-only full joint or first action then IDM it’s quite limiting to fix the model to one specific mode. But why not one model can do all these different things? And it’s in this process you’re trying to internalize internalize different representation, different signals, and all into one model. And this one model can be quite useful. And another thing is like we know the action-only is actually worse than like the full joint generation. But we see that it’s getting closer at a fraction of latency. So if you are so I think I believe with more data and more pre-training, the gap between action-only and the full full joint generation can be closer and closer. And in that way, you can get a very even faster generation without sacrificing too much performance. Ge Yan (01:04:24.436) Yeah, I think I think that’s all. yeah, I’m free to take more questions. Yeah. Jiafei Duan (01:04:30.229) Cool. Yeah. Yeah, thanks thanks for thanks for sharing with us this new work that you guys have done. I think it’s pretty cool. And definitely encourage people to check out and I I g I guess like the the code is also open source. So yeah. Raj, do you have any other questions? RJ He (01:04:50.987) No, very cool. I guess just the way we usually end. any papers that you all wanna give a shout out to? doesn’t have to be related to to your specific work. Ge Yan (01:05:05.222) Yeah. Jesse, do you want to say this? Yep. go ahead. RJ He (01:05:06.723) Is there is Jesse Zhang (01:05:09.835) I think like I think Fast-WAM was one of the first to kind of show that you that you could drop some modalities at inference time. So I think definitely check that out. Like they they also have some other ablations that were useful. I know we kind of said it’s not a good baseline, at least in the real-world, but I think their performance is simulating. But I think more the takeaways from that paper are still very relevant. RJ He (01:05:34.179) Ge, any from here? Ge Yan (01:05:37.228) I I think I think we’ll we’ll also like open source a few large scale pre-trend checkpoints and we are excited like to for the community to to to test it out like zero-shot deployment. I think we’re working on that and we hope to release you know soon. RJ He (01:05:55.319) Yes, it would be nice for us to no longer just use π0.5 as the baseline. So very supportive of that. That’s awesome. Thanks guys. Jiafei Duan (01:05:59.019) Mm-hmm. Ge Yan (01:06:00.454) Yeah. Ge Yan (01:06:03.826) Thank you. Jesse Zhang (01:06:05.397) Thanks for having us. Jiafei Duan (01:06:05.653) Yeah. Cool. Yeah. If not, good to have you guys and let’s hope to see you guys next time. bye. Jesse Zhang (01:06:12.63) Yep, all right. All right. Thanks. Ge Yan (01:06:12.787) Yeah. Thanks for having us. Bye. RJ He (01:06:14.572) Thanks everyone. Yep. This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit robopapers.substack.com

  • September 18 · 49 min

    Ep#105: Beyond Imitation: Self-Improving Robot Policies via Off-Policy Q-Planning

    Imitation learning, especially with interventions, has driven so much recent robotics progress. However, improving a policy via targeted interventions until it reaches a useful and deployable success rate is a time and labor intensive process. Instead, wouldn’t it be great if policies could improve on their own? That’s what Varun Giridhar and Animesh Garg join us to talk about. In Q-Planning, they start with a large policy like pi-0.5, and add a Q-function estimator to predict value instead of just actions, then use both successful and failed rollouts to update this Q-function online, then use it to guide sampling and trajectory selection. With just a few rollouts they can dramatically improve policy performance online. This provides a way to do really difficult tasks like inserting a credit card into a wallet, increasing success rate from 25% to 80% in just a few iterations. Learn more in Episode 105 of RoboPapers, hosted by Michael Cho, Chris Paxton, and Ruijie He! Abstract Behaviour Cloning (BC) has driven remarkable progress in robot manipulation, yet it is fundamentally limited by its inability to self-improve: a policy that fails cannot learn from that failure without additional human demonstrations. Reinforcement Learning fine-tuning offers a path to self-improvement but has proven difficult to scale to the multi-billion-parameter models underpinning modern robot policies. We propose Q-Planning, which equips a large visuomotor BC policy with a small off-policy Q-function. Because a Q-function estimates value rather than imitates actions, it can be trained on the same successful demonstrations as the BC policy and later absorb both successful and failed deployment rollouts, an asymmetry BC does not have. We exploit this asymmetry to enable value-guided action selection at inference (a single-step QQ-weighted average over BC draws) and online self-improvement that fine-tunes only the Q-function, leaving the BC weights untouched. On LIBERO and bimanual RoboTwin, ten iterations of self-improvement lift every benchmark score we tested (LIBERO-10 93 → 99%, RoboTwin 83.8 → 91.4%) and shorten successful episodes on the near-ceiling suites (LIBERO-Object, LIBERO-Goal). On two contact-rich bimanual real-robot tasks, the same loop (BC frozen, no human intervention) improves purely from its own deployment rollouts: stack-cups 40 → 90% and insert-wallet 25 → 80% in five iterations, whereas SFT on successful rollouts alone stalls at 55% and 30%. Under an identical online budget Q-Planning is the only method, among Best-of-N, filtered SFT, IBRL, DSRL, and DAWR, that improves stably from failures without training an auxiliary actor. Learn More Project page: https://q-planning.github.io/ ArXiV: https://arxiv.org/abs/2608.21204 This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit robopapers.substack.com

  • September 14 · 42 min

    Ep#104: Light-Loco-Parkour: Versatile Perceptive Whole-Body Locomotion via Multi-Skill Distillation

    One of the key advantages of legged robots like humanoids should be how effectively they can move across a wide variety of terrain types to accomplish their task. But Light-Loco-Parkour from the team at Light Origins aims to change that: using only onboard sensing, they show a policy which can decide when to walk, vault, climb, or otherwise traverse as it moves through a complex environment. Unlike many others, it uses sparse seeds instead of relying on a large motion corpus, learning when to use its skills to move around without specific sub-task labels. Xiaodao Chen and Yuntao Ma join us to go into the details. Watch Episode 104 of RoboPapers now, with Michael Cho and Chris Paxton, to learn more! Abstract Existing humanoid whole-body control systems still fall short of the way humans move through cluttered terrain: they either track expressive whole-body references without terrain generalization, or react to terrain online while leaving the arms, torso, and knees largely unused. We present Light-Loco-Parkour (LightLP), an end-to-end perceptive whole-body locomotion system that closes this gap with a single deployable policy. Conditioned only on onboard depth and a velocity command, the policy decides when to walk, balance, climb, step down, or vault, with no reference input, skill label, hand-coded gate, or runtime motion graph. Compared with prior humanoid systems, LightLP makes three contributions. First, it introduces a whole-body perceptive-control pipeline that extends an RL-trained, velocity-tracking locomotion policy with parkour skills learned from object-interacting motions, so the same policy tracks velocity in open terrain, executes whole-body traversal at obstacles, and resumes locomotion afterward. Second, it acquires terrain-conditioned skills from sparse seeds by expanding a single motion into dynamically feasible, terrain-paired references across obstacle geometry, rather than relying on a large motion corpus. Third, it learns autonomous skill transitions from reward, letting the policy decide when and which whole-body skill to invoke from depth and command alone, with no one-hot skill label, hand-coded state machine, or runtime motion generator. Simulation and real-world experiments show high success across both benchmarked terrains and unseen obstacle variations, and the same policy transfers zero-shot to indoor and outdoor hardware experiments. These results demonstrate autonomous perceptive whole-body locomotion on a humanoid in outdoor settings, using only onboard sensing and a single deployable policy. Learn More Project page: https://light-loco-parkour.github.io/ Paper: https://light-loco-parkour.github.io/paper.pdf This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit robopapers.substack.com

  • September 9 · 47 min

    Ep#103: Freeform Preference Learning for Robotic Manipulation

    Specifying reward functions for robots is one of the hardest things about reinforcement learning. Robot rewards often need to be very detailed; metrics like progress can be ill-defined and hard to estimate. This leads to most robot learning defaulting to sparse rewards or simple preference learning. But naive preference learning (having human annotators choose one trajectory over another) is an easy solution, but obscures a lot of the signal in complex tasks and can make learning a lot less efficient. Marcel Torné, Anubha Mahajan, and Abhijnya Bhat join us to talk about their solution: freeform preference learning, which lets annotators define natural-language axes to compare trajectories over. This improves real-world performance on long-horizon manipulation tasks over sparse rewards and simple binary preference learning. Watch Epsiode 103 of RoboPapers, with Michael Cho and Jiafei Duan, today to learn more! Abstract Reward design remains a central bottleneck for autonomous robot policy improvement, especially in long-horizon manipulation tasks where sparse success labels provide too little signal and binary preferences collapse many competing notions of quality into one ambiguous signal. We introduce Freeform Preference Learning (FPL), a method for learning robot policies from freeform human preferences. Rather than asking annotators which of two trajectories is better overall, FPL lets them define natural-language preference axes, such as speed, safety, quality of placement, or carefulness, and provide pairwise preferences along each axis. These annotations are used to learn a language-conditioned reward model that maps a trajectory and preference label to an axis-specific reward. We use this model to train a reward-conditioned policy that optimizes across the multiple human-specified dimensions. Across four real-world and two simulated long-horizon manipulation tasks, FPL improves over sparse-reward and binary-preference methods by 38 percentage points. Beyond improved performance, FPL learns dense progress signals without explicit subtask segmentation, shows compositionality of behavior not present in the data, and allows users to steer the policy towards different behaviors at test time without retraining. Blog post with videos available at this https URL Learn More Project page: https://freeform-pl.github.io/fpl.website/ ArXiV: https://arxiv.org/abs/2606.32027 This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit robopapers.substack.com

  • September 8 · 1 hr 9 min

    Ep#102: EgoSuite-Open100K from Lightwheel

    Robotics has a data problem, and egocentric data is a compelling way to solve it because egocentric data is (1) scalable — it’s cheap to collect — and (2) easily captures the breadth and diversity of real human tasks, while (3) being true to real physics. Lightwheel recently released a hundred thousand hours of high-quality egocentric video data, spread across a wide range of human tasks from cleaning and tidying to assembly and construction to retail tasks. Here to tell us about this tremendous effort is Steve Xie, CEO and co-founder of Lightwheel. The data is also available on HuggingFace right now. Watch Episode 102 of RoboPapers, with Michael Cho and Jiafei Duan, to learn more! Learn More Project page: https://egosuite100k.lightwheel.ai/ Blog post: https://huggingface.co/blog/LightwheelAI/egosuite-open100k Data on HuggingFace: https://huggingface.co/collections/LightwheelAI/egosuite-open100k This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit robopapers.substack.com

  • September 4 · 51 min

    Ep#101: Coupled Local and Global World Models for Efficient First Order RL

    Reinforcement learning has unlocked tremendous gains in broader AI and humanoid robot whole body control, but still has yet to deliver strong results for robot manipulation due to the difficulty of capturing tasks in an accurate simulation; one way to fix this is to create complex environments with learned world models. But learning fully within world models is often intractable as powerful world models are computationally too expensive. Instead, Joseph Amigo and Rooholla Khorrambahkt propose to break the problem down: into a large-scale world model that can generate forward trajectories, and a lightweight, low-dimensional latent-space model which can approximate local dynamics of a problem, without needing to back-propagate through a heavy global model. What this means: you can do reinforcement learning in this coupled local-global world model, and learn contact rich skills for a robot. To learn more, watch Episode #101 of RoboPapers, with Michael Cho and Jiafei Duan! Abstract World models offer a promising avenue for capturing complex environment dynamics where simulators face challenges. However, large-scale world models required for complex real-world settings are computationally expensive to adopt in popular RL approaches. We introduce a novel first-order RL method that enables policy training via a decoupled first-order gradient (FoG): a large-scale world model generates accurate forward trajectories while a lightweight latent-space surrogate approximates its local dynamics for efficient gradient computation. This coupled local-and-global formulation allows high-fidelity forward dynamics alongside the computationally efficient differentiation needed for model-based RL. Across a range of real-world robotic tasks we demonstrate tractable RL and zero-shot deployment, with significantly better sample efficiency than PPO on a canonical real-world Push-T benchmark and similar gains on more complex ego-centric manipulation and grasping. Learn More Project page: https://coupled-global-local-wm-rl.pages.dev/ ArXiV: https://arxiv.org/abs/2602.06219 This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit robopapers.substack.com

  • September 2 · 1 hr 29 min

    Ep#100: 100 Episodes of Embodied AI

    Embodied AI is exploding, and it’s been amazing to learn about it with you all. We have now recorded over a hundred discussions with the best researchers in the world on embodied artificial intelligence and robotics, covering topics like scaling robot learning, humanoid whole body control, tactile sensors, sim-to-real, and so much more. For our hundredth episode, we brought on our newest co-host, Ruijie He, to discuss what we’ve seen and learned in the first hundred episodes. Which were our most-watched episodes? Which institution shows up the most? Who was our most frequent guest? What did we learn? Find out on Episode 100 of RoboPapers, with Michael Cho, Chris Paxton, Jiafei Duan, and Ruijie He! Learn More https://robopapers100.com/ This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit robopapers.substack.com

  • August 18 · 1 hr 7 min

    Ep#99: DYNA-2: A 1 Million Hour Scaling Law for World-Action Models

    Excitement about world-action models and robot learning has never been higher — they promise a way to use human egocentric data to train massive robotics models which can provide the “GPT” moment for robotics and unlock general-purpose embodied intelligence. And yet there’s been little concrete demonstration of scaling in robot learning. Dyna Robotics aims to change that, with an in-depth look at how scaling works as they approach 1 million hours of training data. Jason Ma, Tianyu Li, Anh-Quan Pham, and Chet Bhateja joined us to tell us more. They show that as the amount of data they use in pretraining increased, they saw predictable, statistically significant gains on accuracy metrics on held-out data (data not seen during training). They go on to talk about what they learned, and show how this can be applied to many different problems. Watch Episode #99 of RoboPapers, with Michael Cho, Chris Paxton, and Jiafei Duan today to learn more! Learn More Read the blog post: This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit robopapers.substack.com

  • August 14 · 59 min

    Ep#97: Cross-Embodiment Robot Manipulation via a Unified Hand Action Space

    Representing actions for robot hands is actually very challenging. Robot hands have different sizes and shapes, and different degrees of freedom. Representing their actions purely as joint states — as we naively would — leads to less transfer across the wide variety of available hands. Instead, could we design a universal hand action space to allow robots to learn cross-embodiment dexterous manipulation more easily? Luis Felipe Casas and Yu Xiang come on to tell us about UHAS: the Unified Hand Action Space, a sphere-based action representation which enables cross-ebmodiment learning of dexterous manipulation skills. Watch Episode #97 of RoboPapers, with Chris Paxton and Jiafei Duan, today to learn more! Abstract Robot manipulation policies are typically tied to specific robotic hand embodiments, limiting the transfer of learned behaviors across platforms with different kinematic structures. In this work, we propose the Unified Hand Action Space (UHAS), a sphere-based unified action representation for cross-embodiment dexterous manipulation. UHAS represents robotic hand actions as geometric deformations of a canonical sphere and uses a Cascade Inverse Kinematics (CIK) algorithm to map the shared representation to embodiment-specific joint configurations. Using reinforcement learning, we train dexterous manipulation policies directly in the proposed action space for in-hand cube reorientation tasks. We evaluate our method in both simulation and real-world experiments across multiple robotic hands, including the Allegro Hand, LEAP Hand, Shadow Hand, and MANO Human Hand. Experimental results demonstrate effective dexterous manipulation, zero-shot transfer to unseen hands, rapid finetuning across embodiments, and successful real-world deployment. Our experiments show that the proposed UHAS representation enables stable dexterous control and cross-embodiment policy transfer across robotic hands. Learn More ArXiV: https://arxiv.org/abs/2607.03570 This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit robopapers.substack.com

  • August 12 · 36 min

    Ep#96: EgoHumanoid: Unlocking In-the-Wild Loco-Manipulation with Robot-Free Egocentric Demonstration

    How can roboticists scale human manipulation data in the wild? EgoHumanoid builds a comprehensive pipeline which unlocks mobile manipulation training for robots — meaning that you can walk around and collect data for your robot anywhere you go. There are two key components to their recipe: view alignment, to reduce mismatch between human and robot camera views, and action alignment, to make sure human actions can be converted into robot actions. This makes it easier than ever to train robot policies and deploy them in previously-unseen environments. Modi Shi joins us to tell us the details. Watch Episode #96 of RoboPapers with Michael Cho and Jiafei Duan today! Abstract Human demonstrations offer rich environmental diversity and scale naturally, making them an appealing alternative to robot teleoperation. While this paradigm has advanced robot-arm manipulation, its potential for the more challenging, data-hungry problem of humanoid loco-manipulation remains largely unexplored. We present EgoHumanoid, the first framework to co-train a vision-language-action policy using abundant egocentric human demonstrations together with a limited amount of robot data, enabling humanoids to perform loco-manipulation across diverse real-world environments. To bridge the embodiment gap between humans and robots, including discrepancies in physical morphology and viewpoint, we introduce a systematic alignment pipeline spanning from hardware design to data processing. A portable system for scalable human data collection is developed, and we establish practical collection protocols to improve transferability. At the core of our human-to-humanoid alignment pipeline lies two key components. The view alignment reduces visual domain discrepancies caused by camera height and perspective variation. The action alignment maps human motions into a unified, kinematically feasible action space for humanoid control. Extensive real-world experiments demonstrate that incorporating robot-free egocentric data significantly outperforms robot-only baselines by 51\%, particularly in unseen environments. Our analysis further reveals which behaviors transfer effectively and the potential for scaling human data. Learn More Project page: https://opendrivelab.com/EgoHumanoid/ ArXiV: https://arxiv.org/abs/2602.10106 Github: https://github.com/OpenDriveLab/EgoHumanoid This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit robopapers.substack.com

  • August 5 · 49 min

    Ep#95: Action-to-Action Flow Matching

    Diffusion Policy was one of the big breakthroughs that has enabled an explosion in real-world robot learning. However, it’s always had a weakness, which is that it works by computing a final action trajectory from random noise, which leads to high latency when predicting a final action sequence. Instead, why not initialize the search based on previous actions? This allows for incredibly fast policy inference and in many cases improved generalization, generating high-quality predictions with sub-ms latency. Jindou Jia and Jianfei Yang join us to explain. Learn more on Episode 95 of RoboPapers, with Michael Cho and Chris Paxton! Abstract Diffusion-based policies have recently achieved remarkable success in robotics by formulating action prediction as a conditional denoising process. However, the standard practice of sampling from random Gaussian noise often requires multiple iterative steps to produce clean actions, leading to high inference latency that incurs a major bottleneck for real-time control. In this paper, we challenge the necessity of uninformed noise sampling and propose Action-to-Action flow matching (A2A), a novel policy paradigm that shifts from random sampling to initialization informed by the previous action. Unlike existing methods that treat proprioceptive action feedback as static conditions, A2A leverages historical proprioceptive sequences, embedding them into a high-dimensional latent space as the starting point for action generation. This design bypasses costly iterative denoising while effectively capturing the robot's physical dynamics and temporal continuity. Extensive experiments demonstrate that A2A exhibits high training efficiency, fast inference speed, and improved generalization. Notably, A2A enables high-quality action generation in as few as a single inference step (0.56 ms latency), and exhibits superior robustness to visual perturbations and enhanced generalization to unseen configurations. Lastly, we also extend A2A to video generation, demonstrating its broader versatility in temporal modeling. Learn More Project Page: https://jingliangli.com/A2A_Flow_Matching/ ArXiV: https://arxiv.org/abs/2602.07322 Github: https://github.com/JIAjindou/A2A_Flow_Matching This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit robopapers.substack.com

  • August 3 · 1 hr 16 min

    Ep#94: Learning a Thousand Tasks in a Day

    For general-purpose robots to be useful, we must be able to teach them new tasks quickly and repurpose them to new roles. But most techniques for teaching robots — even from human demonstrations — take a great deal of new data. But it turns out that it is possible, in part through decomposing tasks into component subtasks, that it’s possible to learn a robot skills quickly. Kamil Dreczkowski, Pietro Vitiello and Edward Johns join us to talk about their extensive study on how to teach robots new skills efficiently, while also generalizing to novel object instances, using a combination of task decomposition and retrieval, work that was published in Science Robotics. Watch episode #94 of RoboPapers now, with Michael Cho and Jiafei Duan, to learn more! Abstract Humans are remarkably efficient at learning tasks from demonstrations, but today's imitation learning methods for robot manipulation often require hundreds or thousands of demonstrations per task. We investigate two fundamental priors for improving learning efficiency: decomposing manipulation trajectories into sequential alignment and interaction phases, and retrieval-based generalisation. Through 3,450 real-world rollouts, we systematically study this decomposition. We compare different design choices for the alignment and interaction phases, and examine generalisation and scaling trends relative to today's dominant paradigm of behavioural cloning with a single-phase monolithic policy. In the few-demonstrations-per-task regime (<10 demonstrations), decomposition achieves an order of magnitude improvement in data efficiency over single-phase learning, with retrieval consistently outperforming behavioural cloning for both alignment and interaction. Building on these insights, we develop Multi-Task Trajectory Transfer (MT3), an imitation learning method based on decomposition and retrieval. MT3 learns everyday manipulation tasks from as little as a single demonstration each, whilst also generalising to novel object instances. This efficiency enables us to teach a robot 1,000 distinct everyday tasks in under 24 hours of human demonstrator time. Through 2,200 additional real-world rollouts, we reveal MT3's capabilities and limitations across different task families. Videos of our experiments can be found on at this https URL. Learn More Project Page: https://www.robot-learning.uk/learning-1000-tasks ArXiV: https://arxiv.org/abs/2511.10110 Science Paper: https://www.science.org/doi/abs/10.1126/scirobotics.adv7594 Github: https://github.com/kamil-dreczkowski/learning_thousand_tasks This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit robopapers.substack.com

  • July 29 · 1 hr

    Ep#93: CHORUS: Decentralized Multi-Embodiment Collaboration with One VLA Policy

    Many tasks cannot be completed by one robot alone. But coordinating multiple robots performing complex manipulation tasks is very difficult. Many solutions rely on complicated centralized control, which tends towards bespoke methods that do not scale well with team size. Enter CHORUS by Ria Doshi, Jeanette Bohg, and team. They train a single VLA to control multiple, diverse robots, given only local observations and identifying information. This allows robots to collaborate on tasks like using a tape measure, handing over a book, or lifting a laundry basket. To learn more, watch Episode #93 of Robopapers now, with Michael Cho, Jiafei Duan, and Chris Paxton! Abstract Multi-robot collaboration allows robots to efficiently take on a wide range of tasks, from moving a couch through a doorway to assembling structures on a construction site. However, achieving such coordination in mobile multi-robot settings remains challenging: centralized methods conditioned on the combined observations of a team scale poorly with team size, and decentralized methods that train one policy per robot often require explicit alignment procedures or information sharing at inference time to overcome partial observability. Our key insight is that the visuomotor priors of pretrained vision-language-action (VLA) models should enable reactive, decentralized collaboration from each robot's local observations alone, without these inference-time assumptions. We propose CHORUS, a framework that adapts a single VLA backbone to control diverse, multi-robot teams. At inference time, each robot runs an independent copy of CHORUS, conditioned only on its own observations and a robot-identifying prompt. In real-world experiments including mobile tape measurement, library book handovers, and laundry basket lifting, CHORUS achieves a 64% point improvement over decentralized, from-scratch models, improves reactivity to teammate behavior by 40% points, and outperforms centralized baselines. Together, these results show that a shared VLA backbone is capable of achieving decentralized multi-robot collaboration, without per-robot policies or inter-robot communication at inference. Learn More Project Page: https://chorus-model.github.io/ ArXiV: https://arxiv.org/abs/2606.12352 This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit robopapers.substack.com

Showing 1–20 of 20 episodes