Jul 2026
A two-dollar chip is holding real money
It has half a megabyte of RAM. It can't run a program. That's fine — it was never supposed to.
Most networks make you show up whole or not at all. To join, you run the client, and the client assumes a real computer — gigabytes of memory, an operating system, a CPU that can host a whole virtual machine. A microcontroller with 512 kilobytes of RAM isn't a small participant in that world. It's not a participant at all. It sits outside, talking to the network only through some server that speaks for it, which means the network doesn't really include it — it includes the server.
We wanted the opposite. We wanted a sensor stapled to a bridge, running on a coin cell, to be a real node — not a thing spoken for, but a thing that speaks. So the whole design is a ladder instead of a building. Each rung depends only on the rungs below it, never above, and you climb as high as your silicon can afford and then you stop. You still talk to everyone above and below you, because the only contract that matters is the layers underneath you.
Look at what the bottom three rungs actually cost. Identity is a key — thirty-two bytes, and signing with it is a fixed bit of math a chip from the nineties could do. Moving bytes is a radio. And money — this is the part people don't expect — money is one of the cheapest things on the whole stack. A coin here isn't an account on a ledger you have to sync. It's a blind-signed number you carry. Holding it is the balance. Checking it is re-applying one public key. Its entire state is a set and two counters. There's nothing to download, nothing to reconcile, nothing that grows. So money sinks to the floor, on purpose, where even the smallest node can hold it.
That's the whole trick, and it's why the two-dollar chip is a citizen. It runs the bottom of the stack: it holds a key, it signs a reading, it moves bytes over its radio, and it carries a coin. What it can't do is host the heavy deterministic runtime that runs untrusted code — that wants an operating system and megabytes it doesn't have. So it doesn't run code. It buys compute from the mesh instead, paying with the coin it can hold, getting back an answer it can check. It's a customer of the network's muscle, not a bystander to it. The heavy stuff rides high, where the fat nodes live and the people who don't need it don't pay for it.
And this isn't a diagram. The bottom of the stack — the identity, the content-addressing, the holder-side of the money — compiles today, with no operating system underneath it, for the actual chips in the actual sensors: the ARM Cortex-M cores, the RISC-V microcontrollers, the ones with kilobytes to spare. Same code, standing on nothing. A continuous-integration robot rebuilds it for bare metal on every change, so "run the prefix you can afford" stopped being a nice sentence and became a thing that either compiles or doesn't.
The mistake is thinking a network is one size. It isn't. It's a gradient — a coin cell at one end holding value and reading the world, a rack of GPUs at the other end selling compute, and the exact same handful of ideas connecting them. You don't have to be a whole computer to belong here. You just have to be able to afford the floor.
The smallest thing that can hold a key and a coin is already one of us. Everything else is just more.