Adura Copilot: Automation for the Factories the Market Forgot

The problem

More than 80 percent of the manufacturing capacity of the world is outside the Fortune 500. Small factories in Nigeria, Ghana, Kenya, and Vietnam use manual labour and old machines.

These factory owners want automation. They cannot buy it. A programmable logic controller (PLC) system costs between 3,000 and 15,000 dollars.

Cost is not the only barrier. A PLC needs a program written to the IEC 61131-3 standard. Engineers who hold this certification work mostly in Europe and North America. A factory owner in Lagos must pay for an engineer to travel to the site. Most owners do not do this.

The inspiration

The name Adura is a Yoruba word. It means prayer.

The idea came from one observation. A factory owner knows the process very well. The owner knows when the valve must open, how long the mixer must run, and which condition must stop the machine. The owner cannot write ladder logic.

The knowledge is present. The translation layer is absent.

Large language models supply that layer. This was not possible ten years ago. The microcontrollers existed. The interface between a person and a running program did not exist.

What this project does

Adura Copilot reads a description of a process in plain English. It writes an IEC 61131-3 Structured Text program.

The copilot runs offline. This is a requirement, not a preference. Factory sites in these markets have poor internet and frequent power interruptions. A copilot that needs the internet fails at the moment an engineer commissions a machine.

The copilot adds safety logic to every program. It puts an emergency stop guard on the last digital input and a watchdog on the last digital output. The system reserves these two channels. The model cannot remove them.

The larger system

This model is one part of Adura PLC.

The full system replaces conventional PLC hardware with a node that costs less than 250 dollars. The node uses an ESP32 microcontroller. It runs a real-time scan cycle. It reads digital inputs, writes digital outputs, and kicks a hardware watchdog.

The firmware has a hardware abstraction layer. This layer keeps platform code separate from control logic and permits a different microcontroller later.

The product line will grow. Adura HMI will add an operator interface. Adura VFD will control motor speed. Adura Arm will add motion control.

The first market is agro-processing: ginger, pepper, and egg pasteurisation. These processes are simple, the benefit of automation is large, and the current level of automation is near zero.

Why this matters

Automation is a condition for industrial growth. A factory that cannot measure a process cannot improve it. A factory that cannot control a process cannot increase output.

The tools exist. The demand exists. The price was wrong.

How we built it

The copilot uses a provider router. One environment variable selects the inference path. The online path calls a cloud API. The offline path calls a local llama.cpp server.

We built the router before the competition. This decision made the offline work easy. We changed a base URL and added one model name to a list.

The system prompt supplies the hardware profile, the output schema, and the safety rules. A validator checks the output before the client receives it.

Challenges we ran into

The first model was Llama 3.1 8B. It wrote invalid Structured Text. It used labels from a different language standard and called timer function blocks with syntax that does not exist. We changed to Qwen3, which has an Apache 2.0 licence and better output.

Quantization caused a different failure. At Q4_K_M, the model put single incorrect characters into the JSON output. One response contained a double quotation mark, another an extra comma. Each error made the full response unusable. A higher precision removed this fault.

We also tested the wrong configuration first. We compared an 8-billion-parameter model against a 4-billion-parameter model at Q8_0. The smaller file was almost the same size as the larger one, so the test showed almost no gain. We repeated the test at Q6_K. The smaller model was then 62 percent faster and used 2.4 gigabytes less memory. We had nearly rejected it on bad evidence.

We also lost time to our own mistake. Our error message cut the model output to 200 characters. We believed the model stopped early. It did not. Our log was too short.

Accomplishments that we're proud of

All four test processes now produce correct, complete JSON.

We measured where the time goes. The system prompt is cached, and generation uses 97 percent of the time. This result stopped an optimisation that would have given no benefit.

We rejected Yoruba language support for a specific reason. The available datasets use non-commercial licences, and we did not want legal risk in a commercial product.

What we learned

Test the assumption, then test the test. Our first comparison used a quantization that made the two models almost the same size. The result was misleading. The corrected test changed our decision.

Know what a benchmark measures. The smaller model scores higher on the competition benchmark. It also writes worse control logic. The benchmark tests general reasoning, not IEC 61131-3. We selected on the published rubric and we state the gap.

Quantization affects structured output. A small loss of precision can break a JSON response completely.

Licences decide architecture. Three paths to Yoruba support failed for licence reasons, not technical ones.

What's next for enigma-labs-adura

The next step is a fine-tuned model. The test data shows which errors to correct. Most of the faults are format faults, and correction of format faults is reliable. The remaining faults are logic faults and need more examples.

After that, the work returns to hardware. The next tasks are the analog input driver, the pulse-width modulation output, and the printed circuit board.

Built With

• cpp
• llama.cpp
• python
• qwen