X-Safe: Embodiment-Agnostic Safeguarding for Robot Arm Manipulation Policies via Action Masking

arXiv:2606.22278 · cs.RO, cs.LG, cs.SY, eess.SY · Submitted 2026-06-21 · Read on arXiv

Listen

Transcript

Introduction to the show: ident: Robotics Radio. Generated commentary on the latest robotics and control papers.

Rosa: Today's paper: "X-Safe: Embodiment-Agnostic Safeguarding for Robot Arm Manipulation Policies via Action Masking".

Dev: The gist The proposed approach, XSafe,

Rosa: First, who's behind it and why it matters.

Paper summary: Rosa: So this paper is about something called X-Safe, which they claim is a universal safeguarding approach for robot arm manipulation policies across different robot setups and tasks <ref:2606.22278#pg1>. Basically, it aims to get formal probabilistic guarantees for collision avoidance without needing a lot of manual engineering or learning new safety functions <ref:2606.22278#pg1>.

Dev: That sounds like they’re trying to solve the problem where existing methods are either too conservative, too slow for real-time use, or just don't transfer well between different robot setups <ref:2606.22278#pg1>. They propose reasoning directly in the robot’s configuration space to ensure collision avoidance <ref:2606.22278#pg1>.

Taro: So if I understand this correctly, it suggests that instead of relying on specific models or learned safety rules for every robot, you can use a single method that works generally <ref:2606.22278#pg1>. That’s a big deal because it removes the need for setup-specific tuning <ref:2606.22278#pg1>.

Rosa: Exactly. They say X-Safe operates by computing probabilistically safe polytopes in the robot’s configuration space and then using action masking to restrict what the policy can actually do <ref:2606.22278#pg1>. It relies only on an object-based, quasi-static scene representation and a forward kinematics model of the manipulator <ref:2606.22278#pg1>.

Dev: The paper talks about how they adapt a sampling method called Edge Inflation – Zeroth Order (EI-ZO) to find these local safe polytopes, which they call LocalZeroOrderSeparatingPlanes <ref:2606.22278#pg1>. They use a statistical test called UnadaptiveTest to check if they’ve found a probabilistically safe polytope and get a bound on the volume fraction in collision <ref:2606.22278#pg1>.

Taro: That means they are iteratively sampling points in the configuration space, counting collisions, and refining those polytopes using hyperplanes <ref:2606.22278#pg1>. So it’s a way to map out where you can safely move the robot right from where you are standing <ref:2606.22278#pg1>.

Rosa: And once they have those polytopes, they use a ray masking algorithm, which checks if the safe polytope encloses the action set or the action set in a specific ray direction <ref:2606.22278#pg1>. If it doesn't enclose it, they adjust that candidate action to a safe one along that ray <ref:2606.22278#pg1>.

Dev: The paper shows this process sequentially corrects all n actions in an action sequence from a policy and the safety-relevant state <ref:2606.22278#pg1>. That sequential correction is what makes it work for longer sequences <ref:2606.22278#pg1>.

Taro: So, how does this apply to something like bimanual manipulation, which the paper mentions as a challenging task? Is it still effective in those complex scenarios?

Rosa: They tested X-Safe on three embodiments and five tasks in both simulation and on actual hardware <ref:2606.22278#pg1>. On the xArm7 hardware evaluation, they observed a collision fraction of zero point zero two percent, which is much lower than the two percent expected from their formal safety guarantee <ref:2606.22278#pg1>.

Dev: And regarding performance, they found that even when comparing it to a safeguarding approach called RAIL five, which reduced performance by almost twenty percent, X-Safe only caused a drop of six percent <ref:2606.22278#pg1>. That’s a significant difference in how much the task gets messed up <ref:2606.22278#pg1>.

Paper summary: Taro: So, when we look at what this changes for us on the ground, it seems like it keeps the performance drop down quite low compared to other existing methods <ref:2606.22278#pg1>. But there are some limitations they mention, right?

Rosa: They do flag a central assumption: the availability of the violation function C <ref:2606.22278#pg1>. That function is usually provided by a simulation framework like MuJoCo forty, which means integration becomes more complex for environments where perception has to detect changes in safety-relevant elements in real time <ref:2606.22278#pg1>.

