Hi,

This is Plain Strata, the Thursday Layer.

Every twelve seconds or so, on a decentralized AI network, a machine sells a small piece of the network. No one decided it was failing. It happens on a timer, because that is how the network pays the people parked in its safest spot. To hand them their return, it sells off slivers of the very tokens the network is built on, around the clock, the thriving subnets and the dying ones alike. The belt has no opinion.

A proposal called Root Reborn wants to switch that belt off: stop selling, reinvest the return instead. Do that, and the largest recurring flow in the whole system changes sign, from selling to buying. But the moment you reinvest, someone has to choose where the money goes, and whoever chooses gains real power over most of the capital in the network. The fix that stops the bleeding hands a few validators the steering wheel.

That trade, between a blind, fair, self-harming rule and a smart, self-supporting, but capturable one, is the whole episode. The mechanism, the names, and the pattern underneath it are in the written version.

One question to carry, because it outlives this one fight: to pay its holders, does a system have to sell the thing that makes it valuable?

Spotify: [link]

The two voices are AI. The research and writing are mine.

Decentralized AI, layer by layer. Dastan

---

Cold open

Somewhere on a decentralized AI network, every twelve seconds or so, a machine sells a small piece of the network. Nobody decided the network was failing. No trader pressed a button. It happens on a timer, automatically, as a side effect of paying the people who park their money in the safest spot the network has. The network earns a return for them, and to hand that return over, it sells off little slivers of the very tokens the network is built on, around the clock, strong and weak alike.

That is not a bug someone forgot to fix. It is the rule, working exactly as written. And it has quietly become one of the most argued-over facts in the field, because someone has now proposed to turn the machine off.

The spine

Here is the one idea this episode is about, worth the next half hour because it reaches far beyond this one network. A system can be built so that the only way to pay its holders is to sell the thing that makes it valuable, draining itself a little with every payment. The fix sounds obvious: stop selling, reinvest instead. But the moment you reinvest, somebody has to choose where the money goes, and whoever chooses gains real power over the largest flow of money in the system. So the fix that stops the bleeding also hands a small group the steering wheel. That trade, between a blind, fair, self-harming rule and a smart, self-supporting, but capturable one, is the spine. Everything else is here to make it clear.

Foundation before altitude

Start from the ground, because none of this needs prior knowledge, only a few plain pieces stacked in order.

Picture a network where independent machines all over the world do AI work: running models, answering queries, scoring each other's answers. They get paid for that work in the network's own token. A shared ledger, think of it as a spreadsheet that nobody is allowed to lie to, keeps the score and pays out. On Bittensor, the network in question, that base token is called TAO.

The network is not one big pool. It is split into many smaller groups called subnets, more than a hundred of them, each a cluster of machines doing one kind of task. The important part: each subnet has its own separate token, called an alpha token. So the network is really a hundred-plus little markets, each with its own currency, all hanging off one shared base currency.

Now two more pieces. Staking: to help secure the network and earn a share of the rewards, you lock up some of the base token as a refundable deposit, money on the line that says "I am backing this." And the safest place to put that deposit, which the network calls the root: staking there is a bet on the entire network at once rather than on any single subnet, so it is the safe base, and it pays a steady return, lately around seventeen percent a year.

Hold those five pieces: machines paid in tokens, a ledger keeping score, subnets each with their own alpha token, staking as a deposit, and the root as the safe base. That is the whole stage. Now we can ask the question the episode turns on: when the root pays its steady return, where does that money physically come from?

Etymology and naming

The names here are unusually honest, so it pays to open a few of them.

Root. In this network the root is subnet zero, the base of the tree, and the word is doing two jobs at once. In botany, the root is the part of the plant that holds it in the ground and feeds everything above it. In mathematics, the root is the base node a tree grows from, every branch descending from it. Both senses are exactly right. The root anchors the network's stake and feeds security to everything built on top.

Dividend, from the Latin dividendum, "the thing to be divided." A dividend is a slice of return handed to the people who hold a stake. The word matters because it frames the whole fight, one question: in what form is the dividend paid? A company can pay you in cash, or in more shares. This network pays its root dividend, under the hood, in a pile of subnet tokens, then has to decide whether to convert that pile to cash for you or leave it invested as more shares.

Reinvest and liquidate are the two answers, opposites pulled straight from their roots. Invest comes from the Latin investire, "to clothe," to put capital to work by dressing it in a new form, so to reinvest is to take the return and put it back to work. Liquidate comes from liquidus, "to make flowing," to turn an asset back into spendable money. The whole debate is one word against the other: today the network liquidates the root's return every block; the proposal wants it to reinvest.

And vector, from the Latin vehere, "to carry." We will need it shortly, because the proposed fix is built out of a vector that carries money toward the subnets a chooser believes in.

