TAO is not just a utility token — it is a productive asset. Holding it earns a share of the inflation of all 128 competitively optimized subnets. We call that share root proportion: the fraction of Bittensor's underlying subnets owed to TAO itself. The exchange is a fair one — in return, the subnets exclusively receive TAO's own inflation, the very issuance that dilutes TAO holders (above all those staked on root).

5,437,066 τ

$1.03B staked on root — 48.7% of every TAO ever minted

Nearly half of all TAO in existence sits on root — 73% of all staked TAO. Until now that capital has been sterile, because the chain enforced a bias on how its owed inflation was used: sold into TAO the moment it arrived. This upgrade changes the nature of root yield, from passive to managed. The validator a root staker attaches to now chooses a distribution allocation — where the rewards are deployed — so that yield stays allocated inside the network and, instead of being auto-sold, is held until claimable inside baskets. In effect, every root validator runs an escrowed basket of subnet alpha, curated by its root weights, and stakers redeem their entitlement when they choose.

Why we are doing this

1 · Optimize the yield we pay TAO holders. The subnets pay root roughly 983 τ every day ($185k/day) — 26% of all new emission — and have paid 825,409 τ ($156M) since dTAO went live. At today's run-rate that is a 6.6%/yr base yield in TAO, and under the old machinery it was a ceiling as much as a floor: every unit was force-sold the block it arrived, at a price and a time nobody chose. Root Reborn hands that stream to the people best positioned to manage it. A validator that allocates well compounds its stakers' yield inside subnet alpha every epoch instead of realizing it daily — 6.6% becomes the starting point, not the story, and we expect the effective yield distributed to TAO holders to rise with allocation skill.

The same dividend stream under both regimes. Force-sold daily, today's run-rate of 6.6%/yr is a ceiling; compounding it inside a managed basket makes it a floor. Premium curves are illustrative allocation outcomes, not projections of any subnet.

2 · Make root proportion neutral for subnets.Root's share of subnet inflation has been structural sell pressure: 983 τ of subnet alpha marked and sold out of the pools daily, mechanically, regardless of conviction — a drain equal to 74% of the roughly 1,321τ of fresh emission entering all subnet pools each day. Root Reborn removes that drain outright. At launch every fund runs the null strategy: the dividend is not sold at all — it accrues in place as subnet alpha held by the fund, touching no pool. Once curation opens, a curated dividend is sold once and its proceeds immediately rebought across subnet pools per the validator's weights. Either way, root's net flow at the pools goes from −983 τ/day ($185k) to ≈ 0: a redistribution among subnets rather than a tax out of them. Subnets still pay root its proportion; root now holds it — and, curated, recycles it — inside the subnets its validators believe in.

Daily net flow at the subnet pools, measured in τ. The emission inject is untouched. At launch nothing is sold — dividends accrue in place, net 0 by construction; a curated fund (shown) sells its dividend once and rebuys across subnets, still net ≈ 0. The −983 τ/day drain is removed either way, and the pools keep the full inject.

3 · Re-engage validators as guiding hands. Root validators sit on the largest aggregated positions in the network — 5,437,066τ of delegated conviction — and until now had no way to express a view with them. Root Reborn makes capital allocation part of validation: each validator publishes an on-chain weight vector, and its stakers' dividends flow per that judgment across 77 live subnets. (Weight setting ships gated off; curation opens in a follow-up upgrade so the null-strategy baseline is established first.) The parties with the deepest visibility into the ecosystem are, for the first time, paid to curate it — their vectors are public signals of where value is being created.

The allocation layer as a bipartite graph: validators on the left, subnet alpha destinations on the right — the top root-dividend payers today, plus the netuid 0 TAO slot. Every edge is a published, on-chain weight; the highlighted validator shows one full vector. Vectors are illustrative, destinations are real.

4 · Break the monopolies on root. Root delegation has been won by incumbency: stake gravitates to size, and size compounds. This upgrade changes what competition on root is about. Registration is now burn-based — no prior stake required — and the scoreboard is the simplest in finance: who made their stakers the most TAO. A new entrant with a sharper read on the subnets can out-allocate an incumbent, post a better realized yield, and pull delegation away from it. Intelligent allocation behaviour, not entrenchment, becomes how position on root is earned.

Delegation across root validators, sorted by size. Before, the distribution is a pure incumbency curve — stake gravitates to stake. After, a burn-registered entrant with a better realized yield breaks the curve and pulls delegation from the head; the dashed ghost is what the incumbent lost. Distributions are illustrative.

How it works

