What Vigora does, stage by stage.

Vigora connects to your industrial controllers using standard protocols and reads signals at five-second intervals. The data goes into a local time-series store on your factory server. No agents on operator workstations, no parallel sensor network, no rip-and-replace.

Today we support Siemens S7 (used by S7-1200, S7-1500, S7-300 and others) via the snap7 library. One pilot uses S7-1200; one uses S7-1500. We've connected six different machine types across the two pilots: a 22 kg specialty coffee roaster, an industrial continuous-process roaster, an extraction unit, an evaporator, a centrifuge, a spray dryer.

We don't write back to your PLC during pilot. Recommendations go to operators, never to setpoints. Your control system stays in control.

Modbus TCP and OPC-UA are on the near-term roadmap. They're the next two protocols our pilot pipeline will likely need.

Each PLC reading is captured with the metadata that gives it meaning — which factory, which section, which machine, which signal, which batch (when batches are detectable), and which recipe. Without that context, raw values are noise. With it, they become evidence.

Data is stored locally in a time-series structure. Multi-tenant from the database layer up — every query is automatically scoped to the customer's tenancy. No customer can ever see another customer's data, by design, not by convention.

We don't ship your raw data anywhere. No cloud aggregation, no SaaS warehouse, no third-party analytics. Federated learning shares anonymized statistical weights only — no signals, no batches, no recipes, no operator names, ever.

PostgreSQL with TimescaleDB on the roadmap for sites that grow beyond what local SQLite handles cleanly. Our two current pilots run on SQLite without strain.

Three detection methods run continuously against incoming signals:

Threshold detection. Each KPI has warning and critical limits, configurable per machine and per recipe. Cross a limit and a breach event starts. Stay in breach long enough and an alert fires. This is the foundation — the equivalent of a SCADA alarm, but multi-state and lifecycle-tracked.

Statistical anomaly detection. Each signal has a learned baseline. Deviations from that baseline flag anomalies even when no fixed threshold is breached. Catches the kind of drift that a static alarm misses.

Trend and drift detection. Moving averages and slope analysis surface gradual changes — the slow walk away from a target that doesn't trip an alarm but predicts a problem.

All three feed the same alert lifecycle: start, hold, fire, clear. Operators see one consolidated stream, not three.

We don't claim the anomaly and drift methods are tuned for every machine type yet. They work today. They'll get sharper as we accumulate more pilot data across more machines.

Per-recipe anomaly baselines. Today the baselines learn at the signal level. We're moving toward baselines that respect recipe context — what's normal for a Light Roast is different from what's normal for a Dark Roast.

When a deviation matters, Vigora generates a recommendation — what to check, what to consider adjusting, what's happened in similar situations before. The recommendation is in plain language, not algorithm output.

Recommendations come from two sources: rule-based playbooks (curated logic for known situations) and a locally-deployed AI model running on the factory server itself. The AI handles novel situations where no clean rule applies. The rules handle the situations we've seen often enough to formalize.

Either way, the recommendation includes a confidence score and a short rationale. Operators see what was recommended and why.

We don't send factory data to a cloud LLM. The AI model is local. Your operations data never leaves your site, even during AI-assisted decision-making.

We don't recommend setpoint changes blindly. Recommendations are bounded by the safety logic of the underlying machine — Vigora can suggest "consider reducing gas by 5%" but cannot suggest things outside the operating envelope.

Confidence calibration tuned per signal type. Today confidence is computed across all recommendations uniformly. We want it to reflect how reliable Vigora has been on this specific machine, this specific recipe, this specific kind of deviation.

Recommendations appear on the operator kiosk. The operator (or a supervisor, depending on configuration) decides — accept, reject, modify, defer. Whatever they choose, Vigora records the decision and timestamps it.

Three levels of action authorization are configurable: human-led (operator decides directly), approval-gated (supervisor must approve before action), and automation hooks (PLC writeback — disabled by default during pilot, only available after explicit customer authorization and pilot maturity).

We don't override operator judgment. We don't escalate without consent. We don't bypass your existing approval chains — we work alongside them.

We don't enable automation hooks during pilot. Your PLC stays your PLC. Trust is earned through evidence, not asserted by default.

Multi-recipient alert routing — different categories of alerts going to different roles based on severity and shift. Today the routing is configurable but not role-aware.

Each completed cycle — alert fired, recommendation made, action taken, outcome observed — becomes an episode. Episodes accumulate. Recommendations that worked get reinforced; recommendations that didn't get demoted. Over time, the system's playbook becomes specific to your factory.

This is the part most monitoring systems don't have. SCADA alarms don't learn. Dashboards don't learn. Alert thresholds don't learn. Vigora does.

The learning loop is young. Six weeks of pilot data is not six months. The infrastructure is in place; the depth of learned behavior accumulates with operational hours.

We don't claim Vigora is "AI-powered" in the marketing sense — that the system is making magical predictions. Most of what Vigora does is rules, statistics, and structured feedback. The AI shows up where it's genuinely useful (recommendation generation) and stays out where it isn't.

Cross-factory learning — patterns learned at one factory becoming starting points for another, while keeping all raw data local. The architecture supports it; the deployment patterns will mature alongside customer trust.