Hi,

Nobody who opens an exam result can tell whether a second marker ever saw the paper. That is the whole difficulty, and it is why a board pays for one.

On the sixth of October a network that pays strangers for AI work gave the owner of any one of its parts the choice to stop. It is a switch, cheap to throw and expensive to throw back.

Nothing visibly stops when it is thrown. Every holder is still paid, every rule about what a score means is still written exactly as before, and the part that goes quiet is the part that made a false number cost its author anything.

If the payment arrives either way, what was the judging for?

Listen:

Apple Podcasts: https://podcasts.apple.com/kg/podcast/plain-strata/id6783455764?i=1000797640222

YouTube: https://youtu.be/BxWCPYVDk8M?si=hO38HBkF_qj-v_pk

---

The full piece, no need to click through:

An exam board posts a batch of scripts to two markers who have never met, one in Leeds and one in Plymouth. Each reads the same answers and writes a number, neither knowing what the other wrote. The office compares the two. Close together, and the script is settled. Far apart, and a third marker decides. A marker whose numbers keep landing far from the final mark is not invited back next session.

Then the board decides one marker per script is enough. Every script is still read, every grade still goes out on results day, and the envelopes look exactly as they did. What left the building was never the marking. It was the comparison, the only instrument that had ever told anybody whether a marker was marking.

On the sixth of October a change was merged into the software that runs Bittensor, a network that pays strangers for AI work and decides who gets paid by a vote. It lets the owner of one part of that network switch off the step that compares the judges. The comparison of several judgments was the only thing that made a false one cost anything, and when it goes the payments keep arriving exactly as before. By the middle of the month one part of the live network was running that way, and on the test network a single switch like it had stopped four hundred others from being paid at all.

Underneath all of it sits a ledger, a shared spreadsheet nobody is allowed to lie to, kept in full by every machine that joins, and anyone may join. It holds balances and receipts, and no AI at all.

The work happens on ordinary machines beside it, grouped into sub-networks: a few hundred computers running the same program, competing at one job, all pointing at a single row of that spreadsheet. One sub-network answers questions with a language model, another serves images, another rents out graphics cards. The machines doing the job are called miners, a word inherited from Bitcoin and meaningless here beyond habit.

A validator produces no blocks and writes nothing into the spreadsheet by hand. Its job is to score: it sends the miners work, looks at what comes back, and publishes one row of numbers, one number per miner.

A weight row is not a grade. It is a financial instruction: one number per miner, turned into whole integers, saying what share of this round's new tokens that miner should receive. The network never asks how a validator arrived at its numbers. It asks only for the list.

Rounds come about every seventy-two minutes. At the end of each one the chain creates new tokens and splits them in half, one half to the miners for the work and one half to the validators for the judging. The judging is paid. So if writing a list moves money, writing a self-serving list moves money toward yourself.

So what stops a judge from writing a list that pays itself?

The other judges, and how many must be in the room has a name borrowed from parliamentary procedure. A quorum is a count of who must be present: the word is the Latin for "of whom", the opening words of a commission naming which of whom had to be there for the business to stand. Bittensor's quorum is half, and it is half of the money rather than half of the heads.

Every validator has tokens staked behind it, its own and other people's, locked up as a security deposit. To settle what one miner is owed, line up every validator's number for that miner from high to low, each number carrying the weight of the stake behind the validator who wrote it. Walk down the line adding stake as you go, and stop the moment you have passed half the total. The number you are standing on is the agreed value for that miner. Every number above it is cut down to it, not scaled and not blended, before a single token moves.

A judge who writes a wildly high number for a machine it owns does not get that machine paid at the high number. The number is erased, and the judge pays for having written it.

The guarantee is weaker than it looks. In an ordinary vote about whether a transaction is valid, every machine can check the claim independently and reach the same answer, so a liar is provably wrong and taking its deposit is fair. A vote about whether a piece of AI work was any good has no equivalent fact behind it, so the only available standard is what the other judgments said, which makes the defence against a dishonest majority the majority itself.

Cutting the high number stops a lie from paying. It does nothing for a judge who was right. So what pays a judge?

Not the stake. Stake is only the weight on the opinion. What pays a validator is a bond, and the word carries the mechanism: bond is the same old word as band, a thing that ties, and this one ties a judge's future income to a judgment it made in the past.

What sits in storage is one number for each validator and each miner. At the end of a round the chain computes a fresh version of it: that validator's stake multiplied by its cut-down weight for that miner, divided by the same quantity summed across every validator that backed the miner. The result is a share, and it answers one question, what fraction of the room's support for this miner came from this judge.