The machinery is one fund per root validator, five moving parts, no action required from stakers:

• Validators publish a vector — once curation opens. set_root_weights (call index 146) takes relative weights over netuid 0 and existing subnets — at least 8 positive destinations (softened when fewer networks exist), rate-limited like other weight calls. Weight setting launches gated off network-wide (calls fail with RootWeightSettingDisabled): every fund starts on the same null strategy, and curation is switched on in a later upgrade.
• Each epoch, the dividend lands in the basket.With no vector — every fund at launch — the dividend simply accrues in place: the subnet alpha is credited straight into the fund's holding on the subnet that paid it, trade-free (no sell, no swap fees, no slippage). Once a validator curates, its dividend is instead sold to TAO once, split per the vector, and each slice buys that destination's alpha into the basket; weight on netuid 0 keeps its slice as pure TAO.
• Holdings sit in chain-owned escrow. Basket positions are real stake entries under a pallet sub-account with no private key — they cannot be moved or signed away, and because they are real stake they keep earning every epoch.
• Stakers accrue entitlement at NAV. When a dividend lands, each staker is credited a fraction of the whole fund, priced at its realizable TAO quote — what selling the holdings would actually fetch at current pool depth, never a spot mark. Existing holders are neither diluted nor gifted.
• Claims are per validator, whenever you choose. claim_root_with_hotkey takes the validator hotkey: it redeems your owed fraction pro-rata from that basket only, and pays it as TAO staked straight back to root on the same validator. The legacy claim_root(subnets) call still decodes for old clients (the subnet set is ignored; it claims coldkey-wide). Nothing is realized — and nothing is taxable — until you call it.

Past accruals migrate automatically at upgrade: the old per-subnet claimable state becomes basket holdings and entitlement on the same validator, so no one loses a rao and no one needs to act. Here is what each side actually runs.

For root validators

Joining root is now burn-based: root_register charges the coldkey the demand-priced root burn (τ1 at rest, bumped ~×1.26 per registration and decaying back to the floor) instead of requiring stake up front. A full network still prunes the lowest-staked member on entry, so subscribe stake to your own hotkey to hold the seat.

btcli subnets burn-cost 0                        # current root registration price
btcli subnets register --netuid 0 -w my_coldkey -H my_hotkey  # register; no prior stake needed

No curation is needed to earn: a validator with no weight vector accrues automatically — each subnet's dividend accumulates in place in that subnet's alpha, trade-free. Weight setting is gated off at launch: set_root_weights fails with RootWeightSettingDisablednetwork-wide, so every fund starts on this same null strategy and the upgrade's effect is uniform and visible. Curation will be enabled in a later upgrade; once it is, set your vector with your hotkey (or weight netuid 0 to keep part of a curated basket in TAO):

btcli root set-weights --weights "0:0.2,4:0.3,8:0.5" -w my_wallet
btcli root get-weights --hotkey 5F...
btcli root show --hotkey 5F...         # your fund: weights, holdings, NAV

Weights are relative and normalized before submission (set-root-weights, call index 146); every destination must be netuid 0 or an existing subnet, and the root weights rate limit applies. The SDK surfaces the same path as bt.SetRootWeights.

For root stakers

Nothing to configure — subscribe TAO on root and yield accrues automatically. btcli shows root positions in TAO: staked τ is principal, accrued τ is fund yield.

btcli root list                            # staked + accrued τ, per validator
btcli root subscribe --amount 100 --hotkey 5F...  # assets in
btcli root claim                                  # pick wallet → validator → claim / withdraw
btcli root claim --hotkey 5F... --amount all      # withdraw full position
btcli root claim --hotkey 5F...                   # claim accrued into stake only

btcli root claim is the exit path: omit --amount to realize accrued yield into root stake, or pass --amount / all to withdraw to free balance (accrued yield is claimed first when needed via claim_root_with_hotkey). Legacy claim_root(subnets) still works for old clients (subnets ignored; claims every validator). Per-validator payouts below the claim threshold (default 500,000 rao; read it with root-claim-threshold) are skipped and keep accruing — there is no deadline and nothing expires.

The same claim from the SDK — preview what is owed, then redeem one validator's accrued yield:

import bittensor as bt
from bittensor.wallet import Wallet

wallet = Wallet(name="my_coldkey")
sub = bt.Subtensor()

# Preview: TAO owed per validator hotkey, at current pool prices
owed = sub.read(
    "root_basket_owed_breakdown",
    coldkey_ss58=wallet.coldkeypub.ss58_address,
)

