Robots shouldn’t have to guess.
When a robot meets a real appliance, OPERANDI supplies what it cannot see: the exact controls, the correct procedure, and the safety limits, verified before the robot ever moves.
One request and the robot pulls all of it, grounded in the maker's own documentation. No guessing, no scraping, no surprises.
Russell Hobbs RHM2063B
A real 700 W microwave. Seven controls, no number keypad. Power, time and weight are all set by turning one dial.
A real appliance, end to end: the microwave a general AI tries to operate with a number keypad it doesn’t have.
It sees the appliance.
An ordinary robot or phone camera frames the machine. A vision model proposes its category and brand, and reads any text on show: brand marks, panel labels, badges. No rig, no barcode.
It resolves to one exact model.
Visual candidates are cross-checked with nameplate OCR and resolved to a single model number. Low confidence surfaces as a question, never a guess. Identity is confirmed before a single instruction is issued.
One call returns the whole package.
A single request returns everything for that exact model: the control map with physical anchor points, the executable step graph, the safety envelope, and per-step checks. Grounded in the manual, re-expressed machine-readable.
Your robot runs it, checked every step.
The package compiles to a behaviour tree your stack executes: SDK, ROS 2, or BehaviorTree.CPP. Every actuation carries a force bound; each step is verified; anything unexpected triggers a safe abort. We supply the knowledge; your robot supplies the hands.
You just watched it. Now do it.
Point your phone at any appliance in your kitchen. OPERANDI works out the exact model — or tells you plainly that it cannot — and says whether a grounded, robot-ready package exists for it. The first look takes about half a minute, because a real vision model is doing the reading. No sign-up, right in your browser.
A capable robot is still a stranger to your machine.
General-purpose AI can recognise a washing machine. It cannot know this washing machine. On real appliances, improvising is how things get broken.
Controls it can’t see
Panels differ model to model. The right dial, the hidden latch, the mode behind a long-press: none of it is visible from a photo.
The package carries a per-model control map: every control’s function, its physical location anchor, its actuation type (press, turn, hold, long-press) and its states. The mode behind a long-press is documented, not discovered mid-task.
Procedures it can’t infer
The correct sequence lives in documentation, not in pixels. A guessed step fails quietly, or loudly.
Procedures ship as executable step graphs, not prose: preconditions, actions, expected outcomes, and the branches that change everything, like a press-once vs press-twice distinction that switches the machine’s mode.
Limits it must not cross
Every machine has boundaries that matter. A robot needs them stated up front, not discovered by accident.
A machine-readable safety envelope per model: hard interlocks, prohibited states (never run empty), valid ranges (timer bounds) and force caps attached to every action. Enforced by the runtime, not offered as advice.
Capable is not the same as trusted.
A robot can already move with precision. What it lacks is knowledge of your machine: the dial that means defrost, the door that has to be shut, the single limit it can never cross. We build that knowledge, and verify it, before the robot is ever trusted to move.
One package.
Everything the robot needs.
For a specific appliance model, OPERANDI delivers a single machine-readable operation package, grounded in the manufacturer’s own documentation, never guessed.
Built to drop into your stack.
The same package runs wherever your robot does. Bring your platform; implement one thin adapter.
Python SDK
A minimal adapter. The runtime walks the procedure, enforces the limits, and verifies each step for you.
ROS 2
A native action interface for the mainstream robotics stack: plan, act, report, abort safely.
Behaviour trees
Compiled, executable behaviour trees for industry-standard executors, drop-in nodes included.
One robot. Any appliance. Done right.
With the right package, the same robot handles whatever machine it meets: the exact steps, the exact limits, no guessing.
Everything that ships today.
The product is bigger than one demo. These are the pieces you can pick up right now.
REST API
Identify and retrieve over HTTPS. Start free: ten packages a month on the house.
Read the API docs →Python SDK
Implement two methods; the runtime handles walking the tree, checking each step and aborting safely.
Quickstart →ROS 2 interface
A native action server for the mainstream stack: plan, act, report, abort.
Integration guide →BehaviorTree.CPP
Drop-in skill and check nodes for industry-standard executors.
Integration guide →MCP server
The same packages served as an agent tool, ready for LLM-driven robot stacks.
Get the server →Control maps
Labelled panels with real dimensions and anchor points a robot can aim at.
See the API →Graded packages
Every package carries its validation tier — 81% are
sim-validated or better, the rest are marked auto — so you can filter
on how proven it is instead of taking our word for it.
Escalation, not a coin flip
Unsure, it climbs a rung: the rating plate, the control panel, a barcode — a person only if one is there. Uncertainty is a state, not a failure.
How it works →Built to be trusted.
Grounded
Every package traces back to the manufacturer’s own documentation. Nothing is invented; nothing is assumed.
Every claim in a package traces to the maker’s documentation for that exact model, and the manual itself is never shipped — what you get is our own re-expression. Anything that cannot be grounded is left out rather than made up, and a package with no controls or no procedures is discarded rather than filed.
Verified
Packages are validated in simulation and screened by an automated safety gate. Clearing one for autonomous execution is your sign-off, never ours.
Each package compiles to a behaviour tree and runs in simulation; failures block release, and every package carries the validation tier it earned (81% sim-validated or better) so you can filter on it. A deterministic safety gate screens every manifest and refuses to ship one whose safety content is missing. We do not claim a package is cleared for your robot — that certification is yours to make on your own hardware, and it is recorded as such.
It refuses
Identification escalates until it is certain and abstains when it runs out of rungs. Zero wrong packages served across 1,500 closed-loop runs.
A package is released only when at least two independent signals agree and at least one is a direct read — a model number read off the rating plate or decoded from a barcode. Appearance narrows the field; only a direct read decides. Where two models cannot be separated it names the family rather than guessing a SKU, and where it cannot prove they operate identically it refuses outright. Measured over five independent 50-appliance samples, including adversarial runs that hand it a genuine rating plate belonging to a different appliance: 1,500 closed-loop runs, zero wrong packages. Unknown model, missing data and low confidence surface as explicit answers, never as a guess. A refusal is a safe outcome; a wrong package never is.
The road ahead.
Prove it on hardware
Pilots with robotics teams: putting operation packages in front of real machines, measuring what changes.
Scale the catalogue
From the appliances people use every day toward everything a robot will be asked to operate.
Set the bar
A dependable, certification-grade standard for how embodied robots operate real machines safely.
LITTERA: a small robot learning to pick up litter.
Field robotics, built on the bench and judged by evidence.
Put it in front of a real robot.
We’re looking for pilot partners: robotics teams who want their machines to operate appliances safely, without guesswork.