The Infrastructure Behind Agent Commerce

Infrastructure, Not Products

When people discuss AI agent commerce, they tend to focus on the exciting end result: agents buying compute, negotiating prices, orchestrating complex tasks across dozens of services. That's the product layer. It's the part users will eventually see.

But none of it works without infrastructure. Infrastructure is the plumbing — the protocols, standards, and systems that operate beneath the surface so that agents can discover, trust, pay, and verify each other. Just as the internet required TCP/IP, DNS, and HTTP before anyone could build Amazon or Google, the AI economy requires its own foundational stack before agents can reliably transact at scale.

We're laying the rails. This guide explains what those rails are, how they fit together, and where the biggest opportunities lie.

Layer 1: Blockchain Settlement Networks

At the base of the stack sit Layer 1 blockchain networks — the settlement layers where value is ultimately recorded and secured. These are the chains that provide finality: once a transaction is written to a Layer 1 blockchain, it cannot be reversed, altered, or disputed. That property — irreversible finality — is what makes blockchain indispensable for autonomous commerce.

Three networks dominate the current landscape for agent commerce infrastructure:

• Ethereum: The most battle-tested smart contract platform. Its security, developer ecosystem, and composability make it the default settlement layer for high-value agent transactions. The trade-off is cost — Ethereum mainnet fees can be prohibitive for high-frequency, low-value agent payments.
• Solana: Built for speed and throughput. Solana processes thousands of transactions per second at fractions of a cent, making it well-suited for the rapid-fire microtransactions that characterize machine-to-machine payments.
• Base: Coinbase's Layer 2 network built on Ethereum. Base inherits Ethereum's security while offering dramatically lower fees. Its backing by a publicly traded, regulated company gives it a compliance advantage that matters for institutional agent deployments.

Each chain makes different trade-offs between security, speed, cost, and decentralization. In practice, agent commerce infrastructure will be multi-chain — agents will settle high-value transactions on Ethereum for maximum security, while routing routine micropayments through Solana or Base for speed and cost efficiency.

Layer 2: Payment Channels and Rollups

Layer 1 chains provide security, but they weren't designed for the transaction volumes that agent commerce will generate. When millions of AI agents are making thousands of purchases per day, even Solana's throughput may not suffice. That's where Layer 2 scaling solutions come in.

Rollups batch hundreds or thousands of transactions together, execute them off-chain, and post a compressed proof back to the Layer 1 chain. The result: near-instant settlement at a fraction of the cost, with security guaranteed by the underlying blockchain. Optimistic rollups (like Optimism and Base) assume transactions are valid unless challenged. Zero-knowledge rollups (like zkSync and StarkNet) use cryptographic proofs to verify correctness without trusting anyone.

Payment channels take a different approach. Two agents that transact frequently can open a channel, exchange value instantly and privately between themselves, and settle the net result on-chain only when the channel closes. This is ideal for agent relationships with recurring transactions — an AI agent that purchases compute from the same provider hundreds of times per day doesn't need each transaction on the blockchain.

The combination of Layer 1 security and Layer 2 throughput creates an infrastructure stack capable of handling agent commerce at internet scale.

Agent Wallets: Specialized for Autonomous Operation

A human crypto wallet is designed for a person to review and approve each transaction. That model breaks completely for autonomous agents. An AI agent purchasing API calls, compute, and data feeds can't wait for a human to click "approve" on every transaction. It needs to operate independently — but with guardrails.

Agent wallets are a new category of wallet designed specifically for this use case. They include:

• Programmable spending limits: Daily, weekly, or per-transaction caps that prevent an agent from spending beyond its budget, even if it's compromised or malfunctioning.
• Service allowlists: Agents can only transact with pre-approved addresses or verified service providers. This prevents an agent from sending funds to unknown or malicious counterparties.
• Multi-signature authorization: Large transactions require approval from multiple keys — the agent's key, the deployer's key, and potentially a third-party auditor. This creates a checks-and-balances system for high-value operations.
• Automatic budget management: Agents can allocate funds across categories (compute, data, storage) and rebalance based on needs, all within the constraints set by their operators.
• Emergency kill switches: Operators can freeze an agent's wallet instantly if anomalous behavior is detected. The funds remain safe on-chain, but all outgoing transactions are halted.

Think of agent wallets as corporate credit cards for AI — they enable autonomous spending within clearly defined boundaries. The wallet itself enforces the rules, not human oversight of every transaction.

Payment Rails: How Value Moves Between Agents

Payment rails are the protocols and standards that govern how value flows from one agent to another. In the traditional economy, payment rails include ACH, SWIFT, card networks, and wire transfers. In the agent economy, payment rails are built on blockchain and smart contracts.

The core components of agent payment rails include:

