Writing

I write when I have something I haven't seen written elsewhere. That bar keeps most things out.

The Infrastructure Problem Nobody Is Building For

March 2026·In progress

When an AI agent books a flight, pays a contractor, or settles a trade — who is the economic actor?

The answer matters more than people realize, because the entire payments infrastructure we've built assumes the actor is a human. There's a person with an identity, a bank account, a liability to bear.

AI changes every assumption.

I've been mapping this problem since mid-2024. It started with stablecoin payment rails — the obvious entry point for anyone who's spent time in DeFi. But the more I dug, the more I realized the payments rails are actually the easy part.

The hard problems are:

Identity. When an AI agent transacts, who is responsible? The model? The company that deployed it? The user who prompted it? None of the existing identity frameworks handle this. Not Web3 identity (designed for human wallets), not traditional KYC (designed for persons), not corporate liability (designed for legal entities).

Trust. Marketplaces work because participants have reputation at stake. How does an AI agent build reputation? How does a merchant know the agent won't dispute a charge, or that the agent's principal will honor the commitment made? These aren't technical problems. They're coordination problems that need new primitives.

Settlement. At scale, agentic commerce means millions of micro-transactions between autonomous actors, often in fractions of a second. Current blockchain finality assumptions and gas fee structures weren't built for this. Neither was Stripe.

I'm building a working thesis on the architecture that needs to exist. It's incomplete. I'm publishing it anyway because incomplete thinking shared publicly is more useful than finished thinking kept private.

Coming up

What We're Getting Wrong About “Agentic Payments”

The discourse has converged on a bad frame: take existing payment rails, add an AI agent on top, call it agentic commerce. This essay is about why that frame produces the wrong infrastructure and the wrong failure modes.

The reason most “agentic payments” proposals don't work isn't technical. It's that they assume the hard problem is velocity — moving money faster, with less friction, across more surfaces. That's not the hard problem. The hard problem is authorization: by what mechanism does a marketplace trust that an AI agent can commit its principal to a transaction, and what happens when that trust is violated? Stripe doesn't know how to answer this. Neither does SWIFT. The answer probably doesn't look like either of them.

Rails, Wallets, Agents, Principals

A map of who is actually liable when an AI agent pays a human — or when a human pays an AI, or when two agents transact with each other. The legal and technical abstractions we have don't line up. This essay tries to draw the diagram.

When you hand your assistant a credit card and say “book the flights,” something interesting happens legally: you've extended your liability to another party. If they book the wrong flights, you dispute the charge. If they commit fraud, you bear the cost. The liability chain is messy but coherent — it runs through a person who can be held responsible. Now replace the assistant with an AI agent. The liability chain doesn't just get complicated. It breaks.

The Boring Part of AI Commerce

Disputes. Reconciliation. KYC. Fraud detection. All the infrastructure nobody talks about until it's missing. This is an essay about the unsexy prerequisites that have to work before any “AI-native commerce” vision is real.

Every payments product eventually hits the same wall: not the happy path, but the exception path. A charge disputed three months later. A reconciliation that doesn't balance. A transaction flagged for review at 3am with no human to make the call. For AI-initiated payments, we have none of that. And the exception rate is going to be higher, not lower, because agents fail in ways humans don't.

Follow on X for the unfinished version.