Dev: And the runtime itself is an issue, because computing those safe polytopes requires drawing samples and evaluating them with the violation function repeatedly, and that gets slower as you get closer to a near-collision state <ref:2606.22278#pg1>. That latency needs to be managed for real-time operation <ref:2606.22278#pg3>.

Taro: So, the paper admits that while it’s formal, making it run fast enough in a dynamic, real-world setting is still a hurdle <ref:2606.22278#pg3>. What about policies that aren't just state-based or image-based?

Rosa: They say they achieved efficiency by combining fast-computed safe polytopes with an efficient action masking formulation, allowing it to work for both image- and state-based policies <ref:2606.22278#pg2>. It’s designed to handle high-degree-of-freedom manipulation tasks <ref:2606.22278#pg1>.

Dev: So, the main point is that they’ve managed to get formal guarantees without adding heavy engineering or needing extra data for different environments <ref:2606.22278#pg1>. The core contribution of X-Safe is moving the reasoning into configuration space <ref:2606.22278#pg1>.

Taro: It’s interesting to see how they handle the comparison to other methods, like control barrier functions or reachability analysis, which are often used for continuous action spaces <ref:2606.22278#pg3>. X-Safe seems to provide a formal proof of forward invariance that those other approaches lack <ref:2606.22278#pg3>.

Rosa: And they showed that their approach doesn't just avoid collisions; it actually keeps the performance drop much lower than the state-of-the-art safeguarding baseline <ref:2606.22278#pg1>. This means you can deploy it with less worry about task success <ref:2606.22278#pg1>.

Dev: So, to wrap up this part of the discussion, X-Safe is a method that provides probabilistic guarantees for collision avoidance in quasi-static environments and is transferable across different embodiments with low engineering effort <ref:2606.22278#pg1>. The results show it stays below the formal collision probability and doesn't let performance drop too much <ref:2606.22278#pg1>.

Taro: It seems like the big implication here is that we can build more robust manipulation policies because we have a reliable, formal way to check their safety without having to manually design every single constraint for every robot <ref:2606.22278#pg1>.

Rosa: It really suggests that the future of learning-enabled robotics might involve these kinds of universal checks built directly into the configuration space reasoning <ref:2606.22278#pg1>. That’s where we’ll be looking next, right?

Conclusion: Rosa: So, we’ve been looking at X-Safe, which is this new framework for safeguarding robot arm manipulation policies across different robots and tasks <ref:2606.22278#pg1>.

Dev: Yeah, it’s about getting formal probabilistic guarantees for collision avoidance without needing tons of manual engineering or learning new safety functions <ref:2606.22278#pg1>.

Taro: It basically lets you reason directly in the robot’s configuration space instead of relying on specific models for every single setup <ref:2606.22278#pg1>.

Rosa: That's right, it transfers across different embodiments by only needing an object-based scene representation and a forward kinematics model <ref:2606.22278#pg1>.

Dev: And the core mechanism is computing probabilistically safe polytopes in that space and then using action masking to restrict what the policy can actually do <ref:2606.22278#pg1>.

Taro: The paper details how they adapt a sampling method called Edge Inflation – Zeroth Order, or EI-ZO, to find these local safe polytopes <ref:2606.22278#pg1>.

Rosa: They use an UnadaptiveTest statistical test to check if they found a polytope that’s probabilistically safe and get a bound on the volume fraction in collision <ref:2606.22278#pg1>.

Dev: So, they're iterating through sampling points and refining those polytopes with hyperplanes until they hit a statistically safe zone <ref:2606.22278#pg1>.

Taro: Then they use a ray masking algorithm to check if the action set fits inside that polytope or in the direction of a ray, and if it doesn't, they correct the candidate action <ref:2606.22278#pg1>.

Rosa: The overall conclusion is that X-Safe provides probabilistic guarantees for collision avoidance in quasi-static environments without requiring specific model simplifications <ref:2606.22278#pg1>.

