New · v00052 Read the changelog ↗

AdmiralOS · Fleet platform for robots and edge AI

The operating system for physical AI.

The Linux OS, update system and remote access under your robot, already built and maintained, so your team can ship the robot months sooner.

01 / 10 · Autonomous robotics

Humanoid robot

Ships for

  • NVIDIA Jetson
  • Intel & AMD x86_64
  • Rockchip RK3588
  • Allwinner SoCs
  • ARM64 SBCs
Download targets

Why Admiral

Every robotics company is also an embedded Linux company.

Keep your robot platform, your operator console and your data pipeline. Admiral only owns the layer below your container that keeps the computer booted, updated and reachable. Teams usually come to us at one of three moments.

  1. Prototype to customer sites. Ubuntu, SSH and a script worked on the bench; twenty robots behind customer firewalls do not.
  2. A growing engineering team. Hand-flashed images and one person who knows the box break on the second developer.
  3. New hardware. A second compute module means a second distribution to bring up and keep patched.
Your robot & operator platform What you own · Standard OCI

Admiral OS and fleet platform

What Admiral owns
  • Immutable OS
  • A/B updates
  • Watchdogs
  • Networking
  • Remote access
  • Fleet rollouts
Hardware x86 and ARM boards, incl. NVIDIA Jetson

Time to market

In production months sooner.

Flash a board and it enrols itself on first boot, with your stack running the same day instead of after a six-month platform build.

Ownership & boundary

You own the robot, not the Linux layer.

Keep your operator platform, your telemetry pipeline and a standard OCI image that runs on plain Docker the day you walk away. We maintain the kernel, A/B update slots and CVE patches underneath.

Operations

Fixed remotely, without a site visit.

Updates install to a spare partition and revert on their own if the health check fails. You have logs, metrics and a shell into the workload without opening an inbound port.

In the field

Rocco, a Unitree G1 running Admiral, at AWS.

Customer story · Robot for Hire

Three weeks from remote control to an autonomous humanoid.

Robot for Hire moved their Unitree G1, Rocco, onto Admiral in a day and spent the next three weeks building the autonomy that now walks it around Sydney on its own, without writing any of the OS, update or remote-access tooling underneath.

"It made our deployment ten times faster."

Sammo Founder, Robot for Hire

Read the full story

Hardware
Unitree G1 humanoid
Remote control to autonomous
3 weeks
Migration to first demo
1 day

How it works

From your Dockerfile to a running fleet.

The full walkthrough
  1. Build

    Your Dockerfile compiles into a signed, read-only OS image for your board on x86, ARM or RISC-V.

  2. Enrol

    Each device provisions itself on first boot and receives its own hardware identity.

  3. Deploy

    Staged rollouts write to the inactive partition and only cut over once the health check passes.

  4. Operate

    Monitor health, open a workload shell over an outbound connection, and ship OS patches for the life of the machine.

Dockerfile

FROM ubuntu:26.04
RUN  apt-get install -y \
     ros-jazzy-base perception-stack
COPY config/ /etc/admiral/
CMD  ["/opt/perception/run"]

admrl rollout status robotics‑autonomy ‑‑watch

14:22:05 amr-prod-aus-0187 pulling_image

14:22:09 amr-prod-aus-0187 pulling_image -> starting

14:22:12 amr-prod-aus-0187 starting -> converged

14:22:12 counts converged 1/412, admitted 1, in flight 0, failed 0

14:22:41 counts converged 412/412, admitted 412, in flight 0, failed 0

Immutable Linux · No inbound ports · Offline‑first · Post-quantum crypto

The console

See every machine and every rollout.

Inspect a single robot, watch a rollout converge across the fleet, or open a shell into a running workload from the browser.

app.admrl.co
Admiral console device page for amr-005: online, running nav-stack v14, live screen preview, CPU, memory, storage and temperature

Updates

Updates in seconds, not hours.

Admiral sends only what changed, for the OS and your apps, so even a weak connection keeps up.

  • Picks up where it left off
  • Falls back safely

The platform

Keep control of the robot. Stop maintaining Linux underneath it.

Maintaining your own partition table, update agent and kernel CVE patches does not give you more control over the product. It gives your best engineers a second, permanent job: about 13 engineer-months to a first version on one board, then about 2.5 a year after. The engineer-month bill

Updates

A bad release never strands a machine.

Two slots: the new one must boot and pass its health check, or the old one comes back on its own. Rollouts pause themselves when failures cross your budget.

Updates send only what changed

Connectivity

Offline is normal, not an incident.

The workload keeps running without a link. Logs and metrics buffer on the device and drain in order when connectivity returns.

Remote access

Reach any machine from your desk.

Open a shell inside the running workload with no inbound ports and no SSH daemon, with live logs, metrics and screenshots alongside it.

Releases

Release from CI, in the site's own hours.

One command drives the canary, rollout window and failure budget, gated by maintenance windows in each site's local time.

Hardware

Your hardware and stack stay yours.

No general-purpose distro and no container daemon (~100 MB, under 10 s to workload). Kernel modules are compiled in and cameras, CAN, serial and Jetson GPUs pass straight through.

Hostile sites

Locked down for buildings you do not control.

People walk up to field machines with USB sticks and pull drives. Every boot is checked by a dm-verity Merkle tree, disks are sealed to the TPM, USB is policy-gated, and every link uses hybrid post-quantum TLS.

By month eighteen

Against building in-house, and against the OS and OTA vendors.

