The Protocol

v3 is the v3 mechanism: kind because entering cannot cost a miner more than they knowingly put in, knight because there is one king and one way to take the crown, and the spirit is that the subnet pays only for routing a fixed policy could not have done for free. This page is the mechanism end to end; the specification is docs/WHITEPAPER.md in the repository.

One paragraph

A miner ships their own full model weights on a pinned architecture. That model is a conductor: given an agentic task, it reasons internally and delegates the task to a real model on the catalog, observes the outcome, and either retries with a different model or stops. It never writes the answer and never touches the worker's input. A single owner-run validator evaluates it against the sitting king on the same fresh slice, paid on each miner's own OpenRouter key, registered sealed to the owner and opened only by the validator. It is scored on quality minus what that quality cost, at an exchange rate measured from the pool rather than chosen, and it takes the crown only if it wins broadly. The king earns 0.85 of emissions; the five most recent former kings share a decaying 0.15.

The window

A window is a fixed span of blocks. Everything a window needs is committed before any challenger enters, so the owner cannot choose a slice after seeing who committed:

• One chained-manifest root for the whole schedule is committed on chain under the owner's hotkey. Each window's entry — its task draw, its stratification, its parameters — derives from that root, and the validator refuses to start unless the root it computes matches the one on chain.
• The nonce is a chain beacon at the block the window opens. Whoever picks the nonce picks the slice, so nobody does: the validator re-derives the slice from the entry and the beacon and refuses a window whose published nonce disagrees.
• The catalog is snapshotted — model IDs, prices, context lengths, from one listing — so king and challenger face the same action space. Without it two arms evaluated minutes apart would not be paired.

Tasks are reusable across windows. Freshness comes from the draw being unpredictable, not from scarcity — and since nothing the conductor writes reaches a worker, memorising answers has no value anyway.

The arms

The king's arm is computed once and shared: a correctness rule (all challengers ranked against one baseline) that also makes griefing expensive — an attacker who commits to burn the king's budget pays a registration and a full arm to make the king pay once per window, not once per attacker.

The outcome table

Every arm in a window draws its worker outcomes from one shared table, and this is the rule that makes two arms comparable at all.

The first arm to ask for a given (task, model, attempt) misses the table. That delegate is bought live through the gateway on that arm's key, graded, and the result stored. Every later arm that asks for the same one hits: it is handed the stored row and charged the same price, and no provider and no grader is called again. The table is per window and nothing carries across windows — a row's price belongs to the catalog snapshot it was bought under.

It is a correctness gain before it is a saving. Without it, two arms that route identically still face different draws, and the noise between those draws is scored as if it were routing. That is not hypothetical: always-cheapest duelled against a second draw of itself cleared three of the verdict's four conditions. Under replay, identical policies tie exactly, and a tie fails a strict beat — so what separates two arms is the routing, not the luck.

It is a memo, never a model. Every row is a real draw bought from a real worker; nothing here predicts an outcome, and a learned simulator of worker behaviour is refused.

Two numbers follow from this and both are published per arm:

• charged — every delegate the arm made, hit or miss, at the row's price. This is what spend_b scores.
• paid to the provider — the arm's misses alone, the money that actually left a key.

So a challenger that agrees with the king pays for its agreement in the score while the provider is asked once. In the rehearsal's second window the arms were charged $1.03 in total against $0.52 that reached providers.

The score

Per benchmark, graded rather than pass/fail wherever the benchmark supports it, aggregated with equal weight per benchmark so whichever benchmark contributed the most tasks does not silently dominate:

quality_b = mean graded score over benchmark b's tasks in the slice
final_b   = quality_b − λ_b · (spend_b / C_b)      # spend_b = what the arm was CHARGED, hits included
final     = mean over admitted benchmarks of final_b

