imesh Run a node
Architecture

Three parties, and one rule: nobody is believed.

Every number in this system is counted by the party that has no reason to lie about it. A machine can offer work and can refuse it; it cannot decide what it earned.

01

The machine

A node on someone's desktop or server. It reaches out; nothing reaches it. It reports what it has, takes work the operator allows, and answers a challenge for every parcel it wants to be paid for.

no listening portunix socket 0600no account
02

The server

The only place a balance exists. It mints grants, counts bytes and seconds on its own clock, prices each parcel by the output it actually received, and writes off what a silent machine never proved.

ledgerpriced by output60 s silence = written off
03

The partner

Whoever needed the work. For an offer, the partner confirms the completion to the server; without a partner, no offer is paid at all. For a compute parcel, the proof is the confirmation.

offer verificationno self-report

What a machine can be asked to do

Four kinds of work, and one thing that is not work at all. Each has its own ceiling, because each one fails differently.

CPU

A container that uses N cores

Any OCI image, a command, a core count and a memory ceiling. The container starts with no network at all, is killed at its deadline, and its output comes back with the result.

Image
any OCI reference the machine can pull
Limits
--cpus N, --memory Nm, --memory-swap equal to memory
Network
--network=none — a task cannot phone home
Deadline
at most 60 s per parcel, enforced by the node and by the server
GPU

Work that needs a card

A job can require a graphics card, and the card has to prove it was there. Every card parcel carries a fresh challenge worth 17 billion hashes; the answer is accepted only between 3 and 60 seconds after the challenge was minted, on the server's clock. A card finishes in seconds; a CPU doing the same work is minutes late and its parcel is refused, unpaid, and barred. The make of the card never decides who runs the job — the make never prices anything.

NVIDIA
--gpus all, through the NVIDIA container runtime
AMD
/dev/kfd and /dev/dri, with keep-groups
Intel
/dev/dri
Windows / WSL2
no card passed through, so no card is offered
Apple
observed, never rentable: no container can reach Metal
KINDS

Three kinds of work, three prices

A mining job and a streaming job are not batch jobs with more output, so they are not priced like one. Every job states its kind when it is submitted, the kind is sealed on the job, and both the price and the proof follow from it. A node never picks the most profitable reading of the same bytes.

bytes
1 credit per KiB of verified output — the original model
hashes (mining)
priced per share: 2^(bits−22); a share is checked against the job's own seed before it is paid
frames (streaming)
1 credit per megapixel-frame; proved by a manifest naming the frame count, the resolution and the digest of the archive that arrived
Card work
mining and streaming are card parcels whether or not the customer ticked the box: a CPU box never sees them, and a card parcel is answered inside a window only a card can meet
RAM

Memory a machine is not using

Lending memory is not a job and it does not pay on its own. The reported free-memory figure is a number the node reads from its own kernel, so nothing is ever paid for it: memory that a job really uses is paid inside that job's parcel, out of the work the job produced.

Rate
no rate — a claim is not work
Switch
still yours to turn off; it never moves a credit
Paid when
only as part of a parcel that produced verified output
Reservation
held with a real allocation, released with the parcel
training

A run that outlives a minute

Nothing in this system waits longer than 60 s, so a training run is a series of rounded parcels: the container writes its state to /work, the next parcel mounts the same directory and picks it up, and the meter keeps running between parcels.

Workspace
/work, kept between parcels
Billing
each parcel pays for its own output, between 1 and 16 credits
Stop
one command, and the meter stops at that second
Silence
a run whose machine disappears is requeued, not paid

The rule, in one paragraph

Bytes are counted at the exit. Seconds are counted on the server's clock. Memory is counted by the minute the machine is online. The one thing a machine spends that the server cannot see is CPU time — so before a parcel closes, the machine has to answer a challenge that only someone holding that parcel's output can answer: a value whose SHA-256(seed ‖ task ‖ SHA-256(output ‖ work) ‖ answer) starts with 24 zero bits. That is about 16.7 million hashes, a few seconds of real CPU, checked by the server with one hash. A machine that skips the work cannot close the parcel, and the credits it accrued are written off rather than handed on.

A card parcel carries a second challenge, and it is cut from a measurement rather than a guess: 2^34 hashes (about 17.2 billion). On this four-core box that is roughly seven minutes of every core; a sixteen-core CPU still needs 107 seconds. A mid-range card needs 3 to 17 seconds. The server accepts the answer only between 3 and 60 seconds after it minted the challenge — inside the time a card needs, outside the time a CPU needs — and clocks it on its own watch. Too late is a refused parcel paid nothing; too early is an answer that was not computed for this parcel at all. A machine that fails this is barred from card work for six hours, so lying is not a retry.

Measured, not claimed

These were taken from a running server and the shipped binaries, on a 4-core box with no graphics card. Where hardware was missing, a synthetic machine stood in — and the page says so.

WhatHow it was testedResult
CPU parcel alpine:3.20, 500 MB read, 2 cores, real docker done, exit 0 · 16 credits for 16 KiB
Memory lent a machine reports 64 GiB free, no job involved 0 credits — a claim is not work
GPU job, no card a node claims twenty cards at 5 G/s each one parcel, 0.5 % of the bench in 55 s, refused · paid 0
GPU job, real card no card exists on this rig, so the window is the fixture inside 3–60 s accepted, outside refused, bar 6 h
Silent machine node killed mid-parcel, watched for 60 s queued, paid 0 at t+60 s
Forged answer own token, wrong proof, running parcel refused: “did not close a job”
Machine lost mid-run node killed with SIGKILL on parcel 4 of a run that counts its parcels 11 credits forfeited · job requeued · next machine resumed at step 5
Server reboot queue snapshotted to disk every five seconds unfinished jobs and their workspaces read back

What this system does not do

  • It is not a marketplace for arbitrary jobs. A job names an image and a command. There is no bidding, no reputation and no scheduler that optimises placement; the first machine that fits gets the parcel.
  • A card on a Mac is not rentable. The node sees it and reports it, and any GPU parcel will skip that machine, because no container on macOS can reach Metal.
  • No machine is promised to be up. That is not a caveat, it is the design input. Every parcel carries its /work back to the server, which keeps the newest one per job on a budget and hands it to whichever machine takes the next parcel — including the server's own reboot, because the queue is on disk. What a lost machine costs is one parcel in flight, never the run.
  • The proof proves CPU, not honesty. It shows a machine spent real work for this parcel, now. It cannot prove the container did the thing its image was supposed to do — that is the partner's confirmation, or the operator's judgment, not this system's.