Latest / Embodied AI 101 / ConstrainedMimic: Safe Humanoid Robot Motion Tracking

Transcript

ConstrainedMimic: Safe Humanoid Robot Motion Tracking · Embodied AI 101

• ConstrainedMimic: Safe Humanoid Robot Motion Tracking. Modern reinforcement learning (RL) has enabled some truly impressive humanoid behaviors – from backflips and parkour-like agility to human-like motion imitation. However, these achievements often come with a catch: the learned policies operate without formal safety guarantees. A policy trained in simulation for maximum agility may ignore constraints like joint limits, base stability, or avoiding obstacles. In the real world, that can quickly lead to falls, damage, or unsafe collisions. ConstrainedMimic is a new framework aiming to bridge this gap. Presented by Morton, Mohnot, and Pavone (2026), ConstrainedMimic wraps any learned whole-body motion-tracking policy with a real-time safety layer that enforces kinematic and dynamic constraints, using the robot’s own model. In other words, it seeks to combine the flexibility of RL motion policies with the rigor of model-based control safety guarantees. The core idea of ConstrainedMimic is to “minimally restrict the capabilities of the policy” whenever a safety constraint might be violated. At each control timestep, the method takes the RL policy’s desired motion (for example, a sequence of target joint angles or end-effector tasks) and passes it through a real-time optimizer. This optimizer uses whole-body kinematics and dynamics plus a set of control barrier functions (CBFs) to adjust the commands just enough to stay safe. In practice this means that if the policy’s action would drive the robot into a joint limit, a self-collision, or a loss of balance, ConstrainedMimic “filters” or corrects the control. Crucially, as long as the suggested motion is already safe, the system leaves the policy’s command unchanged (hence “minimal restriction”). In simulation experiments with a 22-DOF Unitree G1 humanoid, the authors demonstrate this approach with tasks like full-body motion tracking and teleoperation. The system successfully prevents body-self collisions and collisions with obstacles, keeps all joint angles within limits, and maintains the center-of-mass inside the support polygon – all while following motion references generated by an RL policy. From a performance standpoint, ConstrainedMimic is surprisingly fast: the framework is fully differentiable (meaning the optimizer and constraints are implemented in a way that supports backpropagation), runs on CPU/GPU/TPU hardware, and can update control commands at 300–500 Hz. In short, it provides a high-frequency safety overlay for whole-body humanoid policies. Below we unpack how ConstrainedMimic works and why it matters. We first review the challenges of safe humanoid control, then describe the key ingredients – operational-space control and control barrier functions – that let ConstrainedMimic enforce constraints in real time. We will also discuss the types of constraints handled, how this approach contrasts with related work (such as safe RL or compliant imitation learning), and what the experiments show. Throughout, we keep the explanation high-level and intuitive, aiming to give robotics and RL practitioners a clear sense of what ConstrainedMimic does and how one might build on it. The Challenge: Agile Motion vs. Safety. Humanoid robots are complex, high-dimensional systems with many joints, a free-moving base, and intermittent contact with the environment. Designing controllers for them is notoriously difficult. Conventional model-based controllers (like inverse dynamics controllers or model-predictive controllers) can enforce physical constraints (joint limits, balance, contact forces, etc.) explicitly, but devising those controllers and tuning them for rich, lifelike motions is a huge effort. Model-based planners can be overly conservative or limited by modeling errors. Reinforcement learning promises an alternative: train a policy (often a deep neural network) to imitate demonstrations or optimize locomotion rewards. In recent years RL-driven humanoids have learned to replicate human walking, dancing, and even complex tasks like parkour moves. These policies can be quite agile and generalize to varied motions. However, learning alone rarely guarantees that every possible safety constraint will be honored once the robot is running. For example, an RL policy might not explicitly know about:. Self-collisions: Will the robot’s swinging arms hit its body or legs in an extreme motion?. Obstacle collisions: Will a new piece of furniture or a person in the room get clipped?. Joint limits: Will actuators hit their mechanical hard stops in an aggressive motion?. Balance: Is the robot’s center of mass within its support polygon (to avoid tipping over)?. Contact modes: Does the policy respect which feet (or hands) are supposed to be fixed on the ground vs. moving?. During training, one can try to bake some of these concerns into the reward or into environment constraints, but it’s difficult to anticipate all constraints, especially those that arise after training (e.g. a new obstacle appears that wasn’t in the simulation). Moreover, adding hard constraints into RL training can make the learning problem much harder. This leads to a common pattern: researchers push RL as far as it can go to produce flashy motions, and then search for ways to patch up safety at the end. ConstrainedMimic takes this philosophy literally. Instead of changing the policy or training environment, it treats safety as a runtime control problem. The policy is trained (or operates) as if unconstrained, and ConstrainedMimic acts like a “safety filter” on top of it. Specifically, it uses knowledge of the robot’s kinematics and dynamics to correct or filter the policy’s commands in real time whenever some safety limit is about to be broken. This separation – let learning handle high-level agility, let model-based control enforce hard limits – is a powerful idea. It means you can take a skillful RL controller and deploy it in many different settings with different safety requirements, simply by swapping in different constraints at the control layer. You avoid re-training the RL policy for each new scenario. The authors describe their system succinctly: it “leverages whole-body kinematics and dynamics for real-time constraint enforcement within RL tracking policies,” by combining operational-space control and control barrier functions. This ensures the robot stays within the safe “envelope” of allowed motions at runtime, without significantly altering the intended movement when it’s already safe. ConstrainedMimic: Framework Overview. Let’s delve into how ConstrainedMimic is structured. Conceptually, it sits between an RL motion-tracking policy and the robot’s actuators. At each timestep, the RL policy produces a desired motion (trajectories or accelerations) that aims to follow a reference (e.g. a desired pose or trajectory sequence). ConstrainedMimic then takes this desired motion and processes it through a differentiable control pipeline that respects the robot’s kinematic and dynamic constraints. The output of this pipeline is a set of actuation commands (such as joint torques or accelerations) that the robot can execute safely. Here are the main ingredients:. Whole-body kinematics and dynamics. ConstrainedMimic uses a model of the robot’s full-body kinematics (how joints move and link geometries) and dynamics (mass, inertia, Coriolis, gravity, etc.). Having the model allows the controller to predict what will happen if certain torques are applied, and to calculate quantities like the position of the center of mass or contact forces. Importantly, the method can reason about the robot in operational space – that is, in terms of task-level variables like end-effector positions, center-of-mass, body orientation – while still accounting for all joints. Operational-space control. Rather than commanding individual joint efforts directly, ConstrainedMimic formulates tasks in higher-level coordinates. For instance, it might specify: “move the left hand to this point,” “keep the torso upright,” or “track this trajectory of Cartesian waypoints.” Operational-space control (originally introduced by Khatib et al.) is well-suited to humanoids because it naturally handles redundancy (many joints per task) and multiple simultaneous tasks. ConstrainedMimic builds on these ideas: it essentially forms a low-level control law that tries to follow the policy’s target tasks. The RL policy often thinks in terms of joint targets or reference poses; ConstrainedMimic translates that into forces/accelerations via inverse dynamics in operational space. Control Barrier Functions (CBFs). This is the mechanism that enforces safety constraints. In simple terms, a control barrier function is a mathematically-defined “safety condition” that a system state must satisfy. For example, to avoid collision with an obstacle, you might define a function (h(x)) that measures the signed distance between the robot and the obstacle – positive if they are apart, zero or negative if colliding. A CBF then enforces that (h(x)) never decreases below zero. In practice, this means adding a constraint on the system’s time derivatives (via a quadratic program) so that if (h(x)) is getting small, the control is chosen to drive it back up. CBFs can encode all sorts of constraints: distance to obstacles, distance to self-collision, staying inside joint limits, keeping the center-of-mass above the support polygon, etc. Real-time quadratic program (QP). Putting the above together, ConstrainedMimic typically solves a small QP at each control step. The objective is to follow the RL policy’s commanded motion as closely as possible (e.g. minimizing the difference between the desired and actual accelerations), subject to linear constraints derived from the CBFs. Because the constraints are enforced “inwards” (the robot must stay in a safe set), the solution of the QP yields the closest safe control to what the policy wanted. This is what the authors mean by “minimally restrict the policy” – the optimizer only deviates from the policy’s command when absolutely necessary to satisfy the safety constraints. Figure-wise, imagine the RL policy suggests a certain pose or motion for the next time step. ConstrainedMimic checks if following that suggestion would violate any barrier (e.g. cause self-collision). If not, it applies it directly. If yes, it tweaks the command via the QP so that all CBF constraints remain satisfied. The result is a safe actuation command that still tracks the intended motion as much as possible. Morton et al. highlight that their system is “fully differentiable” and runs at high frequency (hundreds of Hz) on standard hardware. This implies they have implemented the kinematic/dynamic computations and the QP solver in a machine learning framework (e.g. JAX or PyTorch) that supports backpropagation. In principle, this means you could even integrate ConstrainedMimic into a training loop, though in this paper they seem to treat it as a post-training filter. The fact that it’s differentiable also suggests efficiency: they likely exploit GPUs or TPUs for matrix operations in the QP, which helps achieve the 300–500Hz control rates they report. In summary, ConstrainedMimic is an online control layer that wraps around an RL policy, using an operational-space inverse dynamics QP with barrier-function constraints to enforce arbitrary safety limits at runtime. The framework is general: you can define any constraints you like (as long as they can be written as CBFs or similar linear constraints on the control), and it will ensure those are met. Operational-Space Control and Dynamics. To understand how ConstrainedMimic translates RL commands into safe motion, it helps to recall operational-space control. In humanoid robotics, we often think in terms of tasks: for example, we want the robot’s swing foot to follow some trajectory, or the torso to remain upright. Operational-space or task-space control lets us specify accelerations or forces in these task coordinates rather than individual joints. Conceptually, one writes down a mapping from joint accelerations/torques to task-level accelerations/forces using the robot’s Jacobian and mass matrix. Inverse dynamics then computes the required joint torques to achieve desired task accelerations, while satisfying equations of motion. ConstrainedMimic leverages this idea. The RL policy probably outputs something like desired joint angles or a target pose for the humanoid (since they call it a “motion tracking” or “teleoperation” policy). The first step in ConstrainedMimic’s pipeline is to interpret that as desired operational tasks. For instance, it could derive target positions for the feet, center-of-mass, and torso orientation from the policy output. (The exact mapping depends on the policy and task; the paper doesn’t describe the RL details, but this is the typical approach.). Once it has targets for tasks, ConstrainedMimic uses an inverse dynamics controller in operational space. Essentially, it builds an equation of motion for the humanoid (floating base plus legs/arms), which looks like: [ M(q)\ddot{q} + C(q,\dot{q}) + g(q) = \tau + \text{contact forces} ] where (q) are the joint angles (plus base pose), (M) is the mass/inertia matrix, (C) accounts for Coriolis/centrifugal forces, (g) is gravity, and (\tau) are the joint torques. The “contact forces” term enforces whatever feet are on the ground. In operational space, one might decompose tasks so that certain coordinates (like foot positions) are fixed by contacts, others (like COM) are controlled. For example, if the robot is in double-support, the contact Jacobians are known; one can project motion control into the nullspace of the contact constraints. ConstrainedMimic likely uses a hierarchical or combined control formulation:. The primary task is “match the RL’s desired motion.” This could mean minimizing (in some norm) the difference between the actual body configuration and the target pose the policy wants. The secondary tasks are the safety constraints, which we’ll cover next. To be concrete, imagine the RL policy says “I want the robot’s pelvis to pitch by 20 degrees and move forward quickly”. ConstrainedMimic will first compute the necessary joint accelerations or torques to try to achieve that target acceleration of the pelvis, taking into account the robot’s dynamics and current contact. Without constraints, that alone could be solved by standard inverse dynamics. But with constraints, we embed that goal in a QP as a soft objective. Control Barrier Functions. Control Barrier Functions (CBFs) are the heart of the safety guarantees in ConstrainedMimic. The quick intuition is this: for any safety constraint, define a function (h(q)) of the robot’s state (configuration/velocity) such that (h(q) \ge 0) represents “safe” configurations. For example:. If we want to avoid self-collision between link A and B, (h(q)) could be the distance between A and B minus some safety margin. We require (h(q) \ge 0). If we want to stay within joint limits, for a joint angle (q_i) we might define (h_{\text{min}}(q) = q_i - q_{i,\text{min}}) and (h_{\text{max}}(q) = q_{i,\text{max}} - q_i). Both should stay non-negative. To keep the center of mass over the support polygon, let (h_{\text{CoM}}(q)) measure how far the projected CoM is beyond the edge of the support region; again (h_{\text{CoM}}(q) \ge 0) means it’s safe. Once these (h(q)) are defined, a CBF enforces them by constraining the system’s dynamics so as not to decrease (h) too quickly. In practice, one implements this by adding a linear constraint on (\dot{h}(q,\dot{q},u)), where (u) is the control input (e.g. joint torques or accelerations). A simple version of the CBF condition is: [ \dot{h}(q,\dot{q},u) + \alpha,h(q) \ge 0, ] for some positive constant (\alpha). This constraint means that whenever (h) is near zero, (\dot{h}) must be non-negative (i.e., keep (h) from going negative). When (h) is large, the constraint is looser (since (\alpha h) can dominate). The net effect is: the robot is not allowed to enter the unsafe region (h<0) if it was previously safe. If it starts dangerously close, the controller must act to increase (h). In ConstrainedMimic’s implementation, these CBF constraints become linear inequality constraints on the control inputs in the QP. For example, if (h(q)) is distance to an obstacle, one computes its Jacobian and forms a linear function of the joint accelerations or torques that ensures (\dot{h} \ge -\alpha h). The QP solver then treats (\dot{h} + \alpha h \ge 0) as a linear inequality to satisfy. By stacking one CBF for each safety requirement, ConstrainedMimic can handle multiple constraints simultaneously. The beauty of CBFs is that they can encode very general constraints: any smooth function of the state that describes a safe set can, in principle, be turned into a CBF. This is how the authors claim they can enforce “arbitrary runtime constraints” on the motion. For instance, the user could add a new obstacle at run time by defining a new distance-based (h(q)) and plugging it into the control program. It’s worth noting that CBFs are widely used in safety-critical control. For example, Liu et al. (2023) used a CLF-CBF QP (Control Lyapunov Function + Control Barrier Function) on a bipedal Cassie to avoid multiple obstacles in real time. Similarly, Sharifi and Heshmati-Alamdari (2024) applied CBFs to a floating-base mobile manipulator to enforce joint limits and velocity constraints during force/position tracking. ConstrainedMimic is in this vein but specialized for whole-body humanoid motion tracking under an RL policy. Real-Time Constraint Enforcement. Putting operational-space control and CBFs together, ConstrainedMimic essentially solves a single optimization at each control tick. The form is typically:. Objective: Stay close to the nominal policy command. For example, minimize (| \ddot{q} - \ddot{q}{\text{ref}}|^2) or similarly for torques, where (\ddot{q}{\text{ref}}) is the acceleration the RL policy would like (converted from its pose target via inverse dynamics). This ensures tracking of the reference motion. Linear dynamics: Ensure that (\ddot{q}) and "(\tau)" satisfy (M(q)\ddot{q} + C(q,\dot{q}) + g(q) = \tau + J_c^T f_c), where (J_c) and (f_c) are contact Jacobians/forces. This can be included as equality constraints (or built-in by parameterizing (\tau) properly). In effect, the solver uses the full robot model. CBF constraints: For each safety function (h_i(q)), include the linearized condition (\dot{h}_i(q,\dot{q},\ddot{q}) + \alpha_i h_i(q) \ge 0). After substituting (\dot{h}_i = \nabla h_i(q)\dot{q}) and further differentiating, this becomes a linear inequality involving (\ddot{q}) (or (\tau)) and the current state. By solving this QP for (\ddot{q}) or (\tau), ConstrainedMimic gets the safest possible acceleration that still tries to follow the policy’s intention. If the policy’s command is already safe, the QP will simply output that command. If not, it adjusts it (for instance by slightly rotating a limb away from an obstacle) just enough to keep (h_i \ge 0) for all constraints. A helpful way to think of this is as a safety filter: imagine the RL policy output as a preferred action, and the CBF-QP as a “shield” that projects that action onto the set of safe actions. This idea has appeared elsewhere too: there are works in RL on “safety layers” or “action correction” which solve an optimization to enforce linear constraints on actions. ConstrainedMimic is like a highly sophisticated safety layer for humanoids, with nonlinear (but locally linearized) constraints derived from physics-based barrier functions. Because heterogeneous constraints are being enforced, ConstrainedMimic can handle things like self-collisions and obstacles (which are kinematic in nature) together with balance and force limits (which are dynamic) in one go. For example, if the robot is nearing an edge of balance, the CoM stability CBF will start to dominate so that the center of mass is pulled back over the foot. If a swinging arm threatens to hit the torso, the self-collision CBF kicks in and pushes the arm away. Joint limit CBFs gently crowd the joint motion to prevent surpassing mechanical stops. The CBF framework ensures these constraints are always respected at the next instant, guaranteeing safety at runtime. One key property noted by the authors is that ConstrainedMimic remains “consistent with the current contact mode”. This means the controller does not try to change which feet are in contact in order to satisfy constraints – it only exerts forces/accelerations while keeping the contact pattern fixed. This is important: if the RL policy expects a certain contact (say, both feet on the ground), the constraint filter won’t attempt, for instance, to lift a foot just to avoid a collision. It stays within the assumed contact mode and within the nominal task priority. In practice, this is achieved by embedding the contact Jacobians into the dynamics constraints and not allowing contact mode transitions in the QP at runtime. Finally, we should highlight the implementation achievement: the authors keep this loop at 300–500 Hz. For context, whole-body QPs can be heavy, but two factors help here. First, the robot’s structure (Unitree G1) has a tree structure of legs and arms, so some block-diagonal exploitation is possible. Second, they coded it differentiably, likely using GPU/TPU support, which means the solver can run matrix ops in parallel. The result is a very fast safety layer suitable for real robots with millisecond control loops. Types of Constraints Enforced. In their experiments, Morton et al. focus on several core safety constraints. These illustrate the kinds of things ConstrainedMimic can handle. Specifically, the robot is kept safe with respect to:. Collision avoidance. They consider both self-collision (one part of the robot hitting another) and external obstacles. For each potential collision pair, they define a CBF that keeps the signed distance above a threshold. For an external obstacle, this might mean the torso or limbs maintain a buffer distance from the obstacle’s geometry. Because these distances can be nonlinear in (q), they are linearized each step in the QP, effectively treating them as linear (tangent-plane) constraints locally. The experiments show that with ConstrainedMimic, the robot successfully avoids hitting virtual obstacles during motion tracking tasks. Joint limits. Every revolute joint has a mechanical range. ConstrainedMimic includes a CBF for each joint limit: for joint angle (q_i), require (q_{i,\text{min}} \le q_i \le q_{i,\text{max}}). In practice, one can handle this by defining separate CBFs (h_{\text{min},i}(q) = q_i - q_{i,\text{min}}) and (h_{\text{max},i}(q) = q_{i,\text{max}} - q_i). The CBF constraints then ensure that the joint angle never crosses its bounds. This is important in whole-body tracking because the policy might request extreme configurations (e.g. bending too far) that a hardware-bound robot could not safely achieve. With ConstrainedMimic, the motion is automatically clamped just in time to stay inside limits. Center-of-Mass (CoM) stability. Perhaps the most critical constraint for a humanoid is balance. ConstrainedMimic explicitly enforces that the projected center of mass stays within the support polygon of the feet. One way to do this is to compute the horizontal distance from the CoM to the support polygon’s edge and use that as (h(q)\ge0). If the CoM drifts too far forward or sideways, the CBF forces corrective action (usually adjusting whole-body posture) to bring it back. In effect, this imposes a quasi-zero-moment point (ZMP) stability condition. The authors note that ConstrainedMimic maintains center of mass stability constraints in their tracking tasks, meaning the robot never topples despite dynamic motions. In addition to these, nothing in the method prevents other constraints from being added. For instance, one could include joint velocity or torque limits in a similar way. The phrase “arbitrary runtime constraints” in the paper suggests any measurable quantity of state or control can be made safe via a CBF. The only restriction is that the constraint must be expressible (or at least approximated) as a smooth inequality for the state+control. The upshot is that ConstrainedMimic supports a very rich constraint set without redesigning the RL policy. It is a flexible layer: the same learned policy could be used in different settings (walking in a cluttered hallway vs. walking in the open) simply by changing the external-obstacle CBFs. The policy itself need not have been trained for obstacle avoidance at all; the CBF will handle it on-the-fly. This post-training adaptability is a major advantage. Integration with RL Tracking Policies. A key question is: how do we integrate ConstrainedMimic with an RL policy? The idea is that you first train an RL controller in some environment (possibly a modification of the robot simulator). The RL objective in this paper is motion-tracking: the policy is trained to make the robot follow a desired reference motion (which could come from motion capture or a predetermined trajectory). The details of that RL training are not the focus of this paper – they use a “learned policy” as a given. During execution, the policy outputs at each timestep a raw action or desired change in pose/velocity. ConstrainedMimic takes that output and constructs the corresponding operational-space targets. For example, if the policy outputs joint position targets, ConstrainedMimic might convert them to desired accelerations for the end-effectors or CoM. (The exact specifics would depend on how the RL policy is set up; commonly, RL outputs joint torques or target joint angles.). The crucial point is that the RL policy is not aware of the constraints. It acts as if it were free-running. ConstrainedMimic then corrects it if necessary. One way to think about this is that ConstrainedMimic augments the policy: the policy says “do this”, and ConstrainedMimic says “okay, but only if it’s safe; otherwise do this slightly modified thing that is safe”. This means the policy can be trained with any velocity or torque control objective, and then be used in different safety scenarios. In practice, this typically means implementing ConstrainedMimic as a low-level controller loop that sits after the policy. The loop might go like this:. Get policy command: The RL controller (which could be running at e.g. 30–60 Hz) provides a target or desired acceleration for the robot’s body. ConstrainedMimic may interpolate or hold this at a higher rate. Compute reference tasks: Transform the policy command into desired accelerations or forces for a set of high-level tasks (foot positions, CoM, etc.). Solve QP with constraints: Formulate the QP whose objective is to match these desired tasks, and whose constraints are all the CBF inequalities (and dynamics consistency). Solve for the optimal (\ddot{q}) or (\tau). Apply control: Send the resulting joint torques or accelerations to the robot (or simulator) until the next control cycle. This loop runs at 300–500 Hz in their implementation, which may require running several policy commands (if the RL policy is slower) or otherwise smoothing input. The authors highlight that their implementation is “fully differentiable” and runs not only on CPU but also GPU/TPU. This suggests they might actually integrate RL and control into one pipeline for experimentation, but it certainly doesn’t hurt that gradients can flow through – perhaps they could later fine-tune policies that are aware of this safety layer. One especially interesting claim is that ConstrainedMimic only “minimally restricts” the RL policy commands. In practice, this means the QP is formulated so that it favors the policy’s original command whenever possible. For example, one could set the objective to penalize deviations from the policy’s desired acceleration very strongly, and treat the CBFs as hard constraints. Then the solution will always exactly match the policy unless it would violate a constraint. If a violation is imminent, the solution changes just enough to satisfy the CBF, while staying as close as possible to the original command in a least-squares sense. In optimization terms, the original policy command is a soft objective, and the safety limits are hard constraints. This design is important: it ensures the RL-trained locomotion or tracking skill is preserved as much as possible. For example, if the RL imagines a fast squat but that would bend a knee past its limit, ConstrainedMimic will let the squat happen but just not as deeply. If the RL wants to swing an arm through a new obstacle, the arm will be slowed or rerouted slightly, but the policy can otherwise do its job. The result is graceful degradations instead of abrupt cuts – a hallmark of good safety filters. Experiments and Results. The paper’s experiments (all in simulation) serve to illustrate ConstrainedMimic’s effectiveness. The testbed is a simulated Unitree G1 humanoid – a relatively small 22-DOF biped robot (with legs, arms, and a floating base). The authors use a “learned policy” (likely trained separately with RL or imitation to do motion tracking) and then apply ConstrainedMimic on top during execution. Two main scenarios are reported: whole-body motion tracking and teleoperation. Motion Tracking: Here the robot is given a reference motion trajectory (possibly coming from a human or from pre-recorded demonstrations), and the task is to follow it as closely as possible. The learned RL policy attempts to do the tracking. ConstrainedMimic is then used to ensure safety constraints. The experiments show that with ConstrainedMimic, the robot accurately tracks the motion without violating any of the selected constraints – it steers clear of (simulated) obstacles and respects limits. By contrast, an unconstrained policy presumably would occasionally penetrate obstacles or reach joint limits (though specific comparisons are not given in the summary). They likely measure some tracking error when the safety filter acts, to show it only slightly degrades performance if at all. Teleoperation: In a more interactive test, the robot is “teleoperated” via the learned policy. This could mean, for example, an operator controlling the robot through a joystick or motion capture, which is interpreted by the RL policy. During such tasks, unpredictable instructions (like swinging wildly) can cause unsafe situations. The results indicate that ConstrainedMimic prevents unsafe outcomes even when the operator tries to command risky motions. For example, if the human operator drives the robot’s arm into a wall, the CBF for collision will adjust the action to avoid hitting the wall, but still try to follow the operator’s intention. In both experiments, the authors explicitly demonstrate the three constraint types mentioned earlier: collision avoidance, joint limits, and center-of-mass stability. They report that in simulation the robot never violates these constraints when ConstrainedMimic is active. Moreover, the method does not “hack” the contact pattern – for instance, it does not violate foot contacts or flip feet just to avoid an obstacle. The robot stays in its current gait or stance, and makes adjustments within that mode. Quantitatively, one could imagine they measured metrics like the number of constraint violations with vs without the filter (likely zero vs some positive number), tracking error increase, and timing of the QP solver. The abstract notes the differentiable high-frequency implementation, implying they achieved real-time control rates without slowing down the policy. Unfortunately, the summary does not give numbers for tracking performance, but we can infer that the method performed well enough to warrant claiming success. The statement “by remaining consistent with the current contact mode and tracking objectives, we minimally restrict the capabilities of the policy when constraints are active” suggests that even when constraints engaged, the robot still managed to continue the motion in a sensible way rather than jerking to a halt. Finally, the authors make a meta-point that ConstrainedMimic (and accompanying software) will be released. This suggests the method is not just a one-off demonstration but intended as a tool for others. It jives with modern research practices: if you train an RL policy for a new humanoid, you could layer in ConstrainedMimic to make it deployable on real hardware with safety. Relation to Prior Work. ConstrainedMimic sits at the intersection of several active research areas: safe reinforcement learning, motion imitation for humanoids, and model-based whole-body control. Let’s put it in context by considering related approaches. Safe RL and Safety Layers. In general RL literature, people have studied the idea of a “safety filter” or “safety layer” that corrects an RL action to satisfy constraints. For example, Carlantonio et al. and others have looked at second-order cone programs or simple projections as a safety step after an RL action. The newer CBF-based safe training (like CBF-RL by Yang et al. 2025) integrates barrier functions during policy training. ConstrainedMimic differs: it keeps the RL policy training agnostic, and only enforces constraints at execution time. This is akin to the older notion of a shield: a hard guard that monitors and overrides unsafe moves. The key novelty here is applying this idea to whole-body humanoid dynamics with multiple simultaneous constraints. Motion Imitation and Residual Controllers. There have been many “Mimic” or imitation works for humanoids (e.g., HumanMimic, LessMimic, HybridMimic, ResMimic, etc.). These focus on learning or controlling the robot to reproduce desired motions, often with RL or Machine Learning. What sets ConstrainedMimic apart is its explicit safety focus. It’s less about which motion to do (any reference is fine) and more about how to do it safely. Among imitation works, perhaps SoftMimic (Margolis et al., 2025) is closest in spirit: they also worry that pure imitation can produce unsafe, stiff behavior. SoftMimic uses an inverse-kinematics-based data augmentation to train the RL policy to be compliant to external forces, making it inherently safer when contacts occur. In contrast, ConstrainedMimic does not change the policy’s compliance – it assumes the policy might be stiff – but then wraps a barrier function filter over it. One could imagine combining these: first train a policy with SoftMimic to be more gentle, then deploy it with ConstrainedMimic to guarantee safety. Behavioral and MPC Controllers with Safety Guarantees. Outside of ML, robotics has a rich history of whole-body control using QPs or MPC, often with hard constraints. What ConstrainedMimic adds is the interface to arbitrary reference motions. It’s similar to a Model Predictive Control (MPC) that has contact and balance constraints, except the reference (from RL) is given, and the horizon is essentially one timestep. In that sense it is a “one-step QP” approach. Nevertheless, it embodies ideas from advanced control: multi-task QPs, CLF/CBF-QPs, and interaction control. You can draw connections to works like Kimmel et al. on constrained MPC or Xie et al. on contact-implicit control. What’s special here is the claimed speed – solving such a QP at up to 500 Hz. Differentiable Control and Auto-Diff in Robotics. The implementation detail of being fully differentiable is part of a trend (e.g. diff sim, diff QPs). By making all computations differentiable, Morton et al. enable seamless integration with machine learning tools and custom gradient-based optimization. This is forward-looking: one could imagine differentiating through ConstrainedMimic to fine-tune the policy to work better with it. In summary, ConstrainedMimic is a novel synthesis of RL-based whole-body control with classical constraint-enforcing control methods. It draws inspiration from safe control (CBFs), imitation learning, and operational-space robotics. The result is a hybrid system: use learning for agility, use optimization for safety. The experiments back up their claim: the Unitree G1 can perform complex motions while provably avoiding unsafe states. Conclusion and Future Directions. ConstrainedMimic represents a promising direction for making learning-based humanoid control more practical. By decoupling the what (policy’s intended motion) from the how (safe execution), it offers a modular way to add safety to any learned controller. In scenarios where adaptability is needed – say, new obstacles in the environment or a different robot morphology – one can reuse the same policy and simply redefine the constraints in the ConstrainedMimic layer. For practitioners, this means you might train a walking or manipulation policy once, and later deploy it in situations with varying safety requirements without re-training. For example, a humanoid could learn a set of tennis swings with RL. Later, if the robot must play on courts with varying net heights or additional padding, ConstrainedMimic could enforce new height or reach constraints on the fly. Of course, ConstrainedMimic also has limits. It assumes an accurate kinematic/dynamic model and known contacts. On real hardware there will be sensor delays, model errors, and unexpected disturbances – typical challenges. The high control frequency helps, but real-world testing will be needed to see how robust the CBFs are under noise. Also, solving a QP leaves little room for violation: if one constraint becomes infeasible (e.g. an obstacle moves too suddenly), the solver might fail. In practice, one might need to add slack (soften constraints) or fallback behaviors. Looking ahead, it would be interesting to see variants of ConstrainedMimic learned jointly with the policy. Since the pipeline is differentiable, one could in principle train the RL agent with the filter in the loop, getting a policy that anticipates the safety layer. This might reduce abrupt corrections and lead to even smoother compliance. The authors already mention the framework runs on TPU/GPU, hinting that integration with ML training is feasible. In conclusion, ConstrainedMimic is a significant step toward safer humanoid robots through smart control design. It demonstrates that we can have our cake (agile RL motion) and eat it too (safety guarantees) – at least in simulation. As the field of embodied AI grows, such hybrids of learning and control will likely become essential. The full code release promised by Morton and colleagues should enable many follow-up studies: different robots, new constraints, and perhaps even real-world experiments. For those of us working on humanoid RL and robotics, ConstrainedMimic offers both a practical tool (a safety filter to try) and an inspiring blueprint for combining learning with classical control techniques. Sources: The core ideas are drawn from Morton et al.’s recent arXiv paper “Constrained Whole-Body Tracking for Humanoid Robots”, which introduces ConstrainedMimic. Supporting context on control barrier functions and safe control comes from related works. These are referenced where relevant in the text.