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.
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.
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.
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.
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.
Four kinds of work, and one thing that is not work at all. Each has its own ceiling, because each one fails differently.
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.
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.
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.
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.
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.
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.
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.
| What | How it was tested | Result |
|---|---|---|
| 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 |