Machine learning for the plant floor
From a historian export to a prediction on a PLC tag.
MLS 2 lets the engineers who know the process import its data, clean it, train a model and run it on live equipment — on a server inside the plant, with every step audited and nothing leaving unless you decide it should.
Free Explorer edition · every feature on screen · no cloud account · works fully offline
- OPC UA
- MQTT
- Modbus TCP
- Siemens S7
- HTTP / JSON
- IP cameras
- Siemens AI Inference Server
- ONNX
- 17algorithms, each declaring its own search space
- 14cleaning operations, replayed on every prediction
- 5field protocols, read and proved before use
- 1code path for training and serving — the whole point
The idea it is built on
The cleaning travels with the model.
Most plant models fail quietly: trained on data somebody cleaned in a spreadsheet, then fed raw tags on the line. Nothing errors. The answers are just wrong. In MLS the recipe is frozen into the model and replayed on every reading — so what the line sends is what the model learned from.
- Raw export
- Recipe v2fill gaps · clamp · kPa → bar
- Training
- Live tag
- Same recipe v2replayed, never re-fitted
- Prediction
How it works
Six steps, one application.
Every screen below is the real product, captured from a running installation.
Bring in the export you already have
A CSV straight out of the historian — European decimal commas, odd encodings, two header rows and all. MLS works out the dialect, shows you why, and lets you confirm every column before a byte is stored.
- Rows that do not parse are reported one by one, not silently dropped
- Every column profiled: gaps, ranges, and where the readings actually sit in time
- Each dataset traces forward to every run and model built on it
Clean it in a studio built for exactly that
Fourteen operations on a toolbar — fill gaps, clamp, convert units, resample, look back in time. Stand on any step and see the data as that step left it, with what it changed counted for you.
- Click a column and it offers what its own numbers justify
- Recipes are versioned and never edited in place
- Custom Python runs in an isolated sandbox with no network
Train, and see the honest score
Seventeen algorithms, from ridge regression to gradient boosting and neural networks. Time-ordered data is split by time, by default — because a random split of process data flatters every model it touches.
- Held-out scores beside training scores, so memorising shows
- Hyperparameter search that never sees the test rows
- Runs in a background worker; close the tab and it carries on
Promote one version, and it answers
Register a run as a model, put one version into production, and call it over a REST API. The cleaning recipe is replayed on every request, so the model sees exactly what it was trained on.
- Exported to ONNX, verified against the original on real rows
- A warning whenever an input is outside what the model was trained on
- API keys carry a role, never more than their owner’s
Wire it to the line
Draw a flow: tags in, predictions out. Read from OPC UA, MQTT, Modbus TCP, S7 or HTTP; write a prediction back to a PLC tag, publish it to a broker, or send an alert to Teams or Discord.
- A binding is proved before it is saved — unit, type and range
- Writing to equipment needs an administrator to arm that exact revision
- A node that loses its source degrades; the rest of the flow keeps running
Or put it on the device itself
One button builds a configuration package for Siemens AI Inference Server: the model, its frozen recipe, and the very same serving code — so the device computes what the server computes.
- Built offline, from pinned dependencies — no internet on the plant network
- Predictions and extrapolation warnings arrive as pipeline outputs
- Works for tabular models and for camera-based defect models
A glass box, not a black one
Every number says what it does not cover.
A score is one number for a whole test period. MLS draws the rest: where the model is wrong, what it leans on, how it would behave at the threshold a line would actually run, and which mistakes it is most sure of.
Vision
Spot the bad part from a photograph. On a CPU.
Upload a folder of photographs, label them from the keyboard, train a defect model in seconds, and run it on a camera at the line. A frozen vision network does the seeing; a classical model learns your part — so there is no GPU to buy and nothing to babysit.
- CollectFolders, zips, or a camera button. Each photo stored once.
- LabelKeyboard-first grid; several frames of one part kept together.
- FreezeA snapshot that never puts the same part in training and test.
- TrainSupervised, or one-class from good parts only — day one.
- RunA PLC trigger takes the photo; the verdict goes to a tag.
- ReviewLive frames come back unlabelled, for an inspector to confirm.
On live equipment
Built to be trusted with a valve.
A model on a dashboard is a curiosity. A model on a setpoint is a responsibility — so MLS asks for proof before every connection and for a person before every write.
- Units are checked. A model trained in kPa is refused a tag that reads bar.
- Stale is not a reading. A value that stopped updating degrades its node instead of being reused.
- Drift is watched. Each live model compares what it is fed today with what it was trained on.
- Writes are armed. An administrator approves one revision; any edit disarms it.
- Silence is an alert. A flow that stops predicting tells a Teams or Discord channel.
Equipment monitors
Learn what normal looks like. Hear when it stops.
Point MLS at one machine, let it record a few weeks, and it learns that machine’s normal. Then it judges every hour, names the signal that moved, and keeps a health index that climbs before the first alarm — with every episode reviewable as a real fault, a false alarm or a planned change.
- Learn
- Freeze
- Clean
- Train
- Review
- Monitor
An assistant that knows where it runs
Ask in plain words. Approve what it does.
“What will the compressor draw at 750 Nm³/h and 35 °C?” The assistant finds the model, reads its inputs, and asks it — using the same tools and permissions as the person asking.
- Your choice of model. A local one on the plant network, or a hosted one — every screen says which.
- Nothing changes without a click. Anything that writes is shown in full and waits for a person.
- Readings stay home. It sees column names and scores, never the rows of your datasets.
- Also an MCP server, so your own AI tools can drive MLS with an ordinary API key.
Made to be used every day
Light or dark. English or Portuguese. Keyboard or mouse.

