Systems · Robotics

The robot truck dog.

Put intelligence in motion. Kilo is an embodied agent built to see, move, communicate, remember and operate under a safety-first motion authority. It drives itself. Teaching it to read ground nobody surveyed for it is the work in front of us.

The Kilo rover, three-quarter view: a white-bodied off-road truck with an Android phone mounted as its head, showing large animated eyes through the windscreen
Kilo. An off-road rock-crawler chassis, on-board compute, a stereo depth camera, and a phone for a head — eyes, voice, ears and face recognition in one part.

Where it stands

Two different problems, two different answers

Autonomous driving

DEMONSTRATED

Kilo drives itself. Perception, decision and actuation close the loop on the vehicle, and the machine moves under its own control rather than under a hand on a controller.

Rugged-terrain autonomy

ACTIVE DEVELOPMENT

Making that autonomy robust across highly irregular ground — rock, rut, camber, loose surface, drop-off — is the current work, and it is a materially harder problem than driving a floor.

Kilo is a research and development platform. It is not for sale.

The hard problem

Can a machine learn what its own body can do?

Most autonomy is a navigation problem: find a route, hold a lane, avoid the thing in front of you. Kilo is aimed at a different question.

Can an embodied agent reason about what its machine can physically negotiate across highly irregular terrain — and learn from the experience?

This is the same problem the rest of Knowlton is built around, in its most physical form. A model trained on the world's terrain knows what rocks look like in general. It does not know what this machine, on this ground, can actually take.

A rock is not simply an obstacle or a path. It is one or the other depending on approach angle, surface, momentum, ground clearance and the machine itself. A slope one vehicle climbs will roll another. The judgment a good driver makes in that moment is not a map lookup and it is not object detection — it is a model of the vehicle's own capability, applied to ground it has never seen.

The goal is not just obstacle avoidance. It is teaching a machine what its body can actually do.

The Moab analogy The shape of the ambition is a truck picking its own line through Moab — reading terrain, judging what it can take, attempting it, remembering the outcome, and knowing when to stop and ask. That is an analogy for the class of problem: not a benchmark, not a claim about any production vehicle, and not a comparison to any commercial autonomy system. Kilo is a small-scale rover, which is exactly what makes it the right place to test the idea and cheap enough to fail often.

The foundation

Safety first, and it is structural

An agent that drives a physical machine has to be governed differently from one that writes text. Kilo's safety layer was built before its autonomy, and every drive source — a human at a browser cockpit, the autonomous driver, an AI agent over an API — reaches the wheels through the same authority.

One road to the wheels

There is no privileged path. Human, autonomous or AI, every command passes the same gate and satisfies the same conditions. That is enforced by architecture, not by convention.

Silence is not permission

Every input carries an age. An input that has gone quiet is treated as a failure rather than as the last known good value — and a robot that cannot see does not get to assume the road is clear.

It says why

When Kilo denies motion it publishes a named reason and the evidence behind it, so no dashboard can show a green light without also showing what the light is green because of.

Kilo's operator console showing raw live state: the safety payload reporting that motion is denied with a named reason, beside the control payload reporting applied steering and throttle at zero
Kilo's own live state, unedited. The robot's safety verdict beside the control output actually applied to the hardware — the reason for a refusal is first-class telemetry, not a log line. RUNTIME OBSERVED

Capability

What it does

Perception

It sees

Stereo depth, surface classification and drop-off detection, plus attitude sensing — so the machine knows when it is looking at sky or at ground rather than at open road.

DEMONSTRATED

Motion

It drives

Autonomous driving on the vehicle, plus low-latency teleoperation from a browser cockpit. Steering aims at gaps the vehicle physically fits through, not gaps that merely exist.

DEMONSTRATED

Voice

It talks and listens

Wake word, speech recognition and speech synthesis, all resident on the device. Kilo hears its name, understands what was said and answers out loud with no network connection of any kind.

DEMONSTRATED

Recognition

It knows faces

On-device face recognition and greeting by name. The image never leaves the machine.

DEMONSTRATED

Explanation

It answers for itself

Ask Kilo why it stopped and it answers from its own live state, in plain language — including saying it does not know, when it does not track the thing you asked about.

DEMONSTRATED

Experience

It is learning to remember

The experience layer — what the terrain looked like, what was attempted, what happened — is built and being brought into the driving loop. This is the frontier of the project, and it is named as such.

ACTIVE DEVELOPMENT

The head

A machine people are willing to stand next to

Kilo's head is a phone, and the phone shows eyes. They are not decoration. A machine that can move under its own power in a shared space has to be legible — a person should be able to tell at a glance whether it is idle, attending to them, working, or unhappy about something. The eyes orient by gravity, so they stay level when the truck does not.

The head runs one purpose-built application, and it carries more of Kilo's character than any other single part: the face, the voice, the ears, and a consent-gated memory for the people it meets. It has its own page →

You can run it yourself. The head is an ordinary Android application, and it is available for testing on a phone with no robot attached — the face, the offline wake word and the consent-gated recognition all work standalone. What testing it involves →

Kilo's eye display — idle Kilo's eye display — focused Kilo's eye display — happy Kilo's eye display — speaking Kilo's eye display — worried Kilo's eye display — asleep

Six of Kilo's expressions. State an operator can read from across a room.

The machine

Built, not rendered

The Kilo rover with its body removed, showing the ladder chassis, drivetrain, speed controller, wiring loom and the phone head mounted at the front
Body off. Ladder chassis, drivetrain, speed controller and loom — with a hardware kill line sitting in the motor's power feed.
The Kilo rover head-on, showing the stereo camera module mounted centrally behind the bumper, below the phone head's eyes
Head-on. The stereo camera sits centrally behind the bumper, below the eyes.
The Kilo rover mid-assembly on a workbench, surrounded by 3D-printed brackets, fasteners, wiring and tools
Mid-build. Kilo is an engineering platform first — the brackets, the loom and the mounts are all part of the experiment.

What it can become

The part that generalizes

Kilo is a small truck, and the small truck is not the point. Three things it is proving out are worth more than the vehicle:

  • A motion authority an AI agent cannot talk its way around. As agents start driving machines, the interesting question stops being what the agent can do and becomes what the machine will let it do. That layer is chassis-agnostic by construction.
  • Terrain reasoning grounded in the machine's own capability. Judging what a specific body can negotiate, and improving that judgment from experience, applies anywhere a machine has to cross ground nobody surveyed for it.
  • An embodied agent that can be interrogated. A robot that answers why it stopped, in words, from its own live state, is a robot you can supervise, debug and trust incrementally.

Stated plainly: the safety layer is designed to port and has not yet been ported to a second machine. It is a demonstrated architecture, not a packaged product.

Why it matters

Where the thesis meets the ground

Knowlton's position is that generation is close to solved and judgment is not. Kilo is that argument in physical form: an agent whose decisions have consequences measured in mass and momentum, held inside a structure that requires it to justify what it is about to do — and to stop when it cannot.

This page describes what Kilo is and what it does. The deeper technical record — architecture, verification evidence, the open-items ledger and the safety audit we ran against our own robot — exists, is maintained, and is available in partner diligence.