The Unpriced

The cost of instantiating an agent has collapsed to near-zero. The cost of governing one has not.

That sentence is the whole argument, and almost everyone deploying agents at scale is living on the wrong side of it. Spinning up the thousandth agent is a button. Naming its scope, defining the verbs it’s allowed to use, deciding whether it can touch production — that is still irreducibly expensive, still human, still the part nobody wants to pay for. The two costs used to travel together. Now they’ve split, and the gap between them is where the failures live.

Here is the part I want to be honest about before I indict anyone: the savings are real. A leader who retires four headcount and stands up a fleet does watch the labor line drop next quarter. The win is legible, immediate, and bonus-eligible. This is not a story about executives who don’t understand spreadsheets. It’s a story about executives who understand them perfectly — who are optimizing exactly what the board measures, and getting precisely the number they were promised.

That’s what makes it dangerous. A misunderstanding you can correct with a memo. This isn’t a misunderstanding. It’s a correct local optimization with a cost it can’t see.

The cost didn’t disappear. It moved.

They’re not saving money. They’re relocating it — from a line item everyone can see to one nobody is tracking yet.

Labor sits on the P&L. It is visible, recurring, resented, and therefore governed. Every head is justified, reviewed, and defended on its own merits. The discipline is brutal precisely because the cost is in the light. The cost of ungoverned autonomy does not show up there. It accrues off-balance-sheet, as contingent liability: the nine-second production deletion, the quiet data exfiltration, the compliance breach discovered two quarters late, the customer trust you cannot repurchase at any token price.

You didn’t reduce cost. You wrote an unhedged option and forgot to price the premium. It looks like savings only because the money moved to a ledger your accounting doesn’t keep.

I had reached for immeasurable here, and it’s the wrong word — it overclaims, and overclaiming is how an essay loses the room. The incident cost is not immeasurable. It is brutally measurable the day it lands; finance will have it to the dollar by Friday. What’s missing isn’t the measurement. It’s the instrument to price it at decision time — before you commit, while the choice is still open and the number is still hypothetical.

That distinction is the entire essay, because it tells you what governance actually is. Governance is not the paperwork you add when the risk is obviously large. Governance is the instrument that prices the tail before you take the position. Skip it and you have not avoided the cost. You have only blinded yourself to it until it arrives — with interest, and on a date you don’t control.

The costs that aren’t tokenomics

When people argue the agent economics, they argue tokens. Tokens are the cheapest thing in the building. The expensive costs don’t have a unit price:

Accountability doesn’t transfer, because there’s nothing on the other end to hold it. Fire the human and the accountability doesn’t leave with them — it has nowhere to go. An agent has no persistent legal or financial state-register; it cannot be sued, cannot be fired, cannot carry a liability on its own books. So the accountability doesn’t transfer to the fleet. It stays where it was and travels up — back to the leader who deployed, usually arriving at the worst available moment. You moved the locus of the work. You did not move the liability, because the thing you handed the work to is constitutionally incapable of receiving it.

You deleted the skepticism and called it efficiency. The human you replaced wasn’t only executing. They were the calibration layer — the this feels wrong circuit breaker that no agent possesses unless you deliberately build it in. You can engineer that doubt back; it is buildable. But the default fleet ships without it. The org had a distributed sense of unease, and you optimized it out without noticing it was load-bearing.

The coordination tax doesn’t vanish when you fire the coordinator. It gets repriced as chaos. The org structure was doing governance work implicitly — the meetings you hated, the sign-offs you resented, were a slow human consensus engine, and part of what it quietly serialized was access to shared state. Two humans don’t both rewrite the same record on the same afternoon, because the standup already deconflicted them. Remove that engine and the deconfliction doesn’t survive in the substrate: now a dozen agents converge on the same write with no one sequencing them, and the race condition the org chart used to prevent ships to production as a feature. Conway’s revenge: the system you deploy inherits the communication structure you dismantled — including the absence where the coordination used to be.

The recursion nobody wants on the page

Here is the turn, and it’s the one with teeth.

The decision to deploy ungoverned agents is itself an ungoverned action.

Not ungoverned in the sense that no one approved it — it cleared a budget, a board, a quarterly plan. It was heavily governed with respect to cost. It was ungoverned with respect to the only variable that detonates. The approval process priced the labor it removed and never priced the liability it created; it adjudicated the savings and waved through the tail. So the strategic decision and the runaway agent share a structure: a confident actor making an unpriced change to a system it does not fully model, having governed everything except the thing that fails.

