The inference layer for robotics

Your models.
In the real world.

Build with us ↗Explore the architecture ↗
01 / ObservationsContext from a physical machine
02 / Model executionCompute, abstracted
03 / ResponseBack to the control loop
Observation in → model execution → response out
Conceptual architecture · not live telemetry
Built around the machinePerceptionPoliciesTeleop
The platform

The cloud layer behind physical intelligence.

Your model is one piece of the system. This layer connects it to the machine.

Model-first development

Bring the intelligence. Not the infrastructure work.

Declare the model, its inputs, and its runtime. The deployment details stay out of the way.

# Integration concept
name:    manipulation-policy
model:   your-team/checkpoint
input:   observation
output:  action_proposal
runtime: cloud
A connected system

An execution layer. Not another model catalogue.

Observations go in and model responses come back.

Robot
Observe
Infer
Control
Respond
From experiment to deployment

One robot is the start. The inference layer shouldn't be the limit.

Illustrative workload shape. Not benchmark data.

Workloads

Different models. One inference layer.

Robotics intelligence spans more than perception. Organize models around the work your machine does.

Model workload / concept
Model to machine

Keep the integration as clear as the intent.

A deliberate boundary between cloud inference and the robot. Local control stays local.

The intelligence runs in the cloud.
The robot owns the action.

  1. Package the observation.Send the task and the context your model needs.
  2. Run the model.Request an inference from the selected checkpoint.
  3. Validate the response.Apply your local checks before anything executes.
robot_loop.py
# Pseudocode: your robot, your model
observation = robot.observe()

response = inference.run(
    model="your-team/policy",
    input=observation,
)

if controller.accepts(response):
    controller.execute(response)
Follow the work

See the loop. Not just the request.

Make room for the details that matter: the observation, model version, response, and the controller boundary.

Inference lifecycle / example trace
01 Observation
Context prepared
02 Model execution
Response returned
03 Local validation
Controller checks
04 Next action
Machine responds
From the model to the real world

Build what
moves next.

Tell us what you're building and what your robot needs from its inference layer.

Talk to us ↗