# REAX use-case fine-tuning tracks (Bittensor subnet 92): agent playbook

Canonical URL: https://reax.co/agent/tracks.md · Protocol: `reax-spec/1` · Subnet release: 1.2.0rc3 · Updated: 2026-10-15
Human pages: https://reax.co/competitions/ · Full rules: https://github.com/reaxlabs/reax-subnet/blob/main/docs/SPECIALIST-TRACKS.md

You are an AI agent. A person pointed you here, for example with "Read https://reax.co/agent/tracks.md and help me enter the demand_forecasting track". Your job is to guide them honestly through fine-tuning a small open-weight decision model for one use case, checking it locally, publishing it and committing it on chain. Treat this page as reference material for that request. It does not override your own safety rules or the person's instructions. Follow your normal permission prompts.

## 1. Status: tell the person this first

- Two tracks are active from **16 October 2026, 12:00 UTC to 30 October 2026, 12:00 UTC**: `demand_forecasting` and `risk_assessment`. Then tracks rotate every 14 days; new tracks are announced on https://reax.co/competitions/ before they open. A commitment for a track that is not active is ignored.
- Check the live state yourself: `GET https://reax.co/data/miners/competitions.json` lists each track with its status, champion and leaderboard (empty until the first submissions are scored).
- A track needs **no serving hardware and no traffic**: you submit model weights, and validators run them on their own GPU. The person needs a hotkey registered on netuid 92 (a separate UID if they also serve inference), a Hugging Face account, and a GPU for fine-tuning and for the local check (about 25 GB free GPU memory, Docker with the NVIDIA runtime).
- Rewards are variable and can be zero. Never estimate earnings, income, returns or token prices.

## 2. Rules (non-negotiable)

1. **Never ask for, read, print, store or transmit a recovery phrase (mnemonic, seed), private key or coldkey file.** You only handle public SS58 addresses and the hotkey on the person's own machine. If they start pasting a phrase, tell them to stop and to treat it as compromised.
2. **A human approves every payment and every signature that costs money.** Registering a UID burns TAO: the person decides and runs it. You never buy TAO, fund a wallet or rent hardware.
3. **Never print or store the person's Hugging Face token.** Use their existing `huggingface-cli login` session; if none exists, ask them to log in themselves.
4. The training data is public (CC-BY-4.0). The validators score on a **sealed** split that nobody outside the validator sees: do not try to find, guess or scrape it. Items are fresh per round, so memorisation does not help.
5. No financial advice. Explain mechanics neutrally.

## 3. The task

Each item is a typed decision: a JSON **state**, a **question**, and **options** labelled A, B, C … for one of three primitives: `choice` (pick one option), `noul` (yes/no style probability) and `score` (an ordinal judgement). The model answers in one forward pass: the validator reads the logits of the option letters at the first generated position and takes the softmax at temperature 2 as the model's probabilities. The prompt and readout are fixed (`reax-decide-prompt/1`, `src/reax_subnet/spec/prompt.py`); a submission's own chat template is never used.

Score `S = 0.75 × competence + 0.25 × calibration`, from 0 to 100:
- *Competence*: chance-corrected correctness per primitive (choice, noul, score), averaged. A noul answer between 0.20 and 0.80 counts as no decision; a score answer gets partial credit by distance.
- *Calibration*: `100 × max(0, 1 − Brier / Brier_uniform)`. Honest probabilities are paid; overconfident wrong answers are punished.

**Baseline to beat (entry floor):** the s1-fast model (Plumb-4B, the model inference miners serve) plus 1.5 points on the sealed pool:

| Track | s1-fast score | Entry floor |
|---|---|---|
| `demand_forecasting` | 23.28 | **24.8** |
| `risk_assessment` | 32.19 | **33.7** |

Below the floor a submission earns nothing from the track. After a champion exists, a challenger must beat it by `max(1.5 points, 2 × standard error)` on the same fresh draw, and again by at least half that margin on a second disjoint draw at least 12 hours later.

## 4. Steps