Physical grounding: what literally happens every block

Forget proposals for a moment and watch the machine that runs right now.

The chain ticks forward on a steady beat, a new block every twelve seconds or so. Each block creates a fresh dose of the base token and the rules split it across the subnets. Follow one specific stream: the return owed to people staked at the root.

Here is the part that is easy to miss, and it is the hinge of everything. Root stakers are not paid directly in fresh base tokens. Because staking to the root spreads your influence across many subnets, what comes back to you is a share of those subnets' rewards, and those rewards are denominated in the subnets' own alpha tokens. So at each block, the return owed to root stakers is not clean money. It is a heap of dozens of different alpha tokens, a fruit basket of currencies the staker never personally picked. But the staker was promised a return in the clean base token, not in forty obscure subnet coins.

So the network does something automatic and relentless. Every block, it takes that heap of alpha tokens and sells it for the base token, then pays the staker in base token. To see why the selling matters, you need one last plain picture: how an alpha token is priced. Each alpha token trades in an automated pool that holds two buckets, one of the base token, one of that alpha. The price is simply the ratio between the two buckets. When you sell alpha into the pool, you pour alpha into one bucket and pull base token out of the other, and the ratio moves against the alpha. Its price drops a little.

Now multiply. Every block, across every subnet that owes the root a dividend, a dose of alpha is dumped into its pool, a small downward nudge, then another, thousands of times a day, on the prices of the very tokens the whole network is built on. Not because anyone judged those subnets bad, purely because that is how the return gets converted to clean money.

Picture it as a conveyor belt. Every twelve seconds it scoops up subnet tokens and dumps them on the market so that clean base token comes out the far end. The belt has no opinion. It dumps the thriving subnets and the dying ones with the same indifference. That belt is the thing the proposal wants to switch off.

The connected story: from auto-sell to reinvest

Walk it as one thread.

The contradiction came first. This network had already spent a year nudging participants toward conviction, rewarding people who reinvest their earnings instead of cashing out, on the theory that reinvestment signals belief and selling signals leaving. And yet one floor down, the root-dividend machine was selling alpha every single block, regardless of anyone's belief. The network was pressing the accelerator and the brake at the same time. The proposal, which carries the name Root Reborn, starts by noticing that contradiction.

The change it proposes is small in code and large in consequence. Keep the dividend, but change its form. Instead of selling the alpha heap each block, let each root validator file a distribution vector over the subnets: a simple list of proportions saying "send this much of my reinvestment here, this much there, none to that one." The return that used to be sold is instead reinvested into the chosen subnets and held as a growing basket, staked back under that validator. The staker's position compounds as a basket rather than dripping out as clean money, and the staker can still cash out to the base token whenever they want. The relentless every-block sale becomes an occasional, voluntary one, on the staker's own schedule.

The first effect is the headline. Switch off the every-block sale, and the structural downward pressure on alpha prices lifts. But it is bigger than just selling less. Replace selling with reinvestment, and the same flow that used to push prices down now pushes them up, because reinvestment is buying. The sign of the largest recurring flow in the system flips, from minus to plus.

The second effect is the one that names the proposal. Once a validator is choosing which subnets get the reinvested money, it is no longer a blind pipe converting tokens to cash but an active allocator, a fund manager picking holdings. Subnets it believes in attract a compounding inflow; subnets it judges weak get nothing. The validators become the network's capital curators, and that is not marketing language but the literal mechanism, because a list of proportions over subnets is a portfolio.

And here the clean story breaks, on schedule. A large, well-funded validator group came out against the proposal, warning of serious risk. Their objection is not that the mechanism fails, but that it works too well in one direction: if a validator both secures the network and decides where reinvested money flows, it can steer money into subnets it already holds and profit from the price rise it causes. The blind old belt could never do that, because a conveyor belt has no favorites. The fix and its cost turn out to be the same act, seen from two sides.

Technical depth: the sign that flips

Two quick mechanical notes, then the one dip worth taking all the way down. The vector the proposal reuses already exists: validators here constantly file weighted lists to score the machines they oversee, and the proposal simply points that same tool at subnets, a list of proportions the protocol reads as "route my reinvested money this way." It is a fund manager's target allocation in disguise, and the reuse is both the elegance and the worry, because clean code makes the new power frictionless to wield. The basket it builds is a snowball: the reinvested tokens earn more, which get reinvested, which earn more, and the staker can still convert back to clean money whenever they want, so the real change is simply who controls the timing of the sale, the protocol every block, or each staker on their own schedule.

