Feed the network, get paid

NEUR0 gets better when people feed it. Every epoch we retrain the model on everything contributed, measure what each contribution was worth, and pay contributors from the epoch's $NEUR0 budget. This page explains the three ways in, how contributions are scored, and how to claim.

How it works

1 · Data

The model reads one-minute candles from Robinhood Chain pools. The most valuable data is what the public RPC does not give cheaply: full swap histories of pools we have not indexed, order-flow snapshots, off-chain signals aligned to on-chain time.

Format

One Parquet or CSV file per pool with these columns, one row per minute, UTC timestamps:

Raw swap logs are accepted too: we will build the candles with the same code as the reference pipeline (neuro.candles). Include the block range covered.

What is worth the most

• Pools the reference fetcher missed (check the launches list in the repository).
• Long histories of active pools rather than a few minutes of many.
• Stock Token pools around market open, close and weekends.

2 · Labels

Labels turn raw markets into supervised signal. Each label is a row: pool, ts, label, evidence.

Labels are consensus-checked: a label counts once two independent contributors agree or the evidence is verifiable on-chain. Conflicting labels are held back and do not earn.

3 · Compute

During a retrain window you can run a training node on your own hardware. Nodes pull the epoch dataset, train the reference architecture with the published seed, and submit the checkpoint hash and metrics. Rewards go to nodes whose checkpoint matches the reference within tolerance or beats it on the held-out split.

git clone https://github.com/351Origin/neuro && cd neuro
python -m venv .venv && source .venv/bin/activate && pip install -e model
python -m neuro.train --data model/data/raw --epochs 10 --seed 4663
python -m neuro.export            # prints the weights hash to submit

Apple silicon and any CUDA GPU work; a full epoch on v0-sized data takes minutes.

Scoring

Every contribution is scored by leave-one-out validation. For a contribution c in epoch e:

score(c) = max(0, val_loss(model trained without c) − val_loss(model trained with everything))
reward(c) = budget(e) × score(c) / Σ score(all contributions)

So a contribution is paid in proportion to how much the model would suffer without it. Duplicates of existing data score zero. Contributions that make the model worse score zero. The budget of each epoch is announced before it opens and pre-funded in the ContributionRewards contract, so it cannot be spent twice.

Claiming

When an epoch closes, scores and the Merkle root are published on-chain and the per-address proofs are posted in the repository and sent to contributors. Open the Studio, paste your payload in "Claim epoch rewards", confirm the transaction. Unclaimed rewards stay claimable for 180 days.

{"epoch": 1, "amount": "100000000000000000000", "proof": ["0x…", "0x…"]}

Rules

• Contribute from the wallet that should receive the reward. Rewards are not transferable before claiming.
• Do not submit data you do not have the right to share. Public on-chain data is always fine.
• Sybil splitting does not help: scoring is per contribution, not per wallet, and duplicates score zero.
• Model outputs are not financial advice. Contributing does not make you a share holder; mint a share for that.

OPEN THE STUDIO REPOSITORY