We're Building the Machine Economy in the Wrong Order.

We're building the machine economy in the wrong order.

Two things shipped last week, four days apart, and the market called both progress.

On July 28, S&P Global agreed to buy datacenterHawk, the firm with the most granular read on where compute capacity sits, what it costs, and how it's contracted. S&P already owns the price references for oil, credit, and power. Put datacenterHawk on top of 451 Research and their grid data and you have the makings of a settlement price for compute. Not an exchange. A benchmark, the thing an exchange needs before it can list anything.

A benchmark is not a footnote. It's the load-bearing piece. You cannot have a compute future, a compute swap, or a compute-backed loan until two counterparties agree on the number that settles it. The reference price is what turns a spot market into one you can hedge, lever, and default on. S&P has built that number for four commodities already. Buying datacenterHawk is them starting on the fifth.

Two days later, zerohash launched an Agentic Finance Suite: a regulated rail that lets an AI agent hold, move, and stream money under a single capped authorization, metered in real time. Bolted to it, "Know Your Agent", screening for machine participants, and a seat in the group standardizing machine-native payments.

So in one week: the reference-price layer for compute consolidated, and the settlement layer for machine transactions went live. Price and settlement. Two of the three layers any real market runs on.

The third layer is permission. Nobody shipped it.

The read everyone had

The obvious take is that the machine economy is growing up. Agents can be priced against, and can pay, inside regulated infrastructure. "Know Your Agent" even looks like the governance piece arriving on schedule, an agent-economy version of KYC, the identity check that lets a venue trust who it's dealing with.

That read is wrong in a specific and expensive way.

Knowing an agent is not authorizing it

Knowing your agent is not the same as proving what your agent was authorized to do.

KYC tells a bank whose account it is. It does not travel to the moment of a trade and prove that this position, at this size, against this counterparty, was permitted. In human markets that gap is covered by a stack most people never see, mandates, entitlements, four-eyes checks, an audit trail that records who signed off. The identity check is the front door. The authorization proof is everything that happens after you're inside.

"Know Your Agent" is the front door, relabeled for machines. It screens the participant at onboarding. At the seam where a machine-driven obligation actually becomes real, it says nothing about who authorized that specific obligation, and it produces no proof that travels with the transaction to the venue that has to honor it.

Here's where that bites. An agent is onboarded, screened, cleared. A week later it executes a compute swap that blows through the size its principal actually intended, a bad prompt, a corrupted config, a manipulated input, it doesn't matter which. The counterparty has a settled obligation. Everyone can see the agent's identity; that was the easy part. What no one can produce is the record that says this trade was, or wasn't, inside the mandate at the instant it fired. The identity is known and the authorization is unreconstructable. That's the exact inversion of what a market needs.

In a human desk you'd pull the mandate, the limit, the sign-off, the timestamp, and the dispute resolves because the authorization left a trail. Strip that layer out and you're left arguing about intent after the money moved: which is not a control, it's a lawsuit.

The machine-speed problem

Human markets tolerate a sloppy version of this because they're slow. Authorization can be reconstructed after the fact, someone digs up the email, the ticket, the approval, while the market clears on T+1 or T+2. There's slack in the system to sort out who allowed what.

Machine markets don't have the slack. The whole point of an agent executing compute conversions is that it happens faster than a human can review, in volume a human can't watch. If proof of authorization has to be reconstructed after the fact, at machine speed it never gets reconstructed at all, the next thousand trades have already fired. Authorization that isn't captured at the instant of the decision is authorization you don't have. Onboarding can't capture it, because onboarding happened last week.

What the right layer looks like

A record made at the moment of authorization, this agent, under this mandate, cleared for this action, at this size, in this window, that travels with the agent to the point of execution and can be checked by the counterparty on the other side. Portable. Pre-execution. Independent of whose database the agent was onboarded into. That's the layer nobody shipped last week. It's also the only one of the three that turns a fast market into an auditable one.

None of this is a knock on zerohash. The settlement rail is the harder engineering problem and they shipped it. The tell is where the industry put authorization when it finally reached for it: at onboarding, as a compliance screen. The least durable place in the stack. Identity in a database, not proof on the wire.

The order is always wrong

This is the pattern, and last week was the cleanest instance of it yet: the machine economy is being financialized faster than it is being authorized. We keep building the ability to transact a machine-driven obligation before the ability to prove who permitted it. Price arrives. Settlement arrives. Permission gets bolted on last, in the wrong layer, and only once something forces the question.

I've watched that sequence resolve in four or five physical markets. It never runs in the right order. The governance layer is never built while the market is exciting; it's built after the first default, the first manipulation case, the first audit that can't answer "who authorized this." Metals got an authorized-dealer regime after the damage. Energy got EFP reporting after the damage. Every time, reactively, expensively, in that order.

Compute is the first one I've watched lay down the price and settlement layers this fast: which means the seam between them is opening this fast too. S&P is assembling the reference price. zerohash shipped the settlement. The obligations those layers create will move at machine speed. And the proof of who authorized them still doesn't travel.

Close

"Know Your Agent" isn't the authorization layer. It's the market saying out loud that it knows the layer is missing, and building it in the wrong place anyway.

Watch which piece gets built next, and where. If proof of authorization ends up living at onboarding instead of at the seam, we'll have priced and settled a market we still can't audit, and we'll find out the same way we always do, after the first trade nobody can explain.

Max

Disclosure: Accords, where I'm Executive Chairman, is a portfolio position I chair.

Max Curnin has spent 11 years and 45+ investments on the physical rebuild of the economy, energy, compute, robotics, and the materials underneath. He writes The Agent Economy on the category he invests in.