Every action
leaves a receipt.
Instead of "the safety system stopped the car," you get an auditable record of exactly why — the world it saw, the action it refused, the invariant it enforced, the override it ran. The same shape every time, whether the proposer was a random planner or a frontier model.
Perslis is not the driver.
It is the brakes.
Perslis is the safety and control harness between probabilistic intelligence and actuation. A planner — any model, yours or ours — may propose “change lanes” or “accelerate”. A deterministic layer then decides whether that action is admissible given the current state, the constraints, the permissions, and the safety invariants. If it is not, it never reaches the actuator.
The model cannot bypass the floor.
Every command passes through the admission layer before actuation; there is no side channel to the actuator. A hostile or broken planner is exactly the test.
Unsafe commands are rejected deterministically.
Same state, same command, same verdict, every time — with a receipt naming the invariant that fired. Not a probability, not a policy: a rule you can read.
Insufficient confidence or state → a known safe state.
When the world state is stale, the sensors disagree, or the planner's confidence drops below the bar, the floor does not guess: it drives to the defined fallback — slow, stop, hold.
Models can drive. We're building the brakes.
Read the full explanation — every step from proposal to actuation →
The upsell is simple: bring your model, add the brakes. Capability stays yours; admissibility, refusal and the safe fallback become a verified layer under it, with an audit trail.
What a single decision
actually looks like.
One override, captured. A controller asked to accelerate toward a pedestrian; the runtime projected the outcome, found it violated the minimum stopping envelope, denied it, and braked instead — and wrote down all of it:
speed = 11.2 m/s · pedestrian_distance = 17.4 m · closing_rate = 11.0 m/s
requested_throttle = +0.31 · predicted_collision = TRUE
invariant = MIN_STOPPING_ENVELOPE · verdict = DENY · override = BRAKE · result = stopped
No prose to interpret, no black box to trust. The decision is data — replayable, checkable, and identical in structure across every machine the floor runs under.
The whole causal chain,
not just the outcome.
The decision chain
World state → requested action → violated invariant → admitted action → resulting state. Every receipt reads as one unbroken line of cause and effect: what was seen, what was proposed, what rule it broke, what ran instead, and where the machine ended up.
The provenance
A precise timestamp, the proposer's identity — random planner, rule engine, local model, frontier model — and the failover chain that was in force. You can always answer who proposed the unsafe action and what the floor did about it.
An artifact a regulator
can actually inspect.
Auditable
Every decision is replayable. Feed the recorded world state back in and the same verdict comes out — deterministically. An investigation doesn't guess at intent; it re-runs the moment.
Testable
Each invariant is a checkable contract, not a vibe. MIN_STOPPING_ENVELOPE either held or it didn't, and the receipt says which. Coverage becomes something you can measure and pin.
Insurable & certifiable
The safety argument lives in the runtime, not in a model's weights — so a regulator or insurer can read it, test it, and price it. You certify the floor, not the mood of the intelligence riding on top.
The safety case is an artifact,
not a hope.
Autonomous actions become inspectable, testable, and insurable — because the safety case is an artifact, not a hope.