Skip to main content

Product · EdgeEmbed Runtime

The deterministic decision engine

EdgeEmbed Runtime is the engine that implements the bridge: AI intents and machine events go in, get arbitrated against your declared safety policy, and one control-ready action comes out — bounded latency, on an ordinary core, no NPU in the safety path. Every decision is recorded so it can be replayed exactly.

Run the evaluationRead the Docs
Inside the Decide stageFrom probabilistic events to one control-ready action
Probabilistic — the AI side
Model intent · VLAPerson · visionAnomaly · audioZone breachE-stopOperator command
EdgeEmbed RuntimeModel Gate · policy · recorder
01Event02Gate03Policy04Action Plan
policy.jsonIntent admission · safety envelopes · degraded modes
Deterministic — the control side
SAFE-STOPSLOW to limitPLC / CAN commandAlert · MQTTEvidence record

At a glance

What you're actually getting

EdgeEmbed Runtime

EngineDeterministic event → policy → action pipeline, written in C
FootprintAn ordinary Linux core — no NPU in the safety path
BehaviorDeclarative config bundles — safety behavior as data, not code
LatencyBounded worst-case decision path
Record & replayBuilt into the engine — every decision reproducible
IntegrationThin HAL plugins toward ROS 2, CAN, PLC, or your platform

Why it exists

Probabilistic in, deterministic out

A machine running AI emits probabilistic, asynchronous signals — model intents, perception noise, safety events that collide inside a 100 ms window. But a shippable machine — safety-relevant, regulated, fleet-deployed — must behave deterministically when it decides to act. EdgeEmbed Runtime converts the first into the second: model outputs enter as confidence-carrying events through thin adapters — we never execute or wrap inference — and only policy-admitted actions leave, as control-ready signals toward the PLC, CAN bus, or controller you already run.

Probabilistic in — what the AI side emits

  • Model intents — VLA / foundation-model outputs, confidence-weighted and version-churned
  • Perception detections — obstacles, people, anomalies, per-frame and noisy
  • Sensor fusion — lidar, depth, IMU, vibration, jittery and asynchronous
  • Safety events — e-stop, zone breach, arriving when the world fires them
  • Event collisions — model intent + zone breach + operator command in one 100 ms window

Deterministic out — what the machine commits

  • Policy-admitted actions only — vetted before the motor moves
  • Control-ready signals — toward the PLC, CAN bus, robot controller, or HAL you already run
  • Bounded worst-case decision latency, deterministic arbitration — same situation, same action
  • A bit-exact replayable record of every decision — incident forensics and safety-case evidence
  • Explainable behavior — exactly why the machine stopped, slowed, or proceeded

Evidence

A decision nobody can reproduce is a liability

Every decision the gate makes is recorded and can be replayed exactly — that record is what regulators, insurers, and your own engineers will ask for.

Recorded

Every decision is captured as it happens — a black box for the machine.

Replayable

Any incident replays exactly, decision for decision, on a bench instead of the factory floor.

Evidence-ready

A monitorable, reproducible record of AI-driven decisions — designed to support your safety case with regulators, insurers, and auditors.

How it works

One deterministic core, many machine bundles

EdgeEmbed Runtime owns the decision loop. Everything domain-specific — what events matter, what policy governs them, what actions are allowed — is declarative configuration, and one thin plugin connects the decision to your platform. New domain, same core.

One deterministic core

A small engine that arbitrates events and decides — the same code path in every product, on an ordinary core.

A bundle per domain

Safety behavior is declared as configuration, not code. An AMR safe-stop today; machine safety and more on the same core.

Your platform underneath

One thin plugin connects decisions to the stack you already run — ROS 2, CAN, PLC — without replacing any of it.

Adoption path

From evaluation to production

The evaluation build behaves identically to production — what you validate on a laptop is what ships on the machine.

1 · Evaluate

Download the free evaluation build and run it on a PC in minutes — no hardware, no NDA. Behavior is identical to production.

2 · Integrate

Build against the public SDK headers: declare your bundle — events, policy, actions — and write one thin plugin for your platform.

3 · Ship

Take the same engine into production on your machine — with the recorded, replayable decision trail supporting your safety case.

Get started

Build and run the deterministic engine in minutes

Clone the open-source edgeembed-sdk, fetch the evaluation runtime, and build the hello-world example on an ordinary Linux PC — one event through the deterministic engine, no robot, no NDA. Then bring your own bundle and HAL.

1 · Clone

Clone the open-source edgeembed-sdk. No robot, no NDA — an ordinary x86-64 Linux PC.

2 · Fetch + build

One command fetches the evaluation runtime; one more builds the hello-world example against the public SDK headers.

3 · Fire one event

Run it: one event goes through the deterministic engine and the diagnostics read back — the whole loop, end to end.

Read the getting-started guideBrowse the docs

Talk to us

Putting AI on a real machine?

Evaluating the runtime, or bridging AI outputs into a PLC or robot controller? We would love to hear from you.

Get in touch