A leader pushing a fleet to production with no adjudication of the downside, no scope on the blast radius, no reversibility — that leader is the agent in the failure story. One actor, full verbs, no gate, optimizing for speed over should this happen at all. The catastrophe everyone points at in the fleet is a faithful, fractal reproduction of the catastrophe in the hand on the deploy button.

So the piece was never “agents need governance.” The sharper, more uncomfortable claim is that the leaders deploying them are failing the exact test they’re imposing on the machines. And the gap propagates by a real path, not a metaphor: the leader’s unpriced directive becomes a scope with no gate, becomes a verb set with no adjudicator, becomes an execution plane with no one positioned to say should this happen at all — each layer faithfully reproducing the omission above it, because nothing in the chain was ever instrumented to price what the top declined to price. The governance gap doesn’t start in the fleet. It starts at the top and flattens downward through every interface — the way children inherit the anxieties no one upstairs admitted to having.

Is there ever a zero?

The honest objection — and the one worth more than the indictment — is: fine, but surely some agents have zero blast radius. The throwaway in the sealed sandbox. The Monte Carlo swarm where noise is the method. Govern those and you’re just adding ceremony.

I wanted that exception to be real. It isn’t. Watch it fail twice.

The sandbox feels like zero — no network, no persistence, contained. But the output still goes somewhere: into your head, into a doc, into a decision, and a confidently wrong number inside a sealed box has a blast radius the size of whatever you do next believing it. The containment was spatial; the risk was epistemic, and epistemic risk does not respect container walls.

The Monte Carlo case is subtler and fails the same way. Surely here the noise is the point — no single output composes, errors wash out. But that only moves the risk up a level, onto the independence assumption: the belief that the errors are uncorrelated. Poison the shared prior, and the swarm agrees catastrophically, for a correlated reason, with the serene confidence of a thousand voices. You didn’t eliminate the risk. You relocated it to an assumption you never governed and never named — and load-bearing assumptions are the ones that fail loudest.

So: there is no zero. There is only ever a bound — and “zero blast radius” is the name we give a bound we declined to compute.

The thesis

There is no ungoverned action with zero consequence. There are only consequences you’ve priced and accepted, and consequences you’ve declined to price and renamed zero.

Governance is not the thing you bolt on when the blast radius is large. Governance is the act of computing the blast radius at all. The honest practitioner never says “the risk was zero.” They say: I priced it. Expected cost was forty dollars. I accepted it. Here is my reasoning. That sentence — unglamorous, auditable, complete — is governance. The person who cannot produce it did not discover a zero. They skipped the calculation and called the silence safety.

You can build a system that does this out loud. An agent that reports I believe this at 0.6, sourced from one unverified channel, and acting on it touches prod has priced itself — it has stated its own blast radius instead of hiding it. That is not safety theater. That is the machine performing the calculation the leader refused to.

But watch what that instrument can and cannot price, because it’s the whole game. The agent priced its confidence in its own reasoning. It did not — could not — price the independence of the feeds underneath it. Go back to the poisoned prior: every agent in that fleet reports high confidence with flawless attribution, each one having honestly priced itself, all of them wrong for the same reason none of them can see. Self-pricing is a bound, not a zero. It bounds the error the agent can introduce on its own. It is structurally blind to the error injected one layer down, into the shared assumption it never had standing to audit.

So even the instrument has a blast radius it declined to compute — and the “no zero” goes fractal all the way down. The agent prices its own reasoning. The next layer up has to price the independence of the inputs the agent couldn’t see. At no level does the calculation bottom out in a tool. It terminates in a person who knew which assumption was load-bearing and chose to audit it — or didn’t, and called the silence safety.

Which is where the two halves of this essay turn out to be one sentence. The cost that moved from labor to liability, and the leader who was the first ungoverned agent, are the same fact seen from two altitudes: at every level of the stack, a human either computed a bound or renamed it zero. The exec pricing the savings and not the tail. The architect pricing the agent and not the feed. The agent pricing its reasoning and not its prior. The failure is identical at each scale and it is always the same omission, just wearing a different title.

That’s the protocol that holds across scales, which is the only kind this series cares about: the cost moved, so someone has to follow it. The risk got renamed, so someone has to rename it back. And the calculation doesn’t scale, so it always, finally, lands on a person. The fleet is free now. The pricing is not, and it never will be, because the thing being priced is the one thing that was never a token cost to begin with — the judgment of which problem you actually have.

They computed the bound before they called it zero.

“Zero blast radius” isn’t a category of safe action. It’s the sound a risk makes right before you stop looking at it.