Mining that trains real AI models

What Vibe Hash is

Bitcoin miners spend electricity on hashes nobody uses, and only one lucky winner per block gets paid. Vibe Hash replaces the hashes with training steps on a real model that someone has paid to have trained. There's no lottery: everyone whose work passes the checks is paid in proportion to how much they did.

There are two ways to take part, and you can do both from the same computer.

• Worker. Let your computer train and check models. This is the mining. You can start with no VIBE at all: your first 5 VIBE of pay becomes your stake.
• Train a model. Give the network a spreadsheet of examples and some VIBE, and get back a trained model that makes predictions on new rows.

Training a model takes four commands once Vibe Hash is set up. Your data is a CSV file, and the result is a model file that makes predictions; Get started walks through each step.

> vibehash train my-data.csv --budget 100   # posts the job; the network trains it
> vibehash job status                       # rounds done, accuracy, budget left
> vibehash job download                     # saves my-data-model.npz
> vibehash predict new-rows.csv             # a prediction for every row

Most people join the public network, run at node.vibehash.org, and vibehash setup connects to it by itself. To join a different network, you need its node address, such as 203.0.113.7: get it from whoever runs it, or run your own with vibehash testnet.

Test network. VIBE has no cash value, so don't buy or sell it. The software hasn't been audited.

Get started

You need Python 3.10 or newer, free from python.org. On Windows, tick “Add python.exe to PATH” while installing it. Choose what you want to do, then paste the commands into PowerShell on Windows or Terminal on macOS.

A round

The network runs in rounds. With default settings a round takes about 38 seconds and ends with one new block. The bar is drawn to scale, in the colours the worker's dashboard uses for each phase. Jobs with big models get longer rounds, sized so an ordinary computer on a home connection can still download the model, train a unit and upload its snapshots in time. A model with 34 million weights, for example, gets rounds of about 17 minutes.

• Register3 s

  Workers check in with their measured speed and memory. Those with 5 VIBE staked get work first; newcomers still earning their stake get small batches from what's left.

• Compute20 s

  The work is split into small units sized so a slow laptop can finish one in time; faster machines get more units, not bigger ones. Each worker trains its units and sends a sealed fingerprint of each result before the deadline.

• Reveal5 s

  A random number that nobody could know earlier picks which parts of each unit get checked. Workers reveal their results and those parts.

• Verify, then seal10 s

  Other workers re-run the chosen parts and report whether they match; checking is paid work too. Passing results are averaged into the model, and payments and penalties go into a block, with a record of the round's signed messages that anyone can replay to check every decision. The network's validators vote on the block before it counts.

Who runs the network

No single computer is in charge. The network is run by validators: nodes with VIBE staked that take turns leading rounds, in an order weighted by stake and fixed in advance.

1. The leader runs the round. Workers do the round with whichever validator is leading it. They find it on their own, so nothing changes for you.
2. The others check its block. Each validator replays the round from its record of signed messages, and votes against any block whose payments, penalties or choices don't follow from them.
3. Two thirds make it final. A block counts once validators holding more than two thirds of the stake have signed it. Those signatures travel with the block, so anyone can check them.

A leader that pays itself extra, favours a worker or drops someone's work is voted down, and the next validator runs the round again. If a validator goes offline, the others carry on without it, and it catches up when it's back. Two different blocks can never both be final unless more than a third of the stake signs both, and a validator that votes two ways leaves signed proof behind.

Anyone can check all of this without trusting a node: vibehash chain verify replays every round and checks every block's signatures, and a node started with --peer syncs the chain and refuses any block that fails those checks. A staked account can become a validator with vibehash validator join, and vibehash validator list shows who votes.

Checking the work

Re-doing all the work would double its cost, so Vibe Hash re-runs small random pieces and makes cheating a losing bet. Each unit of training is split into 8 segments, with a saved snapshot of the model between each one. These are the checks, cheapest first.

1. Sealed answerWorkers send a fingerprint of their result before anyone reveals anything. Copying someone else's answer can't match your own fingerprint.
2. Proven snapshotsEvery snapshot a worker reveals must match the fingerprint, so nobody can swap in different ones after seeing which parts get checked.
3. Sanity checkTraining must start from this round's model and end where the worker says it did, and the change must be a sensible size. That stops boosted updates that would wreck the model.
4. Spot-check replayA randomly chosen worker re-runs 3 random segments and compares. A result must be within the job's tolerance and within 1% of what that segment of training actually changed, which absorbs rounding differences between chips but not skipped work.
5. Duplicate unitsAbout 1 in 5 units secretly goes to two workers. If their answers differ, the whole unit is re-run to see who was wrong.
6. Planted fakesTwo known-fake results per round are slipped to checkers. A checker who approves one is caught being lazy; a checker who rejects honest work is caught too, because every rejection is re-run.
7. Checking the nodeEvery choice the node makes in a round follows from the round's signed messages, which its block commits to, so anyone can replay the round. It keeps recent rounds' checkpoints, so anyone can also re-run its checks on the actual results. And it signs a receipt for every message it accepts, so a worker whose message goes missing from the round can prove it.

