Latest / Embodied AI 101 / Learning Unified Force and Position Control for Legged Loco-Manipulation
Transcript
- Learning Unified Force and Position Control for Legged Loco-Manipulation. Legged robots are naturally motion platforms – they walk, run, and jump – but in many real-world tasks they must also manipulate the world through contact. For example, a quadruped with an arm might press a button, open a drawer, or wipe a surface. These loco-manipulation tasks involve complex contact interactions with the environment. In such situations, simply commanding joint positions or trajectories is often insufficient. The robot needs to regulate the forces it exerts and reacts to, just as much as its positions. Classic robotics control has long recognized this as a hybrid force/position control problem – controlling positions along some axes while controlling force along others. However, most modern learning-based controllers for legged robots have focused only on position control, ignoring forces or relegating them to fixed compliance. This works well for unconstrained locomotion or free-space manipulation, but fails on contact-rich tasks where force continually matters. Recent advances in reinforcement learning (RL) have produced agile legged locomotion and even whole-body manipulation policies (e.g. combining locomotion and arm movements). For instance, deep RL has taught quadrupeds to sprint, jump over obstacles, and track moving goals, and humanoids to perform parkour. These same techniques can integrate locomotion with manipulation — enabling a walking robot to reach, grasp, push, or pull objects. But in almost all prior work, the policies take position or velocity commands as inputs, and the outputs simply drive joint targets or torques to follow those commands. The implicit assumption is that if you command the right position trajectory at the end effector or base, the forces will work out. In practice, this means the robot may slam into walls, or lose grip on an object when contact occurs. Meanwhile, the field of force control – including hybrid position/force, impedance, and admittance control – has shown how to systematically handle these interactions on robot arms and mobile manipulators. Traditional whole-body controllers can distribute forces and adjust compliance, often using force-torque sensors or careful dynamics models. But these model-based methods require complete understanding of contacts and can be brittle on high-DoF systems like legged robots. A recent preprint by Zhi et al. (2025) takes an intriguing new approach: train a single reinforcement learning policy that unifies force and position control for legged robots, and does so without any force sensors. In essence, their policy can accept an end-effector position command and a force command at the same time. It then learns internally to estimate the contact forces and adjust the robot’s posture so that the commanded force is applied while tracking the commanded position. The policy is trained in simulation with randomized force inputs and disturbances, and can be deployed on both a quadruped robot (Unitree B2 with a Z1 arm) and a humanoid (Unitree G1), controlling both locomotion and arm end-effector. In parallel and closely related work, Portela et al. (2024) demonstrated learning force control on a legged manipulator via RL. They trained a quadruped+arm policy that could take a force command for the end-effector (in addition to a base velocity), enabling things like gravity compensation (holding heavy loads) and whole-body impedance control. Their user could teleoperate the manipulator, commanding forces through a joystick, and the robot would automatically coordinate its legs to help apply those forces. Crucially, Portela’s policy also estimated contact forces from joint torques and motions, doing implicit force sensing without a physical sensor. They reported tracking errors around 5–10 N on forces up to 70 N. Building on these ideas, Zhi et al. push the envelope further by truly jointly learning both force and position control modes in one policy. They show this unified approach enables a wide spectrum of behaviors: pure position tracking, pure force application (e.g. holding a payload at constant force), force tracking (comply with external pushes), and classical impedance control (position tracking with spring-damper response to forces). The policy uses a “force estimator” network to infer external and reactive forces from proprioceptive history. Remarkably, this lets them inject force commands into a robot with no force-torque sensor, and still control compliance and contact forces reliably. In addition to pure control, they leverage this capability to improve imitation learning. Most robotic imitation datasets today record robot trajectories (positions) and maybe images, but lack any contact information. Zhi et al. use their force-aware policy to collect new demonstration data: teleop the robot while explicitly commanding forces, record the policy’s inferred force estimates along with states and images, and then train a high-level diffusion policy that learns from images+states+forces. The result is a diffusion-based visuomotor policy that is force-aware. In tests on real tasks like wiping a blackboard or pressing an occluded switch, the force-aware policy drastically outperforms a vision-only policy, improving success rates by ~39.5%. Let's unpack how this new unified force-position framework works, why it matters, and what it can do in practice. Why force matters in contact-rich tasks. Imagine a quadrupedal robot reaching out with its arm to wipe ink off a blackboard. If it only follows a strict position trajectory, it might lose contact if the board is slightly bowed away, or crash too hard and stall. A human would modulate force – “press lightly but firmly while sweeping.” This kind of behavior requires the robot to know (or sense) how much force it’s applying, and adjust the commanded position accordingly. In hybrid control theory, one would treat the task directions constrained by contact differently from free directions: along the surface do one thing, perpendicular to it keep a constant force (for example). Traditional control approaches do exactly this with impedance or hybrid position/force controllers, often relying on force-torque sensors at the wrist or sophisticated whole-body dynamics. For a legged robot, adding accurate force sensors on its arm is expensive or bulky. Moreover, computing whole-body contact forces and planning a consistent strategy online is complex. Data-driven methods until now have largely skipped the force part. Reinforcement learning can find robust strategies, but if you never give it a force command (or provide force observations), it can’t be told “apply exactly 20 N of force here.” Nor can it easily learn compliance just from seeing positions. In fact, Zhi et al. point out that many high-profile robot learning pipelines and datasets (PerAct, Diffusion Policy, RT-2, OCTOP, etc.) focus solely on reproducing end-effector trajectories, discarding any force information. Trajectories in these datasets miss an important piece of the puzzle: how hard the robot is pushing. Without that, even a perfect position-tracking policy might fail on a simple task like wiping, because it doesn’t know how to react when contact kicks back. The authors illustrate this vividly: they tried training pure position-based policies (like a standard imitation pipeline) on basic contact tasks and found them wanting. For a “wipe blackboard” task, a trajectory-only policy would often “lose contact intermittently or press excessively”. The robot might not press at all sometimes, leaving ink uncleaned. Or it might slam so hard that the arm strains. On a spring-loaded drawer that needs a firm press to latch open, a vision-only policy could not reliably sense when it was in contact. One cabinet-open task has only a 3 mm push-to-open stroke – essentially a spring – and vision can’t see those last millimeters of displacement. The paper reports that in such cases a vision-only imitation policy dropped to 30% success, whereas their force-aware policy jumped to 76%. That dropoff (0.30 vs 0.76) highlights how crucial contact awareness is. In short, position commands alone are not enough for contact-rich loco-manipulation. We need a way for the policy to handle forces: to know when and how much it is pushing, and to adjust its motion accordingly. This is exactly what hybrid force-position control is about, but we want it embedded in a learning policy rather than hand-designing it. A unified force–position policy. The core of Zhi et al.’s approach is a new policy architecture and training setup. The input to the policy includes:. A desired end-effector position $\mathbf{x}^\text{cmd}$ (in the robot’s body frame). A desired end-effector force vector $\mathbf{F}^\text{cmd}$. A desired base velocity command $\mathbf{v}\text{base}^\text{cmd}$ and optionally a base force command $\mathbf{F}\text{base}^\text{cmd}$ (for locomotion). The robot’s proprioceptive state history (joint angles/velocities, base orientation/velocity, foot contact timing, etc.). The previous action command (for smoothness). The output is a set of joint position targets for a PD controller (i.e. the policy directly specifies joint angles, which are then enacted by the low-level controller). This single policy, when given different combinations of force and position commands, can enact many traditional control modes. To see why, the authors start from an impedance control viewpoint. A simple 1D impedance relation is $$ F = K (x - x^\text{des}) + D(\dot x - \dot x^\text{des}) + M(\ddot x - \ddot x^\text{des}) $$ where $K,D,M$ are stiffness, damping, inertia, $x^\text{des}$ is some desired trajectory, and $x$ is the actual position. For slow end-effector motions (or after settling), the inertia and velocities are low, so we approximate roughly $F \approx K(x - x^\text{des})$. Thus, if you command a position but encounter a force, the system equilibrates when $K(x - x^\text{des}) = F$. Rearranging, the effective target position to achieve a given force can be written $$ x_\text{target} = x^\text{cmd} + \frac{F^\text{ext} + (F^\text{cmd} - F^\text{react})}{K}. $$ Here $F^\text{ext}$ is any external force (disturbance) and $F^\text{react}$ is the environment’s reaction to $F^\text{cmd}$. Intuitively, if you command a force $F^\text{cmd}$ while pressing against a stiff object (so $F^\text{react}$ builds up), the target might return to the commanded position once equilibrium is reached. If an external push $F^\text{ext}$ lands on the end effector, the target position must shift by $F^\text{ext}/K$ so that the robot yields like a spring. By selecting $x^\text{cmd}$ and $F^\text{cmd}$, one can realize:. Pure position control: set $F^\text{cmd}=0$ and no $F^\text{ext}$, then $x_\text{target}=x^\text{cmd}$ just tracks the command. Force control: set a $\mathbf{F}^\text{cmd}\neq0$ along a contact direction. The robot will move toward $\mathbf{x}^\text{cmd}$ until its reaction force equals $\mathbf{F}^\text{cmd}$. After equilibrium, it has effectively held that contact force (compensating gravity, for example). Impedance control: set $F^\text{cmd}=0$ but let any $F^\text{ext}$ shift the target as $x_\text{target} = x^\text{cmd} + F^\text{ext}/K$. In other words, the robot follows $x^\text{cmd}$ but yields like a spring under external pushes. Hybrid control: combine both a position trajectory and a force direction perpendicular to the motion. The formula naturally splits into tangential vs normal components. The clever part is training the policy to implement all these behaviors. They do not hard-code impedance equations; instead, they simulate many different scenarios. During training, the policy sees randomized commands and disturbances: sometimes just position commands, sometimes only force commands, sometimes both, and always random external forces on the end effector or base. The training reward incentivizes the policy to make the real end-effector position and base velocity match the implicit targets given by those equations. Meanwhile, the policy includes a state estimator network that predicts the latent external force and other hidden state from the robot’s history of proprioception. Concretely, the policy network has three parts:. An encoder that processes a short history of observations (32 time-steps of past joint states, base velocities, commands, etc.) into a latent feature. A state estimator MLP that takes that latent feature and predicts the robot’s state: specifically the current end-effector position, base velocity, and the net contact force ${\bf F}$ (which is the sum of any external push and the reactive contact force). An actor network that takes the encoded feature (and optionally the estimated state) and outputs the next action (joint targets). The key is that during training, the estimator has a supervised loss: in simulation, we know the true external forces and ground-truth states, so the network learns to predict them. Once trained, the policy only sees proprioception and must infer forces indirectly. This is analogous to the "learning by cheating" approach in legged locomotion (where privileged simulation info trains a state estimator). Indeed, Portela et al. did something similar: they also trained a force-control RL policy that estimated the external force on the gripper from history. The new work extends that idea to hybrid control commands. The command inputs are merged into the observation vector: they include the base velocity command $\mathbf{v}\text{base}^\text{cmd}$, the end-effector position command $\mathbf{x}\text{ee}^\text{cmd}$, the end-effector force command $\mathbf{F}\text{ee}^\text{cmd}$, and (for locomotion) a base force command $\mathbf{F}\text{base}^\text{cmd}$. During use, these come from the high-level task specification or teleoperation stickers. For the quadruped, all four command types are active. For the humanoid, they used the dual-arm/humanoid differently – in the experiments here the humanoid didn’t have an arm, so they focused on locomotion forces, i.e. base commands. The action output of the policy is joint angle targets (10–12 DOF on the quad+arm, 29 DOF on the humanoid). These feed into standard PD controllers on the real robot. So essentially this is a “low-level” policy that maps high-level commands plus proprioception ➞ leg/arm joint trajectories. Training regime. They trained in NVIDIA Isaac Gym, with thousands of parallel simulated environments. An episode involves a sequence of juxtaposed commands: random target end-effector positions for a few seconds, random force commands, plus random external pushes applied at the end effector or base. In fact, they carefully schedule the forces: a force ramps up, holds steady, then ramps down, etc. This exposes the policy to many dynamic situations. They follow a two-stage curriculum. First, they train without any external forces (just position and base-velocity commands). This lets the policy learn basic locomotion and reaching. Second, they add the random force commands and disturbances. This staged approach stabilizes learning; if they had thrown strong random pushes from scratch, learning was difficult. The reward function at every step is mainly “how close is the end-effector position to $x_\text{target}$ and the base velocity to $v_\text{base}^\text{target}$ under the current force conditions.” There are also penalties for collisions, joint limits, torque usage, etc. Importantly, they also include an MSE term for the estimator: encouraging the network to correctly predict the external force and states. The range of simulated forces goes up to about ±60 N on each axis at the end effector and base (Table in Appendix C shows these bounds). In effect, the policy must learn to position the robot so that, when the commanded force and any disturbance are balanced by reaction, the steady-state is achieved. Training used PPO with 4096 parallel agents for fast convergence. Domain randomization (body mass, friction, motor strength) is applied to aid real-world transfer. They trained thousands of episodes; learning curves show some drop when forces are added but the policy eventually masters the objectives (Appendix shows reward vs iteration). Control behaviors and scenarios. Once trained, the one policy exhibits a rich set of behaviors, simply by changing its inputs. The authors categorize these as foundational hybrid control modes, which emerge naturally:. Position tracking (no force command): When $\mathbf{F}^\text{cmd}=0$ and no external disturbances, the policy performs like an ordinary position-controller: move the end-effector to the commanded position in space. Their simulation tests with 6000 random position trajectories (within the robot’s full rac workspace) confirm that the end-effector error stays mostly under 0.1 m across axes. Force control (no position target change): Set a nonzero force command on a contacting axis (for example, push upward with 25 N). The policy will move the end-effector in that direction until the contact force rises to 25 N. For instance, in one test a 2.5 kg dumbbell (which exerts ~25 N of gravity) is attached to the end effector. With a 25 N upward force command, the robot automatically lifts the dumbbell and holds it steady under gravity. Without that command, the arm sags under weight. No separate training was needed for this – it follows from the unified law in Appendix (case b) of their formulation. The result is classic force-control: the end effector effectively regulates to produce the commanded force against the payload. Force tracking (compliance mode): Set the commanded force $\mathbf{F}^\text{cmd}=0$. Now if someone or something exerts a force on the end-effector, the policy treats that exactly like a force-disturbance. The end-effector will move in the direction of the push (since $x_\text{target} = x_\text{cmd} + F^\text{ext}/K$). Crucially, when the external push stops, the end effector stays where it was pushed to; it does not spring back, because the zero-force command means the target position has shifted. This yields a purely compliant behavior: the robot can be “pushed around” and will hold the new pose. They demonstrate this: with a zero force command, any external push causes the end-effector to follow the force and settle in a new position once contact is removed. This is useful for kinesthetic teaching or when you want the robot to move with a person’s guidance. Impedance control: This is a combination: track a position command, but respond compliantly to disturbances. It’s like anchoring to $x^\text{cmd}$ with a virtual spring. To do this, one keeps $\mathbf{F}^\text{cmd}=0$ but has a nonzero $x^\text{cmd}$. Under an external disturbance, the end-effector deflects by an amount proportional to the force and stiffness. The policy does exactly this. In the experiments, they show human-robot tug-of-war or arm-wrestling scenarios: the further you deflect the arm from its target, the stronger the robot pushes back (like a spring-damper). Base force/impedance: Similarly, one can apply the same ideas to the robot’s base. If the robot is walking or standing, an external force on its base can be compensated by adjusting base velocity. In practice, if you push the robot on its body, the policy will interpret that as needing a velocity offset in the opposite direction (up to canceling out motion). They show for the Unitree G1 humanoid: when the policy counteracts an external push by commanding a base velocity that opposes the disturbance, the robot does what a human would – it halts and leans into the force to maintain balance. Remarkably, for the quadruped, an unexpected push (e.g. a kick) caused it to start walking forward under the force, even without any velocity command input. In other words, the robot automatically tries to keep moving at the commanded base velocity by recalculating how to walk, effectively turning a push into a locomotion command. This enables intuitive human-guiding by pushing the robot, which the authors liken to “BASE force tracking: robot responds compliantly to pushes on its base”. These behaviors cover the continuum from fully stiff control (position-only) to fully compliant force tracking. All arise from one policy, with mode controlled by the inputs. No separate training was done for each mode – the policy’s network learned to implement the underlying impedance law. Figure 5 in the paper (referenced from [25]) visually shows these emergent skills: holding a weight under a force command, base compliance to pushes, etc. Accuracy and robustness. A key question is: can the policy accurately estimate and regulate the forces without a sensor? The paper tests this in both simulation and reality. In sim, they generated random position commands with and without matching force commands, and measured positioning error. With no force, the end-effector stayed within ~0.1 m of target. When applying a force command that exactly countered the external push, tracking error remained similar (mostly <0.1 m). This shows the policy was indeed learning to do the “right thing” under those conditions. For real robots (Unitree B2-Z1), they tested force tracking by attaching a dynamometer to the gripper. They commanded forces from 0 to 60 N and measured actual force. The average error was on the order of 5–10 N. This matches the earlier work by Portela et al., who saw ~5–10 N mean error at up to 70 N. A few differences in axis (Y-direction was slightly worse) were noted, but overall the accuracy was deemed sufficient for the intended tasks. In practice, an error of 10 N on a 60 N target is tolerable for opening a drawer or pushing a cabinet door – the robot still knows roughly when it’s in contact and applying force. Importantly, the policy’s success in the imitation tasks (below) implies this force estimation is useful despite any sim-to-real gap. Force-aware imitation learning. Beyond direct control, one of the most intriguing contributions is using the learned force estimation in imitation learning. Modern approaches to robot imitation often involve collecting demonstrations (from humans or teleoperation) and training big models (like transformers or diffusion networks) to map observations to actions. However, existing datasets typically do not include ground-truth contact forces – robot demonstrations are recorded as state and image sequences only. This leaves an “invisible” force variable out of the learning. Zhi et al. create a force-aware data collection scheme. They teleoperate the robot using their learned policy as the low-level controller. Crucially, during teleop, both position and force commands can be issued by the human. For example, the operator might move the arm while also pressing it with a commanded force to maintain contact. As the policy runs, it produces an estimated force at the end effector (from its state estimator) at each time step. They record: robot joint states, base state, the commanded controls, and the estimated contact forces (plus RGB images from cameras on the end-effector and base). This becomes a dataset of “force-aware demonstrations”. With this, they train a diffusion-based policy (inspired by recent visuomotor diffusion policies) that takes as input: the robot state, the estimated force, and the camera images. The output is a sequence of commands (force and position commands) for the low-level policy. In other words, the diffusion model predicts what end-effector position and force to command, given the current situation. The low-level policy then enacts those. At test time, the overall control works like this:. Camera + robot state (joint angles, etc.) feed the diffusion policy. The diffusion model outputs an end-effector Δposition and Δforce to apply as commands. The learned low-level policy (trained earlier) executes those commands by moving the joints. This two-tier approach keeps the low-level policy fixed, and the high-level imitation policy learns task sequences. The key novel input is that estimated force channel: the diffusion model can see “oh, the robot is pushing with 10 N right now” and incorporate that into its decisions. This is in contrast to vision-only imitation, which only sees images and joint states. They tested this on four real-world tasks that require precise contact:. Wipe-blackboard: The robot maintains contact with the wall while sweeping horizontally to wipe marker. Success = erasing 90% of ink. Vision-only teleoperation struggled, because small loss of contact means ink stays. Force-aware policy maintains a steady pressure. Open-cabinet (push-to-open): Press on a springy cabinet door. The mechanism only triggers if ~min 3 mm push is reached. Vision alone can’t see the tiny motion, but the force estimator can sense when enough pressure is applied. Then the door springs open. Close-cabinet: The reverse of open (closing a spring-loaded door). Open-drawer-occlusion: Push open a drawer whose front becomes visually occluded as it opens. Again, vision fails once the drawer hides itself, but force does not. In all these tasks, force estimation gives the huge advantage. The results: over 50 trials per task, the force-aware policy achieved success rates far above the baseline (which is identical training but with no force signal in the imitation model). Specifically, the success rates (w/ force vs w/o force) were roughly:. Wipe-blackboard: 58% vs 22% (± some error). Open-cabinet: 70% vs 36%. Close-cabinet: 72% vs 30%. Open-drawer-occlusion: 76% vs 30%. Averaged, this is a ~39.5% absolute improvement. The narrative observation is that the vision-only policy often fails on these tasks by either not pressing enough or by losing track of contact. The force-aware version keeps the pressure consistent. In the occluded drawer example, the success for vision-only drops to near-random (0.3/1) because the moment the drawer front disappears, it no longer knows how to get to the latch. The force-aware policy senses the push even under occlusion and thus triggers success (0.76). These task results show that adding even a somewhat coarse estimate of contact force dramatically improves performance on real tasks where vision alone is insufficient. It validates the idea that having force in the loop matters in practice, not just in theory. Versatility on different robots. A nice aspect of this work is that the unified policy generalizes across embodiments. They tested the same learned policy (zero-shot, no retraining) on both the Unitree B2 quadruped with arm (13 DOF body + 6 DOF arm) and the Unitree G1 humanoid (29 DOF, dual arms but used as base version here). On the quadruped, the policy provided end-effector force control with arm and base velocity control for locomotion. On the humanoid, they treated the humanoid’s whole base as the moving “end-effector” in a sense: the commands were base velocity and base force. The same framework of adjusting a target velocity by F_ext/D applies. They show qualitative behaviors: if the humanoid is kicked, it will seek balance, and if commanded a nonzero base velocity while being pushed, it can incorporate that push. In fact, the video shows the G1 adjusting its posture (leaning) to counteract a steady shove, demonstrating impedance-like behavior. The text notes specifically that "when the compensated velocity equals and opposes the velocity command, the humanoid halts and leans its body to maintain balance". On the square B2, an experiment is "start walking when being kicked even with zero commands". This implies the unified policy also learned an intuitive response: if you nudge a standing quadruped, it starts walking in that direction rather than just falling over, thanks to the learned base-velocity adjustment. This cross-embodiment success suggests the method captures something general about legged balance and contact compliance, beyond one robot’s specifics. Putting it together: Why it matters. The “unified force-position” idea in this work is an example of bridging two previously separate paradigms. On one hand, there is hybrid force–position control theory and model-based whole-body controllers; on the other, there is data-driven RL-based whole-body control. Each by itself had limitations: model-based methods require laborious tuning and sensors, whereas learned policies had typically thrown away force information. Here, by simulating a wide range of hybrid commands and disturbances, the network implicitly learns a virtual impedance controller that works end-to-end. No explicit force sensor is needed, because the policy learns to infer forces from motion cues (much like how humans feel forces through muscle reflexes). This approach is in line with recent trends of using neural policies as flexible controllers. For example, Sun et al. (2025) showed that a single policy can learn dual-arm tasks and locomotion for a humanoid. Zhi et al. add forces to that mix, showing one policy can now also integrate force control. Traditional whole-body controllers could do this too, but they require accurate dynamics. Here, the neural policy learns everything in one shot from interactions. The force-aware imitation part taps into another trend: large-scale imitation and diffusion models for robot skills. Projects like WildLMa chain vision-based skills, and diffusion policies fuse images and states, but few consider contact forces. By feeding force estimates into an imitation pipeline, this work demonstrates a hybrid of RL and imitation: use RL to get the ‘plumbing’ of contact (a force-estimating controller), then use example demonstrations to teach complex tasks. The success here – 39% better results – argues that next-generation robotic learning systems should incorporate some notion of contact. Finally, because everything is RL-based and sensor-free (force estimated from joint currents/poses), this method could be widely applicable. It could be trained across many tasks or bodies, enabling a generalist loco-manip policy. The authors even mention that their framework could help gather large datasets of force-aware demonstrations, which have been lacking. In a world where people are building multimodal datasets for robotics (images, audio, text), adding estimated contact signals could be a valuable direction. Limitations and Future Directions. No method is perfect, and the authors acknowledge some limitations. The force estimation is coarse – it has about 5–10 N error at best. That is enough for gross contact tasks, but for very sensitive tasks (e.g. delicate assembly or high-frequency vibrations) it could be insufficient. The error was worse for certain axes and when the interaction was outside the nominal workspace. Improving the force estimator is an open challenge. The authors suggest future work could incorporate acceleration terms (the “M” from impedance) to better capture dynamics. Another avenue is to add a small number of real force measurements to refine the estimator via online learning. Another limitation is the assumption of a single contact point. The current policy structure treats the end-effector and the base separately – they estimate only one external force at the end-effector, and one at the base. In more complex tasks (say pushing a door with one leg and the arm at the same time, or leaning against something with the shoulder) the contacts multiply. The paper notes that extending to multiple contact points is interesting future work. It would mean the state estimator must output richer force distributions (perhaps per foot contact, etc.), and perhaps the command space might include forces on legs too. Finally, there is the ever-present sim-to-real gap. They successfully deployed on real robots, but did note discrepancies along some axes. Actuator dynamics, unmodeled friction, and contact uncertainty all contribute. More domain randomization or real-world adaptation could help tighten performance. For instance, next work might combine on-robot force sensing (if available) to fine-tune the estimator, or use online calibration tasks. Despite these caveats, this unified force–position policy represents a substantial step forward. It neatly sidesteps hardware complexity (no need for force torques) and merges complex control modes into one learned model. The ability to seamlessly switch between whole-body pushing, precision touching, and impedance by merely toggling command inputs is compelling. For roboticists, this opens up new strategies: we can now train one policy rather than two, and we gain a built-in contact-awareness that was missing. In summary, Zhi et al. introduce an RL-trained, sensor-free controller that does both force and position control for legged robots. They show it works on both a quadruped and a humanoid, enabling tasks from weight lifting to compliant guidance. Plus, by using it during data collection, they enrich imitation data with contact signals, greatly boosting performance on contact-heavy tasks. This work highlights how important force is in manipulation, and demonstrates a practical way to integrate force control into data-driven robot learning. Sources: All details above are drawn from Zhi et al., “Learning Unified Force and Position Control for Legged Loco-Manipulation,” arXiv 2025, and related works. The reported performance and methods are taken directly from the authors’ experiments and analysis.