DEV Community: Dylan McCarthy

Why We Parse Industrial Code Instead of Embedding It

Dylan McCarthy — Sat, 15 Aug 2026 03:37:56 +0000

Most of the industrial AI you have seen is a retrieval pipeline with a chat box on it. Chunk the manuals, embed them, stuff the top matches into a context window, let the model talk. It demos well. It falls apart the first time somebody asks a question where the answer depends on what a machine is doing right now.

We are an applied research lab called Nodeblue, and the system we build is called Nexus. This is a writeup of the architectural decision at the center of it, which is that the language model is the smallest and least interesting part.

The failure that set the design

Here is the test that made the decision for us.

Industrial control programs live in two places. There is the project archive, which is the file in source control, and there is the program actually running in the processor. Those drift, constantly, because engineers go online to fix a timer during a downtime event and do not always upload the change back. Anyone who has worked on a plant floor knows this. It is Tuesday.

We took a real production controller with exactly that situation, a live edit present in the processor and absent from the archive, and asked eleven frontier models which version of the routine was executing. We gave them the export, the docs, the context, everything a careful human would get.

All eleven answered confidently. All eleven were wrong. Not garbled, not obviously broken. They read the export correctly, described the rung correctly, and then told us the archived version was running, because the archived version was the only version they had ever seen.

Then we put the same eleven models on top of our engine and asked again. All eleven got it right, cited to the rung.

The models did not improve. They got access to a fact that lives in a processor rather than in a corpus. That is the entire lesson, and it generalizes past our domain: when a model is asked something it structurally cannot know, it does not abstain, it produces the most probable sentence. In a domain where the answer dispatches a human to a piece of equipment, that is the expensive kind of wrong.

What sits under the model

Four layers, roughly.

Deterministic parsing. We do not embed control logic and hope similarity search finds the right rung. We parse it. Ladder, structured text, AOIs, UDTs, tag databases, device configs, into a resolved model where a tag reference is a real edge to a real definition, not a nearest neighbor. The same question resolves to the same cited answer on every run. Not usually. Every run. A system that is right most of the time is not one you hand a maintenance tech at two in the morning with the line down.

So far that is 4,386 real production files parsed with zero parse errors, spanning Rockwell, Siemens, Ignition, and the CODESYS family. Real exports off live floors, including files too large to open in any chat interface at all.

Live access. OPC UA reads and subscriptions against the running controller, read only, inside the plant, under the site's own network rules. This is the layer that no amount of context window replaces, and it is also the layer that is genuinely hard for reasons that have nothing to do with AI: it is physical, on premise, safety gated work.

Correlation. A signal on an operator screen has a path. Screen binding to OPC path to controller tag to the rung where the value is born. The correlation engine walks that path in both directions, so when something misbehaves you get where the state started, not just where it surfaced. Trace a PackWeight from the display back through the multiply on rung 14 to the load cell, and forward to the timer on rung 31 that latched the fault.

Citation. Every claim carries the rung, tag, or document it came from. This is not a UX nicety, it is the thing that makes the output usable by a professional. An answer you cannot verify is a rumor with good grammar.

The model sits on top of all of that and does what models are good at, which is turning a resolved, grounded, cited result into a sentence a human can read. Swap it out and the system still works.

The efficiency side effect

We did not set out to optimize tokens, but resolving the graph properly means you send the model the six things that matter instead of the whole export and a prayer.

That works out to roughly seventeen times fewer tokens per answer and about nine and a half times faster than pointing a frontier model at the raw export and asking it to grep. Same cited answer on every run, which grepping does not give you.

Breadth without a rewrite per vendor

The obvious problem with parsing rather than embedding is that you now own a parser per vendor, and industrial automation has a lot of vendors.

We handle the big ones directly: Studio 5000 and RSLogix 5000, Siemens TIA Portal and STEP 7, Ignition, and the CODESYS family. Current IDEs and the legacy ones still running plants, because the plants running twenty year old code are exactly the plants with the worst comprehension problem.

