What EdgeEmbed Runtime is
- A deterministic decision & arbitration runtime for robots
- Driven by declarative config — safety behavior as data
- Auditable and replayable, decision by decision
- Tiny and bounded — runs on an ordinary core, no NPU
EdgeEmbed Runtime · Robotics
Your robot's AI is probabilistic. Its actions can't be.
EdgeEmbed Runtime is the deterministic decision layer between your robot's uncertain perception and the single, auditable action it commits — safe-stop, slow, reroute, proceed. Bounded latency, reproducible every time, no NPU in the safety path. The disciplined referee between probabilistic perception and a deterministic actuator, running right on the robot alongside ROS 2.
AMR Safety RuntimeDeterministic arbitration on the robot
Obstacle · lidarPerson · visionZone breachE-stopLocalization driftFleet command
The decide stepEdgeEmbed Runtime
01Event02Priority03Policy04Action Plan
safety.jsonPriority · safety envelopes · zone speed limits
SAFE-STOPSLOW to limitREROUTEMotor commandAudit record
What is EdgeEmbed Runtime
The decide step of an autonomous robot, made deterministic
Every robot follows a chain: sense → predict → decide → act. Perception makes an uncertain guess; EdgeEmbed Runtime is the decide step that turns competing events — an obstacle, a person, a zone breach, an operator command — into a single, reproducible, explainable action. It does not do perception and does not drive motors. You define safety behavior as a config bundle; the engine executes it. Behavior as data, not code.
Sense→Predict→Decide→Act
What EdgeEmbed Runtime is not
- Not perception, SLAM, or a planner
- Not a motor driver or HAL
- Not an RTOS, ROS 2 replacement, or scheduler
- Not a cloud fleet platform
Why robotics needs it
Probabilistic in, deterministic out
A robot's world emits probabilistic, asynchronous signals — perception noise, per-frame detections, safety events that collide inside a 100 ms window. But a shippable robot — safety-relevant, certified, fleet-deployed — must behave deterministically when it decides to stop. EdgeEmbed Runtime converts the first into the second, and it is complementary by design: it sits alongside the stacks you already run — perception, ROS 2, your motion stack, your RTOS — and fills the deterministic, auditable decide step none of them was built to own.
Probabilistic in — what your robot emits
- Perception detections — obstacles, people, per-frame and noisy
- Sensor fusion — lidar, depth, IMU, jittery and asynchronous
- Safety events — e-stop, zone breach, arriving when the world fires them
- Event collisions — obstacle + zone + operator command in one 100 ms window
- Compute contention — NPU, CPU, memory, thermal under load
Deterministic out — what the robot commits
- Bounded worst-case decision latency for the safety stop
- Deterministic arbitration — same situation, same action, every time
- Auditable decisions — incident replay and certification evidence
- Explainable behavior — exactly why the robot stopped or slowed
- Stable, versioned, testable safety policy across the fleet
How it works
One deterministic core, many robot bundles
EdgeEmbed Runtime owns the decision loop — event arbitration, policy evaluation, action planning, execution. A bundle adds the domain vocabulary and platform glue as declarative config plus one thin HAL plugin. The RoboticsX bundle below is an AMR safety controller: the bundle proves the core is domain-agnostic, and the runtime is the product.
Platform architectureCore + Bundles
EdgeEmbed RuntimeThe deterministic decision core
01Event
02Priority
03Policy
04Action Plan
05Execution
06HAL Dispatch
Domain-agnostic. Same code path powers every bundle.
RoboticsX BundleAn AMR safety controller
events.jsonobstacle, person, zone breach, e-stop
policy.jsonpriority + safety-envelope arbitration
actions.jsonsafe-stop, slow, reroute, proceed
HAL pluginROS 2 · motor controller · your platform
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.
Get in touch
Talk to us about your robot
Our mission is a trustworthy decide step in every safety-relevant robot. Evaluating EdgeEmbed Runtime, exploring an AMR or cobot integration, or planning a fleet deployment? We would love to hear from you.
EdgeEmbed teamOnline — typically replies within a day
Hi — this is the EdgeEmbed team. Tell us about your robot and what you want the deterministic decision layer to do.