Now the dip to the bottom, for the spine concept only. Why does selling lower the price at all, mechanically? The pool holds two buckets and keeps the product of their two sizes constant. That sounds abstract, so make it physical: it means the more alpha you pour in, the less base token you get for each additional unit, and the price slides along a curve rather than staying flat. A single sale walks the price down a small step. A steady drip of forced sales, every block, walks it down step after step and never lets it recover before the next sale lands. That is the entire engine of the loop: a pricing rule that converts every forced sale into a small, near-permanent downward nudge, repeated forever. Surface back up, and here is why it matters: because that nudge is mechanical and constant, flipping it from sell to buy does not merely slow the decline, it reverses the dominant force acting on every alpha price in the network. A small change at the root of a tree moves every branch. That is why a modest patch is being argued about as if the whole network were at stake. It is.

The cross-domain pattern: reflexivity

The shape underneath all of this has a name, and it is the one to carry out of this episode.

Reflexivity. The investor George Soros used the word for markets where the act of pricing a thing changes the thing's actual value, so cause and effect bend back on each other in a loop. The version that matters here is sharper: a system whose own reward mechanism forces it to sell the assets that give it value. Every block, to pay its safest return, the network sells subnet tokens, which lowers their prices, which lowers the measured value of the subnets, which is the very thing the network exists to grow. The reward erodes the asset base it draws from.

Once you have the name, you see the shape everywhere. A token project that funds its staking rewards by minting and dumping its own token. A company that pays its dividend by selling off its core inventory. A country that services its debt by selling its strategic reserves. The diagnostic question is short and worth memorizing: to pay its holders, does this system have to sell the thing that makes it valuable? If the answer is yes, the system is reflexive in this dangerous way, and it is fragile by construction. The proposal we have been walking through is, at heart, one attempt to break exactly this loop.

There is a second pattern stacked on top, just as old. When one party makes decisions on behalf of another but holds its own stake in the outcome, their interests can split. Economists call it the principal-agent problem; in plainer terms, the curator's conflict, the financial advisor paid by commission who steers you toward the funds that pay them most. The blind belt had no agency, so it had no conflict. The smart allocator gains agency, and inherits the oldest problem in finance along with it.

The philosophical hook

Underneath the mechanics sits a question the network cannot dodge: can a system stay neutral, and should it?

The blind belt is neutral. It plays no favorites, it cannot be captured, it has no opinion about which subnets deserve support. Its price for that neutrality is that it harms itself, selling the good and the bad with equal indifference. The curated path is self-supporting, because intentional buying replaces blind selling, but its price is that a few hundred actors now hold a steering wheel over most of the capital in the network, with the conflicts of interest and the legal shadow that always follow discretion over other people's money.

Notice the strangest thing: the strongest case for the proposal and the strongest case against it rest on the same fact, that validators gain real power over capital. For the side that wrote it, that power is the feature, because blind selling is the disease and intentional buying is the cure. For the side fighting it, it is the bug, because concentrated discretion over pooled money is exactly what conflict-of-interest rules exist to constrain. When the feature and the bug are the same fact, you are no longer in a technical disagreement that cleaner code can settle. You are in a values disagreement about how much agency to trust people with, and those get resolved by a vote, not a merge, and by who is still standing when the argument ends.

A converging example: one block, paid two ways

Put it all in a single frame. Picture one block, some ordinary afternoon. It mints its small dose of base token, and we follow only the root-dividend stream.

Today, the protocol assembles the dividend: a heap of alpha owed across maybe forty subnets, a little from a thriving one, a sliver from one quietly dying. The auto-sell fires. Into each pool goes a dose of alpha, and out comes base token. Forty small downward nudges on forty prices, the thriving subnet and the dying one alike, because the belt is blind. The staker receives clean money, is content, notices nothing. Then it happens again twelve seconds later, thousands of times a day. The network has sold a steady stream of its own tokens to pay its safest depositors, who have no idea their return is funded by the slow erosion of the thing they are invested in.

Under the proposal, the same heap is assembled, but no sale fires. Each validator has a vector on file: forty percent to the subnet it believes in most, the rest across a handful of others, a hard zero on the dying one. The reinvested alpha flows into those subnets as buying. The strong ones get a small upward nudge instead of a downward one; the dying one gets nothing, neither pressure nor support, left to the market. The staker's position is now a basket, compounding block by block, redeemable whenever they decide to walk.

Lay the two side by side, and the whole proposal is visible in a single block. Same money, same staker, same return available on demand. The only difference is a sign and a chooser. Today: minus, chosen by a belt. Tomorrow, if it ships: plus, chosen by a person. The sign change is why supporters call it the fix for a network that sells itself. The chooser change is why critics call it a conflict of interest with a regulator's shadow over it. Both are looking at the same block. They simply disagree about whether to trust the hand on the wheel more than the blindness of the belt.