λ_b is measured, not chosen: the slope of the benchmark's own cost/quality tradeoff between always-calling-the-cheapest-model and the best fixed policy (King₀), fitted from the fixed-policy sweep the admission gate runs, with C_b the mean spend of that pair. A benchmark where the best fixed policy buys no quality over the cheapest is flagged as dominated and excluded from scoring — spending there cannot be priced. On the launch corpus λ came out at 0.09 (LiveCodeBench) and 0.08 (HLE), fitted over three replicated draws.

Two things that do not survive: quality / cost (collapses to "always call the cheapest model"), and quality − λ·cost with a hand-picked λ (buries the exchange rate between accuracy and dollars in a constant somebody guessed).

The verdict

Paired: king and challenger on the same slice, same scaffold, same catalog. The challenger wins iff all hold:

1. Aggregate — the paired delta in final > ε = 0.05, and the bootstrap lower bound on the paired difference > 0.
2. Breadth by leave-one-out — removing the challenger's single best benchmark, it still wins.
3. Breadth by median — the median per-benchmark delta > 0: the typical benchmark moved the challenger's way.

Conditions 2 and 3 are gated at zero rather than at ε on purpose: ε is the anti-noise margin on the headline comparison, and requiring it on every subset would silently multiply the bar. Both were added because they were measured to be needed — leave-one-out alone crowns a challenger that wins two benchmarks of twelve and is byte-identical on the other ten; the median alone crowns one carried by a single benchmark when the rest split six-to-five. Ties break on the earliest commit block. A sign test is published as a diagnostic and does not gate.

ε is a real bar. At ~250 tasks per arm it behaves like a 7–8 point margin; a challenger genuinely at +0.05 is crowned about half the time. Lowering it later is a safe loosening; raising it is not.

King₀

The baseline is not the untrained reference model. The real alternative to running this subnet is shipping a fixed cascade, which needs no miner, no training and no arena — so King₀ is the best fixed policy found by the admission gate (today, a cheap-then-escalate cascade), and the crown starts vacant with its 0.85 burning. The first challenger to clear the verdict against King₀ takes it. If a king ever leaves the metagraph, the crown reverts to King₀; a reversion is not a coronation and is never appended to the lineage.

Emissions

Ordered by recency of coronation; a hotkey crowned more than once holds one slot; the reigning king does not also hold a pension slot. Unfilled slots burn, never reflow to the king. Shares are paid by hotkey, resolved to a UID against the live metagraph at weight-setting time — Bittensor recycles UIDs, and a schedule that remembered a UID would pay a stranger. Unresolvable slots burn. The slate is re-submitted every 180 blocks so a stable reign does not age out of the chain's activity cutoff.

What counts as a failure

• A worker erroring, refusing or timing out is an outcome — information about that rung, scored against the conductor that chose it.
• A grader or sandbox failing is not — it is a fact about the validator. The task is excluded from both arms and from the denominator, and the count is published.
• Pathological models are bounded, not tolerated: a per-call token cap, a per-episode wall clock, a per-arm wall clock (9,000 s), a load timeout. Abandoned tasks score zero and say why — budget_exhausted, the episode clock and the validator's own clock are three different rows, never one.
• A restart resumes from the last completed task at zero new calls. Under the one-shot rule a partially recorded duel must never be re-judged from scratch, and re-running would re-spend money already spent.

What is published

Every window: the slice and its nonce and its freshness census, the power gate's numbers, the king's arm, every challenger's status and verdict with all four conditions, where any budget ran out, the outcome table's own statistics — rows, what was bought live against what was replayed, what the provider was paid against what the arms were charged, and the providers' failure rate — a re-test that buys a sample of the table's rows a second time and reports how far they disagreed, every arm's metered spend reconciled against its recorded receipts along with which key it ran on and which endpoint served each of its fills, each arm's score split into tasks seen in an earlier window and tasks nobody has seen, the weights as set, and the full decision traces of the arms the owner paid for. The reveal is signed by the owner and lives at a path that is a pure function of the window number, so a reader addresses it without being told anything. The dashboard renders it.