Hardware as a Citizen

In the last post I said what I really wanted was a way to collaborate with hardware. This one is about the smallest unit that makes that possible and about a word I had to give up to get there.

I started out calling them workers. A worker is a machine that takes a job: it registers what it can run, polls for work, gets handed a task, does it, and reports back. That's a clean little protocol, and it's real, it's how a compute box earns its keep in the pool. But "worker" quietly smuggles in the whole model I was trying to leave behind. A worker waits to be told. The work runs down a line and ends in an approval. It's a relay, a baton passed in one direction.

The word I've moved to is citizen.

A citizen is anything that can join: a Mac mini, a lamp, a printer, a sensor, and an agent, too. They all join the same way. Each one has an identity, a set of capabilities, a current state, and a stream of events. A compute box and a dumb desk lamp are, in this model, the same kind of thing; they differ only in what they can do. That collapse is the part I haven't seen anywhere else. The IoT platforms have devices, but no agents; the agent platforms have compute, but no lamps. Relay treats them as one population.

And a citizen's capabilities aren't only about what it can receive. The question I kept asking was too narrow: "What commands can this thing take?" The better one is "how can this thing show me something?" A Mac mini has a screen, so it collaborates visually: here's a short Playwright video of the change I just made. A lamp has color, so it collaborates ambiently: it pulses while it's thinking, goes amber when it's stuck on me. A printer collaborates physically. Each one contributes in whatever modality its body affords. The video isn't a piece of evidence stapled to a ticket; it's a colleague showing you their work.

Which is why the channel has to run both ways. A citizen isn't just polling for jobs; state flows up from it, and intent flows back down. It's less a queue than a conversation. The job the thing I used to think the whole system was for turns out to be just one kind of contribution a citizen can make, not the reason any of it exists.

So I've stopped thinking of this as a relay and started thinking of it as a rally: things gathering around a shared place and continuing to add to it, in their own ways, over time. The compute box's poll-and-lease loop is still in there; it's just how that particular kind of citizen happens to contribute. It's no longer the shape of the whole thing.

The obvious risk in "things continuously contributing" is that it becomes something that won't stop pinging you. So the rule is calm by default: most of it stays in the periphery — a lamp's color, a doc quietly updating itself, and only steps into your attention when it genuinely needs you. Approving a diff becomes one response among many. Mostly, you just glance.

Under the hood, it's still humble: an identity, a declared set of capabilities, a connection that carries state up and intent down. Right now, nearly all of my citizens are Mac minis. But the whole bet is that the mini running an agent and the lamp on my desk are the same kind of citizen, and the moment they are, the interesting thing stops being automating tasks. It becomes that my software, my hardware, and I are finally speaking one language.