For the long tail we lean on PLCopen XML, which gets one parser to more than 500 OEM brands. A vendor becomes a module, not a rewrite. That tradeoff is the only reason the parsing approach is tractable at all.

Checking ourselves

Benchmarks you write yourself are marketing. For the generated documentation we hired three independent controls engineers with no stake in the outcome and had them grade 137 documents rung by rung against the running logic. Zero errors found.

One reviewer noted that even through nested AOIs it never lost track of a variable, and that this was the part he had not expected it to get right. Nesting is where these tools usually break, so that is the correct thing to have been skeptical about.

Open where it counts

The early connectors the engine was built on are public under MIT at github.com/Nodeblue-AI. The ones shipping in Nexus today have gone well past them, but the originals are still how we show we are not a black box: you can read exactly how we handle SCADA access, PLC parsing, and cross system correlation.

If you work in this space and you think our parsing approach is wrong, the code is right there. We would rather be checkable than impressive.

What the lab is actually after

Nodeblue is an independent applied research lab. The research question is how machines come to understand and act inside physical environments, and it runs along four lines: operational intelligence, knowledge and memory, collaboration between humans and agents, and autonomy.

Nexus is the first system that came out of that. It holds a persistent on premise memory of an operation and keeps building it, so every export, fault, answer, and correction sharpens the next one, and it flags a source the moment it goes stale. The direction from here is one view across every controller and server in a facility, then every device on the wire with document versus logic verification across a whole site.

The broader bet, and the part I think transfers outside industrial work: agents acting in physical environments need a substrate that is deterministic, live, and citable. The reasoning was never the bottleneck. Grounding was.

If you build in this space, I would like to hear where you think this breaks. The connectors are on GitHub and we read every message.

AI Agents in Industrial Automation: Unlocking the Next Era of American Manufacturing

Dylan McCarthy — Fri, 17 Apr 2026 05:04:25 +0000

For decades, industrial automation has been one of the most technically advanced yet structurally stagnant industries in the world. Nodeblue is looking to change that.

Factories run on systems that are extraordinarily reliable, highly deterministic, and often decades old. PLCs, SCADA platforms, industrial networks, and safety systems form the backbone of modern manufacturing, logistics, energy, and critical infrastructure. Yet despite how advanced these systems are in function, the software ecosystem around them remains deeply fragmented, vendor-locked, and resistant to innovation.

This is exactly where AI agents have the potential to create one of the largest industrial revolutions of the next decade.

The Problem: Critical Infrastructure Built as Isolated Layers

Most industrial environments operate as layered systems:

PLC Logic — ladder logic, structured text, AOIs, routines, tags
Network Layer — EtherNet/IP, CIP, OPC UA, fieldbus communication
SCADA / HMI Layer — alarms, visualization, operator controls
MES / Historian Layer — reporting, production data, analytics

Each layer works exceptionally well in isolation.

The problem is that these layers rarely communicate in a way that supports fast troubleshooting or deep system understanding.

An alarm shown in SCADA may be caused by:

a failed permissive in PLC logic
a safety interlock
a dropped CIP connection
a remote I/O fault
a latched bit buried inside an AOI several layers deep

Tracing that fault path today often requires a controls engineer to manually:

locate the alarm source in SCADA
identify the underlying OPC tag
map the tag to a PLC address
cross-reference every write condition
inspect permissives
verify network state
inspect hardware status LEDs

This routinely takes 20–40 minutes, and in complex systems much longer.

During that time, production is down.

What AI Agents Change

The breakthrough is not autonomous control.

The breakthrough is machine-speed understanding of legacy industrial systems.

An AI agent with structured access to SCADA projects, OPC mappings, and PLC logic can perform deterministic fault tracing in seconds.

In one recent case, a conveyor sat in fault overnight.

