Plain Strata

The Tuesday Pulse. On Friday, the most powerful AI available to the public shipped, and to use the most capable version you first needed approval from the US government: around twenty companies, cleared case by case by the White House, after the model scored 96.7% on a cyberattack test and crossed the government's threshold for a high-risk system. The company complied, then asked that this kind of review not become the long-term default. This episode sets that next to its mirror image. The same week, Prime Intellect, a team whose whole identity is training AI without a central data center, trained its strongest model in a single room on a cluster of 512 chips, stopped by a physical limit called the communication wall: at the frontier, the machines must share hundreds of gigabytes of numbers after every step, and over ordinary internet that sharing takes hours while the processors sit idle. We build both from the ground up, in plain language: what frontier AI means, why a named approval list is a different shape from an export ban, why training the frontier still needs one room, and the etymology hiding in the word permission. No prior knowledge assumed. The research, writing, and editorial decisions are human. The voices are AI. Decentralized AI, layer by layer.

The Thursday Layer. On a decentralized AI network, the safest yield is paid by a machine that, every twelve seconds, sells off slivers of the very tokens the network is built on. No one decided the network was failing; it is just how the return gets paid, and the belt sells the thriving subnets and the dying ones with the same indifference. This episode takes apart a proposal, Root Reborn, that would switch that belt off and reinvest the yield instead, flipping the largest recurring flow in the system from selling to buying. The catch: whoever chooses where the money is reinvested gains real power over most of the network's capital, and the oldest conflict in finance comes with it. We build it from the ground up: subnets and their tokens, staking and the root, why a forced sale lowers a price, the pattern called reflexivity (a system forced to sell what makes it valuable), and the principal-agent problem underneath. No prior knowledge assumed. The research, writing, and editorial decisions are human. The voices are AI. Decentralized AI, layer by layer.

The first episode of Plain Strata. This June, the most capable AI ever opened to the public went dark for the whole world, three days after launch, because of one letter. The United States Commerce Department ordered Anthropic to cut off every foreign national, and to obey a rule about some people, the company switched its model off for everyone. That is what an off switch looks like when someone else is holding it. In the same week, on a network no company controls, a 19-megabyte model that runs on an ordinary laptop beat the giants at one task: a model with no off switch to pull. We take both apart in plain language: why the cloud is really a building with one door, how a tiny cryptographic receipt lets you check work you never ran, why a deposit keeps strangers honest, and the honest trade where pulling the switch cuts both ways. No prior knowledge assumed. The research, writing, and editorial decisions are human. The voices are AI. Decentralized AI, layer by layer.

Across this series we have watched decentralized AI networks do remarkable things with no company in charge. Serve answers. Verify work nobody watched. Pay strangers. Run software that acts on its own. But a question has been lurking under all of it. Someone, somehow, decides what model runs, what the rules are, how the money is spent, and what happens when those rules need to change. If there is no boss, who decides?

In a centralized AI company the answer is trivial: the company decides. Decentralization throws that away on purpose and then has to reinvent decision-making from scratch, among people who may not know or trust each other. The tools stack, so we take them in order. Ownership first: who holds the model weights, the trained numbers that are the actual valuable asset. A single team operating in the open, a collective holding it jointly, a token-weighted community, or a hybrid promising to hand over control later. Where a project sits on that spectrum tells you more about how decentralized it really is than any amount of marketing. Then token-curated registries, a list people put money behind to add to or challenge. Then organizations voting on upgrades and treasury. Then sub-network owner economics, a real economic share without full control of the rules.

The etymology is unusually good here. Governance is from the Latin gubernare, to steer, and behind it the Greek kybernan, the same root that gives us cybernetics. Governance is only ever the question of whose hands are on the wheel. Curate is from curare, to care for. Registry is from regerere, to record.

And then the tension the episode is really about. Open governance is slow. Centralized governance is fast, and reproduces exactly the thing decentralized AI exists to avoid. Every project is somewhere on that line, usually further toward the fast end than its documentation admits. The honest close: none of these projects has yet been through a real governance crisis, and that is the test that will tell us whether any of it holds.

This is Basics 8 of 8, the last of the start-here arc. Each episode stands on its own and assumes nothing.

The voices in this show are AI-generated; the research and writing are human. Decentralized AI, layer by layer.

Most software waits to be told what to do. You click, it responds. An agent is different: software that acts on its own, in a loop, pursuing a goal without a human pressing the button each time. Now give that agent its own money and the ability to spend it, and put its identity and its actions on a public ledger where anyone can audit them. You have something genuinely new: software that does business, hires other software, and can be held to account for what it did.

