A single robot operates within its own kinematic envelope and cell fixtures. Add a second robot to the workspace, and actions become joint: each robot's valid choices depend on what the other is doing.
This is an established robotics problem. Factory teams have long used precomputed motion sequences and PLC interlocks. A robot waits for a PLC signal, enters the shared zone, runs its sequence, and releases the lock. This works when motion and timing stay predictable.
Difficulty begins when motion is variable. Learned policies change timing and trajectories with each scene. A robot may pause for more sensor data, take a longer path under uncertainty, or retry a failed grasp, so fixed interlocks no longer compose naturally.
Coordination for Policy Driven Robots
Each robot's policy reads its sensors and outputs an action for the next control cycle. In a single robot cell, observations cover its state and task objects. In a shared workspace, they must also capture enough of the other robot's state for collision avoidance and priority in contested zones.
A naive solution puts each robot's full configuration into the other's observation. This coordinates the policies but couples them tightly. A policy, sensor, or task change in one robot can degrade the other, producing brittle coordination whenever either policy changes.
We separate task level policy decisions from constraint satisfaction. Each policy independently proposes the next action. Before execution, a constraint layer checks shared constraints, then modifies or delays conflicting actions and sends only safe, consistent actions to the controller.
Shared State Architecture
The constraint layer uses a shared cell state that robots can read and write atomically. On the Neuralzome runtime node, a lightweight shared memory structure records zone occupancy, each robot's current and predicted near term trajectory, and priority when both seek the same zone.
Occupancy is binary but updated continuously. A zone is occupied when a current or predicted trajectory intersects it within a lookahead window. The default is 200ms, covering roughly one robot length at typical speeds. An approaching robot can then slow, stop, or reroute before conflict.
Priority is dynamic. A fixed rule can starve Robot A whenever Robot B remains busy. Our scheme uses wait time since last zone access, capped by task urgency from the production scheduler. A robot waiting longer gradually gains priority over one that recently held the zone.
The Constraint Layer Is Not a Planner
A central planner computes joint optimal trajectories for all robots using assignments, constraints, and optimization goals. Though potentially more efficient globally, it scales poorly as robots and policy complexity grow because it must model each policy's future behavior.
Our constraint layer does not plan. It reacts locally, blocking or delaying only actions that violate shared constraints. It needs no model of the other policy and solves no joint optimization at each timestep. Constraint satisfaction is not a substitute for a planner. It operates at the action level.
Local constraint satisfaction does not ensure global optimality. Robots may repeatedly back away from a shared zone, preserving local consistency while hurting cycle time. A deadlock detector tracks each robot's wait time and sends a manual override if either has yielded beyond the configurable threshold, default 2 seconds.
In pilot deployments, the override appeared rarely, about once every 200 to 300 cycles in the highest contention configurations tested. Operators treated it as recoverable: clearing the condition lets the layer resume. Automatic resolution is under development but has not been prioritized.
Constraint Layer Latency Budget
The check between policy output and controller adds latency. Neuralzome targets a total budget below 50ms from observation to actuator command. The layer must fit after policy inference, which typically takes 20 to 35ms depending on policy complexity and hardware.
The layer completes within 3ms when no conflict is found. If it must calculate a waiting state or altered trajectory, processing rises to 8 to 12ms. This remains within budget for most configurations.
Lock free data structures let shared state be read and written without either control loop waiting for the other's mutex. Each robot writes predictions to its own memory region and reads a consistent combined snapshot, avoiding write window blockage.
Current Implementation Limits
The constraint layer supports two robot shared workspace coordination in manipulation cells whose zones are defined at setup. It does not support dynamic zone changes, cells with more than four robots, or non Neuralzome robots without the shared state interface.
Legacy robots often run beside newer collaborative robots. Connecting signals to a legacy controller requires PLC interlocking, adding integration work that varies by brand and controller generation. We have a working path for common configurations, though it is less clean than native shared state.
Multi robot coordination has depth, and we have solved a useful but bounded part of it. For two to four cobots in one task domain, the current architecture supports adaptive decisions without a central planner. Beyond that, contact us to assess what fits.