Skip to content

LazyInfer

The adaptation layer for physical AI.

A Bayesian inference core and runtime. It keeps a belief over the state of the robot and the world, and corrects decisions when that belief changes.

Next to your stack, or part of it.

Start with LazyInfer next to the models and controllers you have: it reads the same telemetry and corrects their actions on the way out. When you are ready, let it take over a layer, such as perception, planning or control, and expand across the stack from there.

Your stack, unchangedSensorsCameras, IMU, jointsPolicy or controllerRL, VLA, MPC, PIDActuatorsArms, motors, speakersLazyInferState, parameters,uncertaintySame telemetryEstimatesAction correction

One core, three layers.

  1. Layer / 01

    Perception

    One belief about the robot, the cameras and every object, in one frame.

    • Odometry and SLAM for mono, stereo and RGB-D cameras
    • Fixed-lag smoothing with two-stage loop closure
    • Objects detected, tracked and fused into the same map
    • Every pose keeps the evidence behind it

  2. Layer / 02

    Learning

    Tracks the physical parameters that drift after deployment.

    • Friction and actuator gain, from live telemetry
    • User and environment parameters on wearables, without a GPU
    • Updates on the device, with no retraining loop
    • Feeds corrections to the policy you already run

  3. Layer / 03

    Planning and control

    Model predictive control, solved as inference.

    • Plans through uncertainty instead of around it
    • Corrects the actions of an RL policy, a VLA or a classic controller
    • Two arms at 100 Hz on one CPU thread
    • The control tick allocates no memory once warm

An inference engine written for robots.

General probabilistic programming is too slow for a control loop. We wrote the solver, the factors and the geometry for real time. On incremental smoothing, our solver runs up to 3.5× faster than GTSAM’s iSAM2 in our benchmarks.

Inference
Incremental smoothing on factor graphs, on Lie groups
Models
Continuous and discrete variables, robust noise models
Memory
No allocation at steady state
Timing
Real time on CPU. No GPU required
Interfaces
Python, Julia, ROS and ROS 2

In early access

What a robotics team gets today.

SDK
Python, Julia, ROS and ROS 2 packages that connect LazyInfer to your sensors, models and controllers.
Runtime
Runs on the robot’s own CPU, next to your stack. No GPU and no cloud round trip in the loop.
Interface
Set up the hardware, calibrate the cameras, record demonstrations and run the cell.
Engineers
We integrate with you on your hardware, from the first log to the first live run.

The LazyInfer interface.

Where your team works with LazyInfer. It takes a robot cell from unboxed hardware to a live run: hardware, calibration, demonstrations, then live operation with a stop button always in reach.

The Hardware step: an arm with a wrist camera, and an overhead camera, placed in the workspace.

Drag the arms and cameras you have into the cell. Nothing to edit by hand.

Coming soon: compute board

Any sensor.
In sync.
Adapting.

One compute board for many kinds of sensors, with their data streams kept in sync. LazyInfer runs on it and adapts while the robot works.

Developed with

Aliensense
Two compute boards with camera connectors and cooled processors, on the edge of a dark plinth
SensorsModular
Connect different cameras and sensors to one board, and change the mix as your robot changes.
Data streamsSynchronized
Data from every connected sensor arrives in sync, ready to fuse.
EstimatesAdaptive
Factor graphs, incremental smoothing and IMU preintegration fuse the streams on the device, and update as conditions change.

Built for

  • Mobile robots
  • Robotic arms
  • Drones
  • Humanoids

Early access is open for robotics teams.

Albert Podusenko

Albert Podusenko

Chief Executive Officer

We work with a small number of teams on real hardware. Tell us what you run and where it struggles.

Send a message