Processes · what is proven, what is scoped

What we automate

The process decides exactly two things: the post-processor that writes the controller program, and the motion layer that turns a part into movement. Everything else in the platform is shared and does not change with the process.

So there is one honest way to read this page. Milling carries the proof. The processes next to it are platform scope — real work, quoted per task, with the motion layer written for the job. We do not show results we do not have.

Shared by every process

  • Cell model
  • Calibration
  • Collision checking
  • Reach and joint limits
  • Operator window
  • Roles and audit trail
  • Live telemetry from the controller

Written per process

  • Motion layer
  • Post-processor
  • Process I/O

This split is why an adjacent process is a project and not a rewrite — and also why we can tell you, before a quote, which half of the work your part actually needs.

Proven in production

Milling

Two ABB IRB 6650S-125/3.5 in one cell, each on a 20-metre IRBT 6004 track, machining plugs — master patterns for composite moulds — up to 15 metres long. This is a working cell, not a demonstration: the numbers below come from parts that were actually cut.

2 × IRB 6650S
one cell, 20-metre tracks
15 m
plug length machined
118,417
points solved in a browser tab
299
controller modules, byte-identical locally and on the server

The last number is the one we would defend hardest. The same toolpath, converted in the browser and converted again on the server, produces the same RAPID program down to the byte across 299 files. A pipeline that quietly disagrees with itself has no business near a 15-metre part.

What the milling layer does

  • Feed ramping
  • Corner deceleration
  • Zone selection
  • Split into controller modules
  • Track placement strategy
  • Soft joint limits
  • Cycle-time estimate with dynamics
  • Upload to the controller

Soft joint limits deserve their own sentence. A reach the controller would refuse becomes a FAIL during conversion, at the desk — instead of an error on the teach pendant with the part already clamped and the shift already started.

Adjacent processes: same core, new motion layer

These three share the defining feature of milling — a continuous contact path along a surface. The solver, the collision checking and the calibration carry over as they are. What is written new is the motion layer and the post-processor, and that is quoted as work rather than offered as a checkbox.

Polishing and deburring

Continuous contact path

The closest port there is. The tool follows the surface the way a cutter does; what changes is contact behaviour and pass strategy, not the shape of the problem.

In scope — quoted per task

Painting and gelcoat

Continuous path + flow control

The path stays; the process gains a controlled flow rate along it. Our own estimate is that roughly three quarters of the core maths carries over — the remainder is process control written for the job.

In scope — quoted per task

Large-format printing

Continuous path + extrusion

The same solver and the same reach-and-collision problem on a large part. The post-processor writes extrusion commands where the milling one writes spindle commands.

In scope — quoted per task

Different class of motion

CNC machine tending

Loading and unloading a machine tool is often assumed to be the easy version of milling. It is not the same problem. There is no toolpath at all: there are points, grippers, an I/O handshake with the machine, and part-presence checking. The motion layer is written from scratch.

Carries over unchanged

  • Cell model
  • Collision checking
  • Calibration
  • Bridge to the controller
  • Operator window
  • Roles and audit trail

Written new

  • Point-to-point motion
  • Gripper control
  • I/O handshake with the machine
  • Part-presence checking

We put this in writing before anyone asks, because the honest version is cheaper than the same discovery two months into a project.

Cell size

One robot, two, or more

More than one robot is native to the architecture rather than bolted on: the cell is described by a document that carries a roster of robots, each workstation is named by its own address, every robot gets its own state instance, and a command cannot reach a controller it was not addressed to. What differs between the levels is the guarding, not the plumbing.

Standard

1 — Single robot

The ordinary case. No coordination is needed, and usually no extra hardware either — the bridge to the controller runs on the shop-floor PC itself.

Proven in production

2 — Two robots

This is where the shared working envelope appears. Each operator window draws a translucent ghost of the neighbour, and a proximity guard stops both robots without waiting for a person to react.

In project scope

3+ — Three or more

The roster, the addressing and the data model already carry it. What has to be built is an all-pairs proximity guard: today the ghost and the guard watch one neighbour, which is exactly right for two and not enough for four. That is engineering work, and it goes into the quote rather than into a promise.

Emergency stop is deliberately outside the token check and does not depend on the internet, and the guard between robots runs locally in the shop. Both are architectural decisions with consequences we accept, not features we advertise.

Is your part on this page?

If the process is milling, the proof is above. If it lives next door, describe the part and the machine: you will get a straight answer about what carries over and what has to be written — before a quote, and long before a contract.