Resource network
Local block storage, content-addressed object storage replicated across peers, and cold archival.
Metered in GB-months, plus egress GB
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
storage.throughput
Unit
MB/s
The node writes a payload to its real disk, times the fsync that makes it durable, reads it back, then issues 4 KiB reads at random offsets. Throughput, durability latency and genuine IOPS are signed together.
The headline is sequential write throughput. A genuine random-read IOPS figure is measured and signed alongside it, with its own signed caveat that the page cache was warm — so it measures the filesystem path rather than a cold device. Until every node has re-benchmarked, an evidence card may still show the old metric name `storage.iops`, which promised operations and carried megabytes: renaming a past signed result would invalidate its signature, so old results keep their name and age out.
Storage is where residency actually bites. A replicated object is only sovereign if you can prove which nodes hold the replicas and where those nodes physically are.
Local disk is free. Cross-node replication is what you pay for, and you choose the replication factor.
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.
Object storage is content-addressed. Take the hashes and the bytes; nothing is proprietary.
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.
Storage is metered in GB-months, plus egress GB. 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 storage — and, below it, everything else that node put inside the same signature.
storage.throughput
834 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.
Block device
nvme0n1
device
The physical disk, not the partition.
Disk model
Amazon Elastic Block Store
device_model
What the drive calls itself.
Free space
13.609
fs_free_gb
What a process may still write, after quotas and the slice reserved for root.
Filesystem size
18.331
fs_total_gb
The disk this benchmark actually ran on.
Filesystem
ext4
fs_type
ext4, xfs, zfs and overlayfs do not make the same promises about when a write is durable, and fsync above is measuring exactly that promise.
How full the disk is
25.756
fs_used_pct
A disk at 95% full behaves nothing like the same disk empty: the allocator works harder, writes fragment, and fsync slows. Read the throughput above with this number beside it.
Durability latency (fsync)
24.899
fsync_latency_ms
How long the disk took to admit the data was really written. Sequential throughput is what copying a file feels like; fsync is what a database waits for on every single commit. They are unrelated, and the slow one decides how many transactions per second you get.
What this IOPS figure is not
4 KiB random reads against a file just written, so the page cache is warm; this measures the filesystem path, not a cold device
iops_caveat
The node signed this sentence along with the number, so it cannot be quietly dropped when the figure is quoted.
Payload size
64
payload_mb
How much data was moved. Small payloads flatter a disk by living in its cache.
Random 4 KiB reads
3,336
random_read_4k_iops
Genuine operations per second, at random offsets — the access pattern of an index, not a file copy.
Read throughput
322
read_mbps
How fast this disk hands data back.
Spinning disk
false
rotational
The kernel’s own answer, not a guess from the model name.
What the grade implies
solid state: no seek penalty, so the random-read figure is close to the sequential one
storage_class
A platter and an SSD can post similar sequential throughput and differ by orders of magnitude on the random reads a database actually issues. Signed with the number so it travels with it.
Write throughput
834
write_mbps
How fast it accepts data. Reads are usually several times faster than writes, and a database lives on the slower number.
Disk grade and filesystem appear only on Linux nodes, for the same reason.
Nothing recorded against storage. That is a statement about our backlog, not a claim of completeness — the full list lives on the proof page.