The fresh share does not replace what was in storage. It moves it. On the usual setting the stored number travels about a tenth of the way toward the fresh one each round and keeps nine tenths of where it already was, a long memory of who has been backing whom. A judge that starts backing a good miner needs many rounds to hold a full position in it, and one that abandons a good miner keeps a shrinking claim for many rounds after.

Payment falls out of two numbers. A miner's cut of the miners' half is its agreed value as a fraction of all the agreed values. A validator's cut of the judges' half is the sum, across every miner, of its stored bond in that miner multiplied by that miner's cut. A judge is paid for having pointed at machines the room later agreed were good, and for pointing at them early enough to hold a position by the time the room caught up.

The bond is built from the cut-down number and never from the raw one, so the reward for spotting a good miner early is capped by what the value at half the stake was willing to believe at the time. A judge who is right too early is paid as though it had been less right.

Every station in that engine needs more than one list. The agreed value needs several. The cut needs an agreed value. The share needs a sum across validators. The bond needs the share. The pay needs the bond.

What does an engine like that do when there is only one list?

That stopped being hypothetical on the sixth of October, when a change called Null Consensus was merged into the chain's code and went out in the runtime released the next day. Consensus, from the Latin for feeling together, is a generous word for machines that feel nothing and simply arrive at the same list. Null is from nullus, ne plus ullus, not any, and the name is accurate about what it removes and silent about what it keeps.

A sub-network owner now picks one of two modes. Under the old one, Yuma Consensus, the lists are compared and the bonds move. Under the new one the chain grants exactly one validator permit, to the identifier holding the largest stake, ties broken by whichever registered first. Only that identifier may publish a row, through any path, including the owner's own. Every other validator may still do all the work of judging and may not write the result anywhere the chain will read it.

Each round then loads that single row. The step that compares lists is skipped, the step that computes bonds is skipped, and the bonds already in storage are preserved and frozen, a photograph of the last round that had more than one judge in it.

And the money still moves, which is where the change bites. A dividend is, by the word's own construction, dividendum, the thing to be divided, and every identifier with a positive stake keeps its proportional dividend, inactive ones and ones holding no permit included. The division is now by balance.

If the elected identifier publishes an empty row, the miners' half of the round is spread across all registered identifiers, so doing no work and doing excellent work are paid identically that round. An open thread on the project's own tracker raises exactly this, citing a sub-network whose elected validator has published no numbers since it registered. The same thread notes that the permit goes to the largest stake and not to a stake above any threshold, so the single judge of a sub-network can be a party holding a small fraction of the money on it.

A staked token on this network was never a savings account. It was a vote about which AI work deserves to be paid, and that vote is why the token is worth anything to the network at all. Under the new mode it is a savings account: it pays its holder for a balance rather than for a judgment, and the one holder whose judgment still moves money is whichever balance is biggest.

Nobody throws a switch like that for nothing, so what does the owner get?

Room. The old mode caps a sub-network at two hundred and fifty-six registered identifiers, a real constraint on work suited to hundreds of machines. The new mode raises it to a shared budget of two thousand five hundred, divided by however many payment mechanisms the sub-network runs: two thousand five hundred with one, half that with two, six hundred and twenty-five with four.

The case for it is stronger than it sounds. On a sub-network where one team runs the only validator with real stake behind it, the comparison was already a formality. The walk down the line arrived at the one number that had been written, the cut cut nothing, and the bond recorded a judge agreeing with itself round after round while the ceiling stayed at two hundred and fifty-six. Switching the comparison off there writes down a fact that was already true.

The answer is that a formality still carried a price. While a second judge could appear, a false number could be cut and could cost its author, and the threat never had to be exercised to be real. Almost nobody ever checks, and the arrangement works anyway because somebody could. Take away the could, and the price of a false number is zero rather than small. The places are not free either: the two thousand five hundred come out of one shared budget.

Undoing the switch is narrow by design. The owner must first prune the sub-network down to two hundred and fifty-six identifiers, and prune is the gardener's word, from the old French for cutting a vine hard. The cutting takes at most sixty-four identifiers a transaction, with pending commitments cancelled before the list is compacted. A switch cheap to throw and expensive to unthrow is a different object from a setting.

That was the design. The week it shipped showed what the design had not accounted for.

