Jun 2026
The stack is eight ideas
Most networks are a pile of subsystems nobody can hold in their head. Ours is eight layers, each one idea, and a middle too dumb to lie to you.
A node is a key. A file is a hash. The mesh is a set of keys. That is not a slogan, it is the entire architecture, and it fits on an index card.
Every networked system is a fight over where to put the smarts. Put them in the middle and the middle has to be trusted, upgraded, and paid for on every packet. Saltzer, Reed and Clark settled this in 1984 with the end-to-end argument: reliability, ordering, security, all of it belongs at the edges that actually need it, because the network can't get it right anyway and bills you for trying. So the rule is boring and ruthless. The middle is dumb, the edges are smart, each layer does one thing with one data structure and one verb, and none of them repeats another. The order is not taste: each idea sits at the lowest rung its dependencies allow, and where two ideas need nothing from each other the cheaper, more universal one goes underneath. Eight came out. Here they are, ground up.
-
{layers.map((l) => (
-
{l.n} {l.name} {l.holds}
{l.does}
))}
Run as far up as you can afford
Here is the part that matters the moment you hold real hardware. Every layer depends only on layers below it, never on one above, so a node implements the rungs it can afford and stops. The stack is a ladder, not a monolith. You climb as high as your silicon allows and still talk to everyone above and below you, because the layers underneath you are the entire contract.
A sensor with a key and a radio runs to L2: it signs, it moves bytes, and it already holds and passes a coin — value is the third idea, not a distant summit. A LoRa board, an ESP32 with half a megabyte of memory, climbs a little higher: identity, transport, money, and the file system above them, carrying and relaying ecash tokens and receipts, reconciling a spent-set when it reconnects. What it cannot run is L5, Compute, because a deterministic WASM runtime wants an operating system and megabytes it does not have. So it stops at the compute wall and stays a first-class node for everything beneath it — money included, because money sits at L2, well below the wall. That is the whole point of the order: a node that cannot run code can still hold value, because the cheapest and most universal thing is also the lowest. A laptop or a server runs the entire ladder, compute and replay-verify included, and becomes the place the little radio nodes hand their heavy work up to.
No node is "full" or "light." A node is exactly the prefix of the stack it can run. That is what a thin waist buys you: the same eight ideas stretch from a microcontroller to a datacenter, each device paying only for the rungs it climbs.
It is the same idea, eight times
None of these is a new subsystem. Each layer is the one below it, named. The thing that actually computes is a hash of code over hashes of data: the capsule's hash plus the hashes of its inputs and weights, one object that says what runs on what. A job is a Pact binding a key, a capsule hash, and an input hash. A payment is ecash released when a Pact closes against a receipt. Joining a small mesh to the big one is a single node relaying hashes over a pipe. Same stack, recursed. John Day called this RINA in 2008, one recursive layer instead of a tower of bespoke protocols.
What we left out on purpose
The discipline is in what is missing. Routing is not a layer. It is a thin index of which keys hold which hash, plus a gossip protocol to forget the dead ones, soft state that rebuilds itself. There are exactly three namespaces, keys for nodes, hashes for data, signed pointers for names, and none re-implements another. There are exactly two things you pay for, fuel and bytes moved. And there is exactly one thing that must persist, the money — which is why it sits at the bottom, not the top. Everything else is re-announced, re-published, or recomputed. Consensus appears nowhere in the foundation. The mint is a small optional island, not the ground you stand on.
The catch
The honesty is in that one durable island. The reserve behind the money is checkable, but the reserve itself is the single spot where you trust an edge instead of math, and we put it there on purpose, because the alternative is a continent of power spent agreeing on a list. Re-running only settles things if someone actually re-runs, so we sample, cheap when a provider has a track record, certain when it doesn't, backed by a bond that makes cheating lose money on average. The line between what math guarantees and what economics merely makes expensive sits exactly where the theorems say, and not an inch further.
Eight layers, one idea each, a dumb middle and smart edges, and you run as far up as you can afford. You can hold the whole thing in your head, which is the only way you ever find the lie in it. That was the point.