Miner onboarding · release 1.1

Mine REAX in 30 minutes

A step-by-step guide for people who have never mined on Bittensor before, and a fast lane for those who have. You will create a wallet, register a miner key, start the miner next to its model on a GPU server and check that validators score it.

The six steps at a glance

What you need

Other cards (L4, L40S, A100, H200, RTX 5090 and more) should work but have not been measured. Run the calibration script from the repository on them before you serve; see Verification & calibration.

Renting a GPU? Choose a virtual machine or bare-metal server where you control Docker and can open a port. Many cheap "GPU container" offers run your code inside their container and do not let you start Docker yourself or publish a port; the REAX setup does not work there.

You also need: a laptop with Google Chrome (for the beginner wallet), an SSH client (built into Windows 10/11, macOS and Linux), and a small amount of TAO for the registration fee.

Two keys, two places

Bittensor uses two keys. The coldkey holds your TAO and signs money operations such as paying the registration fee. The hotkey is your miner's identity on the subnet: it gets the UID (your slot) and signs every answer. A stolen hotkey cannot spend your TAO; a stolen coldkey can. That is why the coldkey stays in your wallet app and only the hotkey goes to the server. More detail: Wallet & registration.

Step 1 · Prepare the GPU server

Log in to your server and check the GPU, the driver and Docker:

nvidia-smi                                   # shows your GPU and "CUDA Version: 13.x" or newer
docker --version && docker compose version  # Docker Engine with the compose plugin
docker run --rm --gpus all nvidia/cuda:13.0.0-base-ubuntu24.04 nvidia-smi   # GPU visible inside Docker
timedatectl | grep -i synchronized           # "System clock synchronized: yes"

