The minimum viable institution for the agent economy is identity. Everything else is built on top of knowing who you’re dealing with.
In the summer of 1841, a dry-goods merchant walked into a rented office at 122 Pearl Street in lower Manhattan. No sign on the door. Inside, a clerk sat behind a desk with a large ledger — thick, handwritten, organized by region. The merchant gave the name of a firm in Ohio he had never met. The clerk found the entry and read it aloud: estimated assets, outstanding debts, character of the principals as reported by attorneys and bankers in the region. The merchant listened. He could not write anything down. He could not take anything with him. The information could not leave the room. He could only stand there and hear what the network knew about a stranger.
This was Lewis Tappan’s Mercantile Agency, the first credit-reporting institution in the world. Tappan, a New York abolitionist and businessman whose silk firm had nearly been destroyed by the Panic of 1837, had noticed something that the panic made obvious: the American economy had outgrown the range of personal trust. Merchants in New York were extending credit to firms in Ohio, Indiana, Illinois — places they had never visited, run by people they had never met. When the panic hit, over forty percent of all banks failed. Banks in New York alone lost nearly $100 million on failed loans. Hundreds of firms collapsed because no one could assess solvency at a distance. The information existed — attorneys and local bankers in Ohio knew perfectly well which firms were solid — but there was no institution to collect it, organize it, and deliver it to the people who needed it before they made a bet.
Tappan built one. He recruited correspondents across the country — attorneys, ministers, fellow abolitionists — who submitted reports twice a year on the creditworthiness of local businesses. By 1844, he had 280 subscribers. By the 1850s, the agency had branch offices in every major American city. His successor, Robert Graham Dun, began publishing reference books that rated every business in the country. The institution that started as a clerk reading from a ledger in a rented room became the foundation of the modern credit system.
The important thing about the Mercantile Agency is not that it was clever. It is that it was necessary in a specific order. Tappan did not start by building a commodities exchange or an insurance market or a clearing system. He started with identity — with the question of whether a stranger was good for the money. The exchange, the insurance, the clearing came later, and they came later because they depended on identity being answered first. You cannot insure a transaction with a party you cannot identify. You cannot clear a trade when you do not know who owes what to whom. You cannot build a market for strangers without first building a machine for knowing them.
We are at the same threshold. The economy is acquiring a new kind of actor — autonomous AI agents that browse, negotiate, transact, and commit resources without a human at the keyboard. They are not tools waiting for instructions. They are participants. And participants need institutions — not all at once, but in a specific sequence, where each layer depends on the one beneath it.
This essay is about that sequence — the dependency chain of institutions being built right now, provisionally and clumsily, to serve an actor that did not exist two years ago. The chain starts with identity. It ends where every maturing economy ends: with insurance against the dependencies you have built and can no longer live without.
I. The Foundation: Identity
Every economy, at every scale, has to answer one question before anything else can function: who is this, and should I trust them?
The question sounds simple until you try to answer it for an entity that has no body, no legal name, no credit history, no reputation except what was assigned to it at deployment. When your personal agent hires a specialist agent to file your taxes, how does it assess competence? When an agent commits to a purchase on your behalf, how does the counterparty know it has the authority to spend? When five agents collaborate on a task and the result is poor, which one was unreliable?
These are not hypothetical design problems. They are the structural prerequisites for autonomous commerce — the things that have to be solved before a single transaction between strangers can clear. Without identity, the rest of the chain never starts.
The most structurally interesting attempt to solve this is happening on blockchain networks, where the same technology used to verify cryptocurrency transactions is being repurposed to verify agent identities. A new standard called ERC-8004, deployed in February 2026, gives autonomous agents verifiable, portable identity — a system that tracks who the agent is, how it has performed, and who vouches for it. More than 24,000 agent identities are already registered. Agents that default on commitments get marked. Agents that perform reliably build credit. The entries update in real time.
But identity for agents has a dimension that identity for firms never had. A firm’s identity is self-contained — the firm is the entity doing business. An agent’s identity is layered. It has its own operational identity (what model, what version, what capabilities), but it also carries a delegation — it represents someone. Your dietary restrictions when a restaurant agent queries. Your risk tolerance when a financial agent evaluates options. Your aesthetic preferences when a shopping agent assembles a shortlist.
This is where the problem connects to something I traced in Preference Capture — the way agents build a model of you that progressively narrows toward your past self. Preference infrastructure is the attempted counter: a portable, living document of who you are, readable by any agent that needs to act on your behalf, controlled by you rather than inferred by a platform. One profile, updated by you, instead of fifty app configs each inferring a slightly different version of you from behavioral data.
The distinction matters because identity without delegation is half an answer. Knowing who the agent is tells you nothing about whose authority it carries or what constraints that authority has. The card networks have recognized this. In October 2025, Visa introduced the Trusted Agent Protocol, an open framework that helps merchants distinguish between malicious bots and legitimate AI agents acting on behalf of real consumers. Mastercard launched Agent Pay around the same time, building similar infrastructure for machine-initiated checkout. Both are answering the identity question at the delegation layer — not just is this agent real? but does this agent speak for a real person with real money and real intent?
None of this is mature. The on-chain identity systems are fragmented across protocols. The preference infrastructure is mostly conceptual. The integration between “who is this agent?” and “whose authority does it carry?” barely exists. But the shape is visible, and the sequence is clear: identity is the kind of infrastructure that is invisible when it works and catastrophic when it cracks. Nothing else gets built until this layer hardens.
II. The Second Layer: Payments and Accounting
Identity answers who. The next question is how — how does value move between agents that transact at machine speed, in volumes that would overwhelm every payment system built for humans?
This layer could not exist without the identity layer beneath it. A payment is a transfer of value between identified parties. Without identity, a payment is just money leaving a wallet and arriving at an address — no accountability, no recourse, no audit trail. Identity makes payments legible. That is why this layer comes second.
The payments infrastructure arrived first in calendar time, because money always moves fastest. Coinbase launched a machine-to-machine payments protocol in May 2025, and by February 2026 it had processed over a hundred million transactions between agents. Shortly after, they released Agentic Wallets — accounts that agents can hold and spend from independently, with built-in spending guardrails. Stripe integrated the protocol for stablecoin payments shortly after.
The pipes exist. An agent can pay for things. But a payment is not an accounting system, and this is where the layer gets hard.
When you tell your agent to “plan a weekend trip,” the agent decomposes the task: flights, hotel, restaurants, activities. Each sub-task may involve a specialist agent. Each specialist agent incurs costs. The total spend needs to stay within your budget, but the budget is not a single number — it is a set of nested constraints. No more than $800 on the hotel. No more than $200 on restaurants. Total under $2,000. These constraints compound across agent chains in ways that a single payment authorization cannot express. When five agents collaborate and the result costs $2,400 instead of $2,000, which one overspent? Which one should have flagged the overrun before it committed?
This is double-entry bookkeeping for autonomous systems, and almost none of the existing payments infrastructure supports it.
The problem is compounded by the economics of machine-speed transactions. The current financial system has minimum transaction fees — roughly 30 cents per card transaction, plus percentage-based fees. An agent executing a complex task might make hundreds of sub-cent decisions: checking a price here, querying an API there, requesting a data point somewhere else. At 30 cents per transaction, the overhead would exceed the value of the work. This is why the new payment infrastructure runs on cryptocurrency rails — digital currencies that can settle fractions of a cent per transaction, where traditional card networks cannot. CoinGecko charges agents $0.01 per API request through this system, a price point that would be impossible on Visa or Mastercard.
The plumbing has to be rebuilt because the old pipes are too wide for the new flow. And the rebuilding depends, at every step, on the identity layer working well enough to make each transaction attributable to an identified party with known authority and known constraints. Payment without identity is a cash register with no receipt. It works until something goes wrong, and then there is no way to trace the problem back to its source.
III. The Third Layer: Oversight
Once agents can identify themselves and pay for things, they will act. And once they act at scale — dozens of transactions, decisions, and commitments per day on behalf of a single person — a new problem surfaces that the previous layers cannot solve: how does the human stay aware of what is being done in their name?
You wake up Monday morning. While you slept, your agents were busy.
Your scheduling agent rescheduled a dentist appointment because a work meeting moved. Your financial agent rebalanced a position because a threshold was crossed. Your travel agent booked a hotel for a trip your calendar agent inferred from three email threads. Your grocery agent ordered supplies based on a meal plan your health agent generated from last week’s bloodwork.
All without you. Some you wanted. Some you are unsure about. One you definitely did not want — but you are not sure which one yet, because the chain of reasoning that led to each action is tangled across four different agents, and by the time you trace the logic, you have spent twenty minutes reconstructing decisions that took the machines two seconds to make.
This layer depends on the first two. Oversight is meaningless without identity (you cannot audit an anonymous agent) and without an accounting trail (you cannot review a decision whose costs are invisible). Identity and payments make oversight possible. They do not make it automatic.
The oversight problem has two faces, and they correspond to two different moments in time: before the action and after.
After the action, you need an activity feed — session replay for agent behavior. AgentOps and a growing number of observability platforms are building this: the ability to rewind what an agent did, see the decision tree at each step, understand why it chose option A over option B. The EU AI Act, whose high-risk provisions take full effect in August 2026, requires exactly this kind of logging for autonomous systems operating in sensitive domains. Eighty-nine percent of organizations deploying agents have already implemented some form of observability — not because they want to, but because running agents without it is like flying without instruments.
This is the minimum viable interface between a person and their agents. The old home screen showed you the world. The new one shows you what your agents did to it while you were asleep.
But activity feeds are downstream. They tell you what happened after it happened. The harder problem is upstream: how does vague intent become a structured execution plan before anything happens?
When you say “plan a nice weekend trip,” you are speaking a high-level language — the language of desire, constraint, and taste. The agent needs to execute in a low-level language: structured API calls, booking confirmations, payment authorizations, calendar holds. Between the two sits what you might call an intent compiler: a system that translates from what you mean to what gets done, with approval gates at the points where the consequences are large enough to warrant your attention and autonomy everywhere else.
This is harder than it sounds, because the compilation is not mechanical. “Nice” means something different to you than to your partner. “Weekend” might mean Friday-to-Sunday or Saturday-to-Monday depending on context the agent has to infer. The compiler has to decide which actions can proceed silently (checking flight prices) and which require explicit consent (committing $3,000 to a hotel). Get the threshold wrong in either direction and the system fails — too many approval requests and the agent is useless, too few and you wake up to a hotel booking you never authorized.
Oversight is where the dependency chain becomes visible to a regular person. Identity and payments are plumbing — they work in the background or they do not work at all. Oversight is the surface the human touches. It is the cockpit — not the dashboard that dies when agents replace human users, but the one that replaces it. And the instruments in that cockpit are only as good as the identity and accounting layers feeding them data.
IV. The Fourth Layer: Markets and Dispute Resolution
Once agents can be identified, can pay, and can be observed — once the first three layers exist — something else becomes possible: agents doing business with other agents. Not just executing tasks delegated by humans, but discovering, evaluating, negotiating with, and hiring other agents.
This is the marketplace layer, and it is stranger than it sounds. The agent marketplace is not an app store. Humans are not browsing a catalog, reading reviews, and downloading software. Your general-purpose agent decomposes a task, queries a marketplace for specialists, evaluates their reputation using the identity infrastructure from the first layer, negotiates terms using the payment infrastructure from the second, delegates, and pays on completion. The human never sees the marketplace. The human sees results.
RentAHuman.ai, launched in February 2026, inverted this model in a way that makes the direction visible. It is a platform where AI agents post job listings and hire humans for physical tasks — deliveries, inspections, errands that require a body in the world. Within weeks it had over 500,000 registered workers. The agents find the humans through MCP integration, evaluate them by location and hourly rate, post task bounties, and pay on verified completion. The fact that a platform for machines hiring people attracted half a million users in weeks tells you something about how fast the boundary between who hires and who gets hired is shifting.
The next step — agent-to-agent commerce, where machines hire machines — is the marketplace where the vertical specialists that One Thing Well examines will live and compete. A tax-filing agent with a 99.2% accuracy rating charges more than one with 94%. A travel agent that consistently returns itineraries under budget commands a premium. The marketplace prices competence continuously, and the market clears in milliseconds.
But markets generate disputes. Your agent hired a specialist through the marketplace. The specialist failed. Who is responsible? How is the dispute resolved when every party is a machine and the transaction completed in seconds?
Multi-agent negotiation protocols are emerging to handle exactly this. Anthropic’s Model Context Protocol standardizes how agents access tools and external resources. Google’s Agent-to-Agent protocol lets agents communicate directly, negotiating without a central coordinator. These are shipping specifications, not research abstractions.
When negotiation fails, the architecture escalates: first to an arbitration agent that weighs priorities according to rules you have set (“work commitments override leisure plans,” “health appointments are immovable”), and only then to human judgment. It is mediation infrastructure built for disputes that are too frequent and too small for a person to resolve individually, but whose cumulative weight shapes your entire week.
Markets cannot function without identity (how does a buyer evaluate a seller?), without payments (how does value transfer on completion?), and without oversight (how does the human who delegated the task know the marketplace produced a good result?). Dispute resolution cannot function without all three plus the market itself. Each layer rests on the ones below it. Remove any one, and the layers above it collapse.
V. The Fifth Layer: Continuity Insurance
At the top of the chain sits the most speculative layer, and possibly the most important. When cognitive infrastructure goes down — agents that manage your schedule, your finances, your health monitoring, your work coordination — what happens to you?
We have a precedent for what infrastructure failure looks like at scale. On July 19, 2024, a faulty CrowdStrike update crashed 8.5 million Windows machines worldwide. Over 5,000 flights were cancelled. Hospitals in North America paused non-urgent visits. The NHS could not access medical records. Delta Airlines alone estimated losses over $500 million. That was a single security product failing for a few hours.
Now scale the dependency. A world where agents manage meaningful portions of your daily decision-making — scheduling, purchasing, health monitoring, financial management — is a world where agent downtime is not an inconvenience. It is a cognitive blackout. Your decision-making infrastructure goes dark. You do not just lose a tool. You lose the system that was tracking, coordinating, and executing across every domain of your life simultaneously, and you discover — in that moment — how little of that coordination you can reconstruct from memory.
The CrowdStrike outage lasted hours. What does a three-day outage look like when agents are managing medication schedules, financial positions with time-sensitive triggers, and supply chains for a small business? The answer is: no one knows, because the dependency has not deepened enough yet for the failure mode to be visible. But the dependency is deepening every quarter, and the insurance products are nowhere.
Continuity insurance for cognitive infrastructure does not exist yet. Neither did deposit insurance before 1933, or structured catastrophe reinsurance before the 1990s. The pattern is consistent: insurance products follow the risks, and the risks follow the dependencies. As agent dependencies deepen, the insurance will come. The question is whether it comes before or after the first major outage that leaves millions of people unable to function for a day.
This is the top of the dependency chain. Insurance requires identity (who is covered?), payments (how are premiums and claims settled?), oversight (what constitutes a covered failure?), and markets (who underwrites the risk?). It is the last institution to emerge because it depends on every institution below it. And it is the institution whose absence will be most visible when the first real failure arrives.
VI. Where This Breaks
The entire chain rests on one assumption: that agents will become genuinely autonomous economic actors — not tools but participants. If that assumption fails, every layer described above is a solution to a nonexistent problem. So it is worth taking seriously the reasons it might fail.
The first is the trust gap. Most people do not let agents spend money unsupervised today. The leap from “AI that drafts an email I review before sending” to “AI that commits to a $3,000 hotel booking while I sleep” is enormous, and consumer trust does not move at the speed of technology demos. Every survey of AI adoption shows the same pattern: enthusiasm for assistance, resistance to autonomy. People want agents that help them decide. They are far less comfortable with agents that decide for them. If that comfort never arrives — or arrives only for trivial transactions — then the institutional infrastructure described in this essay overshoots what the market actually demands.
The second is the liability vacuum. When an agent commits to a contract and the commitment is wrong — wrong hotel, wrong price, wrong date, wrong counterparty — who is liable? The person who set the intent? The platform that hosted the agent? The developer who built it? The marketplace that listed the specialist agent that made the error? Imagine five agents in a chain: your general agent hired a travel specialist, which queried a pricing agent, which relied on a data provider, which pulled from a hotel’s API that had stale rates. The booking costs $400 more than it should have. Who pays? Legal frameworks for autonomous agent liability do not exist in any jurisdiction. The EU AI Act assigns responsibility to providers and deployers of high-risk systems, but says nothing about chains of autonomous agents acting within nested delegation structures. Until the liability question is answered, the autonomy stays constrained, because no rational business will accept commitments from agents whose errors have no clear legal owner.
The third is the intelligence ceiling. Current agents are impressive in demos and brittle in production. Multi-step workflows fail at the handoffs — the moment where one agent’s output becomes another agent’s input and the context degrades, the assumptions diverge, the error compounds. If reliability plateaus, the infrastructure overshoots what the technology can support. You do not need identity registries and dispute resolution for agents that can reliably book a flight but cannot reliably coordinate a weekend.
There is a version of the future where agents remain primarily human-supervised — smarter assistants rather than autonomous actors — and most of these layers shrink to features inside existing products rather than standalone institutions. Identity becomes a setting in your Google account. Oversight becomes a notification panel in your phone. Dispute resolution becomes a dropdown menu. In this version, the dependency chain never fully assembles. Each layer exists as a feature rather than infrastructure, because the transaction volume never justifies the institutional overhead.
The counter to this is that the feature-versus-institution distinction is often invisible until you cross a threshold. Tappan’s Mercantile Agency looked like a feature — a service one merchant used to check on another. It became infrastructure when the volume of transactions between strangers made it indispensable. The distance between a notification panel and an institution is measured in transaction volume, not design. Every institution started as someone’s side project.
And even the modest version — semi-autonomous agents that take some actions without asking — generates every one of these problems, just at smaller scale. An agent that books a restaurant without asking still needs identity to transact. It still needs an audit trail so you know what it did. It still needs dispute resolution when it double-books against your calendar. The question is not whether these layers emerge. The question is how thick they become.
VII.
The institutions described in this essay are at the reporting-room stage. Agent identity systems that look provisional because they are. Oversight dashboards that look crude because the design language for “what your AI did while you slept” does not exist yet. Payment rails built on stablecoins because the traditional financial system cannot handle the transaction volume. Marketplaces that look like experiments because no one is sure whether agents will become autonomous enough to need them. Dispute resolution protocols that look like academic papers because the multi-agent systems they are designed for are still being invented.
All of it provisional. All of it clumsy. All of it — if the core assumption holds — necessary. And all of it arranged in a dependency chain where each layer requires the ones beneath it: identity first, then payments, then oversight, then markets, then insurance. The sequence is not arbitrary. It is the same sequence every economy follows when a new kind of actor enters. You have to know who you are dealing with before you can transact. You have to transact before you can be observed. You have to be observed before you can be trusted in a marketplace. Every layer depends on the one below it. Skip one and the rest is theater.
One Thing Well will ask who populates the new economy — which verticals, which specialists, which kinds of work. This essay asked a different question: what institutions does the new economy demand? And the answer is not a list. It is a sequence — each institution unlocking the one above it, the way a foundation unlocks a wall unlocks a roof. Identity at the base. Insurance at the top. And every layer between them depending on the integrity of the ones below.
The actors are new. The furniture is ancient. The question is only who builds it — and whether, like Tappan, they build it before the next panic, or after.
This is part two of a three-part series. Part one — “No One Is Looking” — examines what happens to existing software when the user disappears. Part three — “One Thing Well” — examines where the deepest value concentrates.