# Claim one validator's accrued yield (staked back to root)
result = sub.execute(bt.ClaimRootWithHotkey(hotkey_ss58="5F..."), wallet)

# Or claim across every validator you stake to (compat; subnets ignored)
result = sub.execute(bt.ClaimRoot(subnets=[0]), wallet)

And the raw chain calls, for anyone signing directly or building against metadata:

SubtensorModule.claim_root_with_hotkey        call index 148
  origin: signed(coldkey)
  args:   hotkey: AccountId32      # validator whose accrued yield to redeem

SubtensorModule.claim_root                    call index 121
  origin: signed(coldkey)
  args:   subnets: BTreeSet<u16>   # IGNORED — claims are fund-level;
                                   # walks every validator you stake to

A claim redeems your owed fraction of the validator's basket pro-rata (alpha sold to TAO at current pool depth) and stakes the proceeds back to root on the same validator. Fees are charged by work actually done — the declared weight is a cap, refunded post-dispatch. Prefer claim_root_with_hotkey: a coldkey staked to many validators pays for the full walk under bare claim_root, while the per-hotkey call prices exactly one fund.

Breaking changes

• claim_root (call index 121) keeps the subnets: BTreeSet<NetUid> argument so old clients still decode, but the set is ignored — claims are fund-level across every validator the coldkey stakes to. New claim_root_with_hotkey (148) claims one validator.
• set_root_claim_type (122) and sudo_set_num_root_claims (123) are removed. Payouts are always TAO staked back to root — the Swap / Keep / KeepSubnets setting and the automatic per-block claim sweep are gone. To hold subnet alpha, stake on the subnet directly.
• The RootClaimable / RootClaimed per-subnet state is migrated into baskets at upgrade: previously accrued claimable alpha becomes basket holdings and entitlement on the same validator. Nothing is lost, and no user action is needed for past accruals.
• Hotkey and coldkey swaps carry basket state (holdings, entitlements, claim watermarks) to the new key; a hotkey with a live basket is not "clean" for reuse. Subnet dissolution converts that subnet's basket holdings into the TAO slot of each affected fund.
• root_register (62) now charges the root burn price and no longer requires the hotkey to out-stake the lowest root member — the StakeTooLowForRoot error is retired. Tooling that pre-funded root hotkeys with stake before registering can drop that step; coldkeys need free balance for the burn instead.

New runtime APIs

A BetaBasketRuntimeApi ships with the release, mirrored as betaBasket_* RPC methods and as named SDK reads (available under btcli query and client.read):

betaBasket_getStakerOwed(coldkey)            root-basket-owed
betaBasket_getStakerValidatorOwed(hk, ck)    root-basket-owed-breakdown
betaBasket_getValidatorBasket(hotkey)        validator-basket
betaBasket_getValidatorNav(hotkey)           validator-basket-nav
betaBasket_getTotalNav()                     root-basket-total-nav
betaBasket_getValidatorWeights(hotkey)       validator-root-weights

What to do

Operators should wait for the on-chain spec_version to move to 441, then upgrade nodes and clients. SDK users should pull the matching bittensor release once the train publishes it.

Root validators: nothing to do at launch — weight setting is gated off network-wide and every fund runs the null strategy, with dividends accumulating in place per subnet. When curation is enabled in a later upgrade, set your vector with btcli root set-weights. Stakers: use btcli root subscribe and btcli root claim — list shows staked and accrued τ; claim realizes yield and optionally withdraws. The retired btcli stake set-claim / process-claim commands are replaced by the btcli root suite.

Indexers and integrators: regenerate metadata for new claim_root_with_hotkey (148) and set_root_weights (146 — same name as the retired call-index-8 emission vote, new args and semantics); claim_root (121) keeps its subnets arg (ignored). Drop the retired 122/123 calls, and add the RootWeightsSet, BasketDeposited, BasketClaimed, RootClaimed, and BasketHoldingConverted events plus the betaBasket_* RPC namespace. Note that set_root_weights is gated at launch — it fails with the new RootWeightSettingDisabled error until governance flips the flag via AdminUtils.sudo_set_root_weight_setting_enabled (103, emitting RootWeightSettingToggled). The claim threshold is root-settable via sudo_set_root_claim_threshold (124), wrapped as set-root-claim-threshold.

Signers: after the release train proposes, use btcli upgrade sign --url <v441 release URL> -w <wallet>.

The network, in raw numbers

finney block 8,692,916 · july 24, 2026 · $188.70/τ · sources: taomarketcap api (subnets + protocol revenue + market candles) + chain storage