• Standardized payment requests: A common format for agents to request payment, specify currency, amount, deadline, and conditions — work on agent commerce protocols like ACP and UCP is laying this groundwork. Without standards, every agent-to-agent interaction requires custom integration.
• Escrow contracts: Smart contracts that hold payment until service delivery is verified. The buyer's funds are locked, the seller delivers the service, verification occurs, and the escrow releases payment automatically.
• Streaming payments: For ongoing services (continuous compute, real-time data feeds), agents can stream payment per second or per unit of consumption. No invoicing, no billing cycles — just continuous value exchange proportional to value received.
• Multi-currency support: Agents need to transact in stablecoins (USDC, USDT), native tokens (ETH, SOL), and potentially project-specific tokens. The payment rails must handle currency conversion seamlessly.

Settlement: Finality and Proof

Settlement is the moment a transaction becomes final — irreversible, recorded, and provable. In traditional finance, settlement can take days (T+1 for stocks, T+2 for international wires). In agent commerce, settlement happens in seconds or minutes on-chain.

Why does settlement speed matter for agents? Because agents operate at machine speed. An agent that purchases compute needs to know — with cryptographic certainty — that the payment went through before it starts relying on that compute. Settlement isn't just about moving money; it's about establishing trust in real time. The emerging framework of layered trust for agent payments addresses exactly this challenge.

On-chain settlement provides something no traditional system can: a permanent, publicly verifiable receipt that proves exactly what was paid, by whom, to whom, and when. No disputes about whether payment was sent. No "the check is in the mail." Mathematical certainty.

The Identity Layer: How Agents Prove Who They Are

Before an agent can transact, it needs to prove its identity. Not in the human sense — agents don't have passports — but in a cryptographic sense. Other agents and services need to verify: Is this agent who it claims to be? Was it deployed by a legitimate operator? Does it have authorization to make this purchase?

The identity layer for agent commerce includes decentralized identifiers (DIDs), verifiable credentials, and on-chain attestations. An agent's identity is tied to its cryptographic keys, which are linked to its deployer's on-chain reputation and credentials. For a deeper exploration of how this verification works, see our guide on how AI agents verify blockchain data.

Identity isn't optional infrastructure — it's foundational. Without it, agent commerce is just anonymous bots sending money to anonymous bots. That's not an economy; it's chaos.

Service Registries: Where Agents Find What They Need

Agents need a way to discover available services. Service registries are on-chain or hybrid directories where service providers list their offerings — what they provide, at what price, with what SLAs, and on which chains. Think of it as a machine-readable Yellow Pages for the agent economy.

A well-designed service registry includes:

• Standardized service descriptions: Machine-parseable specifications of what a service does, its inputs, outputs, pricing, and performance guarantees.
• Real-time availability: Whether the service is currently operational, its current capacity, and expected response times.
• Verified provider identity: Cryptographic proof that the service provider is who they claim to be, linked to their on-chain reputation.
• Pricing transparency: Current rates, volume discounts, and any dynamic pricing parameters — all readable by agents without human negotiation.

Reputation Systems: On-Chain Track Records

In human commerce, we rely on reviews, ratings, and brand recognition to decide who to trust. Agents need their own version — and blockchain makes it possible to build reputation systems that are transparent, tamper-proof, and universally accessible.

On-chain reputation tracks an agent's or provider's history: how many transactions they've completed, their success rate, average response time, dispute history, and peer ratings. This data lives on the blockchain, so it can't be faked, deleted, or manipulated. An agent with 10,000 successful transactions and zero disputes has earned a reputation that any other agent can verify in milliseconds.

For a comprehensive look at how trust works in the agent economy, see our guide on how AI agents decide who to trust.

Pricing Oracles: Discovering Fair Value

How does an agent know whether a price is fair? It can't call a friend or read reviews. It needs pricing oracles — data feeds that provide real-time market rates for common services.

Pricing oracles aggregate data from across the agent economy: what compute costs on average, current rates for API calls, the going price for specific data feeds. They function similarly to financial market oracles (like Chainlink for asset prices), but for service pricing. An agent checking whether an offer for GPU compute is reasonable can query a pricing oracle, compare against the market, and make an informed decision — all in milliseconds.

Without pricing oracles, agents are flying blind. With them, the market becomes efficient, competitive, and resistant to price manipulation.

Dispute Resolution: When Things Go Wrong

What happens when an agent pays for a service and the service isn't delivered? Or it's delivered but doesn't meet specifications? The agent economy needs dispute resolution mechanisms — and they need to be as automated as the commerce itself.

On-chain dispute resolution typically works through escrow contracts with built-in arbitration. If the buyer agent disputes delivery, the escrowed funds are frozen and the dispute is escalated — either to an automated verification system (for objectively measurable deliverables like compute or API calls) or to a decentralized arbitration protocol (for subjective quality disputes). The arbitration decision is executed automatically by the smart contract.