Dev: And the results show less performance degradation compared to state-of-the-art safeguarding, and on hardware, they saw zero collisions in their experiments <ref:2606.22278#pg1>.

Taro: But they do admit a limitation: the method assumes you have access to a violation function C which is usually from simulation software like MuJoCo <ref:2606.22278#pg3>.

Rosa: And they also point out that the runtime can be slow because you have to draw samples and evaluate them repeatedly, especially when things get close to a collision <ref:2606.22278#pg3>.

Dev: The paper is essentially arguing that this approach gives us a robust, transferable way to build safety without getting bogged down in specific robot designs <ref:2606.22278#pg1>.

Taro: It means we can move learning policies into real-world manipulation with less manual constraint design required <ref:2606.22278#pg1>.

Rosa: So, while it’s a big step toward universal safeguarding, the authors suggest future work should focus on integrating X-Safe directly into reinforcement learning during the training phase <ref:2606.22278#pg3>.

Dev: That makes sense. The question is how robust this system really is when the environment misbehaves in a truly dynamic setting, which we’ll be looking at next <ref:2606.22278#pg4>.

Alex Beaudin, Hanna Krasowski, Kartik Nagpal, Sanjit A. Seshia, Murat Arcak Negar Mehr

University of California, Berkeley

cs.RO, cs.LG, cs.SY, eess.SY

Submitted: 2026-06-21

Updated: 2026-10-14

License: http://arxiv.org/licenses/nonexclusive-distrib/1.0/

Importance score: 82/100

The gist: The gist The proposed approach, XSafe, provides a universal safeguarding approach that reasons directly in the robot’s configuration space to provide formal probabilistic guarantees for collision

Key concepts

Configuration Space: This is a mathematical space where every possible position and orientation of the robot arm can be represented as a coordinate. Instead of thinking about physical joints, X-Safe operates in this space to determine if any action leads to a collision with obstacles.
Probabilistically Safe Polytopes: These are geometric shapes calculated in configuration space that represent all the areas where collisions are mathematically unlikely to occur. The method iteratively samples points and refines these shapes using hyperplanes, giving a statistical bound on the volume of safe space.
Action Masking Safeguard: This technique takes an action suggested by a robot's policy and checks it against the safe polytopes. If the proposed action is unsafe, an algorithm masks or corrects it by moving it proportionally toward a known safe direction, ensuring the final executed action is collision-free.
Embodiment-Agnostic Approach: X-Safe is designed to be transferable across different robot physical setups (embodiments) without needing new engineering or learning for each one. It relies only on an object-based scene representation and the robot's forward kinematics, making it universally applicable.

Terminology

Action Masking — 1× in this paper · explained in 1 episode

Summary

The gist The proposed approach, XSafe, provides a universal safeguarding approach that reasons directly in the robot’s configuration space to provide formal probabilistic guarantees for collision avoidance

How it works

XSafe is a framework in configuration space that safeguards manipulation policies and is transferable to different embodiments without additional engineering or learning effort while ensuring probabilistic collision avoidance for quasi-static environments The method operates by computing probabilistically safe polytopes in the robot’s configuration space, which are combined with action masking such that candidate actions are adjusted to safe actions This approach relies solely on an object-based, quasi-static scene representation and a forward kinematics model of the robotic manipulator

The process involves several key components as illustrated in Figure 1, which shows how XSafe takes action sequences from policies together with a scene, i.e., safety-relevant state The safeguarding sequentially corrects all n actions.

Safe Polytope Computation

The computation of safe polytopes is achieved by adapting the sampling-based method of Edge Inflation – Zeroth Order (EI-ZO) by Werner et al. [39] to an efficient algorithm for local safe polytopes, i.e., LocalZeroOrderSeparatingPlanes This process involves iteratively sampling points in the configuration space, counting collision points, and refining the polytope using hyperplanes.

The statistical test UnadaptiveTest is used to determine if a probabilistically safe polytope has been found, which yields a bound on the volume fraction in collision Specifically, Proposition 1 states that given M ≥ 2 log(1/δ) (ετ2) samples for computing the statedependent safe polytope Ps, the admissible fraction in collision ε, the confidence δ, and the decision threshold τ, then we have the bound P vol(Ps - Csafe s) vol(Ps) > ε ≤ δ.

