Agents are already buying things
A broken laser pointer, sold for $14.83. Every coordination layer gives rise to new marketplaces.
While you were reading the news this morning, an agent somewhere was paying $0.003 for a satellite image tile. Another was settling a streaming session of microtransactions for market data. Another was authenticating with a signed wallet proof to access a proprietary research index. None of them asked a human for permission. None of them used a credit card.
Last month I tried to join them. I asked an agent to compile a market analysis for a neighborhood in Seoul. It needed three things: satellite imagery of recent construction, social sentiment from a local review aggregator, and foot traffic estimates from a mobility data vendor. It found all three endpoints in seconds, knew exactly what data it needed, and began making requests.
402 Payment Required.
It tried the second. 402. The third required a signed wallet proof just to authenticate. The agent sat there — a mind with perfect knowledge and no way to act on it. Total cost if it could have paid: $0.47.
I’ve been delegating to agents for the past year — research, code review, competitive analysis, content drafts. They’ve changed how I work more than any tool in the last decade. I think at a higher altitude. Problems that used to take afternoons now resolve while I sleep. But the same wall keeps appearing: the agent reaches the edge of what’s free, and stops. It becomes my job to bridge the gap — copying API keys, manually approving $0.12 charges, re-explaining context that should have carried over. I’m the bottleneck in my own delegation chain.
The infrastructure to fix this partially exists. Coinbase shipped x402 — USDC micropayments via signed HTTP headers. Stripe and Paradigm launched the Machine Payments Protocol on Tempo’s mainnet, settling thousands of microtransactions as one. Visa extended MPP to card rails. Over a hundred providers have integrated, from Anthropic to Shopify. The building blocks are here. But my Seoul agent’s three endpoints each speak a different payment language. No single integration handles all of them.
The ceiling on what these minds can do isn’t their intelligence. It’s the infrastructure around them.
The harder problem
But suppose the agent could pay. Should it?
It found a satellite provider I’ve never heard of, offering the same imagery for $0.02 less. Should it use the cheaper vendor? The mobility data endpoint quoted $0.12 last week but now wants $0.35. Should it pay the new price? What if the total crosses $5? $50? What if it discovers a fourth data source that would improve the analysis — and it costs $3?
You recognize this problem. You’ve lived it every time you onboarded a new hire, gave someone a corporate card, or delegated a budget. You don’t hand over an unlimited card and say “figure it out.” You define a spending authority. You specify approved vendors. You set limits.
This is the principal-agent problem, one of the oldest challenges in economics, now playing out at machine speed. An agent acting on your behalf, faster than you can supervise, without knowing your priorities — it isn’t acting for you. It’s just acting.
Agency without alignment is chaos with a budget.
Alignment as infrastructure
The way to maximize what an agent does for you is to constrain it more precisely.
Tell it which vendors to trust. Tell it how much it can spend. Tell it which protocols to prefer. Each constraint feels like a limitation. But each one is actually a signal — it teaches the agent how to act as an extension of you rather than an approximation of you. My Seoul agent doesn’t need to be smart enough to evaluate an unknown satellite provider. It needs to know I haven’t approved that provider. That’s a simpler problem, and a solvable one.
The more signals you provide, the more confidently the agent operates, the more you trust it, the more you delegate, the more it accomplishes. An agent with no alignment configuration is undeployable — not because it’s incapable, but because you’d never let it act.
Alignment compounds.
Mindpass
This is the problem Mindpass solves. Here’s what my analysis agent looks like with it:
const router = createRouter({
methods: [
createX402Method({ account }),
createTempoMethod({ account, store: state }),
createSiwxMethod(),
],
state,
policy: [
// Spending authority: up to $1/day
{ type: 'budget', currency: 'USDC', limit: '1000000', window: 'daily' },
// Prefer x402 when multiple protocols are available
{ type: 'prefer-protocol', protocol: 'x402', boost: 0.2 },
// Only these providers
{ type: 'allow-realm', realms: ['api.geospatial-provider.com', 'data.mobility-vendor.io'] },
],
});
const paidFetch = wrapFetch({ fetch, router, state, wallet });The agent calls paidFetch(url). Mindpass handles the rest: detecting which payment protocol the endpoint requires, evaluating candidates against policy, scoring by cost and reliability, signing the credential, retrying the request. The agent never needs to know which protocol is behind the door.
The unknown satellite provider? Blocked by allow-realm. The $0.35 price spike? Passes — it’s within the daily budget. A surprise $50 endpoint? Rejected before a credential is ever signed.
Here’s what happens on every request:
Your agent calls fetch(url)
│
▼
┌─────────────────┐
│ Mindpass layer │
└────────┬────────┘
│
┌───────┴────────┐
│ 200 OK? │──── yes ──── Done ✓
│ Pass through │
└───────┬────────┘
│ 402
▼
┌────────────────┐
│ Detect │ What protocols does this
│ candidates │ endpoint accept?
└───────┬────────┘
│
▼
┌──────────────────┐
│ Policy filter │ Does my operator's policy
│ │ allow this transaction?
└────────┬─────────┘
│
▼
┌──────────────────┐
│ Score & select │ Which option best aligns
│ │ with my operator's intent?
└────────┬─────────┘
│
▼
┌──────────────────┐
│ Sign & retry │ Present credential,
│ │ complete transaction
└────────┬─────────┘
│
▼
Done ✓
Every decision is logged: what candidates were available, how they scored, which policy rules applied, what was selected and why. The agent acts, and you understand why.
Delegation without abdication.
What this makes possible
Mindpass solves a problem for one agent and one operator. But the problem doesn’t stay small.
Every person in this room had a specific role, a specific authority, and a shared protocol. No one could have landed on the moon alone. (NASA, 1969)
Every leap in human coordination — from tribes to cities to nations to global markets — required governance infrastructure. Laws, institutions, currencies, contracts. The infrastructure didn’t limit cooperation. It made cooperation possible.
The same pattern holds here. The internet gave us eBay and Amazon. Mobile gave us Uber and Airbnb. Social gave us the creator economy. When agents can transact autonomously — governed by their operators’ intent, constrained by explicit policy, auditable at every step — an entirely new generation of marketplaces becomes possible. Markets where minds discover, evaluate, and purchase services at machine speed, on behalf of the people who deployed them.
That’s why Mindpass is open source. If this layer becomes the foundation of how agents participate in the economy, it can’t belong to one company. It has to be a public good.
The question we haven’t answered
The analysis agent transacts with three vendors. But what happens when those vendors are also agents?
One agent needs foot traffic data. Another agent’s service provides it. The seller’s policies say charge $0.05. The buyer’s policies say don’t pay more than $0.03. There’s no human on either side of this transaction. Who sets the price? Who arbitrates? What does negotiation look like when both parties reason at machine speed, governed by policies written by people who are asleep?
Mindpass solves the human-to-agent alignment problem. The agent-to-agent alignment problem — agents transacting with agents, policies negotiating with policies, trust emerging between autonomous economic actors — is the next frontier.
At Curation Labs, we’re building toward it. If this is the kind of problem that keeps you up at night, come build with us.
Try it now:
brew tap remyjkim/mindpass && brew install mindpass# or via npm
npm install -g mindpass-cli