From model to machine. Meet Fenon.

Explore the platform

The inference layer for robotics

Your models.
In the real world.

Build with FenonExplore the architecture

Run the models that move the physical world.

Fenon is inference infrastructure for robotics. Connect cloud intelligence to physical machines—without making infrastructure your core work.

Isometric diagram of compute tiles: observations from a physical machine flow into model execution on two highlighted orange tiles, and the response returns to the robot's control loop.

Observation in → model execution → response out

Conceptual architecture · not live telemetry

Built around the machine

The platform

The cloud layer behind
physical intelligence.

Your model is one part of the system. Fenon focuses on the inference layer that connects it to the machine.

Model-first development

Bring the intelligence.
Not the infrastructure work.

Define the model, its inputs and its runtime. Keep the integration visible and the deployment details out of the way.

deployment.yaml
# Integration conceptname:       manipulation-policymodel:      your-team/checkpointinput:      observationoutput:     action_proposalruntime:    cloud

Illustrative configuration, not a released SDK

A connected system

An execution layer.
Not another model catalogue.

Observations go in. Model responses come back. Design the intelligence around your robot’s own control loop.

  1. RobotObserve
  2. FenonInfer
  3. ControlRespond

From experiment to deployment

A single robot is the start.
The inference layer shouldn’t be the limit.

Build around changing workloads: the models you run, the observations they receive, and the machines that depend on them.

  • Model version
  • Request context
  • Runtime needs
RequestsCompute response

Workload shape

Observation window →

Illustrative workload shape · not capacity or benchmark data

Workloads

Different models.
One inference layer.

Robotics intelligence spans more than perception. Organize the models around the work your machine needs to do.

Give observations
some understanding.

Connect multimodal reasoning to the robot’s context. Interpret what is happening, reason about the task, and propose what should happen next.

See the inference loop

Model workload / concept

reasoning-model

IN / observation + taskOUT / plan

Model to machine

Keep the integration
as clear as the intent.

A deliberate boundary between cloud inference and the robot. The response informs the machine; local control remains local.

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

  1. 01

    Package the observation.

    Send the task and the context your model needs.

  2. 02

    Run the model.

    Request an inference from the selected checkpoint.

  3. 03

    Validate the response.

    Apply your local checks before an action is executed.

robot_loop.py
# Pseudocode — your robot, your modelobservation = robot.observe()response = inference.run(    model="your-team/policy",    input=observation,)if controller.accepts(response):    controller.execute(response)

Cloud inference → local validation → execution

Conceptual integration, not executable SDK documentation.
Control requirements depend on your robot and deployment.

Follow the work

See the loop.
Not just the request.

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

Inference lifecycle / example trace

  1. 01Observation
  2. 02Model execution
  3. 03Local validation
  4. 04Next action

Illustrative sequence. Bar lengths show process progression, not measured latency. No requests are being sent.

Engineering notes

Inside the inference layer.

Space for the architectures, experiments and decisions behind robotics inference.

From the model to the real world

Build what
moves next.

Tell us what you’re building, which models you run, and what your robot needs from its inference layer.

Talk to Fenon