Action Masking Safeguard

The action correction function is defined as a masking function based on these polytopes The algorithm draws from ray masking [23] to correct candidate actions a consistent with the intended direction in configuration space to a safe action.

The RayMask algorithm checks if the safe polytope Ps fully encloses the statedependent action set A(s) or if it encloses the action set in the ray direction If an intersection occurs, actions are proportionally moved towards the center on the ray to yield a safe action.

Implementation and Results

The implementation requires access to the function PointsInCollision, which is typically accessible when an object-based scene representation is obtained from perception and the robotic manipulator is described by a Unified Robot Description Format (URDF) file The domain D, which is typically an axis-aligned box centered at the current configuration, was found to be most effective for both safety and performance in experiments.

Empirical results demonstrate X-Safe on three embodiments and five tasks in simulation and on hardware For the xArm7 hardware evaluation, X-Safe achieved a collision fraction of 0.02%, which is much lower than the 2% expected from the formal safety guarantee. Furthermore, while RAIL [5] reduced performance by almost 20% compared to the unsafe benchmark, X-Safe's performance drop was only 6%.

Limitations

A central assumption for XSafe is the availability of the violation function C, which is typically implemented with a simulation framework like MuJoCo [40] Integration becomes more involved for quasi-static environments where perception must detect safety-relevant environment changes. The runtime bottleneck is drawing samples and evaluating them with the violation function iteratively, as runtime increases in near-collision states since more iterations are required to obtain and certify the safe polytope.

The experiments suggest that while XSafe exhibits lower performance degradation compared to state-of-the-art safeguarding, for the bimanual task, a brittle VLA policy did not complete the task when used with XSafe. Future work should explore integrating XSafe into reinforcement learning during training.

Conclusion

XSafe is a safeguarding approach that provides probabilistic guarantees for collision avoidance of robotic manipulators in quasi-static environments and that is transferable across embodiments with low engineering effort and without additional data It combines probabilistically safe polytopes obtained with a violation function and action masking to correct actions. The empirical results show that XSafe exhibits lower performance degradation compared to state-of-the-art safeguarding, and does not exceed the formal collision probability.

--- Page 1 ---

Any-Body Guard: Universal Safeguarding for Manipulation Policies via Action Masking Alex Beaudin Hanna Krasowski Kartik Nagpal Sanjit A. Seshia Murat Arcak Negar Mehr University of California, Berkeley alex beaudin krasowski kartiknagpal sseshia arcak negar@berkeley.edu Abstract: Ensuring safety of learning-enabled robotic manipulation across diverse embodiments and tasks still requires significant manual engineering. Existing approaches typically rely on heuristically designed fallback controllers or complex forward invariance assessments. These methods are often too conservative for task success, too computationally expensive for real-time execution, too heuristic to provide useful safety guarantees, or too engineering-heavy to transfer between setups. In this paper, we propose a universal safeguarding approach, XSafe, which reasons directly in the robot’s configuration space to provide formal probabilistic guarantees for collision avoidance. By operating in the configuration space, our method transfers across embodiments while relying solely on an object-based, quasi-static scene representation and a forward kinematics model of the robotic manipulator. Thus, X-Safe provides useful formal safety guarantees without requiring additional data, or engineering effort for different embodiments or scenes. We demonstrate X-Safe for diverse embodiments and policies, both in simulation and on hardware. We observe less degradation in task performance compared to state-of-the-art safeguarding, no collisions on hardware experiments, and empirically corroborate our formal guarantees. Keywords: Safety, cross-embodiment, robotic manipulation, probabilistic guarantees

--- Page 2 ---