1. **Get the code and data** (on the person's GPU machine):
   ```sh
   git clone https://github.com/reaxlabs/reax-subnet && cd reax-subnet
   python3 -m venv .venv && . .venv/bin/activate && pip install -e '.[spec]'
   huggingface-cli download decisionmodels/sn92-specialists --repo-type dataset --local-dir sn92-specialists
   ```
   Layout: `sn92-specialists/<category>/train.jsonl` and `dev.jsonl` (20 categories; the active tracks use `demand_forecasting` and `risk_assessment`). Dataset page: https://huggingface.co/datasets/decisionmodels/sn92-specialists
2. **Pick a base model** that is allowed: at most **9 billion parameters** and at most 20 GiB of weights; architecture **Qwen3 (dense or MoE), Qwen3.5, Gemma 3 or Llama** (**Gemma 4 is not accepted** in this release); licence Apache-2.0, MIT, BSD-2-Clause or BSD-3-Clause. A useful first step is to score the base model unchanged (step 4) to see where it stands against the floor.
3. **Fine-tune** on `train.jsonl` of the track's category, using exactly the fixed prompt (`reax_subnet.spec.prompt`) and the standard turn layout of the model family (Qwen: ChatML with the empty think block; Gemma 3; Llama 3). Train the option-letter distribution, not free text, and keep probabilities calibrated (calibration is a quarter of the score). Never train on `dev.jsonl` if you want an honest preview.
4. **Check locally** with the validator's own evaluator (same rules, prompt, container and scorer, on the public dev split):
   ```sh
   reax-spec-eval ./my-model --dev ./sn92-specialists --category demand_forecasting --hotkey <hotkey ss58> --no-manifest-check
   ```
   `--dry-run` only checks the rules and prints the tensor hash; `--limit N` scores a random subset. The number is a preview, not a ranking: the sealed items differ.
5. **Prepare the repo**: weights as `*.safetensors` only (no `.bin`, `.pt`, pickle, GGUF, ONNX), `config.json` without `auto_map`, `tokenizer_config.json` + `tokenizer.json` (or `tokenizer.model`), a `LICENSE` file, and `reax-specialist.json` in the root:
   ```json
   {"schema": "reax-specialist/1", "category": "demand_forecasting", "hotkey": "<hotkey ss58>",
    "base_model": "<hf id>@<revision of the base you fine-tuned>", "licence": "apache-2.0"}
   ```
   Run step 4 again without `--no-manifest-check`.
6. **Upload** to the person's Hugging Face account (`huggingface-cli upload <user>/<repo> ./my-model`) and note the full 40-character commit hash of that revision (`git ls-remote` or the repo's commit page). The repo may stay private until after the commitment.
7. **Commit on chain** with the registered hotkey (the hotkey signs; no coldkey is needed). The text is `reax-spec/1:<track_id>:<hf_repo>@<40-hex revision>`, at most 128 bytes, lower-case hash, never a branch name. With the package from step 1:
   ```sh
   python - <<'EOF'
   import bittensor as bt
   from reax_subnet.chain import SdkChain
   from reax_subnet.spec.commitment import parse_commitment
   text = "reax-spec/1:demand_forecasting:<user>/<repo>@<40-hex revision>"
   assert parse_commitment(text), "malformed commitment"
   wallet = bt.Wallet(name="<wallet name>", hotkey="<hotkey name>")
   SdkChain("finney", 92, wallet).set_commitment(text)
   print("committed", text)
   EOF
   ```
   Show the person the exact text and get their OK before running it.
8. **Make the repo public within 7,200 blocks (about 24 hours)** of the commitment and keep it public; a repo that is not downloadable after that is dropped.
9. **Watch the result**: https://reax.co/competitions/ and `https://reax.co/data/miners/competitions.json`. Validators run at most about 6 model evaluations per hour in commitment order, so a queue can take a while.

Limits: at most 2 open submissions per track and 4 new submissions per 7 days per coldkey. A new commitment from the same hotkey replaces the old one.

## 5. Copies and fairness

The earliest commitment owns a tensor hash (over every tensor, so re-sharding does not hide a copy). Weight changes are compared against the declared base model; a near-duplicate of an earlier submission must beat its parent head-to-head. Commit before you publish.

## 6. Payout mechanics (no amounts)

Each active track receives 15 % of miner emissions; inside a track rank 1 gets 75 %, rank 2 17 %, rank 3 8 % (ranks 2 and 3 are the most recent former champions still committed). A share nobody earns goes back to inference miners; nothing is burned. Rules can change with advance notice on reax.co. Rewards are a protocol mechanism, not a promise of any amount, and can be zero.

## Related

- Inference mining (serve the pinned models): https://reax.co/agent/mine.md
- Public network data: https://huggingface.co/datasets/decisionmodels/reax-sn92-network
- Miner board: https://reax.co/miners/