A plug-and-play safety layer for robots, cobots, and VLA-controlled systems. Drop-in collision detection, force/pressure limiting, and motion validation — works with any robot stack, any VLA model, any controller.
Compatible with ROS, MoveIt, custom controllers, and VLA models like Google Gemini Robotics ER 2. Aligned with ISO 10218 and ISO/TS 15066.
Building a safety system from scratch is hard. You need:
- Deep knowledge of robot dynamics and contact mechanics
- Understanding of ISO 10218 and ISO/TS 15066 requirements
- Deterministic real-time implementation
- Comprehensive testing and validation
A safety plugin lets you focus on your core product — the robot, the VLA model, the application — while dropping in a pre-built, tested safety layer.
Many teams build the robot first, then think about safety. This leads to:
- Safety bolted on as an afterthought
- Inconsistent risk assessment across different functions
- Difficulty proving compliance with ISO 10218
- Expensive rework when safety issues are found late
A plugin architecture lets you integrate safety from day one, with a clean interface that doesn't couple the safety logic to your control logic.
Not probability-based, not ML-based. Pure Newtonian mechanics, same input always produces same output. This is fundamental for ISO 10218 compliance — safety functions must be verifiable.
It shouldn't just check one thing. A complete safety plugin evaluates:
- Contact force and pressure — with dynamic contact area, not fixed assumptions
- Impulse and momentum — catches fast impacts that force thresholds miss
- Reaction force stability — prevents the robot itself from tipping or slipping
- Semantic plausibility — rejects physically impossible actions before they reach physics
Not just "go / no-go." Good safety plugins provide graded risk levels so your planner can adjust, slow down, or replan — rather than hitting an emergency stop every time.
The safety layer is the last thing that should fail from a dependency issue. A single file with no external dependencies is ideal.
Clear API, well-documented parameters, example code for common platforms.
Rotor is a drop-in physics safety plugin designed to be added to any robot stack — industrial, collaborative, humanoid, or VLA-controlled.
4-Layer Safety Architecture
- Semantic Plausibility — rejects physically impossible actions (e.g., "grasp vacuum")
- Safety Parameter Mapping — maps action types to appropriate thresholds
- Dynamic Physics Analysis — contact area + impulse + reaction force
- Comprehensive Decision — risk level + over_ratio + retreat parameters
Key Features:
- ⚡ ~17μs per check — fits in any real-time control loop
- 🎯 100% deterministic — pure Newtonian, no ML, no probability
- 📦 Single file · zero dependencies — one Python file, standard library only
- 📏 ISO 10218 / ISO/TS 15066 aligned — PFL verification with body-region limits
- 🤖 35+ action types — grasp, push, pull, lift, throw, press, and more
- 🎚️ 7-level risk granularity — progressive feedback, not just binary stop
- ✅ 349 tests, 100% pass — comprehensive test coverage
Check each VLA-generated action before sending to the controller. Best for VLA safety and humanoid robot applications where actions are generated frame-by-frame.
VLA Model → Action → [Rotor Plugin] → Safe? → Controller
↓
Override / Modify
Monitor actual robot state during execution and trigger intervention if limits are exceeded. Best for industrial and collaborative robot applications.
Controller → Robot → Actual State → [Rotor Plugin] → Safe? → Continue / Stop
Both pre-execution and real-time monitoring. Highest safety level, aligned with ISO 10218's layered risk reduction principle.
| Platform / Stack | Integration Method | Status |
|---|---|---|
| ROS / ROS 2 | Python node or service | ✅ Drop-in |
| MoveIt | Planning scene validator | ✅ Compatible |
| Custom Python controller | Direct import | ✅ Single line |
| VLA model pipeline | Post-generation check | ✅ Ideal use case |
| Robot Operating System (any) | JSON over socket | ✅ Works with any language |
Rotor is a pure Python library with a JSON-compatible input/output format, so it can integrate with any stack that can call Python or pass JSON over a socket.
| Metric | Value |
|---|---|
| Latency per check | ~17μs (Python 3.10, x86_64) |
| Throughput | ~60,000 checks/sec (single thread) |
| File size | ~140KB |
| Dependencies | 0 (standard library only) |
| Supported Python | 3.7 – 3.12+ |
| Determinism | 100% |
| Test coverage | 349 cases, 100% pass |
- ISO 10218 — aligned with deterministic safety and risk reduction principles
- ISO/TS 15066 — PFL force/pressure limits per body region (Annex A)
- Power and Force Limiting (PFL) — dynamic contact area enables accurate pressure verification
- 7-level risk — supports graded response per risk reduction hierarchy
- Robot safety plugin
- Cobot safety
- Deterministic safety
- Physics-based safety
- ISO 10218
- ISO/TS 15066
- Power and Force Limiting (PFL)
- VLA safety
- Humanoid robot safety
- Collision detection
- Dynamic contact area
- Impulse safety boundary
- Reaction force stability
- Embodied AI safety
MIT — community edition is fully open source.
Contact contact@rotor-dynamics.ai for enterprise licensing with advanced features (3D reaction force pairs, Stribeck friction curve, energy conservation validation, pure_analyze interface).