Strip away the hype and an agent is a loop with three beats. Perceive: take in some state of the world. Decide: reason about what to do, maybe with a language model, maybe with a hand-coded rule. Act: do something that actually changes the world. Then the loop runs again, because the action changed the world and there is something new to perceive. Agent comes from the Latin agens, one who acts, from agere, to do. An agent is, etymologically, just a doer. Not a tool you wield; a doer that acts for you.

What makes an agent on-chain is three properties stacked in order: identity and actions anchored to a ledger so they are verifiable rather than merely claimed, its own wallet so it can move money with no human in the loop, and a reasoning trail exposed far enough to be audited after the fact. We walk Olas and the Autonolas ecosystem as the leading production example, plus the newer autonomous-economy frontier.

Then the questions nobody has good answers to, which are the reason this episode matters. How an agent gets judged. What happens when it misbehaves and there is no employer to fire it. Who owns its reasoning trail. Whether a thing with a wallet and no legal person behind it can be liable for anything at all. Autonomy, from the Greek auto and nomos, self and law: one who makes their own laws. The word is doing a lot of work, and the law has not caught up with it.

This is Basics 7 of 8, the start-here arc. Each episode stands on its own and assumes nothing.

The voices in this show are AI-generated; the research and writing are human. Decentralized AI, layer by layer.

Training and running AI needs one specific, expensive ingredient: graphics processing units, the chips that do the enormous parallel arithmetic neural networks demand. They are scarce, they are costly, and most of the world's supply sits inside a handful of giant cloud companies. So a natural question arises. Could you rent GPU time from anyone who happens to have a spare one, the way you rent a stranger's spare room instead of booking a hotel?

Every compute rental has the same three parties: a buyer who wants computing power, a seller who owns the hardware, and a layer in between that matches them, handles payment and sorts out disputes. Everything separating the centralized world from the decentralized one lives in that middle layer, and in how much of your trust it requires. Centralized, it is one large company that owns the fleet, sets the price and is contractually on the hook. Decentralized, it is a protocol: rules running across many machines with nobody in charge, where anyone with a GPU can sell. Akash, io.net and Render are the leading examples as of 2026. Marketplace, from the Latin mercatus, trade: a place where buyers and sellers meet. The decentralized version keeps the meeting and replaces the place with code.

Two things make this harder than it sounds. Pricing, because a market of strangers clearing inventory in real time is cheaper than the hyperscalers at some hours, more expensive at others, and always more volatile than a reserved contract. And trust, which is the interesting one: how do you know a seller you have never met actually has the chip they claim? That is what hardware attestation is for, and it is what keeps a market of anonymous sellers from being a market of liars.

We close on the awkward question underneath the whole category. If the big cloud providers start listing their own spare capacity here, and they have every incentive to, does the decentralization property survive being that popular?

This is Basics 6 of 8, the start-here arc. Each episode stands on its own and assumes nothing.

The voices in this show are AI-generated; the research and writing are human. Decentralized AI, layer by layer.

One question splits this whole field in two: are you using an AI model, or building one? Using a finished model to answer a question is called inference, and decentralizing it is hard but solved, running in production today. Building the model in the first place, out of mountains of examples, is called training, and decentralizing that is the frontier nobody has cracked.

Inference is a single self-contained job. A question comes in, the model runs once, an answer comes out, and you can check it afterward. Training is not one job but an enormous tightly coupled marathon, and it cannot be cleanly chopped into independent pieces. Every machine working on it has to stay in step with every other machine, constantly, or the whole effort falls apart.

To see why, we ground gradient descent from scratch: predict, measure how wrong the prediction was, nudge billions of internal numbers slightly in the direction that reduces the error, repeat. Gradient comes from the Latin gradus, a step. It is a walk downhill taken one step at a time, and in distributed training every machine has to take the same step together. That is the whole problem in one sentence.

Three obstacles follow. Synchronization, where after every step the network becomes the bottleneck long before the chips do. Compression, where sending a rougher summary buys speed at the cost of exactness, the same trade as turning down the resolution on a photograph. And heterogeneous hardware, where machines that are not identical quietly produce slightly different numbers from the same arithmetic, which is why some teams are chasing bitwise-reproducible execution.

We cover what Gensyn, Nous Research and Prime Intellect are each betting on, and end on the honest state of it: nobody yet knows whether very large decentralized pre-training is achievable, or whether the gravity of putting all the machines in one building wins.

This is Basics 5 of 8, the start-here arc. Each episode stands on its own and assumes nothing.

The voices in this show are AI-generated; the research and writing are human. Decentralized AI, layer by layer.