If the last docker run fails, install the NVIDIA Container Toolkit (NVIDIA's install guide for your distribution) and restart Docker. Open the miner port in your firewall and in your provider's panel: TCP 8091 inbound. Never open port 8101; that is the model's private port.

Install the Bittensor command line tool (btcli) in its own Python environment. It ships inside the official bittensor package:

python3 -m venv ~/btcli-venv
~/btcli-venv/bin/pip install "bittensor==11.1.0" "typer<0.27.2"
echo 'alias btcli=~/btcli-venv/bin/btcli' >> ~/.bashrc && source ~/.bashrc
btcli wallet list                # prints "0 coldkeys · 0 hotkeys" on a fresh server

The typer pin matters: typer 0.27.2 (released 28 August 2026) breaks btcli 11.1.0 with AttributeError: module 'typer._click.exceptions' has no attribute 'Exit'.

Step 2 · Create your wallet (coldkey)

Short version for Talisman: install it from talisman.xyz, set a password, add a New Substrate Account (Bittensor is built on Substrate), write the recovery phrase on paper, then copy the account's Bittensor address. It starts with 5. The wallet page walks through every screen.

Step 3 · Get some TAO

You pay a one-time registration fee in TAO when you register a hotkey (step 4). How much depends on demand and changes over time; you read the live number with one command just before registering (how the fee works). Leave a small margin on top for transaction fees.

1. Buy TAO on an exchange that lists it and serves your country (for example Kraken, Coinbase, Binance, KuCoin, Gate or Bitget; availability differs by country, so check while logged in).
2. Withdraw to your Talisman address. Choose the network called Bittensor or TAO, never a "wrapped TAO" on Ethereum or BNB Chain. Paste the full 5… address and compare all characters, not only the first and last few.
3. Send a small test amount first, wait until Talisman shows it, then send the rest.

Talisman also has a built-in "Buy" button (a card payment provider); fees there are usually higher than on an exchange.

Step 4 · Create and register your hotkey

On the GPU server, create the hotkey. It is a small file; the command prints its 12-word recovery phrase once, so write that down too (it lets you restore the miner identity later).

btcli wallet new-hotkey -w reax -H miner1
btcli wallet list                         # the address under "miner1" (starts with 5) is your hotkey
chmod 600 ~/.bittensor/wallets/reax/hotkeys/miner1

Check the current registration fee once the netuid is announced: btcli subnets burn-cost <NETUID>.

Now pay the fee from your Talisman wallet. On your laptop, open reax.dev/register:

1. Click Connect Talisman and allow your funded account.
2. Paste the hotkey address from the server and click Check fee and status.
3. Tick the confirmation, click Register hotkey. Talisman shows SubtensorModule: register_limit with your netuid, hotkey and the price cap; click Approve.
4. The page shows your UID. On the server you can check it too: btcli query uid --netuid <NETUID> --hotkey reax/miner1.

The registration page opens for mainnet at launch; its practice mode works today with a local chain.

Prefer the terminal? With a btcli coldkey on a trusted machine it is one command: btcli tx burned-register --netuid <NETUID> -w reax -H miner1; then copy only the hotkey file to the server (details).

Step 5 · Run the miner

An s1-fast miner is two containers on the same server: the model sidecar runs Plumb-4B exactly as System1 production does and listens only on 127.0.0.1:8101; the reax miner answers validators on the public port 8091 and asks the sidecar. They share a random token.

# 1. Get the code (public at launch)
git clone https://github.com/fstandhartinger/reax-subnet.git && cd reax-subnet

# 2. Download the pinned model weights into a plain folder (about 9 GB)
python3 -m venv ~/hf-venv && ~/hf-venv/bin/pip install -U "huggingface_hub[cli]"
~/hf-venv/bin/hf download crh225/plumb-4b --revision 55de037801a8a9b9de3db5c0e16cef86210c2186 \
  --local-dir /srv/reax/plumb-4b

# 3. Shared secret between miner and sidecar
mkdir -p deploy/secrets && openssl rand -hex 32 > deploy/secrets/runtime-token
chmod 0600 deploy/secrets/runtime-token

# 4. Settings
cp deploy/miner.env.example deploy/miner.env
nano deploy/miner.env      # see the table below

# 5. Start both containers
REAX_UID=$(id -u) REAX_GID=$(id -g) REAX_S1_FAST_WEIGHTS=/srv/reax/plumb-4b \
  docker compose -f deploy/docker-compose.s1.yml up -d --build

Settings to fill in deploy/miner.env (the compose file sets mechanism, model and sidecar URL for you):

Delete the lines REAX_MECHANISM=mpm1, REAX_MODEL=… and REAX_DEVICE=… from the copied example: they belong to the older fallback mechanism, and the compose file already sets the right values. The full list of settings is in the repository's docs/CONFIG.md.

What happens on the first start: the sidecar checks every weight file against the release manifest and loads the model (up to 10 minutes). Only when it is healthy does the miner start. The miner then checks the sidecar with a test decision, confirms that your hotkey is registered, publishes your IP and port on chain, publishes your commitment reax-s1/1:s1-fast:ff6e01b983d48024 (this tells validators which model you serve) and starts answering.

Step 6 · Check that you are scored

1. Health. On the server:

curl -s http://127.0.0.1:8091/health
# {"protocol": "reax-s1/1", "version": "1.1.0rc1", "model": "s1-fast", "manifest_id": "ff6e01b983d48024"}

From another machine, curl http://<YOUR_PUBLIC_IP>:8091/health must give the same answer; if it does not, the port is closed.

2. Logs. docker compose -f deploy/docker-compose.s1.yml logs -f miner should show, in this order:

REAX miner 1.1.0rc1 (mechanism s1, protocol reax-s1/1, ...) netuid=... model=s1-fast hotkey=5...
published endpoint 203.0.113.7:8091 for uid 42
published commitment reax-s1/1:s1-fast:ff6e01b983d48024
miner uid 42 listening on 0.0.0.0:8091
metagraph block 123456: 64 neurons, 5 accepted validators; served ok=16 rejected=0 {} errors=0

Each real line starts with a timestamp and the logger name. The last line repeats every 5 minutes. served ok going up means validators are asking you and you answer. (The endpoint and commitment lines only appear when something changed on chain.)

3. On chain. Validators score in rounds of 2 minutes and submit weights roughly every 72 minutes. Your score starts at 0 and rises with every good round: about a third of the maximum after 4 rounds, about 93 % after an hour without misses. Check your incentive with:

btcli query metagraph --netuid <NETUID> --json | python3 -c 'import json,sys; d=json.load(sys.stdin); i=d["hotkeys"].index(sys.argv[1]); print("uid", i, "incentive", d["incentives"][i])' <HOTKEY_ADDRESS>

A new miner shows incentive 0 until the first weight submission that includes it. If served ok stays at 0 for more than 15 minutes, see troubleshooting.

How you are scored, in one paragraph

Every 2 minutes each validator sends you 8 freshly generated decisions and computes the same 8 on its own copy of the model. If your answers match (an average logit distance of at most 0.20), the round scores 0.8 plus up to 0.2 for speed. A clear mismatch loses the round; a large one (above 0.50, or any single answer above 2.0) resets your score to zero. Missing a round counts as zero. There is nothing to tune: run the pinned images unchanged and stay online. A quantised (FP8) build, a different model or a changed prompt drifts too far and loses. Details: Verification & calibration.

Costs and earnings, honestly

• Your costs: the registration fee (burned, not refundable), GPU server rent for 24/7 operation (hourly price × about 720 hours a month), and your time to keep it updated.
• What a miner receives is a share of the subnet's emission in the subnet's own token (alpha), credited as stake on your hotkey, not TAO. Its amount depends on validator weights, on how many miners compete, and on subnet settings that can change. Alpha can be converted to TAO through the chain's exchange pool, and that rate moves.
• Pay is expected to go down over time. The subnet plans to reduce miner pay by directing part of the miner emission away from miners (to the subnet owner or recycled, depending on the chain) and by admitting many miners. Plan with that in mind.
• We make no promise about earnings, about covering your costs, or about the value of any token. You can lose the registration fee and your server costs.

Can I forward requests to an API instead of running the model?

Yes, the rules allow it. Validators judge answers by correctness and speed only, so a miner may also obtain the exact answers from an API that serves the same model (for example the paid System1 API), at its own expense. The subnet does not block this. It reacts through economics instead: as described above, miner pay is expected to fall over time, which favours miners who run the open weights efficiently on their own hardware.

Practise on a local chain (no real TAO)

You can rehearse steps 2 to 4 with test money on your own machine, today. This uses a local Bittensor chain in Docker with a pre-funded test account. Every command needs --network local; without it btcli talks to mainnet. The --seed below is the public "Alice" development key: never type your own recovery phrase or seed into a command line.

docker run -d --rm --name local_chain -p 9944:9944 -p 9945:9945 ghcr.io/raofoundation/subtensor-localnet:devnet
btcli wallet regen-coldkey -w alice --no-password \
  --seed 0xe5be9a5092b81bca64be81d212e7f2f9eba183bb7a90954f7b76361f6edb5c0a   # public test key, local chain only
btcli wallet create -w practice -H miner1 --no-password
btcli tx transfer --dest practice --amount-tao 100 -w alice --network local -y
btcli wallet new-hotkey -w alice -H default               # a subnet owner needs a hotkey
btcli tx register-subnet -w alice --network local -y        # creates a practice subnet (netuid 2)
btcli tx start-call --netuid 2 -w alice --network local -y
btcli subnets burn-cost 2 --network local
btcli tx burned-register --netuid 2 -w practice -H miner1 --network local   # read the summary, then confirm
btcli query uid --netuid 2 --hotkey practice/miner1 --network local

To rehearse the Talisman route instead, fund your Talisman address from Alice (btcli tx transfer --dest <TALISMAN_ADDRESS> --amount-tao 10 -w alice --network local -y), add the local chain in Talisman (Settings → Networks & Tokens → Add network → Substrate, RPC URL ws://127.0.0.1:9944) and use practice mode on reax.dev/register.

The Alice key above is a published development key; anything sent to it on mainnet is lost. When you are done: docker stop local_chain.

For AI agents

This guide is also available as plain data: /miner.json (requirements, image names, ports, environment variables and steps), /llms.txt and /llms-full.txt (all docs as text). Browsers with WebMCP support expose the tools get_launch_status, get_requirements, get_registration_steps, get_run_instructions and check_miner_health_instructions on this page. Agents must never ask for or handle a seed phrase or coldkey; a human approves every payment in their own wallet.

Next: Wallet & registration in detail · FAQ & troubleshooting