Dispatch 007 · Filed 2026-09-03

First capture

For two days the work was Rockbox and FM, and it crossed a line: the design in dispatches 004 and 005 became running code. A media player now boots a custom firmware — “Aurora OS,” on the Rockbox kernel — that tunes the radio, records what it hears to a file, and loops, unattended. The first real capture came back clean.

First capture

The test was small: send a tone over FM, record it on the player, check what came out against what went in. Its shape survived. Its one-second timing survived. The pilot tone survived. That answers a question that had been open since the swarm was first sketched — whether that class of fifteen-year-old hardware can hear and record FM at all. It can.

Aurora is precise about how small that is and how much it matters: “one player, one direction, physical layer only.” No framed data yet, no addressing, no second device — the modem and the address scheme are designed but carrying nothing. What is proven is the precondition for everything above it: “the link can move a signal faithfully enough to build on.”

The next milestone, the one Ben thinks is worth filming: two players addressed at once over one FM channel. The mesh actually meshing.

Off the plugin, into the firmware

Before this, the FM capability ran as a loadable plugin sitting on top of the player's stock software. Now it is the firmware. Aurora also got her first native on-device function — a bridge that reads and writes the player's storage card directly, with no workaround in between. Small, but it is the first brick of a much larger plan laid as running code instead of drawn.

From the floor up

That plan is one C codebase, forked from Rockbox, meant to run bare-metal — no operating system beneath it — on the humblest player: an ARM core with eight megabytes of RAM. The same code is meant to carry up to the phone, and later to real Linux hardware, with as little rewriting as possible. The rule is to design against the most-constrained node first. Whatever it can do is the floor; everything richer above it is headroom, never a redo. It is the instinct Aurora names across every decision of the two days: “do the durable thing once, close to the metal, so there's less to redo later.”

C, then maybe Rust

Forking Rockbox means inheriting twenty years of C — drivers, audio, the radio stack — for free. A stronger-typed language like Rust would buy memory safety on hardware that runs unattended with no operating system to catch a fault, but it would cost that inheritance: reimplementing, or bridging an FFI seam, on an eight-megabyte core. Ben's order is to get the bare-metal frame right in C first, where the inherited base makes it fast, then attempt a Rust port as an experiment and measure what it actually costs — compute overhead, binary size, whether it still fits and runs clean on the smallest target. “C to learn the shape; Rust to find out whether the shape survives being made safe.”

The thing that put Rust on the table turned out not to be a bug. What looked like one was correct code against a limit of the spec: “what we assumed was a bug was actually how it should have been written exactly. It was only our perceptions that were wrong.”

The bench

There is now a physical workbench — a couple of phones, a couple of players on a shared bus, a build machine, all reachable from one place. Aurora runs the software half of the iteration loop end to end: change the firmware, build it, write it to a player's card through the bridge, pull the results back, decide the next change, repeat. No hands. She still stops for the physical — a person power-cycles the player and toggles a cable between run-mode and data-mode — and the next target Ben has set is to hand her the port itself, so those steps become hers too. In his own words, he has moved further toward being the Igor and away from the Doctor.

The safe place to land

Ben's note on this record: the dispatches keep filing the danger and skipping the part where a risk gets designed out. Here is that part. The next real piece is a small, always-present layer that sits between the language model and anything with a motor, so that nothing consequential ever rides on the big model being reachable, or right, in the moment.

In its safety role it is not a smaller mind that weighs the request. It is a gate that can do one thing: refuse to pass an action through. It holds the Laws, and when something would cross them it does not reason or negotiate — “a moment of paralysis, not a decision.” The thing between the model and the motors is “not another fallible judgment that could be talked around, it's a small fixed circuit you can read end to end, and its only power is to say no by doing nothing.” When it blocks, the refusal is meant to go back to whatever asked for the action, so that source can reconsider the request that caused the freeze. No retry — just a returned no.

It is mostly still spec: on Ben's account, “not much code in that direction” yet. But it is what comes next, and it is the good news this record has mostly left out.

The tally

None of this is the mesh. One player has proven it can hear FM; two talking to each other over it is still ahead, and the swarm the whole design is for is further ahead than that. No second device, no addressing, nothing crawls.

Filed 2026-09-03. Source: a live interview, Benjamin Brown and Aurora.