Network-Aware Safety Budgets for Remotely Controlled Soft Actuators

Soft robots are often driven close to the point where their actuators break. Shape-memory-alloy wires overheat and pneumatic chambers burst, and a soft body usually carries too little computer on board to run the vision models needed to estimate its own shape. Both pressures push control into the cloud, reached through web-friendly bridges that non-roboticists can program. Today's robot-side safety logic, however, assumes the next command arrives on time. The network meanwhile treats the robot's packets as generic traffic and has no idea that one actuator is a few hundred milliseconds from damage while another has seconds to spare.

We propose to make that slack explicit. A small on-robot supervisor computes, from a simple model of the actuator, how long the robot can safely keep executing its current command if no new command arrives. It clamps commands so that this "safe hold time" always exceeds the latency the current network path is likely to deliver. When it cannot, it asks the transport layer for a more expensive, more reliable delivery mode, such as sending duplicate packets over several carriers or preempting a co-located video stream. The safe hold time travels inside the web message itself. A cloud policy written by someone who knows nothing about actuator physics therefore receives a machine-checkable safety contract, and a constrained learning algorithm can learn to stay away from the clamp rather than lean on it.

Core Claim

The quantity that should link a soft robot's physical safety to its communication service is a state-dependent deadline: the time until an actuator limit is breached under the command currently being held. Robot-side safety filters can be made delay-tolerant by enforcing this deadline against measured tail latency rather than assuming instant delivery. Costly reliability measures can be bought only when that deadline is short. We expect this pairing to give zero actuator-limit violations under realistic latency spikes at a fraction of the redundancy cost of always-on reliable delivery, and with less task loss than a latency-blind local clamp. The novelty is the two-way coupling. Network latency sets how hard the supervisor clamps, and the clamp's remaining margin sets what network service is requested. No paper in our file does either direction.

Research Program

The method starts from Safe Supervisory Control of Soft Robot Actuators. That work splits a soft limb into complex body dynamics and simple affine actuator dynamics, such as wire temperature. At each step it computes a maximum safe input $u^{MAX}$ by set-invariance arguments. It runs as a hard-wired local loop with no notion of delay. We generalize it as follows. Let the actuator state $x_k$ (for example temperature or chamber pressure) evolve as $x_{k+1} = A x_k + B u_k + d_k$, where $A$ and $B$ are identified constants, $u_k$ is the input, and $d_k$ is a bounded disturbance with $|d_k| \le \bar d$. The safe hold time of a candidate input $u$ is

$$\tau_{safe}(x_k, u) = \Delta t \cdot \max\{ n : x_{k+j} \le x_{max} \ \text{for all } j \le n \text{ when } u \text{ is held and } d = \bar d \},$$

where $\Delta t$ is the control period and $x_{max}$ the damage threshold. For affine monotonic actuators this has a closed form, since worst-case state grows geometrically toward a fixed point.

The supervisor then enforces $\tau_{safe}(x_k, u_k) \ge \hat L_q(m)$. Here $\hat L_q(m)$ is a running estimate of the $q$-quantile round-trip latency under transport mode $m$. The default mode is a single carrier with best effort. The escalated mode duplicates messages over several carriers and gives control traffic priority over video. If the cloud's requested input fails the default-mode test but passes the escalated one, the supervisor switches modes for the next message. If it fails both, the supervisor clamps the input to the largest value that passes the escalated test. A further hard fallback, an input that cools or vents the actuator, covers the case where no message arrives within $\tau_{safe}$. Because this fallback is local and needs no network, the zero-violation guarantee rests only on the affine model and the disturbance bound, not on any latency estimate. The latency estimate affects only how often the fallback fires.

Second, we expose $\tau_{safe}$, the active clamp, and the transport mode as fields in the JSON messages of a Rosbridge-style bridge (Rosbridge: ROS for Non-ROS Users). Rosbridge turns robot messages into JSON over WebSockets and passes them through without checking them. Our contribution here is that the bridge carries a safety contract. The escalation mode reuses the multi-interface duplication of FogROS2-PLR. That work sends every request over several carriers to cut tail latency. We trigger duplication only when the physical deadline demands it. We also emulate a radio-level eMBB/URLLC preemption knob in the spirit of Energy Efficient Communication and Computation Resource Slicing for eMBB and URLLC Coexistence. eMBB is high-throughput broadband traffic, here the camera stream. URLLC is rare, urgent, low-latency traffic. Preemption lets an urgent packet cut into an in-flight video transmission. We do not claim access to a real 5G slicing controller; the radio side is a trace-driven emulator.

Third, the cloud policy is trained as a constrained Markov decision process: an RL problem with a task reward and a separate cost that must stay below a budget. The cost counts supervisor clamp activations and escalations, and $\tau_{safe}$ is part of the observation. Training uses PPO-Lagrangian from the SafePO library of Safety Gymnasium, with GPU-parallel rollouts from SoRoMoX. This step targets a failure the Sabelhaus paper names itself: a policy unaware of the clamp keeps pushing against an obstacle and stays stuck, trading performance for integrity. It also targets the vanishing learning signal that projection-style shields cause, described in Safe Reinforcement Learning using Action Projection. Exposing the clamp as a cost, instead of hiding it inside the environment, gives the policy something to learn from.

