Robots that steer catheters and guidewires through blood vessels are starting to make decisions without a human hand on every motion. They are being built for emergency "bridging" procedures, where a clinician stabilizes a patient now and defers the definitive repair. Examples include holding a stent retriever open across a clot to restore flow before pulling it out, or embolizing a bleeding artery before surgery. The navigation software behind these robots is increasingly learned, proprietary, or run remotely. Nobody outside the vendor can confirm that a given motor command was checked against a safety rule before it reached the patient.
We propose to place a small, deterministic safety checker inside a trusted execution environment (TEE), a hardware-isolated region of a processor whose code and memory the main operating system cannot read or alter. The checker gates every actuator command from an untrusted navigation policy. It tests each proposed motion against the patient's own vessel geometry from pre-operative CT and against live contact-force readings. For every command it emits a hardware-signed receipt proving that the measured checker ran on those exact inputs. The claim is that this can run at robot control rates on the small secure memory of an embedded processor, and that a geometric and force check catches unsafe motions far more reliably than a learned collision detector.
Core Claim and What Is New
The closest prior work is Proof-of-Guardrail in AI Agents and What (Not) to Trust from It. It runs an open-source guardrail beside a proprietary language-model agent inside AWS Nitro Enclaves and signs a binding between the guardrail's code hash and the agent's inputs and outputs. It detected every tampering attempt, but it raised latency from about 421 ms to about 547 ms. The same paper reports the semantic gap that motivates our design: an enclave proves the guardrail ran, not that the guardrail is any good. Llama Guard 3 scored an F1 of 0.56 on unsafe content.
We differ from that work on both axes. The domain is closed-loop actuation rather than asynchronous text. The guarded property is also chosen so that "the checker ran" nearly implies "the command was safe." The check is geometric and physical rather than a learned classifier, so the semantic gap shrinks to the accuracy of CT registration and force sensing.
Concretely, let $u_t$ be a proposed advance or rotation command at time $t$, and let $\hat p_{t+1}$ be the tip position predicted by a kinematic model from the current registered tip estimate. Let $c(\cdot)$ be the nearest point on the CT-derived vessel centerline tree, $r(\cdot)$ the local lumen radius minus a safety margin, and $f_t$ the measured tip contact force with ceiling $f_{\max}$. The gate accepts a command only if
$$ \lVert \hat p_{t+1} - c(\hat p_{t+1}) \rVert \le r(c(\hat p_{t+1})) \quad\text{and}\quad f_t \le f_{\max}, $$
and otherwise substitutes a retraction or hold. The receipt is a signature over the hash of $(u_t, \hat p_{t+1}, f_t, \text{decision})$, chained to the previous receipt and to the attested measurement of the checker binary.
The centerline-tree representation comes from VascularPilot3D: Toward a 3D fully autonomous navigation for endovascular robotics. That system builds multiway trees from pre-operative CT and lifts 2D fluoroscopic tip estimates into 3D, but it runs on unverified compute with no check on its own commands. The force signal comes from CathSim: An Open-Source Simulator for Endovascular Intervention, whose MuJoCo contact forces were validated against load-cell measurements.
Research Program
We would build the checker as a few hundred kilobytes of C running in the secure world of Arm TrustZone under OP-TEE. That is the same setting in which DarkneTZ: Towards Model Privacy at the Edge using Trusted Execution Environments fit network layers into under 16 MB of secure memory at 3 to 10% overhead. DarkneTZ protected model privacy against membership inference. We reuse its partitioning lesson for a different reason: we keep the large untrusted policy outside the enclave and only the small safety-relevant computation inside.
Two design questions are central. The first is how to keep the vessel tree and kinematic prediction small enough to fit, which a centerline graph with radius annotations should do easily. The second is how to keep the force path trustworthy. TrustZone can assign a peripheral, here the force sensor's bus, to the secure world. This lets the checker read force directly rather than through the untrusted host. Whether this holds on a real robot controller is a hypothesis we test, not an assumption. If sensor ownership fails, telemetry spoofing remains an open attack, and we will report it as such.
The bridging setting decides which motions matter. Stent-retriever bridging, as in Dual-stent thrombectomy for recanalization of cerebral embolism caused by infective endocarditis: a case report, and staged embolization before resection, as in Bronchial artery embolization combined with left pulmonary resection in the treatment of fibrosing mediastinitis complicated with massive hemoptysis: a case report, both involve prolonged device dwell in fragile vessels. A rare unsafe push costs far more than a small slowdown. These reports supply motivation and task definitions, not data.
The second component is the remote-verification protocol. A hospital, regulator, or remote supervising clinician receives the attestation of the checker binary and the receipt chain. They can then confirm offline that no command reached the motors without passing the gate. This is the property Proof-of-Guardrail provides for text, now at control rates.
Baselines
The naive reference point is the untrusted navigation policy driving the robot with no gate at all. For the policy we use PPO agents trained in CathSim on Type-I and Type-II aortic arches; CathSim reports PPO generally beating SAC and Type-I arches being harder. For CathSim's absolute success rates, no reported result was found on Lacuna, so we will measure them ourselves with the released simulator. This baseline sets the unsafe-contact rate the gate must reduce.
The strongest learned competitor for deciding which commands are unsafe is a vision-based collision detector of the kind benchmarked in CathAction: A Benchmark for Endovascular Intervention Understanding. There, tiny-object detectors reached a collision-detection mAP of only 16.91 on fluoroscopy, and accuracy dropped by nearly 30% from phantom to porcine data. We will train the same detector family on CathAction and on CathSim renderings, and use it as the gate in place of the geometric check. Training data, compute, and tuning budget will match what we spend calibrating the geometric margin. The geometric gate beats it if it catches more ground-truth unsafe contacts at an equal or lower false-intervention rate, measured on held-out arch geometries.
The strongest navigation baseline is the deterministic VascularPilot3D planner. It reports 100% success over 25 phantom trials, an 18.38% reduction in control moves versus expert surgeons, an RL baseline that failed in 20% of the same cases, and a cycle time of about 2 seconds. We cannot run its physical phantoms. We will re-implement its tree search in CathSim as a second untrusted policy, and require that gating it does not lower task success.
The strongest system baseline for attested guarding is the Proof-of-Guardrail architecture itself, with roughly 25 to 38% latency overhead and 100% tamper detection on ToxicChat. We will port its enclave-signing pattern unchanged around our checker to measure what the per-command receipt costs. Beating it means 100% tamper detection with added per-command latency small relative to the control period, which we will report in absolute milliseconds.
Two ablations isolate the key ingredients. The first runs the identical checker code in the untrusted host. This separates the cost and benefit of the enclave from the cost of checking at all. The second runs a separate microcontroller interlock enforcing only the force ceiling. This separates the value of CT geometry from the value of force limits.
Why not just…?
Why not just put a hardware safety interlock on a separate microcontroller? This is the real threat, and classic safety engineering would do exactly this. An independent force-limiting board needs no enclave and stops the commands that cross the force ceiling. Two things separate our proposal from it. The first is the geometric envelope: a force-only interlock reacts after contact, while the CT check rejects motions predicted to leave the lumen. The force-only ablation measures whether that prevention matters in unsafe-contact counts. The second is that an interlock gives a remote party no proof it was present and unmodified during a given procedure. If the ablation shows geometry adds nothing and no stakeholder needs remote proof, the honest conclusion is that a separate interlock suffices. We would report that.
Why not just sign the controller firmware at boot? Secure boot, including formally verified multiprocessor variants such as PA-Boot: A Formally Verified Authentication Protocol for Multiprocessor Secure Boot Under Hardware Supply-Chain Attacks, proves what was loaded, not what ran on each command afterward. Our tamper experiments include post-boot attacks: a compromised host rewriting commands after the policy emits them, and a host that skips the checker. Boot-time signing does not catch these. The per-command receipt chain should catch them, because a missing or mismatched receipt is detectable.
Why not just improve the learned collision detector and keep everything in software? A better detector would help. But the CathAction numbers (mAP 16.91, a roughly 30% drop to animal data) and the Llama Guard F1 of 0.56 both suggest that a learned guard is the weak link whether or not it is attested. The detector-as-gate baseline tests this directly on held-out geometries. If a learned detector matched the geometric gate, we would keep the detector and still use the attestation layer around it.
Why not just use homomorphic encryption or differential privacy? Neither addresses the threat here, which is integrity of commands rather than secrecy of data. The file also reports TEEs running up to 120x faster than homomorphic encryption in PRESAGE: PRivacy-preserving gEnetic testing via SoftwAre Guard Extension, which rules encryption out at control rates.
Proposed Experiments
All closed-loop experiments run in CathSim on both arch types, with the robot controller emulated on a TrustZone development board running OP-TEE. Each condition is evaluated over multiple seeds and held-out vessel geometries.
The first experiment measures safety. We count simulated contacts whose force exceeds a perforation-proxy threshold under four gates: none, learned detector, force-only interlock, and CT-plus-force. We also record task success and false-intervention rate. The second experiment perturbs the CT registration with controlled offsets, because geometric gates fail when registration is wrong, and reports the margin at which the gate starts blocking safe progress. The third experiment measures integrity. We inject three attacks: command rewriting by the host, checker bypass, and replay of stale receipts. Here we report detection rate, plus spoofed force telemetry with and without secure-world sensor ownership. The fourth experiment measures cost. We report enclave memory footprint against the under-16 MB budget, and per-command added latency against the DarkneTZ and Proof-of-Guardrail overheads.
The decisive checks are three. First, the CT-plus-force gate should cut unsafe contacts relative to both the learned-detector gate and the force-only interlock without reducing task success. Second, tamper detection should be complete for every attack except sensor spoofing without peripheral ownership. Third, the receipt should add latency small against the control period. If the first check fails against the force-only interlock, the geometric contribution is not real and the proposal reduces to attested logging.
References
- Proof-of-Guardrail in AI Agents and What (Not) to Trust from It
- VascularPilot3D: Toward a 3D Fully Autonomous Navigation for Endovascular Robotics
- CathSim: An Open-Source Simulator for Endovascular Intervention
- DarkneTZ: towards model privacy at the edge using trusted execution environments
- Dual-stent thrombectomy for recanalization of cerebral embolism caused by infective endocarditis: a case report
- Bronchial artery embolization combined with left pulmonary resection in the treatment of fibrosing mediastinitis complicated with massive hemoptysis: a case report
- CathAction: A Benchmark for Endovascular Intervention Understanding
- PA-Boot: A Formally Verified Authentication Protocol for Multiprocessor Secure Boot Under Hardware Supply-Chain Attacks
- PRESAGE: PRivacy-preserving gEnetic testing via SoftwAre Guard Extension