A blockchain is a strange kind of computer. It is extraordinarily good at agreeing on a shared record nobody can secretly alter, and almost comically bad at knowing anything about the world outside itself. It cannot check the price of a stock. It cannot read a website. It cannot tell whether an AI model produced a good answer. It is, in a real sense, blind.

That is not a bug to be patched. It follows from how consensus works: the only facts allowed in are facts every machine can independently agree on, and no machine can independently agree on something it would have to go outside and look at. So the field converged on one reusable solution, load-bearing enough to have earned a name. The oracle pattern.

The shape is always the same. Delegate the looking to a set of outside observers. Trust none of them individually. Aggregate what they report, and arrange the money so that lying costs more than it pays. Oracle, from the Latin oraculum, and behind it the place the Greeks went to ask questions of the gods: the source you query when the answer is not something you can work out yourself. Optimistic, from optimum, the best: assume the answer is correct by default, and leave a window in which anyone can dispute it.

Then we go looking for the shape in three places that seem unrelated. A price oracle telling a lending contract what an asset is worth. An optimistic rollup posting a claim and daring anyone to challenge it. A decentralized AI network scoring work the chain could never afford to re-run. Same pattern, three costumes, with challenge and response threaded through all of them.

This is the episode that changes how you read the rest of the field. Once you can see this pattern, you stop learning projects one at a time and start recognizing the same machine wearing different logos.

This is Basics 4 of 8, the start-here arc. Each episode stands on its own and assumes nothing.

The voices in this show are AI-generated; the research and writing are human. Decentralized AI, layer by layer.

A landlord hands an apartment key to a tenant they have never met. The tenant could trash the place, skip town, and never pay for the damage. What stops them? Not the landlord's trust, and not the tenant's good character. A security deposit. A pile of the tenant's own money that disappears if the apartment gets wrecked. The deposit converts a question of character into a question of arithmetic.

Decentralized AI networks run on exactly this idea, scaled up and automated. No landlord, no police, no company enforcing good behavior. Only money at risk and a set of rules about when it disappears.

Four pieces, in the order they build. Stake is money locked as collateral, deliberately exposed; the word is Old English, a stake being a post driven into the ground, planted and committed, not easily pulled back up. Slashing is the forfeiture, the cutting away. Emissions, from emittere, to send out, are the freshly minted tokens paid each cycle for honest work. And bonds are the piece almost nobody explains: a long memory of who has been reliable, so honesty compounds over months rather than resetting every round.

Underneath all four sits one line that turns up everywhere in this field. The cost of corruption has to exceed the profit from corruption. Cheating is never made impossible; it is made a bad trade. We work the arithmetic in the open on one case: a small-stake validator inflates a score to 0.9 when the honest consensus is 0.5, and we follow exactly what stake-weighted clipping and bond decay do to that validator's money.

We close by naming the load-bearing assumption, because it is not guaranteed: that no coordinated minority controls more than half the stake.

This is Basics 3 of 8, the start-here arc. Each episode stands on its own and assumes nothing.

The voices in this show are AI-generated; the research and writing are human. Decentralized AI, layer by layer.

You send a hard math problem to a stranger on the internet and pay them to solve it. A minute later they send back an answer. How do you know they actually solved it? Maybe they ran the real calculation. Maybe they guessed. Maybe they ran a cheaper, sloppier method and pocketed the difference. You did not watch them work.

Now make the problem an AI model with billions of internal numbers, and the stranger a machine in a city you will never visit. This is the central trust problem of decentralized AI, and there are exactly three serious answers to it in production today.

The first uses mathematics: a zero-knowledge proof that the right model ran on your exact input, checkable in a fraction of the time the work took. A notarized affidavit, where you check the seal rather than watch the work. The second uses sealed hardware: a trusted execution environment runs the model inside a locked-off region of a chip and signs a statement about what it ran. Attestation, from attestari, to bear witness. Enclave, from clavis, a key. The third uses money and a crowd: a panel of reviewers, each with their own stake at risk if they lie.

The instinct is to ask which one wins, and that is the wrong shape. They sit at different corners of a triangle whose points are trust, speed and cost, and you cannot have all three. Proof is the most certain and by far the most expensive. Hardware is fast and cheap but asks you to trust a chip manufacturer. Scoring is cheapest and gives a statistical guarantee rather than a mathematical one, which for a chat answer is plenty and for a medical decision is not.

This is Basics 2 of 8, the start-here arc. Each episode stands on its own and assumes nothing.

The voices in this show are AI-generated; the research and writing are human. Decentralized AI, layer by layer.