Resource network
Distributed RAM — pooled across the nodes in a ring so a model larger than any single machine still has somewhere to live.
Metered in GB-hours
The same resource, the same meter, three answers to “whose machine is this?” You choose per workload, and you can move a workload inward when the rules tighten.
On your device
Available
Inside your gram
Available
On a stranger’s machine — not available
Available
Each node benchmarks itself and signs the result with its own key. Where a benchmark does not exist yet, the node says so and emits nothing in its place. So do we.
Signed metric
mem.bandwidth
Unit
MB/s
The node copies a payload buffer repeatedly for sequential bandwidth, then chases a dependent pointer through a buffer larger than any cache to measure the latency of a miss. Both are signed.
Bandwidth is how much memory you can move; random-access latency is how long you wait for a byte you did not predict. Both are measured. Capacity — how much RAM the machine has — is not, so we do not quote it.
RAM, not FLOPS, is what stops an LLM from running. Every other decentralised compute network treats memory as a property of a machine you rent. We treat it as a resource you can draw from a ring, meter, and prove. As far as we know, nobody else does.
Free on your own hardware. The meter only runs when you consume someone else’s.
There is no 24/7 operations centre, because we do not employ one. Instead a node that cannot prove it is healthy is evicted from the ring rather than quietly serving your work. Fail-closed, not fail-silent.
Memory is pooled, never captive. Stop paying and the pages return to their owners.
Every resource above reaches your workload through the same substrate, whichever ring it was drawn from.
Each node runs k3s. One orchestration layer schedules all seven resources, so a workload moves between rings without being rewritten.
Workloads that cannot be containerised run as virtual machines on the same cluster, through the open-source KubeVirt project. Same scheduler, same meter.
Standard containers, standard VMs, content-addressed objects, exportable receipts. The cost of leaving is the reason to trust the platform.
Memory is metered in GB-hours. Each unit of work produces a receipt naming the node that performed it and the price it was charged at, on the one ledger the whole platform shares. We publish no hourly rate table on this page, because a price is meaningless without the signed unit it is counting.
See how we price compute →Not a specification, not a vendor sheet. The best verified result any node on this network has signed for memory — and, below it, everything else that node put inside the same signature.
mem.bandwidth
32,329 MB/s
A benchmark reports one number and signs several. These travelled inside the same signature, so they are as verifiable as the figure above — and they are usually the ones that decide whether the machine suits your work.
Method
sequential memcpy for bandwidth; dependent pointer chase over a buffer larger than cache for latency
method
What was actually run, in the words of the node that ran it.
Payload size
64
payload_mb
How much data was moved. Small payloads flatter a disk by living in its cache.
Random-access latency
15.007
random_access_ns
How long the processor waits for one byte it did not predict, measured by chasing a dependent pointer through a buffer too large to cache. Bandwidth is how much memory you can move; this is how long you wait. A database, a graph traversal and a language model’s attention cache all live on this number, not the other one.
Installed memory
16,384
total_mb
Bandwidth and latency say how fast memory is. Capacity decides whether a model loads at all.
Memory type, speed and channel count are not shown. They live in firmware tables that only a root process may read, and this daemon does not run as root. What you see instead is what the memory actually did.
Nothing recorded against memory. That is a statement about our backlog, not a claim of completeness — the full list lives on the proof page.