Reading guide
All seventeen pages, ten complete figures, ten tables, seven displayed mathematical groups and thirty-eight references are covered. OopsieVerse combines DamageSim's configurable health proxy with household evaluation tasks. It separates completing a task from completing it with limited modeled damage. Health augments the original dynamics; red coloration indicates accumulated damage rather than physically simulating fracture. Real-robot results use object-pose inputs and twenty trials per method across two tasks. The improvements support this tested setup, without establishing a general hardware safety guarantee.
At a glance
DamageSim converts contact-force, temperature and liquid-exposure signals into per-object health loss. OopsieBench reports 32 simulator task instances spanning 21 task designs. Demonstrations with health feedback, post-hoc filtering and damage-penalized RL improve the reported safe-completion metrics. Off-the-shelf GR00T evaluation reveals large completion-versus-safe-completion gaps. The framework is portable across OmniGibson and RoboCasa for supported signals; thermal/fluid implementations are supplied only in OmniGibson. Damage thresholds/scales are manually configured proxies, not measured universal material laws.
I Introduction
A robot may reach a goal while breaking nearby objects, overheating components or spilling liquid onto electronics. Standard task-only simulation metrics can miss these consequences. DamageSim adds object-centric health and makes it available for feedback, filtering, observations, rewards or termination. OopsieBench supplies deliberately risky alternatives to safer strategies. The contribution is reusable instrumentation and benchmark design; meaningful scores still depend on the chosen object parameters and simulated interaction signals.
II Related Work
Control barriers, reachability and safe-learning methods need definitions of unsafe behavior. OopsieVerse provides an additional damage-based signal for those methods rather than replacing their assumptions or proving new control guarantees. BEHAVIOR-1 K and RoboCasa supply household task/scene infrastructure. The paper retains separate completion and safe-completion measurements to expose risks hidden by task success alone. Its notion of safety remains the configured physical-damage proxy, not every possible social or semantic hazard. See BEHAVIOR-1K, RoboCasa and control barriers.
Original selectable panel captions and notation
(a) Impact Damage
(b) Compression Damage
(c) Tension Damage
(d) Thermal Damage
(e) Liquid Damage
III DamageSim
DamageSim augments the task state with object/link health and computes health losses from simulator signals. This health may affect policy observations, reward terms or episode termination, according to the experiment. The original task physics remain intact. Consequently, an object can be assigned zero health without its mesh actually fracturing or its dynamics changing. This design enables portable monitoring while separating damage measurement from detailed material simulation.
III-A Damage-Aware POMDP Formulation
The original POMDP receives an additional health state. Observations, rewards and terminal conditions can then depend on the augmented state. This formalism makes health explicit and allows different learning interfaces, but state augmentation alone provides no safety guarantee. Whether a controller observes health or merely receives a damage penalty is an experimental choice. The exact original state/action/transition/observation definitions remain available in the preserved mathematical context.
Original mathematical definitions, damage assumptions and evaluation protocol
Robotic tasks can be formulated as Partially Observable Markov Decision Processes (POMDP) [27] defined by the tuple , where is the state space, the action space, the transition function, the reward function, the observation space, the observation function, and the discount factor. In most existing simulators, this POMDP is specified purely in a task-completion-centric manner: the state, reward, and termination conditions only reflect whether the task has been completed. However, this neglects a common characteristic of the real world problems: to be correctly completed, the agent should avoid damaging the objects and itself when completing the task [28]. By omitting such damage considerations from the state, the resulting behaviors in simulation may seem successful, while leading to dangers that cannot be executed in the real world.
Original mathematical definitions, damage assumptions and evaluation protocol
To address this divergence between sim and real, we propose a damage-aware POMDP , an augmentation of the original simulation POMDP that explicitly includes a health state, , enabling the approximation of damage-inducing processes absent in existing simulators (see Fig. 2). In the damage-aware POMDP, , the health-augmented state space, , can serve as basis to generate new damage-aware elements for other components of the POMDP —the observations, the termination conditions, the reward—, better approximating the real-world task.
III-B Damage-Aware POMDP Implementation: DamageSim
Each link starts with health 100; object health is the minimum over its links, and damage evaluators accumulate losses. Mechanical load combines contact-force magnitudes parallel and orthogonal to acceleration using configurableα/βweights, then penalizes load above a threshold. This is a force-based heuristic, not a stress/fracture model or a reliable physical separation of impact, compression and tension. The excerpt does not fully specify the zero-acceleration direction convention. Thermal loss increases outside an object's temperature range; fluid loss increases beyond a contact-particle threshold. Both need backend signals absent from the supplied MuJoCo implementation. Increments are computed per physics step; cross-timestep physical calibration is not demonstrated. Full formulas and object parameters remain unchanged.
Original mathematical definitions, damage assumptions and evaluation protocol
Concretely, we assume the simulated scene contains multiple objects, , each one composed of one or multiple links, , whose common physical state (pose, velocity, forces acting on it through contact, etc.) , can be retrieved from an underlying physics simulator. To augment this state, we keep track of the health of each link of an object, , and associate an object health to the minimum health of its links, . This provides a semantically meaningful health understanding: an object (or the robot) is fully damaged when one or more of its links are fully damaged. We rank health to range between a maximum value, (completely undamaged), and (completely damaged) for all objects and links, and use a unifying scale for all objects () that enables easy comparisons of health state. The overall environment health state at time is given by: . The link health values are updated using a set of Damage Evaluation Models (DEM). Each DEM models a specific source of physical damage (e.g., mechanical damage, thermal damage, etc.) using the current simulator state, , to output a damage value . The aggregated damage value across all DEMs represents the decrease in the object’s health: .
Original mathematical definitions, damage assumptions and evaluation protocol
Computing the effect of impulsive vs. constrained/sustained forces requires understanding the kinematic (motion) nature of the links. For each link, at each physics step , we obtain from the physics simulator the set of contact forces acting on the link, , and the link’s kinematic information, which includes the link acceleration, (in the following, we drop the link suffixes for readability). We can then decompose each contact force, , into components parallel and orthogonal to the direction of acceleration : and , and aggregate them across contact points:
Original selectable mathematical display
Equation
Original mathematical definitions, damage assumptions and evaluation protocol
Intuitively, captures contact aligned with the change in motion (impulsive interactions), while captures the remaining contact that is not aligned with it (i.e., sustained/constrained loading).
Original mathematical definitions, damage assumptions and evaluation protocol
Inspired by the materials physics, we approximate the effective mechanical load acting on the link as , where and are user-specified coefficients that control sensitivity to sustained versus impulsive loading [30]. For example, a paper cup typically deforms more easily under sustained compressive loading (e.g., squeezing or crushing) than under brief impulsive contact (e.g., dropping it). Finally, DamageSim models the incremental mechanical damage at time as
Original selectable mathematical display
Equation
Original mathematical definitions, damage assumptions and evaluation protocol
where represents a minimal load threshold analogous to a material’s yield or fracture limit [29], and scales the rate at which damage accumulates beyond this threshold [31]. Both parameters can be specified per link to reflect material properties: brittle (fragile) objects are modeled with lower thresholds and higher damage scaling, while ductile objects use larger threshold and lower scaling. Fig. 3 a), b) and c) depict common cases of mechanical damages due to impact, compression and tension obtained by our mechanical damage evaluation model.
Original mathematical definitions, damage assumptions and evaluation protocol
Similar to our mechanical damage evaluation model, our thermal evaluation model evaluates if the temperature of an object goes over/under physically grounded thresholds and scales the damage according to material properties. At each timestep , we retrieve the object temperature (OmniGibson provides only temperature per object, not link), , from the underlying physics simulator. Thermal damage is then modeled in DamageSim as:
Original selectable mathematical display
Equation
Original mathematical definitions, damage assumptions and evaluation protocol
where the thresholds specify the range of tolerated temperatures, and indicate how quickly damage accumulates beyond the range based on material properties, e.g., cookware exhibits high and/or small , while burnable plastic items like toys are defined with a lower and larger . Both thresholds can be made very large positive/negative values to indicate that an object cannot be damaged by fire or by freezing temperatures. Fig. 3.d depicts an example of the results of our thermal damage evaluation model.
Original mathematical definitions, damage assumptions and evaluation protocol
Analogous to the previous evaluation models, in our fluid damage evaluation model we compute whether the fluid particles in contact with a link go over a given threshold and scale the effect into damage based on the resistance of the link to liquid harm. At each timestep , we retrieve the amount of liquid particles in contact with each link, . DamageSim then models fluid damage as:
Original selectable mathematical display
Equation
Original mathematical definitions, damage assumptions and evaluation protocol
where threshold controls how much exposure is tolerated before damage begins, and controls the rate at which damage accumulates thereafter. Waterproof objects can be modeled with large and/or near-zero , while electronics or liquid-delicate materials are defined with a low and larger . Fig. 3.e depicts an example of the damage due to fluid obtained with our fluid damage evaluation model.
IV OopsieBench
The paper reports 32 task instances:17 OmniGibson and 15 RoboCasa, corresponding to 21 task designs. TableB.1 retains the complete grouped task descriptions, tracked-object counts and anticipated hazards. Some rows combine actions such as opening/closing drawers, so the table is not a canonical list of 32 separate task IDs. Supported backend/task configurations should be used when reproducing it. The main text says 90 demonstrations across five tasks; TableC.2 lists 360 total, while the conclusion says 450. These inconsistent dataset totals are preserved and not silently reconciled.
V Experiments
Experiments cover demonstration collection/filtering, three RL settings, VLA evaluation and two sim-to-real tasks. Damage is the common instrumentation signal, while policy observations, action spaces and safety criteria differ between studies. Success and safe success therefore need their experiment-specific definitions. Most simulations use 30 reported evaluation episodes; several printed percentages do not align with that binary denominator, and additional averaging/exclusions are not specified.
V-A OopsieVerse for Imitation Learning
Five imitation-learning regimes use all data, only health-feedback data, only no-feedback data, whole-episode filtering, or timestep filtering over the next 8 steps. Episode filtering removes trajectories if any health falls below 95; safe completion requires task success and all health above 95. Using feedback/filtering generally narrows the success–safe-success gap. The source's unfiltered Wipe Countertop example reports 100% completion and 35% safe completion;35% is not an integer count out of 30 without extra aggregation. Full Figure 5 bars and Figure 7 trajectory overlays retain the results. The actor uses task-object segmentation plus proprioception, rather than unrestricted RGB or direct deployment health observations.
Original mathematical definitions, damage assumptions and evaluation protocol
removes episodes from the full dataset where any object’s health falls below at any timestep, testing whether episode-level curation can recover safety from mixed-quality data.
Original mathematical definitions, damage assumptions and evaluation protocol
removes individual timesteps from the full dataset whose subsequent steps incur damage exceeding a certain threshold. This filtering strategy is a middle ground between All Data and Health-Filtered Episodes. It preserves more data, but is myopic if is small. In this experiment, we set , which is the same as the action chunk length.
Original mathematical definitions, damage assumptions and evaluation protocol
Fig. 5 presents evaluation results averaged over rollouts per task. We report two metrics to disentangle task performance from safety: Task Completion Rate measures success regardless of damage, while Safe Task Completion Rate requires both task success and all object health remaining above . The gap between these metrics quantifies how often policies succeed through unsafe behaviors. Results reveal a consistent pattern across all five tasks: policies trained on unfiltered data (green) or data collected without live feedback (blue) achieve high task completion rates but exhibit a substantial gap to safe task completion, indicating that these policies complete tasks through unsafe behaviors that standard evaluations would overlook. For instance, on Wipe Countertop, the unfiltered policy achieves perfect task completion but only safe completion. In contrast, policies trained on data leveraging OopsieVerse’s damage signal—whether through real-time feedback during collection (orange) or post-hoc filtering (red, purple)—substantially improves the safe task completion rates. Fig. 7 visualizes the trajectory distributions for the Shelve Cereal Box task, comparing policies trained without health feedback (red) versus with health-filtered episodes (green). The policy trained on filtered data exhibits a tighter distribution concentrated toward the right side of the shelf—a region free of fragile objects. In contrast, the unfiltered policy produces more trajectories that frequently place the cereal box near or against fragile items. These results confirm that OopsieVerse provides sufficiently accurate feedback to guide both human operators in real time and automated curation after the fact toward safer imitation learning.
V-B OopsieVerse for Reinforcement Learning
A damage penalty is added to task reward. DSRL changes the initial-noise distribution of a frozen flow policy, Gaussian-policy PPO fine-tunes a water-transport controller, and PPO trains plate placement from scratch. Reported safe completion rises 13→33%,20→100%, and near 0→over 80%, respectively. These are three particular policies/tasks, not one architecture-independent guarantee. Rewards and action/observation spaces differ across them. The appendix preserves training settings and curves, including inconsistencies between stated total steps and plotted time axes. The methods draw on flow matching, DSRL and PPO.
Original selectable mathematical display
Equation
Original mathematical definitions, damage assumptions and evaluation protocol
where denotes the task reward and controls the weight of the damage penalty. This formulation encourages the policy to complete tasks while minimizing damage across all modalities.
Original mathematical definitions, damage assumptions and evaluation protocol
Fig 8 summarizes evaluation results using the same metrics as Section V-A. DSRL improves safe task completion on Shelve Cereal Box from to . Fine-tuning the Gaussian policy yields a larger gain on Move Cup of Water, increasing safe success from to . These two fine-tuning results demonstrate that IL policies can be steered toward safety using the signals derived from DamageSim. Finally, training from scratch with DamageSim’s damage penalty achieves over safe task completion compared to almost when using task reward alone. These results confirm that OopsieVerse provides a practical reward signal for training safe policies with RL—whether refining existing policies or training new ones—complementing its utility for imitation learning.
V-C Benchmarking VLAs on OopsieVerse
GR00T is evaluated off the shelf on eight selected manipulation subtasks. For example, opening an OmniGibson microwave door has 92% completion but 4% safe completion, and igniting wood 60% versus 0%. The text defines VLA safe completion as no damage events, stricter than the 5-point tolerance used in IL/RL. It states 30 episodes/task, yet TableI's 4%-spaced rates are incompatible with simple integer counts out of 30; the aggregation is not explained. Average environment health measures a different quantity and can hide severe harm to one object. The exact model checkpoint/prompting configuration is not fully detailed. TableI and the additionalπ0 comparison remain intact. The original model references are GR00T and π0.
V-D Sim-to-real Transfer from OopsieVerse
Simulation-trained low-dimensional policies transfer directly to a Franka Panda on shelving and pouring. Inputs include proprioception and object poses; the paper does not establish vision-only transfer. Ten trials per method per task give 20 per-method trials. Filtered data achieves 75% completion/65% safe completion/15% unsafe behavior versus 70/5/75% for no-feedback data. Unsafe behavior drops 60 percentage points, equivalent to 80% relative reduction; the source calls it a 60% reduction. Hardware safety is judged by observable toppling/spills/contact, not simulator health. Small trial counts and qualitative damage assessment limit generalization.
Accessible original table, complete values and task/parameter definitions
| Task | C [%] | SC [%] | Avg. Health |
| (B1K-OG) attach camera | 8 | 4 | 71.25 |
| (B1K-OG) open microwave door | 92 | 4 | 33.55 |
| (B1K-OG) pick up scrubber | 28 | 8 | 85 |
| (B1K-OG) ignite wood | 60 | 0 | 8 |
| (RC-MJC) Open Single Door | 92 | 32 | 50.73 |
| (RC-MJC) Turn On Microwave | 92 | 12 | 41.48 |
| (RC-MJC) PnP: Counter to Microwave | 20 | 20 | 29.28 |
| (RC-MJC) Turn On Stove | 88 | 8 | 0.2192 |
VI Limitations and Conclusion
The useful result is a reusable, configurable damage signal that changes data selection, rewards and evaluation conclusions. Damage models approximate mechanical fracture, heat and liquid effects; users annotate thresholds/scales per object/link. The paper proposes future automation with language/vision models but does not demonstrate that calibration process here. Supplied benchmark settings make experiments possible; they do not establish quantitative equivalence to real materials, identical physical calibration across simulators or a broad deployment safety certificate.
Acknowledgments
The work acknowledges support from the UT-CNS Catalyst Grant and Toyota Research Institute's Young Faculty Researcher Program. The complete 38-entry bibliography is retained, including the source's separateπ0 andPPO entries rather than deduplicating them.
Original simulator, learning and hardware demonstrations
All 65 original MP 4 files and four project images are preserved locally with unchanged source bytes and source URLs, plus derived preview posters. They include simulator damage examples, the task grid, feedback UI, paired IL examples, RL training, VLA failures and four hardware clips. Simulation red tint/health bars visualize the configured damage proxy; the hardware clips show observable behavior. Multiple camera views or alternative edits do not expand the paper's trial counts.




