Subnet 21 is a labor market. Treat it like one.

I have been operating a validator on Bittensor subnet 21 for fourteen months. The rig is a Rust fork of the reference validator. The weighting rubric is published in plain text alongside the code. Thirty-day uptime is 99.98%. The hot wallet is cold-key separated and the cold key has never left a Faraday pouch. None of that is the point of this essay. The point of this essay is that I am increasingly convinced the most useful frame for understanding what is happening on a subnet is not incentive design. It is labor economics.

Most writing about Bittensor subnets is about incentive design. Token emissions, validator weights, the game theory of who farms whom. The vocabulary is borrowed from cryptoeconomics. The diagrams show flows of TAO between addresses. The conclusions are usually variants of if we change parameter X to Y, the equilibrium shifts in direction Z.

I want to flip the frame. A subnet is a labor market. Miners are workers. Validators are foremen. The chain is the wage clearinghouse. Once you see the system that way it is hard to unsee. And labor markets that race to the bottom always look the same.

The thing miners are doing is work.

A miner on subnet 21 is a process running on somebody's hardware. The process accepts a query from a validator, runs an inference, returns a response. The validator scores the response. The chain pays the miner a small amount of TAO proportional to the score.

The hardware costs money. The electricity costs money. The bandwidth costs money. The operator's time setting it up costs money. The miner is providing labor in exchange for a wage. Three claims in that sentence. None of them are controversial in the labor-economics literature. All three of them are controversial in the cryptoeconomic literature, where the standard frame insists the miner is a participant in a protocol rather than a worker in a job. The participant framing is a useful fiction for the people who designed the protocol. It is a worse fiction for the people running the GPU.

The validator is a foreman.

I run a validator. I set the rubric. I weight the responses. I decide which miners get paid and how much. When I push a rubric change to the repo, miners that were earning $80 a day in the morning are earning $30 a day by dinner. I can defend the rubric. I publish it. The miners can read it. But the asymmetry is real. The foreman picks the work. The foreman picks the rate. The foreman is paid out of the same wage pool, in proportion to the work he assigned and the network's confidence in him.

That last clause is doing a lot. A subnet validator earns from the same emission stream the miners earn from. The validator's stake decides his slice. The miners cannot quit and reorganize as a different subnet. They can switch subnets, but the cost of moving the rig is real and the next foreman might be worse. This is gig-economy stratification with extra steps.

What the reward design produces.

Here is what fourteen months of operation looks like, with numbers, on the rig I run:

• Median daily emission to the top decile of miners on subnet 21 over the last 90 days is roughly 3.4× the median daily emission to the bottom decile.
• Median operating cost per miner (electricity + bandwidth + amortized hardware, conservatively estimated for an RTX 4090 rig at $0.18/kWh) is in the $14–$22 per day band.
• That means the bottom decile of miners is earning net negative most days. They keep running because the next rubric tweak might lift them, or because the operator is staking on token appreciation, or because they have not done the arithmetic.
• The top decile is earning a wage that on a unit-of-skilled-engineering-labor basis is competitive with a junior infra job in San Francisco. The bottom decile is earning a wage that on the same basis is below the federal minimum.

These are not catastrophic numbers. They are ordinary labor-market numbers. The interesting fact is that they are produced by code, not by a hiring manager.

The information asymmetry.

In a regulated labor market — even a bad one — the worker is entitled to a wage schedule. They can look at the rate they are being paid. They can compare it to what other workers in the same job are being paid. They can identify discrimination. They can organize.

In most subnets, the wage schedule is the validator's weighting code. The validator's weighting code is, in the strict majority of cases, not published. The rubric the miners are graded against is a black box. When the rubric changes, the miners learn about it the way wage labor has always learned about a cut: the next paycheck is smaller.

This is the part of the system I am asking the rest of the validator class to fix. Not because I believe the protocol designers had bad intent. They did not. The reference validator behaves the way it does because publishing the rubric would let miners game it, which is true and which is also the universal argument every employer has used against publishing the wage schedule. The cost of opacity is paid by the workers. The cost of transparency is paid by the foreman. We should pay the cost of transparency.

The minimum a validator should publish.

Three artifacts. All public. All reproducible.

1. The weighting code. The function that maps a miner's response to a score and a score to an emission share. In a repo, with a hash that ships with every block your validator signs.

2. The rubric. Plain English. What does a good response look like. What does a bad one look like. What are the edge cases. Where do you defer. The rubric should be readable by a miner with no Rust experience, because the rubric is not a developer document. It is a wage schedule.

3. The uptime. A rolling thirty-day number, signed and publishable. Mine is 99.98%. If it ever drops, that should be visible in the same channel the rubric is published in. A foreman who is sometimes asleep is a foreman who pays miners less than they earned.

None of these are radical. All three are work. I have shipped all three for my validator. The repo is open for audit and the rubric is a one-page Markdown file. If every validator class on the network shipped the same three artifacts, the labor market on a subnet would behave more like a regulated craft trade and less like a 2014 ride-share app.

The Open Ladder bet.

The reason I am writing this essay on openladder.tech instead of on a personal log is that this is exactly the pattern Open Ladder is trying to open-source. Reference rubrics, reference validators, reference public-uptime feeds. Tools and patterns that move the median validator on the network from opaque toward auditable. The work is unglamorous. It is mostly Markdown. The point is to lower the cost of doing the right thing for the next operator who sets up a rig.

I run the capital arm of this same network at closedladder.com and I keep the corrections-tech sister at behindbars.tech. The thread that runs through all three is the same: in markets that are slow, sensitive, or under-attended, the operator who publishes the spec wins on durability what the closed competitors win on speed. The closed-ladder thesis applies to a foundry, to a reentry app, and to a subnet. Decentralised AI, done correctly, is a system where the production of useful AI capability is not gated by a single operator and where the value flows to the people who produced it. Right now the value is flowing to the people who control the rubric. Publish the rubric.

The unromantic conclusion.

If you are a validator and you have read this far, the ask is concrete. Open the repo. Publish the rubric. Sign the uptime. Take the small hit on gaming risk for the larger gain in legitimacy. The miners on your subnet are workers. The work they are doing is real work. The wage you set is a wage. The chain is not a magic clearinghouse. It is a public ledger of how you treated the people who showed up to do the job. Treat the labor market like one.