Start a project

Robotics · Embedded · Models · Software

We distil intelligence into machines.

Frontier models, distilled. Boards designed around them. Software that ties it together. And robots that put it all to work. Scroll to watch one take shape.

Talk to an engineer Watch it assemble

01 / Frontier models

It starts at the frontier.

We run pretraining and architecture research on large clusters, and measure every model with evals we write ourselves.

  • Pretraining
  • Architecture R&D
  • Evals

02 / Distillation

Then we distil it.

A large teacher trains a small student until it keeps the skill you need. We prune and quantise until it fits your GPU, your phone or a microcontroller.

  • Teacher to student
  • Quantisation
  • Custom models

03 / Embedded design

Into silicon you can hold.

Custom boards built around edge AI accelerators: schematics, layout, firmware and power budgets, so the model runs offline, in the field.

  • PCB design
  • Edge accelerators
  • Local AI

04 / Software

Run by software we write.

Firmware and drivers, robot control, inference runtimes, fleet updates and the apps your team uses. Every layer, in house.

  • Firmware
  • Robot control
  • Runtimes and apps

05 / Robotics

Until it becomes a machine.

Manipulators, mobile platforms, perception and control. We train in simulation, transfer to real hardware and keep the model on the robot.

  • Manipulation
  • Perception
  • Sim to real

Inside the lab

The model and the machine, designed together.

What leaves the lab

Seven things we build.

Embedded

Edge AI boards

Distillation

Small models with frontier skill.

They run on one GPU, a phone or a microcontroller.

Quadruped robot walking in a workshop
Robotics

Mobile platforms

GPU servers in a data hall
Frontier

Pretraining research

Local AI

Your model, your building.

Private inference. Nothing leaves your network.

Silicon wafer in a cleanroom
Custom models

Trained for one job

Monitors showing a robot arm simulation
Software

The code that powers it all

How it works

From question to running hardware.

One team from the first question to the device in the field. No hand-offs between vendors, so nothing gets lost between the model, the board and the code.

  1. Research

    We define the task, the data and the test that proves success before anything is built.

    You get
    • Problem spec
    • Eval suite

  2. Design

    The model, the hardware and the software are specified together, by one team.

    You get
    • Architecture
    • Board spec

  3. Build

    We train and distil the model, lay out the boards, write the code and assemble.

    You get
    • Trained model
    • Prototype

  4. Deploy

    We ship to the device or the server room, then measure it in the field.

    You get
    • Live system
    • Field data

# Tell us what you are building. It goes straight to our team.

06 / Contact

Bring us the hard problem.