Policy image-based or state-based or teleoperated Safeguarding with X-Safe t = 1 t = 2... t = n action at original pose qt action set A(st) safe action a safe t masking ray safe polytope Pst Environment xArm7 Aloha Panda or... a1:n a safe 1:n policy state s π t ← s πt+n safety-relevant state st ← st+n Figure 1: Overview of our safeguarding method, X-Safe, that can take action sequences from policies together with a scene, i.e., safety-relevant state. The middle box illustrates safeguarding for n actions in two exemplary directions of the configuration space. At t = 1, the action set A is fully enclosed in the safe polytope Ps and consequently the action remains the same. In contrast, at t = 2, the safe polytope intersects with the action set in the direction of the masking ray, and the proposed action a2 is corrected to a safe. The safeguarding sequentially corrects all n actions. given an object-based scene representation, which describes the robot and obstacles spatially in the workspace. We achieve this by computing probabilistically safe polytopes in the robot configuration space, which are combined with action masking such that candidate actions are adjusted to safe actions. Our safeguard is computationally efficient, which we demonstrate in simulation and on hardware for robotic manipulation tasks. Our main contributions are: • We propose X-Safe, a framework in configuration space that safeguards manipulation policies and is transferable to different embodiments without additional engineering or learning effort while ensuring probabilistic collision avoidance for quasi-static environments. • We achieve efficient computation by combining fast-computed safe polytopes with an efficient action masking formulation allowing for both image- and state-based policies, and high-degree-of-freedom manipulation tasks. • We compare our approach on single-arm and two-arm robotic manipulators for pick-andplace tasks in cluttered quasi-static environments, empirically showing that collisions are below the expected probability or zero for hardware evaluations, and the performance drop is halved compared to a state-of-the art safeguard baseline.

--- Page 3 ---

Related Work Learning with safeguards. Safeguarding methods for learning-based robotic systems have been significantly improved and expanded in the last decade [3]. While most literature focuses on soft safety constraints, methods that can ensure probabilistic or hard guarantees on safety are necessary when a violation damages the robot or environment [4]. For continuous action spaces, methods that project unsafe action to the boundary of a safe set dominate, e.g., using control barrier functions (CBFs) [12, 13, 14, 15], buffer sets [16, 17, 18], or reachability analysis [19, 20]. However, boundary projection frequently results in learning and deployment instabilities [4, 9, 10]. Alternatively, continuous action masking has been proposed, where the policy is extended with a function that ensures selecting safe actions only [23]. Here, we introduce an action masking safeguard that corrects actions consistent with the policy’s proposed direction in configuration space.

--- Page 4 ---

Safeguarding for learned manipulation policies. For robotic manipulation, an elementary notion of safety is collision avoidance with itself and the environment, e.g., static obstacles like tables or dynamic obstacles like humans [24]. Developing safeguards to enforce collision avoidance across quasi-static or dynamic environments is challenging.

Improvements for AI systems

textbfThe XSafe framework enables universal safeguarding across diverse embodiments and policies by operating directly in configuration space with object-based, quasi-static scene representation. This allows for cross-embodiment transferability without requiring additional data, or engineering effort for different embodiments or scenes.
textbfCollision Avoidance Guarantees via Probabilistic Polytopes. The method computes probabilistically safe polytopes in the robot’s configuration space using an adaptation of Edge Inflation – Zeroth Order (EI-ZO) to define sets with a quantifiable collision probability, ensuring that the action remains within a region where "P vol(Ps / Csafe s) vol(Ps) > ε ≤ δ."
textbfReal-time Action Correction via Ray Masking. XSafe uses an action masking safeguard where candidate actions are adjusted to safe actions by computing a correction based on the ray direction, specifically by applying the RayMask algorithm to ensure that only actions are executed that lead to the next configuration qt+1 being within the safe polytope Ps.
textbfEnhanced Performance Retention over State-of-the-Art Safeguards. Empirical results show that XSafe exhibits less degradation in task performance compared to state-of-the-art safeguarding, demonstrating a lower collision fraction (0.02% on hardware) and a reduced performance drop (6% vs. 20%) when compared to baselines like RAIL [5].
textbfRobustness to Policy Distribution Shifts via Fallback Control. For long action sequences, XSafe employs a ChebyshevFallbackController which moves the configuration to the Chebyshev center of the candidate polytope P, offering a mechanism that often frees the manipulator, since this typically leads to moving the manipulator in the opposite direction of collision areas.