Agents That Do Real Controls Work

Controls engineering has no shortage of language. Specifications, schematics, points lists, controller programs, commissioning sheets and handover records all describe parts of the same system. Agents are good at working across that material. The valuable step is turning it into a safe, reviewable engineering action.

Automatry Labs brings agents into that workflow as powerful tools that assist engineers.

From documents to executable controls

Our Delta coding agent reads project information, writes GCL+ control logic and tests that logic in a sandboxed interpreter before it reaches a controller. It can work through the same vendor environment used by an engineer, including enteliWEB, while retaining a clear record of the program, validation result and deployment.

The work moves through a controlled toolchain: source material, generated program, syntax and behaviour checks, engineer review, deployment to the intended target, and verification of what is running.

Across our projects, the agent supports program development and turns a demanding engineering workflow into one that is more legible, testable and repeatable.

Commissioning needs the same discipline

Our Titan Netmaster tooling applies a similar approach to apartment commissioning across our projects.

A commissioning run is planned as a sequence of explicit steps. Persistent actions are disclosed before the run. Firmware and device variants are checked rather than guessed. Simulations restore the original state and confirm that restoration by readback. Irreversible or high-impact steps remain behind an owner acknowledgement.

The agent can plan the run, execute the approved steps and assemble the record. The engineer retains a clear view of what the run will change.

Core is the deterministic execution layer

Automatry Core is our next-generation, deterministic controls-execution engine: the longer-term execution layer for our agentic direction. We've selected TypeScript — a language agents understand well, and one that compiles down to fast, deterministic controls code.

The Core Builder verifies, compiles and simulates a program before signing it for delivery. The same engine supports fast simulation and is designed to make incident replay straightforward.

The Builder and lab testing are proving out well; field adoption is the next step. We're looking forward to deploying our take on what will help the industry.

The guardrails are the product

For controls work, useful autonomy is bounded autonomy. An agent should know what it is allowed to read, what it may propose, what it may simulate and what needs a human decision. Writes should be attributable. Safety interlocks should be separate from optimisation logic. Failure should be visible, and recovery should be designed before the first live action.

Those constraints give agents a substantial role in consequential work.

We expect agents to take on more of the repetitive engineering load: tracing documents, producing first-pass code, constructing test cases, checking commissioning records and explaining faults. Accountability remains with the engineering process around them.

The ambition is an engineering system that carries each task from source material to a clear, reviewable result.