Emissions

Emissions run in two stages. Every block, the chain mints TAO, splits it across subnets, and injects liquidity into their pools (the coinbase). Every tempo, each subnet distributes its accumulated alpha to owner, miners, validators, and stakers via Yuma Consensus (the epoch). This page covers the numbers; The network covers the roles.

TAO emission and halvings

The base emission is 1 TAO per block (one block every 12 seconds), decaying toward a hard cap of 21 million TAO — minted by get_block_emission as part of the per-block block_step. Halvings are triggered by total-issuance thresholds, not block counts: emission halves each time issuance crosses the midpoint of the remaining supply (10.5M, 15.75M, ...) (get_block_emission_for_issuance). Because recycled TAO is subtracted from total issuance and can be re-emitted, recycling pushes halvings out. This includes registration burns and transaction fees: native TAO fees and EVM fees reduce issuance directly, while eligible alpha-paid fees are sold for TAO and recycled atomically (see fees).

The first halving occurred in December 2025: current emission is 0.5 TAO per block, roughly 3,600 TAO per day.

A TAO halving also halves every pool's injection: each subnet's tao_in is a share of the halved block emission, and alpha_in tracks it (tao_in / price), so alpha injection halves too — slowing every subnet's alpha issuance and stretching alpha-halving timelines.

Supply accounting in brief: max supply is 21M for TAO and for each subnet's alpha; total issuance counts what has been emitted and not recycled (the halving yardstick), while circulating supply is smaller — issuance includes pool reserves and staked positions. Burned tokens stay counted in issuance forever; recycled amounts are re-emittable (recycled vs burned).

Alpha emission

Subnet tokens date from the dTAO upgrade (February 2025, first dTAO block 4,920,351), which converted all existing stake to root TAO stake at the switch. Each subnet's alpha token has its own 21M cap and follows the same halving curve, applied to that subnet's alpha issuance and starting from the subnet's launch. Per block, a subnet mints alpha in two places:

• alpha_out — up to 1 alpha (at the subnet's current halving rate) destined for participants, accumulated for distribution at the next epoch.
• alpha_in — alpha injected into the pool alongside the subnet's TAO emission, normally tao_in / price so the injection is price-neutral.

So a young subnet mints up to 2 alpha per block in total. The injection is capped at root_proportion × alpha_emission, where root_proportion = (root_tao × tao_weight) / (root_tao × tao_weight + alpha_issuance). As a subnet ages its alpha issuance grows, the cap falls, and the TAO that can no longer be injected as liquidity is instead swapped for alpha on the subnet's own pool — buying pressure that transitions mature subnets from liquidity injection to chain buybacks. Alpha bought this way accumulates as protocol-owned alpha.

Subnet emission shares

Each block's TAO emission is divided in three steps. First, the chain turns each eligible subnet's EMA price into a share of total demand:

demand_share_i = price_ema_i / Σ price_ema

Next, the chain scales that price share by 1 − MinerBurned and renormalizes:

burn_adjusted_share_i = demand_share_i × (1 − miner_burned_i)
                        / Σ(demand_share × (1 − miner_burned))

MinerBurned is the proportion of the last tempo's miner incentive withheld because it was directed to subnet-owner hotkeys. Withheld incentive counts whether it is recycled or burned, so changing RecycleOrBurn cannot bypass the scaling. If every adjusted weight is zero, the runtime restores the unadjusted price shares so emission is not stranded.

Finally, the emission gate reduces weak burn-adjusted shares before the final shares are normalized. The gate has a midpoint called theta. By default, theta is the 32nd-highest positive adjusted share. It is normally recalculated every 360 blocks and stays fixed between updates. A subnet at the midpoint passes half of its adjusted weight. Subnets well above it pass almost all; subnets well below it pass much less:

gate_i = 1 / (1 + (theta / burn_adjusted_share_i)^h)
final_share_i = burn_adjusted_share_i × gate_i
                / Σ(burn_adjusted_share × gate)

The default exponent h is 3. This makes the gate gradual rather than a hard cutoff. A very small share can still round down to zero. If every gated value rounds to zero, the runtime restores the ungated price shares so emission is not stranded. See get_shares.

An emission-disabled subnet receives no TAO-side share; its share is redistributed among enabled subnets. That also stops its tao_in and alpha_in pool injection, while its participant-side alpha_out continues to accrue.

The EMA uses an age-dependent smoothing factor:

ema_alpha = base_alpha × blocks_since_start / (blocks_since_start + halving_blocks)

with halving_blocks defaulting to 201,600 (~4 weeks). New subnets start near zero — their moving price adapts extremely slowly, which blunts launch pumps, coordinated buys, and flash attacks on emission shares. The spot price feeding the EMA is capped at 1.0.

Pools and price

Pools are Balancer-style weighted pools, and the spot alpha price is (w_alpha / w_tao) × (TAO reserve / alpha reserve) (read it with alpha-price). The two weights start at 0.5/0.5 — where the price reduces to the plain reserve ratio and the math to constant-product — and are bounded to [0.01, 0.99]. Per-block liquidity injections shift the weights instead of the price, so emission does not move the market, but it does nudge the weights slightly off 0.5/0.5 — so the price is the weighted ratio, not exactly TAO / alpha. Pool liquidity is protocol-owned by default: the chain has a user-liquidity feature (per-subnet user_liquidity_enabled toggle, off by default) but with it off there are no user LP positions or LP tokens.

The per-tempo split

Per-block alpha_out is divided as it accrues (emit_to_subnets):

• 18% to the subnet owner (SubnetOwnerCut, 11796/65535).
• 41% to miners — 50% of the remainder.
• 41% to validators and their stakers — the other 50%.

A root_proportion share of the validator half (same formula as the injection cap) is reserved for root TAO stakers and accumulated as claimable root dividends — but only in blocks where the sum of eligible non-root subnets' EMA prices exceeds 1.0; otherwise that alpha is recycled.

If an epoch ends with zero total miner incentive, the miner half of that tempo's pending alpha is paid to validators instead of being withheld.

Within a validator's dividends, each staker is paid according to the validator's stake mix: the TAO-staker portion is τ × w / (α + τ × w) and the alpha-staker portion is α / (α + τ × w), where w is the global TAO weight (currently 0.18 on mainnet, governance-set). The validator's take is deducted before delegators are paid.

Epochs

Distribution happens at epoch boundaries. Each subnet's epoch fires once tempo blocks have passed since its last epoch; the default tempo is 360 blocks (~72 minutes), owner-settable between 360 and 50,400 (~7 days), and some older subnets carry smaller legacy values. At most 2 subnet epochs run per block (MaxEpochsPerBlock) — extras are deferred one block (drain_pending) — and a subnet owner can trigger an early epoch manually. An epoch that hits inconsistent chain state is skipped (the schedule still advances); its pending emission keeps accruing and is drained by the next successful epoch. Emission is settled per epoch, at epoch end: the accumulated alpha is paid to the hotkeys holding each UID when the epoch fires, not continuously per block. Deregistration follows the same rule — a neuron pruned mid-tempo gets nothing for the partial tempo, since the payout lands on whoever holds the UID at the epoch (its last payout was the last epoch that fired while it was registered). The metagraph's per-neuron emission field reflects this settlement: it is denominated in rao (of the subnet's alpha) and holds each UID's combined payout from the subnet's most recent epoch — a per-tempo amount, not a per-block rate. epoch-status and blocks-until-next-epoch expose the timing per subnet.

Yuma Consensus

At each epoch the chain resolves the validator-weight matrix (set via set-weights) into per-neuron emission shares.

Stake weight. Each neuron's stake weight is alpha_stake + tao_stake × tao_weight — alpha staked on the subnet plus root-subnet TAO stake scaled by the global TAO weight (currently 0.18 on mainnet, governance-set). Validators below the chain's stake threshold (currently 1,000 tokens' worth) are zeroed, and neurons whose last weight update is older than the activity cutoff (default 5,000 blocks) are inactive and excluded from consensus.

Permits. Validator permits are recalculated every epoch as the top-K neurons by stake weight (is_topk_nonzero), with K = MaxAllowedValidators (default 128). Only permitted neurons can set weights over others; bonds are kept while a permit is held and cleared when it is lost.

Weight filtering. Self-weights are removed (except the subnet owner's), as are weights from non-permitted validators and weights set before the target neuron's latest registration. Each validator's surviving weights are row-normalized, so influence is independent of absolute weight values.

Consensus and clipping. For each miner, consensus is the stake-weighted median (weighted_median_col): the highest weight level supported by at least kappa of active stake, with kappa defaulting to 32767/65535 ≈ 0.5. Weights above consensus are clipped down to it.

Rank and incentive. A miner's rank is the stake-weighted sum of clipped weights, r_j = Σ_i s_i × w̄_ij; normalized ranks become incentive, each miner's share of the miner emission. Validator trust is the sum of a validator's clipped weights. The per-miner trust metric (the ratio of clipped to unclipped rank) is deprecated — the chain no longer computes it, and the metagraph returns empty trust and rank vectors.

Bonds and dividends. Bond weights interpolate between raw and clipped weights by the bonds-penalty hyperparameter (default: fully clipped). Instant bonds ΔB = W ∘ S (weights times stake, column-normalized) are smoothed by an EMA (compute_ema_bonds_normal):

B(t) = alpha × ΔB + (1 − alpha) × B(t−1)

where alpha = 1 − bonds_moving_average / 1,000,000 (default 900,000, so alpha = 0.1). Validator dividends are bonds times miner incentive, d_i = Σ_j B_ij × I_j — validators who recognize good miners early build bonds and earn more when consensus catches up.

Yuma3 (a per-subnet toggle, Yuma3On) switches to fixed-point bond computation (compute_bonds) with per-pair scaling, and computes dividends differently: the row-sum of bonds × incentive, scaled by each validator's active stake, then renormalized. With liquid alpha enabled, the EMA rate becomes dynamic per validator–miner pair (compute_liquid_alpha_values), moving between alpha_low (default 0.7) and alpha_high (default 0.9) via a sigmoid on the distance from consensus (steepness default 1000). Liquid alpha only takes effect when yuma3_enabled is also on — the classic bond path ignores the toggle entirely. Both toggles and their parameters are owner-set hyperparameters.

If no valid weights exist, emission falls back to stake proportions, so a subnet without consensus still pays its stakers. The epoch writes consensus, incentive, dividends, validator trust, bonds, and permits back to chain state — metagraph returns all of it in one read, and combined emission drives pruning (deregistration) order.