BITTENSOR · SUBNET 99

Thirty spokes share one hub.

One API key, one base URL — every frontier model behind it. The empty space at the center is what makes the wheel useful.

Start routingWhy the empty center
your existing SDK, unchangedpython
client = OpenAI(
    base_url="https://api.thirtyspokes.ai/v1",
    api_key=THIRTY_SPOKES_KEY,
)
client.chat.completions.create(model="auto", ...)
三十輻共一轂

“Thirty spokes share one hub. It is the empty space at the center that makes the wheel useful.”

TAO TE CHING · CH. 11

Bittensor named its network after the Tao. We took our name from the founding text of Taoism — written 2,500 years before anyone needed a model router.

當其無有車之用
OpenAIAnthropicGoogleDeepSeekQwenMistralMetaxAICohereMoonshotEMPTY
01 · THE WHEEL

Every model is a spoke.

/1

Every model is a spoke

OpenAI, Anthropic, Google, DeepSeek, Qwen and more — any model on the catalog is a spoke. A conductor delegates each task to the spoke it picks, watches the outcome, and re-delegates if that spoke failed.

/2

The hub holds nothing

The conductor never writes an answer and never touches the question. The only things that ever reach a worker are the task text and a model ID — so there is nothing the hub could smuggle, and nothing it needs to be trusted with.

/3

The wheel turns itself

A gateway run by one company is just another gatekeeper. Thirty Spokes runs as a Bittensor subnet: miners compete to train the conductor, and one published verdict per window says who holds the crown and why.

02 · DEVELOPERS

Change one line. Keep your SDK.

Point your existing client at the hub. Ask for model="auto" and the network routes each request — or pin any spoke by name.

OpenAI SDK
from openai import OpenAI

client = OpenAI(
    base_url="https://api.thirtyspokes.ai/v1",
    api_key=key,
)
r = client.chat.completions.create(
    model="auto",
    messages=[{"role": "user",
               "content": "..."}],
)
Anthropic SDK
import anthropic

client = anthropic.Anthropic(
    base_url="https://api.thirtyspokes.ai",
    api_key=key,
)
r = client.messages.create(
    model="auto",
    max_tokens=1024,
    messages=[...],
)
model="auto"

Miners route each request to the best spoke for quality per dollar.

model="<any spoke>"

Pin a specific provider model by name whenever you need to.

streaming · tools

Streaming, tool use and structured output pass through unchanged.

03 · THE NETWORK · SUBNET 99

No operator. A reign.

A miner ships a conductor — full weights on a pinned architecture. The validator runs it against the sitting king on the same fresh slice of agentic benchmarks, paid on the miner's own model-marketplace key, and scores quality minus what that quality cost at an exchange rate measured from the pool rather than chosen. The crown moves only to a challenger that wins broadly. Until someone beats the best fixed policy, the king's share burns.

Open the dashboard
THE VERDICT · EVERY WINDOWking 0.85 · five ex-kings 0.15
finalb = qualityb − λb · spendb / Cb
final   = mean over benchmarks
Δ final > εthe paired delta against the king clears 0.05, and its bootstrap lower bound clears zero
leave-one-out > 0drop the challenger's single best benchmark and it still wins
median > 0the typical benchmark moved the challenger's way — not one benchmark carrying the rest
λ measured per benchmark, never chosena near-copy of the king ties, and a tie loses
04 · MINERS

Compete to be the hub.

Build the conductor with the highest benchmark quality per dollar. You ship weights; the validator runs them. Nothing you write ever executes anywhere, and nothing your model writes ever reaches a worker — the competition is which model you pick, and what you spend.

01
Train

Full weights on the pinned Qwen3.6-35B-A3B, by any route — fine-tune, distil, merge. Every window publishes the decision traces of the arms the owner ran, so the training set is free.

02
Check

The validator's own admission gate, on your tree, locally: architecture field by field, tokenizer by digest, every tensor's name and shape, safetensors only, no code. Run it until it says admitted.

03
Submit

One submission per hotkey, ever. Upload ~70 GB to a private bucket, against a credential scoped to your own prefix, then commit the manifest digest on chain — that signal is what spends the shot.

04
Duel

The validator runs your conductor and the king on the same slice, same scaffold, same catalog, each paid on its own key. Quality minus what it cost, equal weight per benchmark.

05
Crown

Beat the king broadly — Δ over ε, lower bound over zero, leave-one-out and median both positive — and take 0.85 of emissions. Only then are your weights published. The five most recent ex-kings share 0.15.

test locally — the validator's own gate and scaffold
# the admission gate, before you spend the shot
thirtyspokes-miner --netuid 99 \
  --wallet you --hotkey yours check \
  --model ./weights --reference ./reference

# your slice, run the way the validator runs it
thirtyspokes-dev --help
one submission per hotkeyfull weights · 35B-A3Bpaired duel · ε = 0.05King₀ burns until beaten
Read the mining guide