Watch
A first in the PLC world: native Hardware-in-the-Loop (HIL) on the EQSP32 lets an AI agent prove its own work on the real controller, unattended. Every state, fault and timer is exercised on the actual silicon, not in a simulation. You describe what the machine should do; the hardware signs off the result.
Dramatically faster, better tested, at a fraction of the cost.
An AI agent is not a chatbot that suggests a line of code, and not an autocomplete. It works the way an engineer at a keyboard does: it reads the files, writes the code, runs the commands, reads what comes back, and corrects itself, over and over, on its own, until the job is actually done.
That shift from "AI that answers" to "AI that acts" is what "agentic" means. Given a goal and the tools to pursue it, the agent plans, executes, and verifies in a closed loop, without human intervention.
The same loop, running unattended until the goal is met.
Three moves take you from a description of the machine to a control program proven correct on the actual hardware, unattended, with no IDE ever opened.
Hand the agent your drawings and a few sentences of plain-language intent. It writes the formal control specification for you to review and approve.
The agent writes the control program, compiles it, fixes its own build errors, and downloads it to the real EQSP32 over a single USB cable. No language to pick, no IDE to drive.
HIL drives the live controller through every state, fault and timer, and reads back what it actually did. The hardware, not the AI, decides the code is correct.
The whole idea in one sentence: the real control program runs on the real chip, exactly as it will in production. Only the sensors and actuators are swapped for a wire.
Inputs are injected over USB and outputs captured in a readable cache, while every line of control logic executes unmodified. The controller can't tell a HIL session from a real plant, so a test that passes is a test of the program that ships, not a simulation of it.
It's standard practice in aerospace and automotive ECUs, and virtually unheard of on industrial micro-PLCs. Erqos is the first to bring it to the micro-PLC world.
The same principle (exercise the real logic, observe the real outcome, let an independent observer be the judge) extends to every interface the EQSP32 speaks. The question is identical: does the device behave correctly as a peer on the network, and not only as a set of I/O terminals?
A USB-to-Modbus adapter gives the agent an independent second vantage point. Whether the EQSP32 runs as a Modbus master or as a slave, the agent plays the opposite role: it loads registers with test values, drives requests, and confirms the EQSP32 sends the right traffic and correctly handles what comes back, including malformed and out-of-range responses.
The agent publishes and subscribes on the same topics the EQSP32 uses, conversing with the device exactly as its real peers would: verifying reconnects, retained messages, payload format, QoS and its reaction to bad messages. Any broker works, local or in the cloud, with no extra hardware.
This workflow works with any capable agent and model combination. For best results, we recommend the latest frontier agent and model: stronger models write better code, catch their own mistakes sooner, and converge in fewer loops.
Just tell the agent that you have an EQSP32 connected to the PC and give it the link to the EQSP32 library on GitHub. Then watch the magic.
Unattended doesn't mean unaccountable. The method puts an independent, falsifiable arbiter between the agent's output and your sign-off.
A passing report isn't the agent's opinion. It's a record of what the physical EQSP32 did when driven through every specified condition.
A wrong trip fails a hardware check the same way whether it came from a typo, a misread setpoint, or an invented detail. The loop catches it before the report can read complete.
Every stage leaves a human-readable artifact: specification, test plan, commented control program and test report. The exact set a formal design review demands.
Seeing is believing.
Read the app noteManual bench testing and even commissioning can only ever sample a tiny fraction of a controller's behaviour: the happy path and a few faults you dare to provoke. Because HIL injects any input over the wire, on demand, its coverage is effectively unbounded. And it reaches precisely the cases that are hard, dangerous, or downright impossible to test any other way.
More coverage than commissioning could ever safely reach, and every case repeatable on demand.
In a real reverse-osmosis skid build (ten sensors, three actuators, eight states, five fault conditions), the agent went from the approved specification to a hardware-validated controller and a full test report in eighteen minutes.
See the full demoThe complete build, step by step: the specification, the agent at work, the HIL test run, and the signed test report.
Everything that makes the method work carries no license fee. The only variable cost is the AI, and it is buying back expensive engineering hours.
The full EQSP32 library, with all Hardware-in-the-Loop functionality built in, is completely free. HIL is a standard feature, not a paid tier.
The build toolchain the agent drives is open source and free to use. No IDE license, no seat fees, no runtime charges.
A fraction of the engineering hours it replaces when you use a frontier tool, and practically free when you run open-source models.
Put simply: the platform is free, the validation is free, and the intelligence that does the work costs a small fraction of the engineering time it saves.
Native Hardware-in-the-Loop is a standard feature of the EQSP32, not an add-on. It's what makes agentic development trustworthy on industrial hardware.