On the eighth of October, on the test network, sub-network four hundred and fifty-five was switched to the new mode, and from the next block the chain's schedule broke. The chain settles sub-network rounds on a budget: up to eight in a single block. When a sub-network running the new mode is due, that cap drops to one. The single slot goes to the first sub-network due in storage order, which is nothing more than the order the entries happen to sit in. Sub-network four hundred and fifty-five sat at position four hundred and seventy-six of five hundred and eighty-nine, so it was passed over every block. Being passed over, it stayed due. Staying due, it held the cap at one, which let a sub-network near the front take the only slot every time.

About four hundred and fourteen of five hundred and eighty-nine sub-networks were settling no rounds at all on the days the report was written, one of them last paid nineteen thousand blocks earlier. The exit was shut from the inside: the owner's window for switching the mode back never opens while a sub-network is perpetually deferred, and unsticking it took an administrator's override.

On the live network, at the time of that report, a single sub-network, number thirty-seven, was running the new mode and the chain was healthy. The collision needs a particular position in a particular order, and it was found by running the mode rather than reading it. An automated security review attached to the change had finished with five unresolved findings, every one about resource accounting and about who is charged for writing weights, and the change was merged with that review standing as its single accepted failing check.

None of it is visible from inside a round, where the money actually moves.

Follow one seventy-two-minute round on a serving sub-network, the kind that answers paying customers' questions with an open model, the largest of which was taking around fourteen percent of everything the network printed each day earlier this year.

During the round the miners serve answers. Several validators, each with stake behind it, send their own requests, read the replies and publish a row. For one miner the chain sorts those rows high to low, carries each one's stake, walks down until half the money sits behind it, and stands on the agreed value. Numbers above it are cut down to it. Each validator's cut-down number, times its stake, over the sum of the same across all of them, gives the share of that miner's support which came from that judge. The stored bond moves a tenth of the way toward the share. The miner's agreed value, as a fraction of all the agreed values, is its cut of the miners' half. Each validator's bonds, multiplied by those cuts and added up, is its cut of the judges' half. The chain writes the balances. The next round starts.

Now the owner throws the switch, and follow the same round again. The miners serve answers, and several validators still send requests and still read the replies. One identifier, the one with the largest stake, publishes a row. No other row is read. There is nothing to sort, because one number is already the agreed value, and nothing above it to cut. No share is computed, no bond moves, and the frozen bonds sit in storage describing a room that is no longer there. The miners' half is divided by the one row. The judges' half is divided by stake. The chain writes the balances. The next round starts.

Every rule about what a score means is still quoted word for word. The number of parties required to produce one has gone from a stake-weighted majority to a single largest holder, and no sentence in the machinery had to be rewritten to say so.

That move has a shape older than any chain: the lowered quorum. A system keeps every rule about what a decision means and quietly reduces the number of parties who must be in the room to make one, and because the rules are untouched they go on being quoted with their old authority. A bookkeeping system built on one clerk writing the entries and a second approving them still looks like double entry after the second clerk is let go, right up to the morning somebody checks. The loss stays invisible for a long time, because a comparison only shows its value on the days the two numbers differ. That is what a cost-cutter cannot see on the spreadsheet, and exactly what is being removed.

The sharpest version of it on this network is a question somebody asked on the project's own tracker and nobody has answered: only the elected identifier may publish a row, so what is a second validator supposed to do with what it finds? It can still send work to the miners, still measure what comes back, still catch a miner serving a smaller model than it promised. It cannot write any of that anywhere the chain will act on. The audit now happens off the chain, and its consequences are reputational: a post somewhere, an owner who cares, a customer who leaves. For a network built on the claim that strangers can check each other's work with no institution in the middle, that is a strange place to arrive, and it arrived without anybody voting.

Most of this network's judging always sat in few hands, and the change made a concentration visible rather than creating one. That is true and not comforting: somebody handing tokens to a validator still cannot read, from any surface the chain publishes plainly, whether the sub-network behind that validator has more than one judge in it.

Two questions are open, and nobody has answered either.

The first is whether a check with no consequence on the chain is a check at all. Every verification arrangement this field has built pairs a finding with a lever: a deposit that can be taken, a challenge that can be filed, a number that can be moved. Take the lever away and leave the finding, and what remains is publishing. Whether that does the same work is now being answered by experiment, and the honest answer today is that nobody knows.

The second is smaller and answerable. Does the chain say out loud, somewhere a person deciding where to put money can read it, which sub-networks run with one permitted judge and which holder holds the permit? One sub-network was running that way in the middle of October, and its number is knowable to anyone who reads the chain's state directly. Knowable to whoever reads the state is not the same as published, and the distance between those two is most of what the separation of ownership from control has ever meant.

---

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

Decentralized AI, layer by layer.

Dastan,