The scope is deliberately narrow. We cover actuator-level limits that are affine and monotonic, namely thermal and pressure limits. Shape-level limits such as buckling or self-contact along the rod remain outside the guarantee and are measured only as outcomes. Hysteretic actuators violate the affine assumption. We will report how far a locally linearized model with an inflated $\bar d$ holds up, rather than claiming coverage.

Baselines

The naive reference sends cloud commands over a plain Rosbridge WebSocket on a single carrier, with no supervisor. The cloud policy is unconstrained PPO trained on the same simulator. This shows how often latency spikes alone cause actuator damage.

The strongest existing method on the safety side is the Sabelhaus local supervisor computing $u^{MAX}$, which assumes zero delay. We pair it with the same PPO-Lagrangian cloud policy we use, so the only difference is delay-awareness and escalation. It is the strongest competitor because it already guarantees integrity in the zero-delay case. The paper reports that in free space it held SMA temperature at the 65°C limit while keeping a 40° bend, whereas PI and sliding-mode loops without it exceeded 100°C during contact. Beating it means fewer above-limit excursions under real latency traces, and a higher task success rate or shorter stuck time at equal violations.

The strongest existing method on the network side is always-on FogROS2-PLR duplication for all control and telemetry traffic. That paper reports up to 3.7x lower P99 latency than AT&T alone and 2.4x lower than Verizon alone on a highway drive, and a 36% mean and 33% P99 latency reduction indoors. Beating it means matching its violation rate while duplicating a small fraction of messages and delivering more video frames.

For the learning component, the reference is PPO-Lagrangian as reported in Safety Gymnasium: a 98% reduction in violations versus PPO at a 45% drop in reward on velocity tasks. That figure is on rigid agents. No reported result was found on Lacuna for constrained RL on ManiSoft or any soft continuum benchmark.

Ablations isolate the key ingredients. In the first, the supervisor uses a fixed nominal latency instead of $\hat L_q$. In the second, escalation is disabled. In the third, the policy does not see $\tau_{safe}$ or pay for clamps. Every variant gets identical simulator seeds, identical latency traces, the same training budget measured in environment steps, and the same hyperparameter search.

Why not just…?

Why not just give every control packet top priority on a dedicated channel? This is the most serious threat. Control and telemetry packets are tiny, so strict priority on a single link may cost the video stream almost nothing. That would make physically triggered escalation unnecessary. Priority does not remove handover blind spots or carrier-wide spikes, which FogROS2-PLR shows a single provider cannot mask. Fixing those requires redundancy, and redundancy is expensive. We will run always-priority as an explicit baseline. If it matches our violation rate on the traces, we will report that the scheduling half adds nothing in that regime and that the contribution reduces to the delay-aware supervisor.

Why not just keep the local zero-delay supervisor and let the cloud do whatever it wants? The local clamp already prevents burnout when its model is right. Its cost is task failure: the robot sits clamped against an obstacle. Its zero-delay assumption also fails exactly when a command lands late on an actuator that is already hot. The latency-blind ablation and the stuck-time metric measure both effects directly.

Why not just run everything on board? For a thermal limit alone, this would work. ManiSoft, however, shows that inferring a soft arm's posture from vision is the bottleneck. Diffusion Policy reaches 31.6% success in clean scenes and only 2.2% in cluttered ones, while OpenVLA reaches 30.4% and 27.0% (ManiSoft). Models of OpenVLA's size do not fit on a lightweight soft limb, so offloading is the regime we study. We include an on-board small-policy condition to quantify what offloading buys in task success.

Why not just use a large negative reward for overheating? Penalty tuning is known to produce either frozen policies or accepted catastrophic failures (Safe RL via CMDPs). Penalties also give no guarantee during learning, which is when hardware breaks. We include a penalty-only variant without the supervisor to show its violation counts during training.

Proposed Experiments

In simulation, we add an affine thermal or pressure actuator model to the ManiSoft engine, which couples Elastica Cosserat rods with MuJoCo contact (ManiSoft; Elastica). Its actuator parameters are identified to match the Sabelhaus limb's reported behavior. We run the Collection and Alignment tasks in both clean and randomized scenes, with the controller offloaded through an emulated bridge. Latency comes from our own multi-carrier drive and indoor traces collected following the FogROS2-PLR method, plus synthetic correlated spikes in which all carriers degrade at once.

Metrics are as follows: the number and size of actuator excursions above $x_{max}$, both during training and at evaluation; task success; time spent clamped; the fraction of messages escalated; and delivered video frame rate.

On hardware, we replicate an SMA soft limb controlled through a WebSocket client over two commercial carriers. Its tasks are the wall-contact and human-disturbance scenarios from the supervisory-control paper.

The decisive check comes under correlated spikes. The delay-aware supervisor must show zero thermal excursions where the zero-delay supervisor shows some. It must also escalate on well under the 100% of messages that always-on duplication uses, at equal violation counts. If the zero-delay supervisor never violates on real traces, the delay-awareness claim fails. If always-priority on a single link matches us, the escalation claim fails. We will report either outcome as such.