Skip to main content
Robotics Advanced Intelligence SwarmsCognitive OS. We make robots smart. Let's Talk
Architecture

Architecture for robot intelligence in the real world.

A layered runtime — built deployment-first, model-agnostic, hardware-agnostic, and designed around uncertainty rather than the controlled demo that precedes it.

01 — Layered architecture

Where the runtime sits in the stack.

Seven layers from embodiment to deployment. RAI Swarms focuses on Cognition Runtime, Learning Loop, and Deployment Layer — the layers where most platforms fail to integrate. The Cognitive OS is intentionally visualised as the dominant centre of gravity.

07 Deployment Layer Fleet rollout, telemetry, intervention, recovery, audit RAI Swarms
06 Learning Loop Site-to-fleet feedback, memory updates, policy refinement RAI Swarms
05 Cognition Runtime Orchestration, memory, decision flow, coordination, supervision, safety, recovery RAI Swarms
Runtime kernel Memory layer Coordination bus Task state Safety gate Operator interface Telemetry Recovery engine
04 Action & Control Motion, manipulation, low-level actuation
03 World Model Live model of agents, objects, constraints, intent
02 Perception Multi-modal fusion, scene understanding
01 Embodiment Hardware, sensors, compute, power, form factor
02 — Integration wall

From fragmented stacks to a coherent runtime.

On the left, the typical deployment integration: bespoke adapters, scripts, and tribal knowledge per site. On the right, the runtime — one operating surface across platforms, sites, and operators.

Before · per-site stack

WMS adapter v3.2 Custom map sync Vendor A SDK Vendor B SDK Override script Site exception list Manual ops handover Vendor-specific telemetry

After · runtime surface

Runtime kernel Memory layer Coordination bus Operator interface Telemetry pipeline Policy interface Safety gate Audit trail
02b — Why static stacks break

The durable layer is no longer the robot.

Static robotics stacks were architected around a single platform in a single cell. Capability lives in the robot. Integration lives outside it. Both ship together, and both have to be rebuilt for every site. The runtime architecture inverts that.

Static stacks value · in the robot

Per-platform, per-site, per-program.

Capability and integration are bundled into the platform. Each site is its own engineering project. Each new platform is its own new engineering project. Nothing travels.

  • —Map, workflow, exception list rebuilt per floor.
  • —Operator interface specific to the vendor.
  • —Memory dies at end of shift.
  • —Cross-platform fleets do not share intent.
  • —Engineering hours per new site — flat.
Runtime architecture valuein the runtime

Per-fleet, cross-site, cross-vendor.

The runtime is the integration. New platforms attach to it; new sites inherit from it; new exceptions feed back into it. Engineering hours per new floor go down, not flat.

  • +Site memory, workflow, exception graph — inherited.
  • +One operator interface, every platform.
  • +Memory compounds across shifts, sites, generations.
  • +Intent broadcast as a first-class signal.
  • +Engineering hours per new site — bend.
03 — Runtime primitives

Five primitives the runtime is built from.

Every higher-level capability in the OS — coordination, recovery, supervision, fleet learning — composes from these primitives. Each has a single, observable purpose.

P · 01

Memory

layer

Episodic, site, fleet, operator-corrected. The runtime’s state across time.

P · 02

Planning

layer

Long-horizon decomposition, dependencies, replan under change, context-bound.

P · 03

Coordination

layer

Intent broadcast, conflict arbitration, task reassignment, congestion negotiation.

P · 04

Supervision

layer

Operator interface, escalation routing, audit trail, confidence thresholds.

P · 05

Recovery

layer

Safe degrade, contain, resume. Every fault has a stated next state.

Hover a primitive — every capability above traces back to these five.

04 — Key modules

Nine modules, composable, with clear interfaces.

Designed to be embedded into a new platform or attached to one that already ships. Each module has a degraded mode, a recovery path, and an audit trail. Nothing operates silently.

M / 01

Agent Kernel

Per-unit runtime. Lifecycle, scheduling, restart, supervision.

M / 02

Memory Layer

Episodic, semantic, and site memory. Time-, place-, and person-aware.

M / 03

Task Planner

Long-horizon decomposition, dependencies, replanning under change.

M / 04

World State Manager

Authoritative current state of agents, objects, and constraints.

M / 05

Policy Interface

Adapter surface for foundation, perception, and policy models.

M / 06

Operator Interface

Supervision, override, escalation, intent input from humans.

M / 07

Safety Gate

Hard constraints, soft policies, safe degradation, kill paths.

M / 08

Fleet Intelligence Layer

Cross-unit memory, shared learning, fleet-wide coordination.

M / 09

Deployment Telemetry

Site state, intervention metrics, recovery traces, fleet rollout.

05 — Deployment topology

Multi-site, multi-fleet, one runtime surface.

Per-unit runtime at the edge. Site-level coordination on the floor. Fleet-level intelligence at the centre. Telemetry, operator routing, and policy travel along the same backbone — not parallel ones.

Cognitive runtime backbone Site coordination Operator routing Telemetry · memory replication
06 — Integration philosophy

Reality is not an API.

Robots operate in environments that are messy, changing, and partially observable. The architecture must assume uncertainty, interruptions, sensor gaps, operator overrides, and real-world failure modes from the beginning — not as exception paths bolted on later.

Every module has a degraded mode. Every decision has an audit trail. Every operation assumes the world will deviate from the script — because it will.

07 — Infrastructure principles

The non-negotiables.

01P

Deployment-first design.

Every module is judged by how it behaves on the floor, not on a benchmark. The demo is a side effect of the deployment.

02P

Modular integration.

Adapters for the dominant runtimes (ROS, proprietary, custom). The Cognitive OS sits above; the metal stays the operator’s choice.

03P

Human override by default.

Supervision and escalation are first-class signals — not exception paths bolted on after the system fails.

04P

Memory across episodes.

No cold starts. Every shift, site, and unit inherits the knowledge of the one before it.

05P

Feedback from real operations.

Telemetry from the field is the highest-quality training signal in robotics. The architecture treats it as the source of truth.

06P

Safe degradation over brittle autonomy.

When the world deviates, the system slows down, escalates, or asks — never silently fails through.

07P

Fleet learning over isolated demos.

What one robot learns on Tuesday, the next robot inherits. Knowledge compounds across the fleet, not inside one unit.

Architecture posture

RAI Swarms builds the runtime between models and machines.

Deployment model Where it applies