The brain behind industrial automation.
Nexus reads the logic, configuration, and documentation behind your machines and reasons over all of it, in plain English, cited to the exact rung. Built to grow into the whole operation.
Pick what you are facing. Nexus runs the same tools an engineer would, on the live controller, and shows its work.
SCADA shows you the line went down. It has never understood the program behind it.
SCADA is the eyes of your operation. It acquires and visualizes live values. Nexus is the brain. It reads the logic, the configuration, and the documentation behind every value, and reasons over the whole thing.
SCADA, the eyes
- Acquires and visualizes tag values, trends, and alarms.
- Flashes an alarm when the line stops or a machine faults.
- Assumes a human is reading and knows what it means.
Nexus, the brain
- Reads the PLC logic, device configs, manuals, and history behind every value.
- Traces the fault through nested logic and names the root cause, cited.
- Assumes an agent in the loop, and answers for the operation itself.
Built to model everything the operation knows about itself.
Operations do not have a model problem, they have a context problem. Nexus gathers the right engineering context on demand, so answers come from your actual equipment behavior, not generic internet knowledge.
Understand, document, diagnose, correlate, generate, and verify, over one grounded interface that learns your operation as it runs.
A deterministic model of your operation. Exact, cited, reproducible, on premise, and honest about what it cannot know.
PLC logic, AOIs, structured text, SCADA views
Controllers, robots, drives, cameras, I/O
OPC UA reads, subscriptions, alarms
Manuals, specs, descriptions, device configs
Work orders, faults, jams, OEE
MES, ERP, WMS, and CMMS
The layer SCADA never had.
Point an agent at your operation and it can do the work that used to wait on the one engineer who remembered how the system fit together.
Understand
Ask what a 3,000-rung legacy program actually does and get a plain-language answer, cited to the rung.
Document
Generate routine descriptions, I/O lists, and tag documentation from the code itself.
Correlate
Follow a signal from the operator screen through OPC to the rung that drives it, both sides at once.
Diagnose live
Read the running controller, pair the live value with the logic, and name the blocking root cause, cited to the rung.
Generate
Scaffold an AOI, routine, or script from a description, as a reviewable artifact you approve, never auto-applied.
Verify the docs
Flag where the site's own specification contradicts the logic that is actually running.
Continuous learning
Nexus holds a persistent, on-premise memory of your operation and never stops building it. Every export, fault, answer, and correction sharpens the next one, so the system gets more useful the longer it runs, and it flags a source the moment it goes stale.
What it gives back, by the people who feel it.
The knowledge that runs an operation is trapped in vendor tools and a few senior heads. Nexus makes all of it instantly answerable, by anyone, with receipts.
Understand any program without the engineer who wrote it.
Trace a tag to its root cause in about 150 milliseconds, not an afternoon of grepping exports. The answer comes back cited to the exact rung.
Know why the line is down right now.
Nexus pairs the live value with the logic and names the blocking root cause. Downtime is dollars per minute, and the first place to look should not be a guess.
Catch where the paperwork lies.
It flags where a description of operations or a spec contradicts the logic that is actually running, before an audit does. A generic chatbot structurally cannot do this.
Keep what walks out the door.
Shift handoff, standups, and onboarding lean less on the one person who remembers. The operation answers for itself, with receipts.
Trace any signal end to end.
The correlation engine walks a screen binding through its OPC path into the controller and back. When something misbehaves, Nexus explains where the state started, not just where it surfaced. Every hop is named, every claim is cited.
- SCADAWhat the operator sees
Perspective view Screens/FillerDetail binds Filler2/FillWeight
- OPCThe path between worlds
[Line2]Program:Filler.FillWeight
- PLCWhere the value is born
Filler_Control rung 14, scaled from WeighCell_Raw
- Root causeWhy it tripped, cited
Rung 31 latches the fault when FillWeight sits out of tolerance for 3s after changeover
Positioned where a bigger model cannot follow.
Nexus is not a chatbot with a large context window. It is a deterministic engine that gets better as the models on top of it improve, with the live floor and your own documents underneath.
Determinism is trust
Exact, cited, reproducible answers a probabilistic model cannot guarantee. The more tempting a confident model is, the more a verifiable engine is worth.
Live access to the floor
Reading a running controller and diagnosing a live fault is physical, on premise, safety-gated work. No context window touches it.
The document to logic join
Linking your own specs, manuals, and tickets to the live model, and flagging contradictions, compounds with every document. Pure retrieval cannot.
Neutral and on premise
One standard for breadth, air-gap capable by default. The deployment shape defense, utilities, and pharma actually buy.
Studio 5000, Ignition, and the CODESYS family, one PLCopen parser reaching 500+ OEM brands. A vendor is a module, not a rewrite.
Validated on real industrial data, not synthetic demos.
Nexus is tested where it has to work: real production controllers pulled straight off the plant floor, including exports too large to open in any chatbot. Not toy demos, and not numbers we made up.
Real PLC project files read in validation, including 24 full production controllers, some over 110 MB, parsed with zero PLC-parser errors.
Thirteen frontier models all failed to tell which live controller edit was actually running. With Nexus underneath, every one got it right, cited to the rung.
Fewer tokens than a frontier model grepping the raw export, about 9.5x faster, and the identical cited answer on every single run.
AI-written program documents graded rung-accurate, with zero errors found, by an independent senior controls engineer.
“It breaks down the functionality to each rung.”
Built in the open
The platform connectors are public under MIT, so you can see exactly how SCADA access, PLC parsing, and correlation are handled. Industrial engineers do not trust black boxes.
One system, released in stages, all available today.
From the engine to the full operation, the brain behind every engineering and operations decision in your facility. Each release is useful on its own, and each builds on the one before.
The engine
AvailableDeterministic comprehension across Studio 5000, Ignition, and the CODESYS family, plus read-only live diagnosis. Built and validated on real production data.
Connected intelligence
AvailableOne view over the whole operation: every controller, device, and server, logic currency and health, top faults and OEE, watch and alert on any tag.
Full industrial intelligence
AvailableEvery device on the wire, every manual and spec ingested, operations and engineering together, anomaly agents, and the document-versus-logic moat across the site.
See it on your own operation.
The product demo at nexus.nodeblue.ai is locked while we onboard by hand. Request access, or book a walkthrough and we will run Nexus against a project like yours.