Operators repeatedly attempted resets through SCADA, but the alarm would not clear.

The AI agent:

traced the alarm through Ignition
resolved the OPC tag path
followed the tag into PLC ladder logic
located the exact rung blocking the reset
traced the blocking permissive upstream
identified a Safety I/O module with a lost CIP connection
found two additional conveyors affected by the same permissive

After one confirming operator input — “the module has a red NET1 fault LED” — the agent returned the exact root cause and corrective steps.

Total time: 28 seconds

Traditional troubleshooting time: 20–40 minutes

This is not theoretical.

This is the beginning of real industrial reasoning systems.

Why Legacy Industrial Systems Need This

Industrial automation has historically been trapped inside vendor ecosystems.

Platforms like Rockwell Studio 5000 and Ignition are powerful, but they are fundamentally siloed.

The logic lives in one place.

The alarms live somewhere else.

The network diagnostics live somewhere else.

The operator context lives somewhere else.

Humans bridge those layers manually.

AI agents can bridge them computationally.

This is the true unlock:
transforming fragmented industrial infrastructure into a unified reasoning graph

Once logic, tags, cross-references, alarms, and network state are represented as structured data, the system becomes machine-readable.

At that point, an agent can reason across the entire control stack.

Breaking Vendor Lock-In

One of the biggest challenges in industrial modernization is vendor lock-in.

For decades, the industry has normalized closed ecosystems:

proprietary project formats
proprietary communications tooling
limited interoperability
poor observability across vendors

This slows innovation dramatically.

Open interfaces such as MCP servers fundamentally change this.

A well-designed architecture can expose:

full L5X logic structures
tag databases
routine cross-references
live SCADA state
OPC mappings
network health

to any compliant AI agent.

This makes the intelligence layer agent-agnostic and infrastructure-local.

That means the factory is no longer dependent on a single software vendor to innovate.

This is one of the most important architectural shifts industrial software has seen in decades.

Why This Matters for American Manufacturing

The global manufacturing landscape is changing rapidly.

Countries like :contentReference[oaicite:2]{index=2} continue investing aggressively in industrial modernization, automation, and digital infrastructure.

The United States cannot remain competitive by relying on brittle legacy workflows and locked-down tooling.

We do not need to replace every PLC, every HMI, and every control cabinet.

We need to make existing infrastructure intelligible, observable, and adaptable.

AI agents allow us to modernize the software intelligence layer without tearing out the physical infrastructure that already powers the economy.

This is how existing plants become dramatically more efficient without billion-dollar rebuilds.

The Real Opportunity: Human Amplification

The most immediate value is not replacing controls engineers.

It is multiplying their effectiveness.

A senior controls engineer today may spend large portions of time on:

fault tracing
documentation lookup
cross-reference searches
root-cause validation
repetitive diagnostics

These are precisely the workflows AI agents excel at.

This allows engineers to focus on:

system architecture
process optimization
controls strategy
new line deployments
safety improvements

The result is not workforce reduction.

The result is engineering leverage.

One engineer becomes capable of supporting significantly more infrastructure with higher confidence and faster response times.

What Comes Next

The first phase is diagnostics and explainability.

The next phase is much larger.

AI agents will soon support:

automated commissioning validation
change impact analysis
logic review and linting
safety permissive verification
maintenance copilots
predictive fault propagation analysis

Eventually, factories will operate with continuously reasoning infrastructure layers that understand their own control logic in real time.

That future begins by making legacy systems machine-readable today.

Final Thought

Industrial automation has spent decades optimizing machines.

The next revolution is optimizing system understanding.

When machines can explain why they stopped, what dependency failed, and how to restore production in seconds, downtime drops and productivity scales.

This is not just a better troubleshooting workflow.

This is the foundation for the next generation of American industrial competitiveness.

AI agents are not replacing industrial automation.

They are finally making it fully observable.

Nodeblue — Engineering-driven technology across software, industrial automation, and applied research.