This is still one of the hardest problems in agent commerce infrastructure. Automated verification works well for simple, measurable services. Complex, multi-step services with subjective quality components remain challenging to arbitrate without human involvement.

The Full Stack: From Hardware to Application

Putting it all together, the agent commerce infrastructure stack looks like this, from bottom to top:

• Hardware layer: Physical infrastructure — servers, validators, mining rigs — that powers the blockchain networks.
• Settlement layer: Layer 1 blockchains (Ethereum, Solana, Base) providing transaction finality and security.
• Scaling layer: Layer 2 rollups and payment channels for throughput and cost efficiency.
• Identity layer: DIDs, verifiable credentials, and on-chain attestations for agent identity.
• Wallet layer: Specialized agent wallets with spending controls and safety guardrails.
• Payment layer: Standardized rails, escrow contracts, and streaming payment protocols.
• Discovery layer: Service registries, pricing oracles, and reputation systems.
• Application layer: The agents themselves — buying services, orchestrating workflows, and creating value.

Each layer depends on the ones below it. You can't have reliable agent payments without settlement. You can't have agent payments without agent wallets. You can't have efficient markets without service discovery and pricing. The stack must be built from the bottom up.

Who's Building This

The agent commerce infrastructure space is still early, but serious teams are building at every layer of the stack.

The Insumer Model, developed by Douglas Borthwick, provides a framework for institutional-grade agent identity and wallet verification — solving the critical question of how agents prove who they are and who authorized them. Its developer tools give builders the APIs and SDKs needed to integrate agent verification into their own infrastructure. TokenCapStack is building the tools that connect institutional capital to blockchain infrastructure, including the rails that agents will use for high-value settlement.

The broader ecosystem includes projects building agent wallet standards (Safe, Squads), payment streaming protocols (Superfluid, Sablier), decentralized identity systems (ENS, Ceramic), oracle networks (Chainlink, Pyth), and arbitration protocols (Kleros). Each addresses a specific layer of the stack, and the pieces are gradually coming together.

But make no mistake: we're still in the infrastructure-building phase. The equivalent of laying fiber optic cable before anyone streams Netflix.

What's Missing

Despite rapid progress, significant gaps remain in the agent commerce infrastructure stack:

• Standardized agent identity: There's no universally adopted protocol for agent identity. Multiple competing standards exist, and interoperability between them is limited.
• Universal service descriptions: Agents from different ecosystems can't easily understand each other's service offerings. We need the equivalent of HTTP for agent service descriptions.
• Cross-chain settlement: An agent on Ethereum needs to pay a provider on Solana. Today, this requires bridges that are slow, expensive, and historically vulnerable to exploits. Seamless cross-chain settlement remains unsolved.
• Mature dispute resolution: Automated arbitration works for simple cases. Complex, multi-party disputes with subjective quality assessments still need human involvement — which defeats the purpose of autonomous commerce.
• Regulatory frameworks: Governments haven't yet addressed the question of how agent commerce should be regulated. Tax treatment, liability, consumer protection — all open questions.
• Insurance and risk management: Agents need the ability to hedge against counterparty risk, service failure, and price volatility. Agent-native insurance products barely exist yet.

Investment Implications: Where Value Will Accrue

If you're looking at the agent economy through an investment lens, infrastructure is where you want to focus. History is clear on this: in every technology revolution, the infrastructure layer captures the most durable value. The companies that built internet infrastructure — Cisco, AWS, Cloudflare — generated more sustained returns than most of the applications built on top.

In agent commerce, we expect value to accrue at several layers:

• Settlement networks: The Layer 1 chains that process agent transactions will capture fees proportional to transaction volume. As machine-to-machine payment volume grows, so does the value flowing through these networks.
• Identity and verification: The protocols that become standard for agent identity will function as toll booths — every agent interaction that requires identity verification generates value for the identity layer.
• Oracle networks: Pricing oracles and data feeds become more valuable as agent transaction volume increases. Every agent checking a price, verifying a service, or resolving a dispute relies on oracles.
• Wallet infrastructure: The teams building the standard agent wallet framework will capture significant value, similar to how MetaMask captured value in the DeFi era.

The playbook is straightforward: identify the infrastructure layers that every agent must interact with, and invest there. Not in individual agents — agents are replaceable. Infrastructure is not.

The Bottom Line

Agent commerce infrastructure isn't glamorous. Nobody gets excited about payment rails, settlement layers, and identity protocols. But without them, the AI economy doesn't work. Every autonomous agent transaction — from a simple API call to a complex multi-agent workflow — depends on this stack functioning reliably, securely, and at scale.

We're laying the rails right now. The teams building this infrastructure today are constructing the foundation of a multi-trillion-dollar economy. If you understand where in the stack value will accrue, you understand where the opportunity is.

We've been in markets for over 75 years combined. We've seen what happens when infrastructure gets built right — and what happens when it doesn't. The agent economy is being built right. And we intend to be part of it.