Your machines act on their own.Every command passes the gate.
MS Reflex is the runtime for any machine that decides and acts on its own. What it is sure of, it decides in the moment, on the device; what it does not know goes to your stack or your operator. It learns from one example, and your stack stays exactly as it is.


Five invariants, on every machine, whatever runs it.
The five invariants →- 01
Every command that acts passes the gate.
Before anything moves, switches, opens or sends, MS Reflex checks the command against your rules. What fails does not run.
- 02
Safety rules loosen only through an authorised, logged act.
Learning never loosens a rule, and neither does time. Loosening one takes an authorised act, and that act is logged.
- 03
Every change is attributable and reversible.
Every change to a rule, a limit or what it has learned shows who or what made it, and when, and a lesson can be taken back on its own, without retraining.
- 04
Learning stays on the device, bounded, with no network.
It learns on the spot, on the machine itself, inside the bounds you set. No network, no cloud, no training run.
- 05
“Unknown” means defer, not guess.
When it meets something it does not know, it hands the call to your stack or your operator. It never guesses.


Sure, it acts.Unknown, it defers.
It decides in the moment, on the device: what to do, which skill to run and when to defer. “Unknown” means defer, not guess. When it meets something it does not know, it hands the call to your stack or your operator.


It acts through your stack.Then it checks it worked.
It acts through your stack: it picks the skill, sends each command through the gate, checks that it worked and defers when it did not. Your rules are part of every decision, and you can add one while the machine runs.
At a weld on the pipeline, MS Reflex picks the skill it needs: hold station and film.


It learns on the spot.One example is enough.
It learns fast and on the spot, on the device: one example is enough, and the lesson carries to cases like it. Every deferral teaches it: what your stack or your operator did next becomes something it knows, for the next time.
A smart camera on a packing line sees a scratch it has never met, so it defers to your operator.
Show it once, and the next one like it is its own call. Something different, it still defers.


It plans to the goal, and plans again.
It plans to the goal over what it has actually seen, chooses the skills that get there, and plans again when the world changes.
Your mission gives the survey vessel a goal: the harbour’s north wall.
When the world changes, it plans again from where it is, over what it has actually seen.


It simulates each move before it makes it.
It simulates each move on the device before it makes it, and sees what a command will do before your machine carries it out. A move that would go wrong is changed on the device, before anything moves.
A robot arm in a warehouse has a heavy box to lift onto a high shelf.


Your stack and ACI.The combination is the product.
Whatever runs your machine today: a VLA, an MPC, an autopilot, a PLC program or an AI agent. It stays exactly as it is. Your stack brings the skills it was built with. ACI brings the intelligence to learn on the spot, plan to the goal, simulate each move, decide in the moment and hold every command to your rules.
On an arm, a VLA picks and places. MS Reflex decides with it, and the VLA stays as it is.


How it works.
Start with one command. MS Reflex sees what your machine senses and what your stack proposes before anything moves, and does one of three things: it decides what it is sure of, defers what it does not know to your stack or your operator, or stops a command that breaks your rules. What happens next comes back to it, so the next case like it can be its own call.
- 01
It reads what the machine senses
On the device, before anything moves: what the sensors show, and what your stack proposes.
- 02
It decides how sure it is
What it knows, it decides in the moment. What it does not know goes to your stack or your operator.
- 03
The gate checks every command
Before anything moves, switches, opens or sends, the command is checked against your rules. What fails does not run.
- 04
Your stack carries it out
Your stack runs the skill it was built with, and MS Reflex checks that it worked.
- 05
It learns from what happened
A deferral, and what your stack or your operator did next, becomes something it knows, inside the bounds you set and on record.
Underneath is ACI, Adaptive Continual Intelligence: a new category of intelligence that works in tandem with the models and controllers you already run.


Edge devices and robots.Two shapes, one runtime.
Built for autonomous systems first: edge devices and robots, on land, in the air, at sea, under water, in orbit and in industry.
Edge devices →
Controllers, gateways and smart cameras, in plants, on sites and out in the field.
Robots →
Arms, mobile robots, drones, vehicles and vessels, on land, in the air, at sea and under water.
On land →
Rovers, ground robots and vehicles, and the machines on farms, mines and sites.
In the air →
Drones for inspection, mapping, delivery, and search and rescue.
At sea →
Surface vessels for survey, patrol and resupply.
Under water →
Underwater vehicles for inspection and survey, far from any link.
In orbit →
Satellites and landers that decide between passes.
In industry →
Arms, cells and lines, and the controllers, gateways and cameras that run plants.
Civil and defence →
For civil and defence programmes alike, from inspection and mapping to search and rescue, convoy resupply and perimeter patrol. The five invariants hold on every machine.


On the device.Any device.
Device agnostic. It runs on the processors your machines already carry, on CPU, with no GPU and no cloud. With or without a connection. It works offline and air-gapped, never phones home, and its licence works offline too.
MS Reflex runs on the processor the controller already carries.
It learns, plans, simulates, decides and acts on the device, and nothing has to leave it.


40 capabilities in six groups.
What it learns on the spot, how it plans, simulates, decides and acts through the gate, the invariants it keeps and where it runs. Press a group to open it in the list.
- Learns on the spotIt learns fast and on the spot, on the device: one example is enough, and the lesson carries to cases like it.
- Plans and simulatesIt plans to the goal over what it has actually seen, simulates each move before it makes it, and plans again when the world changes.
- DecidesIt decides in the moment, on the device: what to do, which skill to run and when to defer.
- Acts through the gateIt acts through your stack: it picks the skill, sends each command through the gate, checks that it worked and defers when it did not.
- Five invariantsFive invariants, on every machine, whatever runs it.
- Runs on the deviceIt runs on the device, any device: on CPU, with no GPU, no cloud and no connection needed.




Built on ACI.Paired with your stack.
MS Reflex pairs your autonomy stack with an ACI model. ACI, Adaptive Continual Intelligence, is a new category of intelligence that learns, plans, simulates, decides and acts at runtime, in tandem with the models and controllers you already run.
Your autonomy stack
Kept as it isWhatever runs your machine today. It brings the skills it was built with, and it stays exactly as it is.
- VLA
- MPC
- Autopilot
- PLC program
- AI agent
An ACI model
The intelligenceAn ACI model brings the intelligence to learn on the spot, plan to the goal, simulate each move, decide in the moment and hold every command to your rules. What it learns is yours.
- Learns on the spot
- Plans to the goal
- Simulates each move
- Decides in the moment
- Holds every command to your rules
- Defers what it does not know
MS Reflex
The productYour autonomy stack and an ACI model, working as one: that is MS Reflex. The combination is the product.
- On edge devices and robots
- On the device, any device
- With or without a connection
- Five invariants on every machine


Questions about MS Reflex.
Which stacks it works with, what it runs on, what it is not, who it is for and where it stands.


Start with one machine.
Your stack and an ACI model, working as one, on the processors your machines already carry. We plan each pilot with you.