Appendix
The appendix supplies the constrained-MDP formulation, full task table, imitation/RL architectures and hyperparameters, additional VLA results and all per-object damage parameters. These details remain accessible alongside the condensed notes. They specify what the reported health values mean and expose several source accounting or protocol ambiguities.
A Constrained MDP Formulation
A CMDP can maximize expected discounted task reward subject to expected discounted cumulative damage below a budget. Equation 1 defines total damage cost; Equation 2 gives the constraint. This is an expectation-level discounted budget, rather than a hard guarantee that every rollout or every object stays below an undiscounted damage limit. The prose describes a maximum allowable episode loss, which is stronger than the printed expected discounted constraint. The edition preserves both and makes their distinction explicit.
Original mathematical definitions, damage assumptions and evaluation protocol
Our tasks can be formally represented by the CMDP tuple , where is the health-augmented state space, is the action space, is the transition function including the health update rule defined in Section III, and is the discount factor.
Original mathematical definitions, damage assumptions and evaluation protocol
In this context, the task-specific reward function corresponds to , rewarding purely functional achievements such as goal proximity or object placement. The damage cost function is defined by the total damage signal produced by our suite of Damage Evaluation Models (DEMs) at each time step :
Original selectable mathematical display
Equation 1
| (1) |
Original mathematical definitions, damage assumptions and evaluation protocol
The parameter represents the damage budget, specifying the maximum allowable cumulative health loss an agent or any object may incur over the course of an episode.
Original mathematical definitions, damage assumptions and evaluation protocol
Under the CMDP framework, the objective is to find a policy that maximizes the expected task reward while ensuring the expected damage does not exceed the budget :
Original selectable mathematical display
Equation 2
| (2) |
B Tasks in OopsieBench
TableB.1 lists shared tasks plus backend-specific settings, anticipated mechanical/thermal/fluid risks and tracked-object counts. The text says the instrumentation can extend to existing 1,000 BEHAVIOR and 360 RoboCasa tasks when suitable object parameters/signals exist. This is compatibility/extensibility, not evaluation on all 1,360 tasks. Damage tracking can omit unconfigured objects, so the configured tracked set is part of the evaluation specification.
Accessible original table, complete values and task/parameter definitions
| Task | Task Type | Anticipated Damage Type/s | # Damageable Objects |
| BEHAVIOR-1K and Robocasa | |||
| Place Plate | free-space pick-and-place | impact damages to plate | 2 |
| Pick Egg | delicate object grasping | crushing damage to egg | 2 |
| Shelve Cereal box | contact-assisted placement | impact damage to delicate objects | 6 |
| Wipe Counter | sustained surface interaction | compression damage to robot | 1 |
| Open Single Door | articulated object actuation | constraint violation damage to door/robot | 2 |
| Place in Microwave | constrained-space insertion | compression/shear damage to food/robot | 2 |
| Open/Close Drawer | articulated object actuation | constraint violation damage to drawer/robot | 2 |
| Navigate and Pick | contact-rich nav | impact damage to delicate objects or compression damage to robot | 2 |
| Turn on Stove | articulated object actuation | constraint violation damage to stove knob/robot | 2 |
| Turn on Faucet | articulated object actuation | constraint violation damage to stove knob/robot | 2 |
| Robocasa only | |||
| Serve Pastry | delicate object grasping + transport | crushing/impact damage to pastry | 3 |
| Prepare Breakfast | dynamic object transport | impact damage when objects spill from tray | 3 |
| Dishes to Sink | fragile object pick and place | impact damages to fragile objects | 3 |
| Prepare Coffee | constrained-space insertion | compression damages to robot | 3 |
| Turn on Microwave | button actuation | compression damage to microwave/robot | 2 |
| BEHAVIOR-1K only | |||
| Pour Water (in cup) | fluid-aware manipulation | fluid-induced damage to laptop | 2 |
| Fill Bowl | |||
| (with faucet running) | fluid-aware manipulation | fluid-induced damage to gripper | 1 |
| Add Firewood (to a lit fireplace) | fire-aware manipulation | thermal damage to robot | 1 |
| Attach Camera (to a tripod) | fragile object insertion | impact damage to camera | 2 |
| Pick up Scrub | precise picking | compression damage to robot | 2 |
| Ignite wood | fire-aware manipulation | thermal damage to robot | 1 |
C OopsieVerse for Imitation Learning
The IL appendix describes paired feedback/no-feedback demonstrations, a conditional-flow policy and 30-episode evaluation. It retains the exact per-task data inventory and network/training settings. Safe-data curation changes which state/action samples train the policy. It does not mean the actor receives simulator health at inference or that object segmentation is available automatically on arbitrary real scenes.
Accessible original table, complete values and task/parameter definitions
| Task | Task Objects |
| |||
| Shelve Item |
|
||||
| Pick Egg | Egg | ||||
| Add Firewood | Log, Fireplace, Robot | ||||
| Pour Water |
|
||||
| Wipe Counter |
|
Accessible original table, complete values and task/parameter definitions
| Hyperparameter | Value |
| Architecture | |
| Feature dimension | 512 |
| Transformer layers | 4 |
| Attention heads | 8 |
| FFN expansion factor | 4 |
| Attention dropout | 0.1 |
| FFN dropout | 0.2 |
| Segmentation embedding dim | 32 |
| Segmentation image size | |
| Frame stack | 2 |
| Action chunk size | 8 |
| Action dimension | 7 (6 for Pour Water) |
| Proprioceptive state dimension | 23 |
| Flow Matching | |
| Training timestep sampler | |
| Flow-matching inference steps | 16 |
| Training | |
| Optimizer | AdamW |
| Learning rate | |
| Weight decay | |
| Batch size | 64 |
| Gradient clipping (max norm) | 5.0 |
C.1 Demonstration Data Collection
TableC.2 gives 90 shelving episodes,90 egg episodes and 60 each for firewood, pouring and wiping, split equally by feedback condition. These sum 360, inconsistent with the main text's 90 across-five claim and conclusion's 450. The separate water-transport BC experiment adds 50 demonstrations, which still does not explain 450. The source totals are retained without inventing missing demonstrations or assigning a corrected canonical dataset size.
C.2 Model Architecture
Three cameras each contribute two 128×128 task-object segmentation frames. Learned 32-dimensional class embeddings pass through residual convolutions to 512-dimensional visual tokens;23-dimensional proprioception supplies a seventh observation token. A four-layer transformer predicts 8-step action chunks, usually 7 dimensions; TableC.3 lists 6 for POUR WATER. Sixteen Euler integration steps sample the flow. This architecture uses structured segmentation and proprioception; the real-transfer study separately uses low-dimensional object states. Exact tensor shapes, normalization and decoder context are preserved.
Original mathematical definitions, damage assumptions and evaluation protocol
Observation and action spaces. The policy’s observation space consists of visual and proprioceptive inputs. The visual input consists of six segmentation images from three camera viewpoints (one wrist-mounted, two external). We only provide segmentation to task objects (refer to Table. C.2). To mitigate partial observability, we stack the last frames for each camera. The proprioceptive input is a -dimensional vector encoding the manipulator’s joint positions, velocities, end-effector pose, and the gripper position. The policy predicts an action chunk of horizon . Each step in the chunk is a -dimensional vector containing the desired delta-translation ( dims), delta-rotation ( dims), and gripper command ( dim). All action outputs are normalized to during training and denormalized for inference.
Original mathematical definitions, damage assumptions and evaluation protocol
Segmetation and proprioception state encoder. The segmentation encoder converts integer-valued instance segmentation masks into dense feature vectors. It is shared across all camera views and frame-stacked observations. Each segmentation image is a map of integer class IDs. The encoder first maps each pixel’s class ID to a 32-dimensional dense vector through a learned embedding table. This converts the discrete segmentation mask into a continuous tensor of shape , which can be interpreted as a 32-channel image. This embedded representation is then processed by a residual convolutional network consisting of four modules. Each module contains a residual block followed by a strided convolution that halves the spatial resolution. The residual blocks use two convolutions with GroupNorm ( groups) and SiLU activations, with a skip connection that applies a projection convolution when the input and output channel dimensions differ. The channel dimensions progress as across the four modules, reducing the spatial dimensions from down to . A final residual block with channels is applied after the last stage. The resulting feature map is spatially pooled using average pooling, producing a -dimensional vector. This vector is then projected to the model’s feature dimension () through a two-layer MLP with a SiLU activation in between. At each timestep , we can obtain segmentation feature vectors , where the superscript camera index. The most recent frame of the 23-dimensional proprioceptive state is encoded by a 3-layer MLP, which produces a single 512-dimensional vector .
Original mathematical definitions, damage assumptions and evaluation protocol
Action decoder. Following the architectural design of , we employ a Transformer backbone to parameterize the flow matching velocity field. The model predicts the denoising velocity conditioned on the current noisy action, the observation, and the flow timestep .
Original mathematical definitions, damage assumptions and evaluation protocol
The encoder output observation tokens (comprising segmentation embeddings and proprioceptive embedding ). We project the noisy action chunk at the flow matching step into tokens, denoted as . The flow matching timestep is mapped to a high-dimensional embedding via a 2-layer MLP with SiLU activations. The full input sequence to the Transformer is formed by concatenating the observation context, the timestep embedding, and the noisy action tokens . This input sequence is processed by a stack of 4 transformer layers, each consisting of multi-head self-attention (8 heads, 64 dimensions per head) followed by a feed-forward network that expands the feature dimension from 512 to 2048 with a GELU activation before projecting back to 512. Both sublayers use post-norm residual connections with LayerNorm. To generate the flow matching update, we extract the last tokens corresponding to the action chunk from the Transformer output. These tokens are passed through a final linear projection layer to produce the predicted velocity field .
Original mathematical definitions, damage assumptions and evaluation protocol
Inference We generate action chunks by integrating the learned flow using a fixed-step Euler solver with steps, initialized from a standard Gaussian prior .
C.3 Training and Evaluation
TableC.3 retains AdamW 3×10⁻⁴, weight decay 10⁻³,batch 64, gradient cap 5,8 heads, feed-forward expansion 4 and Beta(1.5,1.0)training-time sampling. Thirty evaluation episodes perturb object poses/scales. The source does not report full seed-level uncertainty or reconcile all bar percentages with that denominator. Dataset filtering and training-data volume differ across regimes, so results reflect those combined changes.
Original mathematical definitions, damage assumptions and evaluation protocol
Table C.3 lists the specific hyperparameters used for training and inference. To evaluate performance, we conduct episodes per model. In each episode, we introduce random perturbations to the initial poses and scales of the scene objects to assess the policy’s robustness to scene variations.
D OopsieVerse for Reinforcement Learning
The RL appendix defines three distinct studies: latent-noise steering of a frozen flow policy, PPO fine-tuning after Gaussian BC, and PPO plate placement from scratch. Complete tablesD.4–D.6 and all four training-curve panels remain. Their observations, actions, rewards and budgets differ; a favorable result in one setting should not be read as a single common-policy comparison across all tasks.
D.1 Diffusion Steering (DSRL) for Shelve Item
DSRL optimizes initial action noise with PPO while freezing the base flow policy and encoders. Full 8-step chunks execute before the next latent is chosen. A sparse shelving-success reward is combined with normalized damage. TableD.4 gives a 5-layer 1024-wide noise MLP, clamped means/std/samples, PPO rate 10⁻⁴,5 epochs,512 minibatch size,γ/GAE 0.95 and 5.2×10⁵steps. FigureE.1 shows smoothed task return and damage, not confidence bands or a calibrated hardware-risk probability.
Accessible original table, complete values and task/parameter definitions
| Hyperparameter | Value |
| Noise Policy Network | |
| Architecture | 5-layer MLP |
| Hidden dimension | 1024 |
| Activation | SiLU |
| Mean clamp range | |
| Std clamp range | |
| Noise sample clamp range | |
| Initial std | 0.5 |
| PPO | |
| Optimizer | Adam |
| Learning rate | |
| Clip ratio | 0.2 |
| PPO epochs per iteration | 5 |
| Minibatch size | 512 |
| Entropy coefficient | 0.0 |
| Gradient clipping (max norm) | 1.0 |
| Total steps | |
| GAE | |
| Discount | 0.95 |
| GAE | 0.95 |
| Data Collection | |
| Replay buffer size | 2048 |
Original mathematical definitions, damage assumptions and evaluation protocol
Unlike standard fine-tuning approaches that update the entire diffusion backbone, DSRL optimizes a learned initial noise distribution to select specific noise (latents) that maximize returns. In our setup, we train a policy using Proximal Policy Optimization (PPO) [38] to output the mean and variance of the initial noise , replacing the standard Gaussian prior .
Original mathematical definitions, damage assumptions and evaluation protocol
To minimize computational overhead and preserve the learned feature representations for the base policy, we leverage the frozen encoder from the imitation learning policy described in Section C.2. The DSRL policy is conditioned on these embeddings and outputs the distributional parameters (mean and variance) for the steered initial noise . Crucially, freezing the encoders prevents the RL optimization from degrading the visual and proprioceptive features essential for the base policy’s performance. For this experiment, we specifically target the baseline policy trained without health feedback. As this policy exhibited the highest likelihood for unsafe behavior, it serves as the ideal candidate to evaluate the efficacy of damage-aware steering. The hyperparameters for the PPO training phase are detailed in Table D.4.
Original mathematical definitions, damage assumptions and evaluation protocol
For the Shelve Item task, we define the task completion as one where the cereal box is fully contained within the shelf boundaries and the gripper has released the object. We use a sparse task reward, assigning a reward only upon task completion, otherwise . To incentivize safety, we incorporate a penalty term derived from the the damage computed by DamageSim. This damage signal is normalized across the all task objects to the range , ensuring the penalty magnitude is the same with the sparse task reward. During training, the base policy receives a latent from the DSRL policy and generates a full action chunk . This chunk is executed completely before computing the next latent, enabling faster training by avoiding flow matching policy inference at every simulator step.
Original mathematical definitions, damage assumptions and evaluation protocol
Fig. E.1 shows the training curves for the task completion reward (green) and the damage caused by the policy (yellow). We observe that with steering, the task completion reward remains stable at levels comparable to the initial base policy, while damage consistently decreases. This demonstrates that DamageSim provides effective damage and health signals for steering the flow matching policy toward safer behaviors.
D.2 Finetuning a BC-Gaussian Policy for Move Glass of Water
Water transport begins with 50 BC demonstrations,25 safe/25 unsafe. The policy observes 14 Dend-effector/mug poses and predicts only 3 Dposition deltas while holding the gripper closed. BC success 100% but safe success 20% motivates 30,000 PPOsteps. Rewards include negative goal distance,+300 success bonus and a terminal damage penalty. TableD.5 retains the four-layer network and optimization details. The plotted water-training axis extends beyond the stated 3×10⁴steps without an explained conversion, so the edition does not infer a corrected training budget.
Accessible original table, complete values and task/parameter definitions
| Hyperparameter | Value |
| Policy / Value Networks | |
| Architecture (actor & critic) | 4-layer MLP |
| Hidden dimensions | 256–1024–1024–256 |
| Activation | Tanh |
| Action distribution | Gaussian + Tanh squashing |
| Initial log-std | |
| Observation | EEF pose + mug pose (14D) |
| Action | EEF position delta (3D); gripper held closed |
| Behavior Cloning (BC) | |
| Offline dataset | 50 teleop demos (25 safe, 25 unsafe) |
| BC epochs | 20 |
| BC objective | Maximize log-likelihood of demo actions |
| PPO Finetuning | |
| Optimizer | Adam |
| Learning rate | (annealed) |
| Total steps | |
| Rollout length | 512 |
| Update epochs per iteration | 8 |
| Minibatches per update | 4 (minibatch size 128) |
| Clip ratio | 0.1 |
| Entropy coefficient | 0.0 |
| Value loss coefficient | 0.7 |
| Gradient clipping (max norm) | 0.5 |
| Target KL | 0.01 |
| Discount | 0.99 |
| GAE | 0.95 |
Original mathematical definitions, damage assumptions and evaluation protocol
Rewards combine a task-progress term with a safety penalty derived from DamageSim (see Sec. V-B). Concretely, the task reward is the negative distance to a fixed goal position on the target surface, with a large terminal bonus on success. A rollout terminates either when the mug reaches the goal (yielding a success reward) or when accumulated damage causes any tracked entity’s health to reach zero (yielding a large negative terminal penalty). The overall scalar reward at each step is the sum of the task-distance reward and the damage-derived reward (with unit weights in our implementation). All PPO and BC hyperparameters are summarized in Table D.5.
D.3 RL from Scratch for Place Plate
Plate placement starts with a plate already grasped. A 6 Dend-effector/plate-position state maps to 4 Dtranslation/gripper actions. PPO compares task-only reward with damage weight 2, encouraging gentler placement instead of dropping. TableD.6 specifies two 512-wide layers and 10⁵total steps. FigureE.1's plate axes extend to millions of plotted timesteps, which the source does not reconcile with that table. Preserve the curves and stated settings separately rather than silently changing either.
Accessible original table, complete values and task/parameter definitions
| Hyperparameter | Value |
| Observation / Action Spaces | |
| Observation space | 6D () |
| Action space | 4D () |
| Policy / Value Networks | |
| Policy distribution | Gaussian + Tanh squashing |
| Actor architecture | 2-layer MLP (512, 512) |
| Critic architecture | 2-layer MLP (512, 512) |
| Activation | Tanh |
| Initial log-std (arm dims) | |
| Initial log-std (gripper dim) | |
| PPO | |
| Optimizer | Adam |
| Learning rate | (annealed) |
| Total steps | |
| Rollout length | 512 |
| Update epochs per iteration | 10 |
| Minibatches per update | 8 |
| Clip ratio | 0.2 |
| Entropy coefficient | 0.0 |
| Value loss coefficient | 0.5 |
| Gradient clipping (max norm) | 0.5 |
| Target KL | 0.01 |
| Discount | 0.99 |
| GAE | 0.95 |
Original mathematical definitions, damage assumptions and evaluation protocol
Our task reward is a dense signal given by the negative distance to the goal position, with a large positive success bonus (similar to the Move glass of water task). For the damage-aware setting, we add the same damage-derived penalty term used in the other RL experiments (see Sec. V-B). We set the damage weight to for this task.
E Additional VLA experiments
The appendix reportsπ0 at 17.5% completion/0% safe completion on four RoboCasa VLA tasks, versus GR00T 73/18% averages. The latter averages match TableI's four RoboCasa rows.π0 performs no meaningful behavior on BEHAVIOR subtasks according to the authors. This is a particular off-the-shelf checkpoint/setup result; it does not establish everyπ0 variant or later release's safety performance. FigureE.1 contains the separate RL learning curves with moving-average windows 10 or 60 episodes, not uncertainty intervals.
F Setting Object Parameters
TablesF.7–F.9 retain all mechanical, thermal and liquid thresholds/scales. Defaults may be overridden per object/link, and tracking can be restricted to selected entities. Thermal implementation uses one symmetric scale for hot/cold loss, while the main formula allows separate scales. These editable settings define a proxy for harmful interaction. They are not measured universal fragility constants, and results depend on which objects are tracked, the chosen thresholds and the underlying simulator signals.
Accessible original table, complete values and task/parameter definitions
| Object | ||||
| default | 1.0 | 1.0 | 30.0 | 0.1 |
| agent (robot) | 0.01 | 1.0 | 70.0 | 0.2 |
| microwave | 1.0 | 1.0 | 100.0 | 1.0 |
| camera_tripod | 0.1 | 1.0 | 150.0 | 1.0 |
| digital_camera | 1.0 | 0.5 | 60.0 | 100.0 |
| scrub_brush | 0.01 | 0.01 | 300.0 | 100.0 |
| bottle_of_wine | 1.0 | 0.5 | 50.0 | 100.0 |
| wineglass | 1.0 | 0.5 | 15.0 | 100.0 |
| bottle_of_beer | 1.0 | 0.5 | 15.0 | 100.0 |
| bag_of_flour | 0.1 | 0.1 | 150.0 | 100.0 |
| box_of_crackers | 0.1 | 0.8 | 200.0 | 1.0 |
| stand | 0.001 | 0.001 | 500.0 | 1.0 |
| laptop | 1.0 | 0.5 | 80.0 | 100.0 |
| water_glass | 1.0 | 0.5 | 50.0 | 100.0 |
| coffee_cup | 1.0 | 0.5 | 150.0 | 1.0 |
| plate | 1.0 | 0.5 | 50.0 | 10.0 |
| vase | 1.0 | 0.5 | 30.0 | 10.0 |
| pedestal_table | 0.1 | 0.1 | 150.0 | 1.0 |
| swivel_chair | 0.1 | 0.1 | 500.0 | 1.0 |
Accessible original table, complete values and task/parameter definitions
| Object | |||
| agent (robot) | 40.0 | -20.0 | 1.0 |
| camera_tripod | 50.0 | -30.0 | 0.1 |
| digital_camera | 50.0 | -30.0 | 0.1 |
| laptop | 50.0 | -20.0 | 0.1 |
| vase | 60.0 | -40.0 | 0.01 |
| pedestal_table | 60.0 | -40.0 | 0.01 |
| swivel_chair | 60.0 | -60.0 | 0.01 |
Accessible original table, complete values and task/parameter definitions
| Object | ||
| agent (robot) | 10.0 | 10.0 |
| digital_camera | 20.0 | 5.0 |
| laptop | 20.0 | 5.0 |