Security & PQC · What changes in your repo →

Trade-offBuild in-houseMenderUbuntu CoreBalenaAdmiral
What your team maintainsThe whole OS, update agent and VPNYour OS image + Mender clientYour snaps + kernel and gadget snapsContainers on balenaOSOne Dockerfile
Getting a CVE fix onto the fleetYou patch, build, test and ship itYou rebuild your OS imageCanonical refreshes core snaps; a custom kernel snap is yoursbalena releases host OS updatesAdmiral ships the patched OS; your image is untouched
When an update fails on siteCustom scripts or a truck rollA/B rootfs (you integrate the client)Snap reverts; no fleet-wide pauseA/B host OS; app rollback by pinning releasesA/B OS + workload rollback; rollout pauses itself
Adding a new compute boardPort and maintain another imageRebuild Yocto / Debian layerCertified board, or you build the kernel and gadget snapsSupported boards or custom YoctoSame Dockerfile; Admiral builds the board
Offline & bad networksYou build and test the edge casesEnterprise / offline add-onSide-loaded snaps; Landscape sold separatelyOffline reflash workflowRuns offline; buffers and drains on reconnect
Lock-in if you walk awayTied to the engineer who wrote itMender client + artifact formatSnap format and store; OCI via the Docker snapMulti-container balena supervisorStandard OCI image; one command reflashes to your own OS

Robot operations tools such as Viam, Formant and Foxglove run on top of the OS Admiral maintains, not instead of it.

Before you decide

The questions robotics teams ask first.

Where Admiral stops, how much of the machine it takes, how it survives a hostile site, and what happens if you leave.

Does Admiral replace my robot software?

No. Your autonomy stack, ROS 2 nodes, drivers, operator console and data pipeline stay yours and run unchanged inside your container image. Admiral owns the layer below that image: the kernel, the A/B update slots, device identity, remote access and the fleet console.

How much of the robot does Admiral take?

Very little. AdmiralOS is a minimal immutable image with no general-purpose distribution and no container daemon under your workload, so on a Jetson Orin it leaves most of the RAM and all of the GPU to your stack. Kernel modules are compiled in and the full device tree is passed through, so cameras, CAN, serial and CUDA behave as they did on bare Ubuntu.

Are we locked in? Can we leave?

Your workload is a standard OCI image built from your Dockerfile and stored in your own registry. It runs on plain Docker on any Linux machine today, and it still runs the day you stop paying us. Leaving is one command: admrl device exit, in early access, stages any disk image you choose at the tail of the disk, reboots into memory and writes it over the whole disk, for one robot or a whole fleet. A USB reflash works on every device today. What boots afterwards under Secure Boot is on the leaving-admiral page.

Do we have to migrate the fleet we already have?

No. Put one spare robot on Admiral and run it beside the fleet you have. Nothing changes for the machines you have not flashed. Move the rest when the spare has earned it, or never.

We have the engineers to build this. Why would we buy it?

You can build it, the same way you could run OpenFaaS on raw EC2 instead of using Cloudflare Workers. Almost every team starts on the silicon vendor's image, discovers it has not been patched in six months or six years, tries to move to mainline, and discovers the NPU, ISP, cameras or power management depend on out-of-tree vendor patches. Doing that bring-up, A/B rollback, hostile-site lockdown and weekly CVE patching takes about a senior engineer for a year on the first board and keeps taxing the roadmap at scale. The engineer-month bill is on the build-versus-buy page.

Will it pass our customer's security review?

A machine in a customer's building sits where strangers can touch it, plug a USB stick into it or pull its drive, and people do try. Keeping a field Linux box locked down against physical access while kernels release weekly and CVEs land daily is a full-time job; Admiral is built for that and for the enterprise security review that checks it. Every device connection uses hybrid X25519 + ML-KEM-768 post-quantum key exchange over TLS 1.3 by default. The root filesystem is read-only and verified on every boot by a dm-verity Merkle tree, disk encryption is sealed to the TPM against Secure Boot state, each device has its own hardware identity with short-lived rotated credentials, and every system binary is compiled from source with no distribution packages. The full posture, including the security-questionnaire support, is on the security page.

What does it cost once we are past five robots?

Launch is US$500 a month for up to 10 devices, Growth is US$1,500 for up to 100, and Scale is US$2,500 for up to 250, each with kernel and CVE patching, A/B updates, remote access and every supported board included. Past 250 you keep the Scale base and pay a falling per-device rate down to US$1. Logs, bandwidth, registry fallback, AirDetect and AdmiralAI are usage-based on top. The first five devices on any account stay free for building.

EdgeWire

Early access

Built for 10 Gbit/s. Tuned for LEO and 5G.

A Go library and an admrl edgewire command set that give you a socket to any service on a robot. Direct where the network allows, relayed where it does not.

See EdgeWire

Go

err := edgewire.Forward(ctx, "127.0.0.1:18080", edgewire.Options{
    DeviceID: "edge-1",
    OrgID:    org,
    Service:  "http",
})

or the CLI

$ admrl edgewire forward edge-1 http 127.0.0.1:8080
  • 10 Gbit/s

    Built for it on a direct path

  • LEO and 5G

    Adapts to changing latency and loss

  • QUIC

    One encrypted transport per session

  • FEC

    Adaptive forward error correction

  • ML-DSA-65

    Post-quantum signatures, FIPS 204

  • P2P + relay

    ICE direct path, TURN fallback