01
The facts exist, in the wrong places
The screwdriver's torque curve is in a PDF. Its approach vector is in the engineer's head. Its I/O map is in the PLC project. Its tool centre point is in the robot pendant.
OCM standard · Cellwright software
Automation Built by AI.Maintainable by You.
Everything needed to build an automation cell already exists — it just isn't anywhere an AI agent can read it. OCM is the open standard that writes it down as component, module and cell manifests. Cellwright is the software that reads them, builds a machine model, and lets an AI agent program operations, monitor the running machine, and diagnose issues.
STATUS: PRE-ALPHA. The software chain is real and runs on a laptop. The PLC-sequence emitter is not written, the runtime I/O is still simulated, and no hardware has been built. We will say so plainly until it isn't true.
FIG. 1 — frame on a base cabinet at operator height, datum plate, two interchangeable process modules
WHY AUTOMATION CELLS COST WHAT THEY COST
None of it is unknown. It just isn't written anywhere an AI Agent can read.
02
So somebody retypes them
Four places, four transcriptions, four chances to be wrong — and no way to check any of them until the cell is standing on your floor and the schedule has already moved.
03
And every cell starts over
Change a fastener, swap a feeder, add a variant, and the engineering bill arrives again, because nothing about the last cell was written where a program could read it.
What the agent sees
The machine model is built from the same manifests the machine is built from.
Cellwright turns the documents and connections that already exist into a machine-readable context model. The AI agent reads that model to understand what the machine can do, then reads live state to know when it is not doing it.
component
Component context
Transcribed from datasheets and manuals: torque, stroke, voltage, mass, mounting, and the ports a part exposes. The agent knows the physical limits of every part before it touches the program.
module
Module context
User-defined electrical and mechanical connections between components. The agent knows what each module does, how it is wired, and what it offers upward to the cell.
cell
Cell context
Modules, their locations, and how they connect to the frame and each other. The agent knows the full machine: reach, collision, sequence, and I/O.
runtime
Runtime state
The running cell publishes its state back to the same model. The agent compares live data to expected behavior and flags deviations with a specific explanation, not a generic alarm.
How it works
The agent learns the machine from the same manifests the machine is built from.
Datasheets and manuals become component manifests. User-defined electrical and mechanical connections become module manifests. Module layout and cell connections become the cell manifest. The agent reads the resolved cell, generates the robot program, PLC sequence, and cycle-time estimate, and then compares live state back to the same model while the machine runs.
component
Component
One purchased part, transcribed from its datasheet or manual: torque range, stroke, voltage, mass, mounting, and the ports it exposes. Facts only, in the units the datasheet prints.
module
Module
An assembly of components that performs a function — a screwdriver, a feeder, a fixture. It declares which components it contains, how they are wired, and which ports it exposes upward.
cell
Cell
One machine: which modules are fitted, where they sit on the frame, and how they connect. Reach and collision are checked here, and the robot program and PLC sequence are generated from it.
line
Line
Many cells in sequence: conveyance, handoff points, and the order of operations. Each cell keeps its own owner and manifests; the line only declares how they meet.
What it changes on your floor
Quoted cycle time before steel is cut
The estimate comes from the same manifests that generate the program, so the number you approve is the number the machine is built to.
Changeovers stop being projects
Swap a module, regenerate. The re-engineering that used to be weeks becomes a rebuild of generated output.
A refusal, not a plausible guess
Ask for 6.0 N·m from a tool rated to 5.0 N·m and nothing is emitted. Where the manifests are incomplete, you get a completion list — including when the reader is an AI agent.
The agent knows when the machine is not behaving like itself
Live state is compared against the machine model it was built from. A deviation is flagged with a specific explanation — torque low, cycle slow, missing handshake — instead of a generic alarm.
No vendor holding your line hostage
OCM is an open standard, independently implementable. Anyone can write their own generator against the same manifests — which is the test of whether the standard is real.
Cells into a line
A cell stays a machine you can sell, move or replace on its own.
Put two cells side by side and the tempting move is to wire them into one machine. We refuse it on purpose: the seam between cells is deliberately thin, so no cell becomes hostage to its neighbour's vendor.
boundary
Cells join by two wires, not by a shared network
Safety, handoff interlock and data cross a cell boundary on three separate channels. The interlock is two opto-isolated discrete signals — part available, ready to accept — so any machine that can shake hands drops into the line, including one that isn't ours.
identity
Identity rides on the carrier, and is read at every cell
Most target parts can't be marked, so a single RFID tag on the pallet carries an unwritable carrier ID and the bound unit ID. No cell infers which part it is holding by counting handshakes. A failed or disagreeing read is a refusal, never a guess.
records
Your data goes to your system of record
Each cell commits to a local append-only journal before the cycle completes — a plain text file a technician can tail at 02:00. Forwarding to Postgres, MQTT, an OPC UA historian or an MES file drop is declared in the manifest, and the line keeps running when it's unreachable.
The AI agent, and what it is allowed to touch
It can read the cell always. It can write only when you turn a key.
In AUTO and in MANUAL the agent has no write path — not a blocked one, an absent one. The link carrying it is powered through a relay that closes only when the cell's key selector is in PROGRAM. Reading never stops: the controller publishes its state out an RS-422 port whose receive conductors are left out of the cable, so the agent can diagnose and explain a running cell without any means of talking back.
Three layers hold independently — the API refuses the verb, the controller rejects the write, and the conductor is open — and the last one is the one you can be shown at the panel.
How agent authority is enforced- AUTO
- Read only. Engineering link de-energized at layer 1.
- MANUAL
- Read only. Same relay, same open contact.
- PROGRAM
- Key-selected. Writes possible, and logged.
- Read path
- RS-422 publish-only, 10 Hz state frame, RX absent.
Three ways to get one
Build it yourself, buy the kit, or have us build it complete.
Open files
Build it yourself
The OCM standard, the registries, the mechanical files and Cellwright itself. Free, licensed openly, yours to modify. Anyone can build a compatible machine from the same manifests.
- Full mechanical and electrical files
- Manifest schemas and registries
- Every decision record, with reasoning
Verified parts
Buy a kit
The tested bill of materials, verified drive list and measured frame data, shipped as a kit so you skip the sourcing. Build it yourself or have a vendor assemble it.
- Tested BOM, no substitution guesswork
- Measured frame and sync data
- Assembly documentation
Complete
We build the cell
You describe the assembly. Accel Solutions or any compatible vendor delivers a running cell, with the OCM manifests handed over in the open format.
- Specification to commissioning
- Manifests handed to you
- Support on your terms, not a lock-in
Where we actually are
Pre-alpha, and saying so.
The mechanical design comes fourth on purpose. We already know how to build a frame; it carries no information. The question that decides whether this project is real is whether the generator can go from a cell description to a collision-checked robot program and a PLC sequence with no human writing waypoints — and that is testable on a laptop.
Follow the build journal- Interface spec
- Connector pinout, fieldbus and PackML profile frozen
- Manifests
- Component, module and cell manifests load and validate against the schema
- Generator
- Runs on a laptop: collision-checked plan, robot program, cycle-time estimate, refusal engine live
- Not built yet
- The PLC-sequence emitter; the runtime handshake is still simulated I/O
- Registries
- 2 components, 8 modules, 1 cell — plus a web composer under active development
- Hardware
- Nothing built. Deliberately last: the frame carries no new information
From the journal
Built in the open
15 Sept 2026
The silent crash: When collision checkers don't know the jaws closed
A look at a planner failure mode where the Tesseract scene graph only saw static geometry, and how we fix it by binding geometric state directly to capabilities.
28 Aug 2026
Stop Drawing Screens: Why Hand-Crafted HMIs Always Drift from PLC Logic
Hand-drawn HMIs inflate project quotes and drift from PLC logic. We generate operator and engineering interfaces directly from module manifests.
02 Aug 2026
Why an assembly cell costs 400 hours — and why it shouldn't
Every module in an assembly cell knows something important about itself. Almost none of it is written anywhere a tool can read. That single gap is where the 400 hours go.
Next step
Tell us about the assembly you keep paying to re-engineer.
Early conversations shape what gets built first. If you have a cell in mind — or a changeover that costs you every quarter — we want to hear the details.
Start a conversation