AI agent proves code on a sub-$200 controller, before it reaches a plant
9 September 2026 
A Greek developer of industrial IoT controls has announced a technology that allows an AI agent to prove control code that it has generated on a real controller costing less than $200, and to catch any programming errors before the code reaches a real plant. Athens-based Erqos says that the native hardware-in-the-loop (HIL) support for its EQSP32 microPLC tackles a key obstacle to using agentic AI for industrial controls: How do you know that the generated code actually works?
The development avoids the need for expensive simulation rigs and test benches. All a user needs is the sub-$200 microPLC, a USB cable and an AI agent, whose cost depends on the chosen model, which may be a few tens of dollars or – with a small or locally-hosted model, a few cents, or nothing at all. A proving run can replace several days of skilled engineering work.
With HIL, an AI agent injects input states via a serial connection and reads the resulting outputs back the same way, while the controller runs its actual production program. The agent has to prove the behaviour of its code on real hardware against a defined test plan, rather than simply generating the code and assuming it is correct.
The agent writes the control program, loads it onto the real PLC, applies operating conditions and faults, observes the hardware outputs, compares them against expected behaviour, corrects failures – and repeats the tests until every check is passed. Authorship and verification are separated: the agent writes the code, but the hardware decides whether it is correct.
According to Erqos, this is significantly reduces the risk posed by subtle coding errors, before the controller is ever connected to real machinery. A hallucinated setpoint, an invented register, or an off-by-one debounce, fails the hardware check in exactly the way a human typo would, and the agent must fix it before the test report is complete.
The mechanism is simple: the agent controls what the firmware senses, and observes what the firmware does. Through the microPLC’s built-in HIL layer, the agent injects the state of every sensor (such as pressures, temperatures and levels) and reads back the state of every output (pumps, valves and alarms). The control logic itself executes unmodified on real silicon, with real task scheduling, real timing, and the same background network activity it will encounter in production.
Because the stimuli are injected rather than physical, the agent reaches conditions that a wired plant cannot safely provide – for example, a broken sensor wire mid-cycle, an over-pressure fault at its exact threshold, or a 60-minute flush timer compressed into seconds – deterministically and repeatably.
The deeper consequence, according to Erqos, is not speed, but coverage. Writing a test plan, building a harness and running dozens of cases by hand can take days, much of it spent waiting for production-length timers. Under deadline pressure, a few obvious faults may get tested, while every hysteresis band, minimum-time interlock and fault-reset path is dropped quietly. When the agent generates the test plan from the specification it has already written, and time compression collapses, the cost of running it, one more state or edge case costs almost nothing.
Injection also handles cases that are difficult, dangerous or impossible on a real plant. Verifying an over-pressure, dry-run or over-temperature trip on real equipment such as a pump means driving the plant toward the failure that the logic exists to prevent – at a genuine risk to the pump or to the operator. Under HIL, it is a single injected value. Broken-wire and out-of-range faults, which would otherwise require sabotaging the loop, are injected directly, and exact trip points can be applied repeatably in a way a drifting real transmitter never can.
The protection layer – the part of a controller that matters most and is tested least – becomes fully and safely verifiable. Because the test plan and harness persist as artefacts, the whole suite re-runs in under a minute after any change, turning one-time validation into a standing regression suite.
Hardware-in-the-loop is well established in industrial automation, but it has typically required dedicated simulation environments, digital twins, fieldbus emulators or specialised test hardware. This investment has confined it to large programs and safety-critical projects. Erqos says that it reduces the same closed-loop development and verification process to a sub-$200 PLC, a serial connection and an AI agent.
According to the company’s co-founder, Cosma Pabouctsidis: “The AI writes the control logic, but the hardware decides if it is correct. That separation is what makes the result trustworthy rather than merely fast.”
On its Web site, Erqos has published an example of a single-pass, reverse-osmosis water-treatment skid with ten sensors, three actuators, eight operating states and five latched fault conditions. Given only a wiring diagram, a process diagram and a short natural-language prompt, the agent produced a full functional specification, a 31-case HIL test plan, a commented control program, the test harness, and a final test report. The time taken from specification to final test report was 18 minutes of unattended operation – with all 31 tests passed against the real controller.
Erqos says that its system will allow engineers to test:
- Dangerous faults, safely: over-pressure, dry runs and over-temperature trips injected via USB, with no equipment at risk.
- Hours of timing, in seconds: long flush cycles and trip delays compressed for full coverage.
- Exact thresholds: trip points and both edges of hysteresis bands, applied repeatably.
- Sensor and wiring faults: broken-wire and out-of-range values, injected directly.
- Cross-product coverage: every state, fault and interlock combination – not a curated subset.
- Regression on demand: the entire suite re-runs in under a minute after any change.
The same approach extends to Modbus and MQTT. A USB-to-Modbus adapter can give the agent an independent observation point from which to verify the EQSP32 as a network peer, covering register traffic, malformed responses, reconnect behaviour and QoS handling, closing the same verification loop on the communication layer.
HIL proves control logic against its specification on real silicon. It does not exercise the electrical behaviour of real sensors, plant dynamics, network congestion under load, or long-term reliability. Nor does it catch an error made in the specification itself – which is why there is a human review gate. Commissioning against the physical plant remains a separate and necessary step.
HIL is available now in the library for all EQSP32 controllers, and is supplied free of charge with the product – not a paid tier, subscription or add-on. The build toolchain that the agent drives is open-source and free to use, with no IDE license or per-seat cost.
The only variable cost in the entire cycle is the AI agent itself, and that depends entirely on which agent and model the user chooses.
Erqos says that its EQSP32 platform closes the gap between closed legacy microPLCs, limited by proprietary toolchains and vendor-controlled runtimes, and open microcontroller boards that are flexible, but not industrially deployable. It offers certified DIN-rail hardware and rugged field I/O with the processing power and software freedom of modern embedded systems.
