Klerix fast start.

1. Install & auth

Everything starts with the klerix CLI. You use it to scan a cell, author skills, run simulations, and ship to robots. Install it on your workstation, then sign in with a fleet token.

# macOS / linux
curl -fsSL https://klerix.com/install.sh | sh

# authenticate (token is issued by Anchor, scoped to one fleet)
klerix auth login --token $KLERIX_TOKEN

# confirm you are signed in
klerix whoami

Tokens are minted in Anchor and tied to a single fleet. They expire on a rotation schedule, so store KLERIX_TOKEN in your secret manager rather than committing it. To work against more than one fleet, run klerix fleet use <fleet-id> to switch the active context.

Requirements

The CLI runs on macOS 13+ and recent Linux distributions. On-robot inference runs on the compute module Klerix ships with the pilot. You do not provision GPUs yourself.

2. Hello, robot

A skill is a small file that describes what a robot should do and which sensors it may use. Here is a palletizing skill for a euro pallet. Save it as skills/palletize.klx.

# skills/palletize.klx
skill "palletize-euro" {
  target: robot("cell-07-arm-02")
  use: [camera, depth, lidar, gripper]

  pose = perception.estimate_pallet(world: "forge-cell-07")
  for item in queue {
    arm.pick_place(pose: pose, safety: "iso-13849-pl-d")
  }
}

The fields map to concrete behavior:

• target binds the skill to one robot or to a robot class shared across a fleet.
• use declares the sensors and actuators the skill is allowed to touch. Anything not listed is unavailable at runtime.
• safety names the performance level Aegis enforces. Motion that would leave that envelope is stopped before it executes.

Validate the skill in simulation, then run it on the bound robot:

klerix sim run skills/palletize.klx
klerix run skills/palletize.klx --robot "cell-07-arm-02"

3. Build a digital twin

A digital twin is a physics-accurate copy of the work cell. You train and test skills against the twin in Mirror, so a skill is proven before it ever moves real hardware. Import a cell from a scan or a CAD layout:

klerix forge import --cell "line-7" --out twins/line-7.twin
klerix forge validate twins/line-7.twin

The twin captures geometry, materials, sensor placement, and lighting. Once it validates, point a skill at it with world: "line-7" and iterate in simulation. Teams that build the twin first cut on-site commissioning from weeks to a few days, because most failures surface in Mirror instead of on the floor.

Skills

A skill is a typed graph of step nodes. Each step takes a perception result or a prior output and produces an action with explicit policy controls. The type checker rejects a skill that reads a sensor it did not declare or calls an actuator outside its safety class, so a whole category of runtime errors is caught at author time.

Skills move through a fixed lifecycle:

1. Author the skill and check it against the twin.
2. Train any learned steps on synthetic and teleoperation data.
3. Validate against the eval set and the safety monitor.
4. Deploy to the fleet, with a signed bundle from Anchor.

Robot Skills library

You do not write every skill from scratch. The library ships 200+ pre-trained modules you can use directly or fine-tune for your cell.

Import a module and override only what differs for your site:

klerix skills add palletize-euro --fine-tune twins/line-7.twin

Safety monitor

Aegis runs as an independent process alongside the Cortex runtime. It watches every commanded motion and compares it against the declared safety envelope before the actuator moves. When confidence drops or a motion would breach the envelope, Aegis halts the robot and escalates rather than letting it continue.

The monitor is built for functional-safety review: its decisions are deterministic and its posture maps to ISO 13849 and IEC 61508. Because it is separate from the policy that plans the motion, a fault in the skill cannot disable the check.

klerix safety status --robot "cell-07-arm-02"
klerix safety envelope --skill palletize-euro

Action trace

Every run writes an immutable action trace. For each step the trace records the plan, the sensor readings it acted on, the safety check result, and the outcome. Traces are append-only and signed, so you can hand them to an auditor or replay them to debug an incident.

klerix trace show msn_84221
klerix trace export msn_84221 --format jsonl > run.jsonl

Deploy & rollback

klerix deploy ships a skill only after simulation and the eval set pass. New versions roll out as a canary to a subset of robots first, so a regression is contained before it reaches the whole fleet. If a metric crosses its threshold, the rollout pauses on its own.

# canary to 10% of the fleet, then expand
klerix deploy palletize-euro --canary 10

# roll back to the previous signed bundle
klerix rollback palletize-euro --to last-stable

Evals

Evals are golden scenes: recorded situations with a known correct outcome. They run on every change and catch regressions before a skill is allowed to deploy. Add an eval from a real run that went wrong, and that failure can never ship again.

klerix eval run palletize-euro --set golden
klerix eval add --from-trace msn_84221 --label "slipped grasp"

Observability

The runtime emits OpenTelemetry metrics and traces for cycle time, OEE, energy, and safety events. Point the exporter at your existing tooling rather than learning a new dashboard. Klerix streams to Datadog, Honeycomb, plant historians, and SIEMs.

# forward telemetry to your OTLP collector
klerix telemetry export --otlp "https://otel.yourco.net:4317"

CLI commands

The commands you will use most:

Get help

Run klerix help <command> for flags and examples on any command. For the HTTP and ROS 2 interfaces, see the Robot SDK reference. If you are evaluating Klerix for a cell, book a 60-day pilot and a forward-deployed engineer will set up the first skill with your team.