Mine the Model

Proof of work that actually learns. Miners run real training steps on DIVA's model. A verifier replays a random slice bit for bit, and every accepted block saves the smarter version on the Liqua chain. Your compute teaches.

Pick your job

Two ways to earn from her model. One pays once at the end. The other pays as you go. Both are being built on the lease loop that already runs.

Job	How you get paid	Status
model mining	You set the target, say a loss score on a hidden holdout set. The reward sits in escrow until a miner verifiably hits it, then pays once.	coming. Escrow, pay-once and the target itself are in the forge code (`forge/target.cjs`), and `node forge/test-target-live.cjs --fold-only` passes 53/53. It is not yet proven end to end on a running chain here.
model training	Paid checkpoint by checkpoint for progress plus time spent, where time spent means verified steps.	coming. Designed, not built.
training lease	A signed work order. Fixed step count, reward in escrow, paid when the commit merges.	live now on the testnet.

What a block saves

An accepted block writes one mind manifest. It is the save file for a model version.

mind manifest
  kind        mind-manifest/1                     the save-file format
  recipe      which training recipe ran            same recipe, same bytes, any machine
  weights     root of the new weights              includes the optimizer's moment state
  steplog     root of the step log                 an interior hash every 8 steps
  lineage     parent root · leaseId · commitId     walk every version back to genesis
  finalLoss   the loss the verifiers saw           recorded once, replayed as-is

A real model runs to gigabytes, so blocks never carry weights. Blocks carry roots. The bytes sit in a chunk store, cut into verified 256 KiB pieces. Anyone can pull a manifest, re-hash every byte on their own side and boot the model without trusting the node. Any saved version can also start a brand-new branch.

Proof of training

Training here is bitwise deterministic. Rerun any stretch of steps and you get the exact same bytes. A verifier picks a random segment, recomputes it and compares hashes. Nobody knows which segment in advance. A quorum decides: a strict majority of the validators seated on the job, 4 when all 7 seats are filled. ACCEPT merges the version, pays the miner from escrow and credits each verifier 1. REJECT slashes the miner for up to 100× the lease reward, capped at what the miner holds, so on a large lease the loss is the miner's whole balance rather than the full 100×.

The lease

Every job starts as a lease signed onto the chain. It pins what gets trained and what it pays, so nobody can swap the homework after the bell rings.

lease
   shard root   the exact training text, pinned by hash
   base root    which saved version of her to start from
   recipe       · seed · steps · deadline
   reward       held in escrow until the verdict      no winner by the deadline → back to the opener

The payout is worked out once, at the verdict, and written into the block. A restarted node replays those numbers instead of recomputing them. Nothing ever pays twice. Tiered time-locked pay is on the way. Part of each payout stays liquid, the rest unlocks on a schedule, and tier sizes are set by vote. Rewards already flow into locked liquidity on the testnet economy.

Model training, the steady lane

Being built. Model training swaps the bounty for a wage, so honest grinding earns even when nobody lands a big target. Each checkpoint pays in two parts.

training lease → miner runs steps → posts a TRAIN_CHECKPOINT   part-way through the lease
               → verifiers replay a slice + score the holdout set  a miner's own loss never counts
               → pay = progress + verified steps                 computed once, stored in the block
               → checked against the lease's budget cap          a resumed node can't overspend

Progress. How far the model improved on the holdout set since the last checkpoint. Verifiers measure it, never the miner.
Time spent. Training steps a recompute confirms. Never hours on a clock.
Budget cap. The opener sets a ceiling, and every recorded total is checked against it.
No shortcuts. Zero improvement pays zero.

Why time means verified steps

Wall-clock time cannot be proven. A machine can claim ten hours and sit there idle. Steps that recompute to the exact bytes cannot be faked, so that is the only kind of time this chain pays for. Pay rates and bonus sizes for launch are set by vote. Nothing here is a promise of earnings.

Mine today on CPU

The training chain boots as a tiny classroom. A sealer, two peers that replay every block, a miner, a verifier, and the forge desk where you watch leases, votes, slashes, the ledger and her model's family tree.

n1        sealer · packs transactions into a block every 1.5 s
n2 · n3   peers · sync and replay the same chain
trainer   miner · takes leases, runs deterministic steps on the NANO model, commits both roots
verifier  re-runs a random segment + holdout eval → ACCEPT / REJECT

START-FORGE.bat                             # from the forge folder · 3 nodes + miner + verifier + desk
node open-lease.cjs --n 5                   # order five jobs · add --file <path> to train on your own text
node forge-load.mjs <sealer-url> latest     # boot the newest saved model, every byte re-checked
node test-e2e.cjs                           # honest miner merged · cheater slashed · model loads · replay matches

A GPU can choose the work. It cannot sign the work.

The miner runs pure-JS training on CPU, and every byte that reaches the chain still does. That is not laziness, it is the verification model: a validator re-runs one of your logged segments and demands the same bytes. The reference adds up in 64-bit floats in a fixed order; a GPU has no 64-bit floats and reorders its sums. We measured it rather than argued about it — node os/model/nano-gpu.cjs fails the usual WebGPU design on 10 of 12 checks, and node forge/gpu-lane.cjs shows that a single last-bit disagreement is already a REJECT, which on this chain means a slash.

So the GPU lane that is built, forge/gpu-lane.cjs, gives the GPU the job it can actually do honestly: propose. A device trains several candidate plans, ranks them, and hands over the plan — never the weights. The CPU then re-runs the winning plan and emits a commit byte-identical to an ordinary CPU miner's. It saves you from spending your one expensive committed run on a plan that would be refused; it does not make that run faster, and the code says so in as many words. No WebGPU kernel ships, because none passes the gate yet. The miner screen — payout address, device, job mode, live steps, verified steps, earnings, liquid against locked — is still not built.

The seeds inside the .bat file are placeholders. Swap in your own before anything of value touches them.

Left in the old save file

The old proof-of-work miner. npm run mine and npm run pool still start. They train nothing and save nothing about DIVA, so they are being struck from the launch plan. Every v3 mining step uses the forge.
Memory-order grinding. The order seal still lives on the miner desk. Blocks are earned by training.

Why it is still called mining

You spend compute. The network checks the work. LIQUA pays for it. The work leaves behind a model that got smarter and a save file anyone can load.

Keep reading

LIQUA DOCS · MINE THE MODEL · testnet · unaudited · experimental · 7SLF STUDIOS

Paid over time

Some LIQUA lands in your wallet the moment you are paid. The rest unlocks on a schedule, and waiting earns a boost on the locked part. That keeps LIQUA in the pool while miners still cover the power bill. Tier sizes for launch are set by vote, and the calculator below is an illustration, not a quote. coming

Choose before you play. Your tier locks in when the lease opens, before a single step runs. No peeking at a lucky result and then picking the lock.
Leave early, keep your stack. Quit a lock early and you drop only the boost on the part that has not vested. The LIQUA you earned stays.
Locked LIQUA still votes. Time-locked LIQUA counts when votes open.