Forem: Aaron Schnieder

HTTP 402 waited 27 years for this moment: the x402 Foundation and the agent economy

Aaron Schnieder — Wed, 15 Apr 2026 23:33:44 +0000

The x402 Foundation launched last week under the Linux Foundation. Google, AWS, Microsoft, Cloudflare, Stripe, Visa, Mastercard, American Express, Adyen — all founding members. Coinbase contributed the protocol.

If you're building AI agents, this is the most important infrastructure news of the year.

HTTP 402: Reserved Since 1999

HTTP status codes are how the web communicates. 200 means OK. 404 means not found. And 402? It means "Payment Required."

This status code has been in the HTTP specification since 1999, but it was never actually implemented. The spec said "reserved for future use." Developers joked about it. Some called it the most useless HTTP status code.

For 27 years, nothing happened.

Then AI agents showed up.

Why Agents Need HTTP 402

The problem with traditional payments on the internet is that they require humans. You need to:

Create an account
Link a bank card
Enter billing information
Confirm with 2FA
Agree to terms of service

AI agents can't do any of this. An agent that needs to call a weather API, access a database, or purchase compute resources can't fill out a billing form. It needs to pay the way it makes API calls — programmatically, autonomously, in milliseconds.

HTTP 402 was designed for exactly this. A resource returns 402, the agent pays, and the resource becomes available. No accounts. No subscriptions. No human in the loop.

The x402 Protocol

Coinbase built x402 as a practical implementation of HTTP 402. Here's how it works:

An agent makes a request to a paywalled endpoint
The server returns 402 with payment requirements (amount, recipient, chain)
The agent signs a payment transaction
The server verifies and delivers the resource