Drag across — the same screen in both themes.
- Ctrl KJump anywhereA palette that finds pages from a few letters.
- EN · PTTwo languagesSwitch per person; nothing left half-translated.
- A11YAccessibleEvery chart readable as a table; every screen audited.
- OFFLINESelf-containedFonts and assets bundled — a plant terminal needs no internet.
For IT and OT security
Easy to approve. Easy to run.
Most of these rules exist because the first generation of MLS broke them — the rewrite was planned around not breaking them again, and a dated security review is part of its engineering record.
- ON-PREMISEYour server, your networkShips as containers onto a machine inside the plant. No cloud account, and it runs with no internet at all.
- NO PHONE-HOMEA licence is a signed fileVerified offline. No licence server, no telemetry, no hardware fingerprint — and a lapsed licence never stops what is running.
- ENCRYPTEDCertificates, not exceptionsOPC UA signed and encrypted, TLS verified against a trust bundle you choose. There is no switch that turns verification off.
- AUDITEDEvery action has a name on itImports, promotions, bindings, arming a flow, downloading a package: who, when, and what — including what was refused.
- ROLESFour roles, one ruleConsumer, analyst, engineer, administrator. Every route checks one, the API included, and API keys never exceed their owner.
- SAFE FILESNo pickles, anywhereModels are ONNX or skops, data is Parquet, the job queue is JSON. Loading a model can never run somebody’s code.
- BACKUPBack up and restore, checkedOne command captures database and object store; restore verifies itself before it says it is done.
- OBSERVABLEHealth, metrics, tracesReadiness probes, Prometheus metrics and OpenTelemetry traces that follow a job from the request into the worker.
Coming from MLS 1.x?
Your old models come with you.
The converter reads v1 model files without running them, rebuilds each model, translates its cleaning steps, and refuses to write anything that does not reproduce v1’s own scores.
# what is in it — read, never executed
$ python -m migration.inspect line3.model
# rebuild it; refused unless it scores like v1 did
$ python -m migration.convert line3.model --out ./line3
# register it as a draft; refused unless it answers like v1
$ python -m migration.load ./line3On two real exports from a plant: R² 0.9968 rebuilt against 0.9967 recorded by v1, and the translated recipe reproduced 5,406 rows exactly.
Editions
Start free. License per site when it earns its place.
Explorer is the whole product at a small scale, for as long as you like. A licence lifts the limits, is verified offline, and never stops a running flow or a prediction — over a limit, only what is new is refused.
Evaluate everything, no licence file
- 2 people
- 1 model in production · 1 running flow
- Reads OPC UA and MQTT
- Vision: collect, label, train, predict
- Writing to equipment
- Device packages
Models watching the process
- 10 people
- 10 models in production · 5 running flows
- Reads OPC UA and MQTT
- 1 edge device
- Writing to equipment
- Vision
Models acting on live equipment
- 25 people
- Unlimited models and flows
- Every connector: OPC UA, MQTT, Modbus, S7, HTTP
- Writes predictions to PLC tags
- 3 edge devices
- Vision stations as an add-on
A whole site
- Unlimited people, models and flows
- Every connector, with writing
- Live vision, 1 camera station included
- 10 edge devices
Prices are quoted per site, as a subscription or as a perpetual licence with a period of updates. Commissioning, training and model building are available from Azordev — or your own engineers do it, which is the point.
Questions
What people ask first.
Do we need data scientists to use it?
No. It is built for the process engineer who knows what the tags mean. Each screen explains what a number covers and what it does not, the assistant can walk someone from a CSV to a trained model, and the defaults are the safe ones — a chronological split, a scaler where the algorithm needs one.
Does any of our data leave the plant?
Not unless you choose it. Everything runs on your server. The one optional exception is the chat assistant: if an administrator points it at a hosted model, MLS says so on every screen it appears on and records who agreed. Point it at a local model such as Ollama and nothing leaves at all.
What hardware does it need?
A Linux server or virtual machine that runs Docker. Training is CPU-only, including defect detection from photographs: a frozen vision backbone and a classical head train in seconds, with no GPU.
Can a model really write to a PLC?
Yes, on Professional and Enterprise — deliberately with friction. The tag must be bound and checked against what the model predicts, a classifier needs a declared value for every class, and an administrator must arm the exact revision of the flow. Every write is read back to confirm the tag holds it.
We have models from MLS 1.x. Do they come across?
Yes. A converter reads v1 .model files without executing them, rebuilds the estimator, translates the cleaning steps, and refuses to write anything that does not reproduce v1’s own results. It also reports where v1 stored device passwords in clear, so they can be rotated.
Is it available in Portuguese?
The whole interface ships in English and Portuguese, switchable per person, with light, dark and follow-the-system themes.
Bring one export. Leave with a model.
Send us a historian export from one machine. In a one-hour session we will import it, clean it and train a model on it with you — on your data, in your language.
