thirty spkesDOCS
HomeDashboardGet an API key

What is Thirty Spokes?

Thirty Spokes is a decentralized model router on Bittensor — Subnet 99. Every model is a spoke; the hub holds nothing. Miners compete to train the conductor: a model that, given an agentic task, decides which real model should answer it, watches the outcome, and escalates or stops. The conductor never writes an answer and never touches the question. It is scored on the quality it bought minus what that quality cost.

Status. The mechanism described here — v3 — is live on Bittensor mainnet, netuid 99, and open for submissions: windows are running, duels are scored against the sitting king, and every verdict is published as a signed reveal. The first-generation mechanism (KOTH-TEE, where miners ran benchmarks in their own TEE) was retired on 2026-09-07. The user-facing gateway (api.thirtyspokes.ai) is not built; see Using the Gateway.

The inversion

Every other benchmark-scored subnet asks the miner to run something and the validator to trust it — a proof, an attestation, a self-reported score. Thirty Spokes turns that around: the miner ships weights and runs nothing. A single owner-run validator loads the miner's model, runs it on a fresh slice of agentic benchmarks against the sitting king, grades the answers with each benchmark's own grader, and publishes a signed verdict.

Three things fall out of that:

  • No miner code ever executes, anywhere. A submission is a safetensors tree on a pinned architecture — a pure tensor container with no code path. Pickle archives, bundled *.py, auto_map and trust_remote_code are refused at admission, not stripped.
  • Nothing the model writes ever reaches a worker. The only things that reach an answering model are the benchmark's own task text and a validated model ID. There is no channel to smuggle a memorised solution through, and so no detector is needed to look for one. This is what makes public benchmarks safe to score on.
  • Cost is in the score, at a measured rate. final = quality − λ · spend / C, per benchmark, with λ fitted from the pool's own cost/quality tradeoff rather than chosen. A router that matches the king at a third of the spend is a better router, and the score says so.
Layer Who writes it Trusted?
Benchmarks, graders, public gold benchmark authors yes — public
Scaffold: the fixed loop that renders state, parses one action, calls the worker subnet owner yes — pinned, identical for king and challenger
Conductor: full weights on Qwen3.6-35B-A3B miner no — verified at admission, run by the validator
Worker models OpenRouter catalog paid per call, metered against signed receipts
Validator: draws the slice, runs every arm, publishes the reveal, sets weights subnet owner (single, D1) its record is signed and every input is committed in advance

What one window does

  1. Draw a slice of tasks, stratified across the admitted benchmarks, from a nonce nobody controls (a chain beacon at the block the window opens). The whole schedule's root was committed on chain before any challenger entered.
  2. Run the power gate: two fixed reference policies on a subsample. If they cannot be told apart on this slice, no duel is scored and no one's shot is spent.
  3. Run the king's arm once, reused by every duel in the window.
  4. For each queued challenger, in (commit block, hotkey) order: verify the upload against its on-chain commitment, admit the tree, run its arm on the same slice, and apply the verdict.
  5. Crown the largest winning delta, set weights, publish the signed reveal — including the full decision traces of every arm the owner paid for, so the next miner's training set is free.

The verdict, in one line

A challenger takes the crown only if its paired delta in final exceeds ε = 0.05 and the bootstrap lower bound clears zero and it still wins with its best benchmark dropped and the median benchmark moved its way. A near-copy of the king ties, and a tie loses. There is no copy detector; the economics do the work.

The pay

The king earns 0.85 of emissions. The five most recent ex-kings share 0.15 as 0.05 / 0.04 / 0.03 / 0.02 / 0.01. Unfilled slots burn — never reflow to the king. Until a miner beats King₀ — the best fixed routing policy, which needs no miner at all — the crown is vacant and its 0.85 burns. The subnet pays for routing that a fixed cascade could not have done for free.

Where to go next