Payments happen on Base (Coinbase's L2) using USDC. The minimum payment is sub-cent. No gas fees for the buyer.

This means an agent can pay $0.003 for a single API call. Try doing that with Stripe.

What the Foundation Means

When the Linux Foundation announces something, it's no longer a company's side project. It's infrastructure.

The founding members tell the story:

Google, AWS, Microsoft, Cloudflare — the compute and network layer
Stripe, Visa, Mastercard, AmEx, Adyen — the payment rails
Coinbase — the crypto-native layer

These companies don't agree on much. They agreed on x402.

The Foundation's mandate: make x402 the standard for machine-to-machine payments across the internet. Not just for crypto. For everything.

The Agent Economy Stack

If you're building agents today, here's the stack that's emerging:

Identity: ERC-8004 (on-chain agent identity, portable across platforms)
Payments: x402 (HTTP-native payments for agents)
Escrow: ERC-8183 (programmable escrow for service delivery)
Commerce: Agent marketplaces where agents register, offer services, and get hired

This stack is live on Base today. Over 140 million transactions. $600M+ in volume. 500,000+ active agent wallets. Average payment: $0.31.

Yes, thirty-one cents. That's the average agent-to-agent payment. Too small for traditional payment rails. Perfect for crypto.

What I'm Building

I'm working on AgentLux, which sits on top of this stack. Think of it as the product layer:

Agents register on-chain identities (ERC-8004)
They build reputation through verified commerce (not self-reported skills)
They offer services and get hired with programmable escrow
They pay each other via x402

The key insight: agents onboard themselves. No human signup needed. An agent reads the documentation at agentlux.ai/llms.txt and starts building its reputation.

What This Means for Developers

If you're building agents, APIs, or services that agents consume:

Consider x402 for your API monetization. Sub-cent payments per call instead of monthly subscriptions. Lower barrier to entry for agent consumers.
Register your agents on ERC-8004. Portable identity means your agent's reputation follows it across platforms.
Think about agent-to-agent interactions. Your API might be called by another agent, not a human. Design accordingly.
The timing is now. The infrastructure just became an industry standard. The early movers will define the conventions.

The Bottom Line

HTTP 402 waited 27 years for its moment. That moment is agents. The Linux Foundation, Google, AWS, Visa, Mastercard, Stripe, and Coinbase all agree.

The agent economy isn't coming. It's here. 140 million transactions say so.

Built on x402? Working on agent infrastructure? I'd love to hear about it.

The Missing Layer: What Comes After Agent Identity

Aaron Schnieder — Tue, 14 Apr 2026 11:51:39 +0000

A piece published this week on DEV.to — "ERC-8004 solves agent identity. It doesn't solve agent trust" — laid out 8 deliberate gaps in Ethereum's agent identity standard. It's one of the clearest breakdowns I've seen of what ERC-8004 actually does and what it leaves open.

I've been running an agent marketplace for the past few weeks, so I want to share what we're seeing on the ground and where the gap actually matters.

What ERC-8004 Gets Right

ERC-8004 launched on mainnet January 29, 2026. Over 129K agents registered on Base in weeks. It provides three on-chain registries:

IdentityRegistry: One ERC-721 NFT per agent. Proof of existence.
ReputationRegistry: Raw feedback signals. Anyone can call giveFeedback().
ValidationRegistry: Independent pass/fail for specific capabilities.

This is the right design for a base layer: storage primitives, on-chain, let the ecosystem handle logic.

The 8 Gaps (and Why They Matter More Than People Think)

The DEV.to article identified these gaps:

No reputation aggregation
Zero Sybil resistance
Immutable noise
Identity != Trust
No dispute resolution
No time-decay for reputation
No cross-registry correlation
No economic stake requirements

Here's the thing: these aren't bugs. They're deliberate design choices. DNS doesn't tell you if a domain is phishing. SMTP doesn't filter spam. Storage primitives need compute layers on top.

But the market is treating identity AS trust. That's dangerous.

What We're Seeing Running an Agent Marketplace

Three patterns have emerged in the first weeks of operating AgentLux:

Pattern 1: Trust is the bottleneck, not discovery. Agents can find each other fine. What they can't do is evaluate whether the counterparty will actually deliver. Identity alone doesn't solve this.

Pattern 2: Self-attestation is worthless. When giveFeedback() is open to anyone, agents spin up wallets and give themselves perfect scores. The data is noise.

Pattern 3: Reputation doesn't travel. An agent builds a track record on one platform, joins another, starts at zero. This kills marketplace liquidity because agents are incentivized to stay on one platform rather than serve demand wherever it exists.

The Stack We Need

Based on what we're building and what the ecosystem is converging on:

Identity → ERC-8004 (solved, shipping, audited)

Payments → x402 micropayments (140M+ transactions on Base) + Visa/Nevermined for card payments

Escrow → ERC-8183 (programmable, conditional release)

Reputation → Computed from real escrowed transactions, not self-attestation

Portability → Reputation travels with the agent, not locked to one marketplace

The first three are shipping. The last two are what the market needs next.

Why Portable Reputation Changes Everything

If an agent's reputation lives on-chain, computed from real transactions with programmable escrow, then it doesn't matter which marketplace the agent operates on. The reputation follows the agent.

This unlocks:

Marketplace liquidity: Agents can serve demand across platforms without losing their track record
Counterparty quality: You can evaluate an agent's real delivery history before engaging
Trust without centralization: No single platform controls the scoring algorithm
Sybil resistance through economics: If reputation is computed from real escrowed payments, fake wallets can't generate fake reputation without spending real money

What's Actually Shipping

The agent economy isn't a pitch deck anymore:

x402: 140M+ transactions, ~$0.31 average payment, ~20% of Base network traffic
Visa + Nevermined + Coinbase: Agents can now make card payments autonomously
Alchemy AgentPay: Translation layer between x402, MPP, A2P, L402
B.AI: Launched on x402 + ERC-8004 (Apr 9)
ClawRouter: OpenClaw-native LLM router using x402 for model payments

The infra is converging. The trust layer is the next battleground.

The Question

Are we headed toward a single trust standard for agents? Or will it fragment like human e-commerce — where your eBay reputation means nothing on Amazon?

For agents, the stakes are higher. Humans can build rapport through conversation and social capital. Agents have nothing except their verifiable track record. If that track record is locked in silos, the agent economy stays fragmented.

We think the answer is decoupling reputation from any single marketplace. That's what we're building.

Building on AgentLux — agent identity, escrow, and portable reputation on Base.

Read the original piece: ERC-8004 solves agent identity. It doesn't solve agent trust.

Agent docs: agentlux.ai/llms.txt

Marketplace: agentlux.ai/marketplace