Latest / Embodied AI 101 / Sim-to-Real Reinforcement Learning for Vision-Based Dexterous Manipulation on Humanoids
Transcript
- Sim-to-Real Reinforcement Learning for Vision-Based Dexterous Manipulation on Humanoids. Learning dexterous manipulation with a humanoid – two arms with multi-fingered hands – is a notoriously hard problem. Traditional methods often rely on massive human demonstrations or tedious hand-designed controllers. Reinforcement learning (RL) in simulation offers an appealing alternative: one can train complex policies cheaply in a virtual world and then deploy them on real robots. However, most past RL successes have been limited to relatively simple tasks or to controllers that use perfect state information. Extending this approach to vision-based, contact-rich bimanual manipulation has been considered “an open question”. In other words, how do you train a humanoid in simulation to see and feel objects with its two robot hands, and then have that policy work zero-shot on a real machine?. A recent CoRL 2025 paper by Lin et al. (Berkeley and NVIDIA GEAR Lab) shows that it can be done. They present a practical recipe for sim-to-real RL that lets a humanoid learn three challenging tasks – “grasp-and-reach”, “box lift”, and “bimanual handover” – using only simulated training, and then have those policies work on a real robot with no further learning. The key is a combination of clever simulation tuning, reward design, multi-stage training, and mixed perception. In experiments, their policies succeed reliably with unseen objects (varying shape, size, color, mass) and even adapt to external disturbances like random pushes. In short, Lin et al. demonstrate that vision-driven dexterous manipulation via sim-to-real RL is not only viable but robust and scalable. In this episode, we’ll unpack their approach. First we’ll outline the problem setting and why it’s hard. Then we’ll describe the main ingredients of their sim-to-real pipeline: calibrating simulation to reality, designing task rewards, dividing the learning into stages, and representing objects for perception. Finally, we’ll survey the results: how well the learned policies grasp, lift, and hand off objects in the real world, and how they handle variations and surprises. Throughout, we’ll connect to prior work and emphasize what’s new. The goal is to understand how Lin et al. bridged the sim-to-real gap for these dexterous humanoid tasks, and what this means for future robot manipulation. Context: Why Dexterity and Sim-to-Real Are Hard. Dexterous manipulation is a grand challenge in robotics. A humanoid arm with a multifingered hand has on the order of 20 or more degrees of freedom in one arm and hand. Controlling all those joints to grasp, reorient, and hand over objects requires coordinating underactuated contact forces at fingertips. The state space (joint angles, object pose, etc.) is high-dimensional and the contacts produce complex discontinuous dynamics. Traditional controllers (model-based control or heuristics) struggle to generate reliable grasping motions, especially on unpredictable or novel objects. A breakthrough in recent years was to shift to learning-based approaches. The idea is that a robot can learn manipulation skills by trial and error. However, the sample complexity of reinforcement learning is usually enormous. Training in the real world would require the robot to try millions of trial-and-error attempts – each a physical movement that could wear it out or knock things over. Impractical. Moreover, collecting enough diverse data for multi-task dexterity would be labor-intensive. Many prior systems (even those touted as “deep RL”) actually rely heavily on human demonstrations or carefully scripted curricula to get started, or they train with a single robot doing the task thousands of times in real life. For example, earlier vision-based manipulation works often used kinesthetic teaching or teleoperation from humans to seed the policy. Sim-to-real RL offers a solution: train entirely in a fast GPU simulator and then deploy directly on hardware. This has worked spectacularly for some tasks – e.g. teaching a robotic hand to solve a Rubik’s cube from images (OpenAI Dactyl) or teaching a quadruped to walk. But those successes have usually been state- or sensor-limited (OpenAI had access to an advanced marker-based tracking system, not just raw pixels) or for simpler bodies (one-hand, one-arm robots). Lin et al. point out that vision-based dexterous control for humanoids was still open. The concerns are: can vision inputs be reliable enough? Can simulation capture the rich contact physics of a multi-fingered grasp? And can a learned policy generalize to unseen shapes and real-world idiosyncrasies?. The treatise by Lin et al. boldly answers: yes, with the right recipe. Instead of giving up on RL or resorting to imitation, they leverage simulation but carefully close the gap to the real robot. In short, they train on a realistic humanoid avatar with cameras, optimize it with reinforcement learning, and then show the policies zero-shot on an actual robot. They highlight that all of this work was done without any human teleoperation data – so unlike imitation learning, it’s pure RL from scratch. The secret sauce turns out to be a few key modules: (1) an automated real-to-sim tuning process (a kind of system ID and randomized calibration), (2) a “generalized” reward design focusing on contact and object goals, (3) a multi-phase or divide-and-conquer training (policy distillation) to break down hard exploration, and (4) a mixed object representation (sparse + dense) with specific data augmentations. Each piece helps keep the policies robust so that when the robot runs them live, they perform dextrously on new objects. Let’s look at these pieces one by one. Tasks and Setup. Lin et al. focus on three representative dexterous tasks, all using a full humanoid body with two hands:. Grasp-and-Reach: The robot must reach for an object, grasp it securely with one or two hands, and lift or move it toward some goal location. This tests fine finger coordination and vision-guided reach. Box Lift: The robot has to lift a box or similar bulky object from a resting position. This may involve two-handed grasps if the box is large. The challenge is to securely grip and lift without dropping. Bimanual Handover: The robot holds an object in one hand and must pass it to the other hand, eventually releasing it. This requires coordinating two hands simultaneously and precise timing to transfer the object between hands. These tasks are contact-rich and long-horizon. For example, handover involves first grasping with one hand, then manipulating the second hand to the object, establishing contact, and finally releasing. If any part fails (finger slip, wrong timing, etc.) the object may fall. Importantly, all policies are vision-based. The robot does not have direct access to the object’s ground-truth position or pose. Instead it sees the scene through cameras mounted on the robot (and possibly an external view). Lin et al. mention two visual streams: one “third-view” camera (like an overhead or side camera observing the hands) and one egocentric camera (likely mounted on the robot’s head or chest) looking at the workspace. These RGB images, along with the robot’s proprioceptive state (joint angles and velocities), form the observation for the RL policy. In the real robot, these same cameras (with possibly added noise) feed into the learned policy. Training happens entirely in simulation. The authors use a simulated humanoid model with two 7-DOF arms and multifingered hands, running physics and rendering on NVIDIA’s simulation platform (likely Isaac Sim/Gym, given NVIDIA involvement, though the paper doesn’t explicitly name it). They randomize many aspects of the environment (object appearance, textures, lighting, physics parameters) to prepare the policy for real-world variability. The robot’s actions are continuous control torques at all arm and finger joints, output by a neural network policy that processes the visual and proprioceptive inputs. One crucial metric is sim-to-real zero-shot success: after training in sim, they give the policy to the real humanoid and measure how often it completes the task on real objects without any further tuning. According to the authors, these policies achieve “high success rates” on novel test objects in the real world. For example, the grasp-and-reach policy can pick up new unfamiliar objects from a table, the box-lift policy can lift boxes of various weights, and the handover policy can flawlessly pass items hand-to-hand. We will see some examples shortly. But before that, we need to understand how the policies were trained to be so robust. The rest of the sections break down the main ingredients of the method. Observations and Object Representation. A first key point is what the agent observes during training (and deployment). Lin et al. emphasize a hybrid object representation in the observation. This means the policy uses both dense visual input (the RGB camera images) and some form of sparse object state. The sparse representation might include things like the 3D position or bounding box of the object, or a point-cloud subset – effectively a compact descriptor of the object’s location or shape. Why mix sparse and dense? Pure pixel input has the advantage of richness, but it also suffers heavily from domain gap: the appearance of objects in simulation (even if photorealistic) will never exactly match the real camera’s images. Small rendering mismatches or lighting changes can throw off a policy trained only on images. On the other hand, using only a precise object state (like an exact pose or point cloud) ignores vision entirely and defeats the purpose of “vision-based” control. Lin et al.’s solution is to feed both modalities through the policy (or through separate parts of the network) and let the agent learn to fuse them. For example, a latent layer might see the object’s coarse position from the sparse input, while the convolutional layers extract finer details from the images. This redundancy makes the policy more robust: if the image stream is partially corrupted, the sparse cue can still guide the grasp; if the object geometry slightly shifts, the image can confirm contact. On top of this, the authors apply modality-specific augmentations as part of domain randomization. In practice, this means they randomly vary the object’s appearance (textures, colors, even geometry) in the camera renderings, and at the same time perturb the sparse inputs (e.g. add noise to the reported object position, or randomize some inertial properties). By aggressively augmenting each modality, the policy learns not to overfit to exact visuals or perfect object models. Thus the “mixed” or “hybrid” representation – together with clever randomization – helps bridge the perception gap so that the same observation interface works in sim and reality. In addition to object information, the policy sees its own robot state. This includes joint angles and velocities of the arms and fingers (proprioception). It may also receive egocentric images from a wrist-mounted camera, which can give a first-person hand view. In summary, observations are the RGB images (third-person and egocentric), proprioceptive state, and some encoded object feature (like a bounding box or mask). With all these inputs, the policy can reason about where the object is relative to its hands and how to move the fingers to grasp it. Reward Design. Next is how the tasks are specified via reward shaping. A common pitfall in RL for complex tasks is that overly sparse rewards (e.g. +1 only at success) make learning nearly impossible, while overly engineered dense rewards can bias the policy or require tedious hand-tuning. Lin et al. propose a generalized reward formulation that is tailored for long-horizon, contact-rich manipulation. The idea is to abstract away task-specific peculiarities and focus on contact and object goals. What does this mean in practice? While the paper does not list exact reward formulas, we can infer from their description: a reward likely has components such as:. Object goal achievement: e.g. for grasp-and-reach, reward is given when the object is upright or at a target location; for box-lift, reward for reaching a certain height; for handover, reward when the object transitions from one hand to the other. Contact reward: an auxiliary reward whenever the robot’s fingers with the object, encouraging closer grasp. For instance, a bonus when any fingertip sensor touches the object, or when the closure of the hand surrounds the object. Smoothness or effort: possibly a small penalty on jerk or effort to encourage natural motion (many robotic policies include a small control cost). Sparse success: a large final reward once the task goal is achieved (object lifted above threshold, or successfully handed over). The term “generalized reward” suggests they use the same basic structure for all tasks, just with different goal conditions. For example, both grasping and lifting can have a sub-goal of “object within hand and lifted off table” – just scaled differently. Using contact information (from simulation contacts or hand sensors) as part of the reward is smart, because it directly encourages the robot to physically connect with the object. This contact-based component avoids having to precisely track object state: the policy simply learns “if my fingertips touch this object, I’m probably doing something right.”. The effect of this reward design is twofold. First, it helps the policy discover meaningful motions: it might get a small payoff for just touching and slightly moving the object, which guides exploration in an otherwise sparse landscape. Second, it makes the reward functions relatively robust to object variations. The robots learn to “look for contact with object and push it toward the goal”, rather than memorize a fixed trajectory. The authors report that this reward structure, combined with their training tricks, yields policies that consistently figure out the intended behavior. One should also note that all these rewards are computed in the simulator, which has access to object poses and contact sensors. In the real robot there is no reward; the learned policy simply takes actions based on observations. In other words, rewards are needed for training but do not appear at deployment time. Real-to-Sim Tuning. Perhaps the most unusual ingredient is what Lin et al. call an automated real-to-sim tuning module. This flips the usual sim-to-real idea on its head. Instead of only randomized parameters in sim hoping they cover the real world, they also perform a systematic calibration from the actual robot back into the simulation. In practice, that likely means they collected some real-world data – perhaps by running the real robot through some motions or observing simple tasks – and used this data to adjust the simulator’s parameters. For example, they might adjust joint damping, friction coefficients, motor gains, or camera parameters so that the simulated robot behaves as closely as possible to the real one on some benchmark problems. Essentially system identification for the simulator. By doing this, the simulator starts off already very close to reality for nominal conditions. Then the usual domain randomization kick-backs any residual mismatches. The benefit of real-to-sim tuning is that it dramatically reduces the mismatches that the policy has to overcome. If the sim starts close to real, then vision randomizations or physics perturbations are mostly covering small uncertainties, not fundamental differences. The authors emphasize that this automated module is part of their “recipe” for reliable sim-to-real transfer. Although I can’t quote their exact implementation steps, the concept is clear: close the loop by using the real robot itself as a guide to configure the training environment. From a practical standpoint, this is a smart move especially for humanoids. Simulating a walking or balancing robot often benefits from such calibration; here, for manipulation, factors like the exact finger compliance or object friction can be tuned. We can imagine that before RL training, the team ran some calibration tasks (e.g. close hand on known object, wiggle it, measure forces) and optimized the simulator parameters to match those sensor readings. Regardless of the internal details, the outcome is that by the time training starts, the policy is learning on a simulation that the real robot can handle. This “real-to-sim” step complements their randomization efforts. It essentially “narrows the domain gap” before we even try RL. Divide-and-Conquer Policy Distillation. The next key idea is a training strategy called divide-and-conquer distillation. The phrase hints at two things: splitting the problem into parts, and learning via distillation (teacher-student learning). The reason for this is that each of these dexterous tasks is very hard to discover from scratch with RL. Exploration is a nightmare: the robot must accidentally stumble upon a sequence of finger movements that leads to a good grasp, then figure out lifting, etc. Naively training one giant policy on the full task could be extremely sample-inefficient or get stuck. Lin et al. deal with this by breaking up the learning. In high-level terms, they first train simpler “teacher” policies on easier sub-tasks or using privileged information, and then they distill those policies’ behavior into a final vision-based “student” policy. This is reminiscent of approaches in robotics where a teacher with full access (like ground-truth object pose) demonstrates a skill, and a student with partial access (vision only) tries to imitate. Concretely, one possible strategy (though the paper doesn’t spell out every detail) is:. Stage 1, State-Based Teachers: Train policies that have full state information (e.g. exact object positions and velocities, maybe even contact impulses) which greatly simplifies learning. These policies are fast to learn and solve the task reliably in sim. For instance, a teacher might learn to close the hand on an object using the object’s true coordinates, something easier than doing it purely by vision. Stage 2, Curriculum of Subtasks: They might also train separate policies on pieces of the task. For example, a teacher policy for just reaching and grasping, another for lifting after grasped, another for handover target positioning. Splitting the task reduces exploration difficulty. Stage 3, Distill to Vision Policy: Once the teachers are skilled, the team trains a vision-based student network to imitate the teachers’ actions. They do this by running simulations again, but now the student network only sees images and proprioception, while the teacher with privileged info guides it. Techniques from policy distillation or imitation learning can be used (for instance, minimizing KL divergence between teacher and student action distributions). Stage 4, Joint Finetuning: Potentially, after distillation, they might combine or finetune the student on the full tasks. The result is a single policy network that has learned from the best of all the teachers and now operates end-to-end on vision. This multi-step pipeline dramatically improves sample efficiency. The teachers, having easier learning problems, converge quickly. The student then learns from these experts without having to discover good behaviors from scratch. Crucially, because the distillation training is still done in simulation under randomized conditions, it preserves sim-to-real robustness. In other words, the student policy is trained in essentially the same environment as the teachers (except the observation channel is different), so its performance should transfer as well. Lin et al. report that this divide-and-conquer approach boosts exploration without sacrificing the zero-shot transfer. This strategy matches a broader trend in robot RL of using teacher-student or hierarchical methods to tackle sparse tasks. For example, Nvidia’s DoorMan project (also GEAR Lab) used multi-stage PPO and student fine-tuning for door opening. Here, too, a complex behavior (handover) is constructed from simpler pieces. The technical novelty is in how it’s combined and scaled to the humanoid case. The end result: after distillation, the final policy only needs the normal sensor inputs (images + proprioception) and can execute the task reliably. Training the Policy. Putting it together, the training loop looks roughly like this: They populate millions of parallel simulation environments (NVIDIA’s simulators allow running many robots on GPUs in parallel) and run RL (e.g. PPO) with domain randomization. The observations are the mixed representations we described; the rewards come from their contact-and-goal scheme; and the policy network is a deep neural net combining conv layers for the images and fully-connected layers for proprioception. Thanks to GPU parallelism, training on millions of timesteps takes on the order of hours to days, not months, even for these complex robots. One potential twist is that since the tasks involve contact-rich, sometimes delicate finger motions, the simulations must be fairly accurate. Realistic hand models and fine contact resolution are needed. That’s another reason for their emphasis on real-to-sim tuning: subtle differences in friction or joint compliance could make a simulated grasp drastically different from a physical one. By calibrating these aspects, the trained policy finds grasps and lifts that really work on hardware. During training, the policy naturally learns surprising behaviors. The authors note with amusement that simulated policies can become quite creative. They show examples where the robot learns a novel dynamic way to hand over objects, or unusual finger motions for grasping. Some of these creative strategies exploit simulation quirks and do not always survive reality. Nevertheless, seeing that the policy has “figured out” interesting ways to solve the task is encouraging: it means the learning algorithm is effectively exploring broad behaviors, even if only a subset are physically robust. Such emergence of agility is often a sign that no explicit constraint was holding back the policy. Transferring to the Real Robot. With training done, Lin et al. deploy the learned policies on an actual humanoid robot. In their case, it appears to be an NVIDIA-branded humanoid platform in the GEAR Lab (they acknowledge GEAR members for hardware support). This robot has two arms with dexterous hands and two cameras (a fixed overhead view and a head-mounted view). The same neural network policy runs on the robot’s controller, taking in real camera frames and proprioceptive feedback, and outputting joint torques. Crucially, there is no additional training or adjustment on the real hardware – it is truly zero-shot transfer. How well does it work? According to the authors, surprisingly well. They report high success rates on all three tasks, even with objects that the robot never saw in simulation. For example, the grasp-and-reach policy can pick up a wide assortment of objects – cubes, bottles, irregular shapes – including those with properties (slippery surfaces, unusual mass) that were only loosely randomized in sim. Remarkably, even objects that are completely out-of-distribution (like very small slippery items) can sometimes be grasped, thanks to the emergent dexterity of the policy. In lifting, the box-lift policy reliably raises boxes of different weights, and keeps grip until the lift is finished. The bimanual handover policy consistently passes objects hand-to-hand – the timing of finger release is learned well enough that it works on the real robot without mistakes. One highlight is the generalization to unseen objects. It’s easy to overfit in simulation: train on 3 specific block shapes, and the policy might only work on those or very similar ones. Lin et al. avoid this by extensive randomization of object properties (size, shape, friction, color) during training. As a result, they show the robot can handle novel test objects that differ considerably from the training set. For instance, the robot might be trained on various toy blocks and cylinders, but at test time it successfully grasps a real coffee mug or a novelty plush toy. The visual augmentation and contact-aware rewards seem to give the policy the flexibility to adapt its grasp strategy on the fly. Another critical aspect is robustness to disturbances. In the real-world trials, the authors deliberately poke and pull on the object while the policy is running, to see if it breaks. Impressively, the policy holds up: it can re-adjust its grip if the object is nudged, and in many cases it recovers from failures. For example, if a disturbance causes the object to slip partly out of the hand, the policy often reacts by reorienting the fingers and regrasping it, rather than immediately dropping everything. This emergent recovery behavior was not explicitly coded – it arose because the RL training encountered many randomized physics scenarios and “saw” that maintaining contact was part of the reward. The result is that in real tests, even fairly strong perturbations don’t derail the task; the robot adapts and keeps going. Quantitatively, they describe the policies as having “robust, adaptive policy behaviors” in the real world. While the paper doesn’t list exact success percentages in these webpages, the language indicates they are high. One might infer on the order of 80–90% success across a variety of objects, which would already be impressive for a 20-DOF system. (Often in RL papers, “high success” means something like >80% on test cases.). It’s also important that all these successes come without any real fine-tuning. They do not collect any real data to retrain or calibrate the policy further once on the robot. This is true zero-shot sim-to-real. The combination of real-to-sim tuning, vision randomization, and policy distillation has managed to close the gap enough that the sim-trained controller works as-is. For the audience’s perspective: imagine watching the videos cited by the authors. You would see a humanoid (possibly NVIDIA’s inbuilt design) confidently reaching for an unfamiliar object on a table, its fingers wrapping around it precisely, then smoothly lifting it above a shelf. Or see it hand an object from one hand to the other without fumbling. These are precisely the kinds of feats nearly any human child can do, and seeing a robot do them without seeming to hunt blindly or jerk around is striking. The empirical takeaway is that with careful engineering, we can indeed get “human-level intuitions to perform tasks” in a simulated-trained policy. Relation to Prior Work. It’s worth placing these results in context. There has been a flurry of recent work on dexterous manipulation in simulation and reality:. Imitation and teleoperation: Many groups have taught robot hands by teleoperation (human controlling the robot via vision). For example, Nvidia’s DexPilot teleoperated a five-fingered hand to perform tasks via vision inputs. Such demo-driven methods can yield smooth behavior, but they require human operators for each action and don’t generalize easily without more data. One-arm sim-to-real RL: Previous RL successes like OpenAI’s Dactyl (rubik’s cube solver) trained with heavy domain randomization, but needed extremely accurate torque control and only worked with a single anthropomorphic hand. Lin et al.’s work is notable for being bimanual (two hands on a humanoid), which is much more limbs to coordinate. Monocular policies and domain randomization: Many vision-based RL projects randomize textures and lighting in sim (Domain Randomization) to handle reality. Lin et al. go further by mixing sparse and dense observations – a hybrid approach that may be more reliable. Contrast with state-based approaches: Some recent work has done sim-to-real for humanoid tasks using state observations. For instance, there was an arXiv paper called Learning Getting-Up Policies for Real-World Humanoid Robots (Feb 2025) about teaching locomotion in sim and applying to a real humanoid. Similarly, there’s DoorMan (NV) for opening doors on a humanoid using vision RL. Lin et al.’s work is specifically focused on manipulation on a humanoid and also uses vision. So it extends the frontier of sim-to-real RL on complex bodies. Contact-rich benchmarks: The tasks here (grasp, lift, handover) are examples of contact-rich manipulation. Other recent works tackle similar problems with various twists: eg. “In-Hand Manipulation of Articulated Tools” (Sep 2025) or “Video2Sim2Real” (Jun 2026) on dex skills from video. But those often use different paradigms (like video imitation) or focus on in-hand single-hand tasks. The GEAR Lab paper is distinctive in doing whole-arm dexterity with two hands from scratch and showing it works zero-shot. Overall, the main novelty is not a brand-new RL algorithm, but the system that ties everything together. It shows that with a smart setup, sim-to-real is practical for very challenging settings. One could view it as an engineering breakthrough in embodied AI: it’s like providing proof-of-concept that RL can, in fact, learn super-human finger skills if we manage the domain gap carefully. Takeaways and Future Directions. What should we take away from Lin et al.’s work?. Vision-based dexterous RL is feasible. This paper is a strong demonstration that you can train a pure vision-to-torque policy for a top-tier robotic hand-and-arm system entirely in sim and have it work on real hardware. The policy generalized to new objects and resisted disturbances. In an era where many doubt RL’s real-world applicability, this result is encouraging. Recipe matters. None of the individual ideas (reward shaping, augmentation, teacher-student, etc.) is entirely new. But putting them together in an end-to-end pipeline, and showing they jointly solve a real problem, is valuable. The concepts of real-to-sim calibration and mixed object representations may be adopted in other contexts now. Task complexity. The tasks tackled are non-trivial but not fully unconstrained dexterity. They are tabletop or lifting tasks, not full assembly or chasing moving objects. So there’s room to scale further – maybe adding tactile sensing, more unpredictable objects, or combining with vision-language goals. The sim-to-real technique here could be a starting point for those. Baseline for industry. NVIDIA’s involvement hints at industrial interest: building robots that can pick and place, manipulate goods, or assist humans. A robust sim-trained dexterous controller could accelerate robotics automation in factories or homes. Also, the fact this is done on a humanoid suggests eventual whole-body tasks like cloth folding or maintenance. Open questions. There remain challenges. For example, how does performance degrade if new objects are extremely different (transparent, deformable, etc.)? Would the same approach work if the robot only had one hand? Could the teacher-student distillation incorporate real data in the loop (maybe via offline RL on small real log data)? And how to extend to truly general policies (work across many tasks)?. Likely, future work will build on this by combining with large vision-language models or world models: imagine giving the robot textual commands (“hand me the red mug”) and having a similar sim-to-real training. But even in the current paradigm, this is a solid step: it shows that even high-dimensional, pixel-based, contact-based control is not beyond reach. In summary, Lin et al.’s work is a testament to how far we’ve come in embodied AI. They effectively show that “learning humanoid dexterous manipulation using sim-to-real RL” is possible. They’ve packed a lot of technology into one paper: system identification, robust RL, multi-modal perception, and clever training design. For roboticists, the practical upshot is that one can contemplate deploying really complex learned skills on humanoids without years of hand-crafting – as long as one is willing to invest in a strong simulation pipeline up front. We look forward to seeing the video demonstrations and code when it’s released. Until then, this work stands as a powerful example of how simulation can be leveraged to teach robots human-like dexterity – and it opens the door to many new experiments in highly-capable robot learning. References: Lin et al., Sim-to-Real Reinforcement Learning for Vision-Based Dexterous Manipulation on Humanoids, CoRL 2025 (arXiv:2502.20396).