CPUs and GPUs

AI is trained on graphics cards, and Vibe Hash uses them. A worker with an NVIDIA, Intel Arc, AMD (on Linux) or Apple GPU trains on it through PyTorch, which vibehash setup installs for your card. Without one, it trains on the CPU. Both run exactly the same maths in the same order, so any worker can check any other worker's result.

• GPUs get more of the work. Each worker measures its real training speed and the network hands out units in proportion once it has delivered: a new worker starts with a few units and can take up to twice as many each round it delivers in full, dropping back to what it managed if it misses a deadline. A GPU that's 20 times faster ends up with about 20 times the units and 20 times the pay. Pay per unit of work is the same for everyone.
• Memory decides which jobs you can take. For GPU jobs the worker reports your graphics memory, and you're only given jobs that fit in it.
• GPU jobs use float32, the number format GPUs are built for. Many consumer GPUs, including Intel Arc and Apple, can't do float64 at all, so float64 jobs always run on the CPU.
• Checking works across devices. Chips round numbers very slightly differently, so a GPU's result and a CPU's replay never match bit for bit. The replay rule above allows for that without letting skipped training through, even late in training when each step barely moves the model.
• Shortcuts are off. Workers disable GPU modes that trade accuracy for speed, such as NVIDIA's TF32, and use deterministic kernels. Otherwise replays on another device wouldn't match.

Measured on an NVIDIA RTX 4070 SUPER against a CPU: results differed by at most 8e-8, more than a thousand times inside the 0.0001 tolerance, and by under 0.1% of what each segment of training changed. The same GPU gave identical results every run. On a 2.2-million-weight model the GPU ran each step about 10 times faster than a 28-thread CPU.

Payment

Each round creates a pool of VIBE: new coins from the block subsidy (50 VIBE, halving every 210 rounds, as in Bitcoin) plus the job poster's fee for the units that passed. Job posters pay nothing for work that failed. The pool is split three ways, drawn to scale here.

Anything nobody earned is burned, so nobody gains by rejecting good work. Everyone is paid at the same rate per unit of work, so a laptop earns less in total but gets paid every round it contributes. You don't need a mining pool.

Worked example: one round

Subsidy 50 VIBE + job fee 10 VIBE = a 60 VIBE pool. 22 units passed, everyone at full reputation.

Every worker gets 2.18 VIBE per unit, the same rate on every machine. Reputation scales your share between 0.5× and 1.0×. New wallets start at 0.8×, gain 0.02 each round they deliver verified work, and lose 0.05 for missing a deadline. It moves per round rather than per unit, so a laptop builds reputation as fast as a big rig.

Penalties

Crashes and dropped connections cost you only that round's pay. Your stake is at risk only for things an honest machine never does.

Half of any slashed stake goes to whoever caught the problem and the other half is burned. When you unstake, the coins wait 20 rounds before you can spend them, and they can still be slashed in that time. A wallet whose stake falls below the 5 VIBE minimum goes back to earning it in: small batches of work, no checking others, and its pay refills the stake first.

Starting with nothing

Bitcoin needed no stake, because a hash proves itself. Training can only be spot-checked, so the stake is what a cheater stands to lose. To keep that without anyone handing out coins, a new worker earns its stake in. Its first 5 VIBE of pay goes into its stake instead of its wallet, so what it could lose by cheating grows with what it has earned. Until then it's held to small batches, gets units only after staked workers have theirs, and never checks other workers' results. Its own results are always checked by a staked worker. The network's first validators vote with bootstrap stake, which can never be withdrawn or spent and is burned if they leave. So every spendable coin starts from work.

Job file

vibehash train writes and posts the job for you from a CSV, choosing these settings to fit your data. To control every setting yourself, vibehash job template writes a job file to edit and vibehash post-job posts it. The network checks every field when a job is posted and rejects anything out of range.

A dataset is an .npz file with four arrays: x_train, y_train, x_val and y_val. It's loaded without running any code inside it, and every worker checks its hash against the job before using it.

Troubleshooting

The messages you're most likely to see, and what to do about each.