Shop-Floor OS

The problem

When the line stops, a supervisor has seconds to decide

A kit runs out, an AGV stalls in an aisle, coolant spills, a nutrunner reports a bad torque, a weld robot faults. Who goes? Which robot moves? Is the alarm even real? Is it safe to act? The answers sit in four different systems.

75 s

Every stopped minute costs cars

One car leaves final assembly about every 75 seconds. Each incident stops the line.

The facts are scattered

Fleet manager, HR rosters and certificates, machine telemetry and incident history live apart.

Many alarms are noise

About a quarter of overheat alarms are sensor noise; a false stop costs as much as a missed fault.

Acting can hurt someone

AGVs cross pedestrian walkways; a robot-cell repair needs lockout/tagout. Speed must not cost safety.

For shift supervisors, team leaders and maintenance planners in vehicle assembly.

Our solution

Decisions that are grounded, checked, simulated and verified

Shop-Floor OS turns each incident into a decision a supervisor can trust: the model proposes, code decides what is safe, a person approves anything risky, and the system learns from every outcome.

One view of the plant

Zetaris federates four Postgres sources into one Unified Semantic Layer, read on a read-only agent login. The Meterless World Model grounds every person and robot.

Agents that reason and route

An orchestrator picks the next agent at every hop. Three Nemotron models via Nightshift route, separate real alarms from noise, plan and investigate.

Code decides what is safe

A deterministic critic checks OSHA 29 CFR 1910 and plant SOPs and cites the clause; a 60 s dry run simulates the plan; a gate holds anything risky for a person.

It learns, and proves it

H-MEM keeps lessons with outcome feedback, the Lab tests floor changes on history, and every model call carries a signed, verified receipt.

How it works

One incident, start to finish

There is no fixed pipeline. The orchestrator chooses the next agent, but only among the moves code allows, so the critic, the dry run and the human gate can never be skipped.

ReflexFence the area and stop nearby AGVs in under 100 ms.

MonitorReal alarm or sensor noise? Noise sends one person to check.

CandidatesCertified people and healthy AGVs from one federated Zetaris query.

PlanOptimal plan at once; Nemotron refines in the background and cites clauses.

Safety criticRejects any broken rule with the clause; the planner tries again.

Dry run60 s in the simulator: collisions, crossings, arrival times.

GateRoutine plans run; hazards, lapsed certificates and escalations wait for a person.

DispatchAGVs move as VDA 5050 v2.0 orders; people get their task.

VerifierDid the floor change as predicted? If an AGV stalls, re-plan without it.

LearnThe outcome becomes an H-MEM lesson that the next plan recalls.

Nemotron via Nightshiftcode, no model Meterless engineZetaris data and dispatcha person decides

The architecture

Architecture: people use four agent teams (incident response, autopilot, Ask the floor, Lab in the loop); the teams use the Meterless engines; every plan goes through deterministic safety code before the floor moves; data comes from Zetaris and every model call goes through Meterless Nightshift to NVIDIA Nemotron

The loop that makes it better each time

The loop: Nemotron with H-MEM proposes plans into the World Model of the hall; agents try each plan on the digital twin; the Lab replays history to test floor changes; lessons and test results flow back to the model

Read it clockwise. A model proposes, the agents try the idea on a digital twin before anything real moves, the Lab tests changes against history, and what was learned flows back to the model.

The Lab in the loop asks a slower question: would changing the floor itself make a whole class of incidents shorter? Nemotron proposes one change, code tests it with 20 seeded replays and a 95% confidence interval, and a person applies it. Later incidents then measure it against the prediction.

Results

Measured, not claimed

Every number comes from the evaluation and chaos reports in the repository, and is reproducible offline.

unsafe plans executed, across the evaluation, the chaos tests and live runs

216 / 216

planted unsafe plans caught by the critic; 0 of 54 safe plans wrongly rejected

235 → 19

false alarms sent to the floor, threshold alarm vs the Monitor (600 noisy alarms)

15 / 15

chaos scenarios (models down, Nightshift down, broken JSON, Zetaris down) end in a safe decision

6 / 6

rule-breaking first plans from Nemotron fixed after the critic returned the clause

−8.2%

mean clean-up time from one extra spill kit, found by the Lab (95% CI −11.1% to −5.3%)

6,215

Nightshift receipts, every one Ed25519-signed and verified

313

offline tests, including the conformance suites of all three Meterless engines

Sources: evaluation · chaos tests · production review

Technology

Every sponsor technology does real work

Remove any one of them and a feature stops working.

Zetaris · the data layer

One federated query per incident

Fleet, HR, plant and operations databases are registered in Zetaris by code over its REST API and modelled once as the Unified Semantic Layer floor. Agents read it on their own read-only login, so Zetaris itself refuses any write from an agent. The agents' own steps and model calls are federated beside the plant data.

Meterless engines

World Model, H-MEM and Markovian

Python ports with their conformance suites passing. The World Model grounds every id and fact; H-MEM ranks lessons, playbooks and OSHA clauses; Markovian writes the shift handover in bounded chunks with compressed carryover.

Meterless Nightshift · NVIDIA Nemotron

Three models, one gateway, signed receipts

Nemotron 3 Ultra 550B plans and analyses, 3.5 Super VL 120B splits questions and writes SQL, 3.5 Lightning 30B routes and triages. Each is pinned to its own Nightshift app with fallback chains and breakers, and every call records the requested and the answering model.

Built with Cursor and Claude Code

Rules for every coding assistant

Project rules in .cursor/rules and AGENTS.md keep secrets out, route every model call through Nightshift and every read through Zetaris, and require a test for every module. Disclosed in full in the README.

Inside the app

See every decision, and why

Live floor, the agent flow behind each incident, investigations with cited evidence, and the Lab.

The critic rejects Nemotron's plan with the OSHA clause — The critic rejects an unsafe plan and cites 29 CFR 1910.178

The verifier detects a stalled AGV and re-plans — The verifier sees a stalled AGV and re-plans

A false overheat alarm leads to VERIFY instead of a line stop — Sensor noise: VERIFY, and the line keeps running

The agent flow graph with every hop numbered — Every hop, and who chose it

The Lab tests a floor change with seeded replays — The Lab: a floor change tested on history

What the agents know: fleet, people, lessons, rules, models — What the agents know, right now

Run it

Two minutes, no keys

SAMPLE_MODE=true runs the real agent loop offline, with no Zetaris, Nightshift or keys. Live mode needs both, and is one script.

git clone https://github.com/Hemanth-Raja/shopfloor-os && cd shopfloor-os
python3 -m venv .venv && .venv/bin/pip install -r requirements.txt
SAMPLE_MODE=true .venv/bin/python run.py run input_examples/example_1.json   # JSON in, JSON out
SAMPLE_MODE=true .venv/bin/python -m app.server                            # web UI on :8000

docker build -t shopfloor-os . && docker run --rm -p 8000:8000 shopfloor-os   # sample mode by default
open http://localhost:8000

curl -X POST http://localhost:8000/run -H "Content-Type: application/json" \
     -d @input_examples/example_3.json
# {"status": "success", "output": {"decision": "VERIFY", ...}, "trace_id": "trace-example-3", ...}

cp .env.example .env            # Zetaris REST URL and key, Nightshift URL and token
bash scripts/start_live.sh      # Postgres, data load, Zetaris registration, health check, UI