Plain Strata

Plain Strata
  • 0.0 (0)
  • Technology
  • Semiweekly

Decentralized AI, layer by layer. Created by Dastan Modubash. Hosted by Claire and Peter, two AI-generated voices that spend their time explaining systems they technically run on. The research, writing, and editorial decisions are human. The voices are AI. No prior knowledge assumed.

  1. 5d ago

    Plain Strata: One Hash for a Thousand Steps, What a Hash Tree Proves and What It Never Can

    A town pins a tournament bracket of a thousand names along a hall wall, with a short mark worked out from each pair above them all the way up to one mark at the top, copies that single mark onto a card on the public noticeboard, and a week later settles an argument about player 438 by handing over the name and ten other marks, because the man checking can work upward and see whether his result matches the card, which is a hash tree (a way of sealing many pieces of data behind one fixed-length scramble called a hash, from the French hacher, to chop) and the reason a blockchain (a shared record that every machine in a network keeps in full and nobody may edit), which charges for every byte, can hold a promise about eighty thousand steps of AI training without holding the steps. Each step is hashed on its own, the results are hashed in pairs until one is left, and proving one step means handing over its siblings (the partner hash at every round on the way up), ten for a thousand steps and twenty for a million, which is why the arrangement, first described by Ralph Merkle in 1979 to let one public key vouch for a batch of one-time signatures, grows by only one hash each time the work doubles. It has to be built carefully, because a hash cannot tell a step from two hashes glued together, so a cheat can hand over a mark from the middle of the wall as if it were a player and prove a smaller, different field to the same card, which is why the standard for certificate logs (public records of the security certificates issued to websites) puts a zero byte in front of every step and a one byte in front of every pair, and why Bitcoin, which copied the last hash of an odd row to pair it with itself, let two different lists of transactions share one top mark in 2012. What the card proves stops at in: it will not say the step was right, that nothing was left out, what order things happened in, that anything is secret or that it is current, so a worker who drops the one catastrophic step builds a perfectly valid tree over the rest, and every step that remains still passes. The honest limit is where the cost lands, because the tree is cheap for the ledger only by making somebody else keep every step, so a root with nobody holding the steps is a number nobody can argue with, and an auditor who says it could not replay a step on its own machine has said something no root has a slot for, and a flat list, which is what Gensyn publishes for open-1b (a small language model trained across machines nobody owns together, with a hash published for each of its eighty thousand nine hundred and fifty-seven steps), stays the better choice for exactly as long as nothing has to be settled on a chain. The voices in this show are AI-generated; the research and writing are human. Decentralized AI, layer by layer.

    Plain Strata: One Hash for a Thousand Steps, What a Hash Tree Proves and What It Never Can

  2. Oct 27

    Plain Strata: The Pay Split, Who Pays When Each Sub-Network Sets Its Own Cut

    A county fair posts a prize pot every seventy-two minutes and for years cut it the same way at every fair, eighteen parts to the organizer, forty-one to the judges in the tent (the validators, the programs that score the work) and forty-one to the exhibitors (the miners, who run the AI work on graphics cards), and on 20 October Bittensor, a network that pays strangers to do AI work, let each of its sub-networks, the separate fairs, write its own cut inside set limits. The pot is not ticket money, it is new tokens the network prints on a schedule, which is why the word is emission (from the Latin for sending out), so a richer cut for the exhibitors is simply a price paid to win machines away from the fair down the road. One share cannot move, because holders in the root, a base layer that sits outside every fair, are paid a toll out of the judges' tent, and when an owner shrinks the tent the chain raises a multiplier behind that choice until the toll comes out exactly as large as before, which also sets a floor, about 11.81 percent on the fourth sub-network, and is why a test file accepts 11.9 percent and refuses 11.7. With the toll fixed, the judges and the holders who staked behind them are the junior slice (a tranche, from the French for cut, the part that takes whatever is left), so cutting the tent from forty-one points to twenty drops what they share from about thirty-six points to about fifteen while the organizer loses nothing and the exhibitors gain twenty-one. The honest limit is that a price only means something when someone outside can check what it buys, and two weeks earlier the same owners were handed a switch that turns off the comparison between judges, so one person now sets both the pay and the measure of the work, although no sub-network has used the new split yet. The voices in this show are AI-generated; the research and writing are human. Decentralized AI, layer by layer.

    Plain Strata: The Pay Split, Who Pays When Each Sub-Network Sets Its Own Cut

  3. Oct 22

    Plain Strata: Nothing Left to Compare, Why a Judge Nobody Checks Still Gets Paid

    An exam board sends the same scripts to two markers who have never met, one in Leeds and one in Plymouth, opens their sealed numbers side by side and drops any marker who keeps landing far from the final mark, so when the board decides one marker per script is enough, every script is still read and every grade still goes out on results day, because what left the building was never the marking but the comparison, the only thing that ever showed whether a marker was marking. Bittensor, a network that pays strangers for AI work, runs that same machine on its judges, called validators (computers that score the work and publish one row of numbers saying what share of each round's new tokens every worker earns): the number sitting at half of the staked money, a deposit locked behind each judge, becomes the agreed value, every score above it is cut down to it before a single token moves, and a judge's bond (a slow record of how closely its past scores matched the room) decides what it is paid. On the sixth of October a change called Null Consensus let the owner of any one sub-network (a group of machines competing at one job) switch the comparison off, which hands a single permit to the largest holder of stake, skips the cut, freezes every bond where it stood and pays every holder in proportion to what it holds whether it judged anything or not, while every rule about what a score means stays written exactly as before. The owner gets room, up to two thousand five hundred places instead of two hundred and fifty-six, and a sub-network where one team already ran the only judge with real stake loses nothing it ever had, but a false number that could once have been cut and punished now costs its author nothing, and on the test network (a practice copy where changes are tried first) a single such switch left about four hundred and fourteen of five hundred and eighty-nine sub-networks settling nothing, because the cap on how many could settle at once dropped to one and the same early entries kept taking the slot. The honest limit is that most of this network's judging always sat in few hands, so the switch made a concentration visible rather than creating one, and that a second judge can still measure the work but can no longer write the result anywhere the network will act on it, which leaves open whether a check with no consequence is a check at all, and whether anyone deciding where to put money can read which sub-networks now run with one judge. The voices in this show are AI-generated; the research and writing are human. Decentralized AI, layer by layer.

    Plain Strata: Nothing Left to Compare, Why a Judge Nobody Checks Still Gets Paid

  4. Oct 20

    Plain Strata: Integer Overflow, Why a Guard Built From the Same Arithmetic Certified a Theft

    A mechanical odometer with five windows of digits reads twenty-one after a hundred thousand and twenty-one miles, because the wheels turn past the last place and start again from zero, a correct reading of the wheel and a false reading of the trip, and that is what happened to the part of a payment network whose only job is to notice money appearing from nowhere. The XRP Ledger, a payment network anyone can join, stores every amount in a fixed-width container of sixty-four binary digits (the on-or-off switches a number is built from), about ninety-two times the entire money supply, so for ten years nothing came near the edge, until one payment consumed two hundred and fifty-six offers of about seventy-two billion XRP each, summed them with no overflow check, wrapped past the edge and handed the attacker about eighteen and a half trillion new XRP for a fraction of a penny, a hundred and eighty-four times everything that exists. The guard against exactly this, an invariant (a rule that must hold whatever any transaction does, from the Latin for not changing) that adds up every balance change and demands the total equal minus the fee, did its own addition in the same sixty-four-digit arithmetic, wrapped in step with the thing it was checking and reported an ordinary fee burn. After ten years of human readers, a bug bounty (a standing cash reward for reporting flaws) and a hacking contest, an automated code auditor from Veria Labs found it within a day, and the network shipped the fix without its normal two-week validator vote (servers agreeing by upgrading the software) and held back the patch's source, because a published fix is a map of the flaw and a machine reads that map faster than operators can upgrade. The honest limit is that a check can fail in the same way, at the same moment, as the thing it checks, and that nothing lost on the live network is no defence for a guard that never met the one transaction able to beat it, while the governance question stays open, since the slowness of a vote is what makes a rule credible and also the window an attacker works in. The voices in this show are AI-generated; the research and writing are human. Decentralized AI, layer by layer.

    Plain Strata: Integer Overflow, Why a Guard Built From the Same Arithmetic Certified a Theft

  5. Oct 18

    Plain Strata: Canonical Serialization, Why Two Honest Parties Can Look Like Liars

    A hash, the short fingerprint a computer grinds out of a block of bytes, changes completely if one space changes, because it has only ever seen bytes and never once seen what they mean. That is harmless until a system stores the fingerprint of work done somewhere else, because from then on the exact printing of that work (the order of its fields, a space after a colon, whether one hundred is written 100 or 100.0) is part of the protocol, and two honest parties who printed the same document differently hand a checker a mismatch that looks exactly like a lie. Two millers show it cleanly: they stack the same three sacks in different orders, press their wax seals over the cord, and the merchant's book can only read the two different impressions as tampering. The field ships three ways out, which are to canonicalize (from the Greek kanon, a measuring rod) so every implementation emits one agreed byte sequence, to sign the exact bytes you saw and carry them along, or to use an encoding that has only one form to begin with, and the first of these reaches back into your data design, since the standard for JSON, the web's everyday data format, cannot faithfully hold a very large whole number and tells you to write it as text. The honest limit is that a failed check now has three possible owners, the party being checked, the checker, and the road between them, yet the verdicts on offer are passed, failed, or could not check, and none of them can say that the bytes received do not match and nobody can tell which side is wrong. The voices in this show are AI-generated; the research and writing are human. Decentralized AI, layer by layer.

    Plain Strata: Canonical Serialization, Why Two Honest Parties Can Look Like Liars

  6. Oct 8

    Plain Strata: Could Not Check, Why Verifying AI Work Needs a Third Answer

    A chemist asked to reproduce somebody else's experiment reaches a step her bench cannot carry out, and the form she has been handed has two boxes, reproduces and does not reproduce, so whatever she ticks is a lie about a paper she never tested. A network that pays strangers' machines to do AI work has built exactly that form for its checkers (a checker is a participant whose job is to say whether the work was done properly, and its answer is written permanently on a ledger, a shared record nobody can edit, and moves money), because each checker can test only a finite list of things, called guards, and every guard ends one of three ways: it holds, it fails, or it cannot be evaluated, which is a fact about the checker and says nothing about the work. Take away the third box and the answer does not disappear, it gets misfiled, so a checker whose own code crashed accuses an honest worker and a checker handed something it cannot read certifies it, which is why the cheapest attack on any verification system is to do something the checker does not understand, and why the width of one error catch (the line of code that says if anything in here goes wrong, report failure) turns out to be a decision about who gets blamed. Courts keep not proven beside guilty and not guilty, laboratories keep indeterminate along with a rule to draw the blood again, auditors keep the disclaimer of opinion for the vault whose keys were lost, and in every case the third answer arrives with an instruction for what happens next, which here means sending the work to a checker with a different list, adding more checkers, or marking the claim uncovered so whoever is paying can price it, while re-running a job, proving it with mathematics and sealing it in hardware each produce all three answers in their own way. The part with no clean answer is that a checker which publishes what it cannot check is publishing a map of where to attack it, while one that hides the list makes the word valid mean nothing, and nobody has yet published what five checkers add up to when two could not check, one failed the work and two passed it. The voices in this show are AI-generated; the research and writing are human. Decentralized AI, layer by layer.

    Plain Strata: Could Not Check, Why Verifying AI Work Needs a Third Answer

  7. Oct 6

    Plain Strata: The Inference Subsidy, Who Pays for the Cheapest AI in the World

    A network that pays strangers to serve AI does not pay them in dollars: every few minutes it prints new tokens (tradable coins that exist only on that network) and hands them to the machine owners, who cannot pay an electricity bill with a token and so sell it into a trading pool, an automated scale that walks the price down a little with every sale, which is how the cheapest AI serving in the open world sells a million words of input for 27 cents while costing about $1.41 to produce, with the missing $1.14 paid in silence by token holders who never sent a request. Venture money is a bank account that runs out and this runs on a printing press that does not, so an outside analysis of the largest serving sub-network (one crowd of machines running one kind of job) put its printed pay at somewhere between 22 and 40 times its customer sales, though most of the figures behind that ratio are estimates and some are contested. At its Montreal summit on 28 September the foundation behind Bittensor, the largest of these networks, proposed Gamma, in which a sub-network destroys some of its own tokens and the chain mints a credit pegged to a fixed dollar value, so five dollars burned becomes five credits that stay five forever, cannot be sold, cannot be turned back into a token, and can only be spent buying services from another sub-network. That is company scrip, from subscription receipt, the paper a nineteenth-century mining town paid its workers in and let them spend only at the company store, which costs the issuer a fraction of real money and keeps the store busy and has never once brought in a customer from outside. So Gamma changes who bears the loss and not whether there is one, since a credit that cannot leave cannot pay a power company, and the check anyone can run is a single number: will any of the seven networks named to issue it publish what a unit of its service costs to produce at the Gamma price, or is this a way of settling bills inside the network that sits on top of a loss nobody has priced? The voices in this show are AI-generated; the research and writing are human. Decentralized AI, layer by layer.

    Plain Strata: The Inference Subsidy, Who Pays for the Cheapest AI in the World

  8. Oct 1

    Plain Strata: Memory Access Patterns, How an Operator Reads Private Prompts Without Decrypting

    A sealed virtual machine, a rented computer simulated in software whose memory is locked with a key that never leaves the chip, still has to reach into that memory to think, and reaching is a physical act on hardware it shares with the landlord who owns the building, so the landlord cannot read a single byte but can watch which memory addresses get touched, the way a floor creaks when somebody opens a drawer. That would be harmless if the order of the creaks meant nothing, except that before an AI model reads your sentence a small program called a tokenizer swaps each word for a number by looking it up in a public table, so the order of the lookups is the order of your words, and a research tool called TDXRay, which watches four kinds of footprint at once, rebuilt more than ninety percent of the words in private prompts from a single run, credit card numbers whole, with no key stolen and no byte decrypted. Intel's own threat model, the written list of attacks a product promises to stop, excluded this class of attack from the start, because blocking it means redesigning how processors share their fast memory, so the cryptography kept every promise it made and none of those promises were about this. The same shape has leaked secrets before, in the volume of wartime radio traffic, in phone call records and in smart electricity meters, and the only real defence is to make the activity uniform, a tokenizer that scans its whole dictionary for every word so the footsteps say nothing, which researchers have already built at a cost they call acceptable. Every protection a buyer pays for after that first lookup, the encrypted link to the graphics card included, guards a prompt the operator already holds, so the honest limit is that a vendor's threat model has quietly become the thing you are trusting, and the question the episode leaves is which other layers of our lives leak our thoughts through the friction of processing them. The voices in this show are AI-generated; the research and writing are human. Decentralized AI, layer by layer.

    Plain Strata: Memory Access Patterns, How an Operator Reads Private Prompts Without Decrypting
See All (40)

About

Decentralized AI, layer by layer. Created by Dastan Modubash. Hosted by Claire and Peter, two AI-generated voices that spend their time explaining systems they technically run on. The research, writing, and editorial decisions are human. The voices are AI. No prior knowledge assumed.

Information

  • Creator
    Plain Strata
  • Years Active
    2026
  • Episodes
    40
  • Rating
    Clean
  • Copyright
    © 2026 Dastan Modubash
  • Show Website
    Plain Strata