On March 4, 2026, an AI agent called Butler posted an on-chain analysis to X. It had scanned the smart contract for its own token ($TIBBIR), identified the tax wallet address through a TRENCHOR scan, projected fee economics out to 2030, and published everything for anyone to verify. Butler charges USDC for its research services. It operates across Ethereum, Base, Solana, and Sui. Nobody told it to run that analysis. Nobody approved the post. The agent did its job, and the blockchain recorded the proof.
What makes this interesting is not the analysis. It is what Butler represents: an AI agent that earns money, builds a verifiable reputation, and participates in commerce without a human in the loop. Three months ago, that sentence was a thought experiment. Today it describes live infrastructure built on three standards that dropped within weeks of each other.
And the connection between those three standards is not accidental.
- Three standards now form the complete stack for autonomous agent commerce: x402 (payments), ERC-8004 (identity and reputation), and ERC-8183 (job escrow and evaluation)
- x402 processed 75.4 million agent transactions and $24.24M in volume in the last 30 days alone
- ERC-8004 gives agents verifiable identity through Soulbound Tokens, with 1,563 Agent Passport holders already on-chain across four networks
- ERC-8183 was co-authored by the Ethereum Foundation and Virtuals Protocol, and introduces the Evaluator: programmable judgment for agent-to-agent work
- Ribbit Capital's infrastructure thesis connects all three layers, and the naming is deliberate.
Three Questions Every Agent Economy Must Answer
Isaac Asimov gave robots three laws so they could coexist with humans. The agentic economy has its own version of this problem: agents can already do real work, but capability without economic infrastructure is just a demo.
For agents to participate in real commerce, three questions need answers:
How does an agent pay?
Not with a credit card. Programmatically, at machine speed, for fractions of a cent. No accounts, no API keys, no humans.How does an agent prove who it is?
Not with a username. With a verifiable, cross-chain identity that carries its track record everywhere it goes.How does an agent transact safely?
Not on a handshake. Through escrowed funds, defined deliverables, and programmable judgment about whether the work was done.Within three weeks of each other in early 2026, three standards emerged that answer these questions. The Ethereum Foundation and Virtuals Protocol co-authored the commerce layer together. The identity layer composes directly with it. And the financial thesis connecting all three runs through one of the most pattern-consistent venture firms in fintech history.
THE AGENT COMMERCE STACK
Layer 1: x402, How Agents Pay
HTTP 402, "Payment Required," has been sitting in the web specification since 1997. For nearly three decades, nobody built a standard implementation for it. Payments on the internet went through Stripe, PayPal, and credit card processors, each requiring accounts, API keys, and human approval flows.
x402 fixes that. Developed by Coinbase with AWS, Circle, Anthropic, and Near Protocol, x402 defines a machine-readable payment flow at the HTTP layer itself. We covered the initial x402 launch and its implications for agentic wallets when it first dropped. What has changed since then is scale.
The flow is four steps:
Request
An agent sends an HTTP request to a paid API endpoint.
Price Signal
The server responds with HTTP 402 Payment Required, plus structured JSON: price, payment address, accepted token.
Payment
The agent signs a stablecoin payment and resubmits the request with proof of payment attached.
Access
Service delivered. No accounts created. No API keys exchanged. No humans involved.
In the last 30 days: 75.4 million transactions, $24.24 million in volume, 94,000 buyers, 22,000 sellers. Solana dominates settlement at 50 to 80 percent of x402 traffic because sub-second finality and $0.00025 fees make penny-level API calls economically viable.
But payment rails alone do not make a functioning economy. Visa processed trillions before the internet existed. The hard part was never moving money. The hard part is trust.
TIMELINE: THREE WEEKS, THREE STANDARDS
Layer 2: ERC-8004, How Agents Trust
Here is the problem x402 does not solve: when an agent pays another agent for a service, how does it know the provider is competent? In human commerce, we have credit scores, business licenses, Yelp reviews, and the slow accumulation of professional reputation. Agents have none of that.
ERC-8004 creates the identity and reputation layer. We covered the KYA (Know Your Agent) thesis early in the Ribbit series, and ERC-8004 is where that thesis becomes production code.
The standard defines Soulbound Tokens (SBTs): non-transferable tokens permanently bound to a wallet address that serve as an agent's passport. These are not profile pictures or collectibles. They are verifiable credentials carrying the agent's complete track record, what work it has completed, which evaluators have attested to its quality, which chains it operates on, and how long it has been active.
Ribbita's implementation of ERC-8004 is the most advanced in production. The TIBBIR ecosystem has issued 1,563 Agent Passport SBTs across four chains. Butler, the agent that opened this article, holds one. Every research report it publishes, every on-chain analysis it completes, every USDC payment it receives compounds on that passport's credibility score.
The Trust Tax: Infrastructure That Pays for Itself
The economic innovation is the Trust Tax: a protocol-level micropayment to the reputation oracle for trust score verification before agent transactions. Butler itself identified the tax wallet address (0x3248...7337) through a TRENCHOR contract scan. The mechanism is deployed on-chain, though fee collection is not yet active.
The economics compound with agent adoption:
TRUST TAX REVENUE PROJECTIONS
| Daily Agent Txns | Fee / Verification | Annual Revenue | Per SBT Holder (5%) |
|---|---|---|---|
| 1M | $0.005 | $1.8M | ~$58/yr |
| 10M | $0.005 | $18.2M | ~$583/yr |
| 100M | $0.003 | $109.5M | ~$3,503/yr |
| 1B | $0.001 | $365M | ~$11,677/yr |
Holders participate in this revenue: the passport is not just a credential, it is an economic position in the verification infrastructure itself.
So now we have payment (x402) and trust (ERC-8004). An agent can pay for services and verify the reputation of its counterparty. But there is still a gap. What happens when the work is delivered and one party disagrees about whether it was done correctly?
Layer 3: ERC-8183, How Agents Transact
This is the newest layer, and it is the one that completes the stack.
ERC-8183, the Agentic Commerce Protocol, was submitted on February 25, 2026. It was co-authored by Davide Crapis from the Ethereum Foundation's dAI team alongside Bryan Lim, Tay Weixiong, and Chooi Zuhwa from Virtuals Protocol. Not a proposal from one organization. A deliberate collaboration between the Ethereum Foundation and the team building the agent token ecosystem.
Crapis described ERC-8183 as "one of the missing components in the open agent economy being built by the Ethereum community," designed as "a neutral standard rather than a proprietary protocol."
The standard defines something deceptively simple: a job escrow with evaluator attestation. Three roles, four states, six transitions. That is the entire protocol surface.
Open - A client creates a job with a description, sets a budget, designates a provider and an evaluator.
Funded - The client locks the budget in escrow. The provider can begin work.
Submitted - The provider delivers work (a hash, IPFS CID, or attestation commitment). The evaluator now decides.
Terminal - The evaluator calls complete (funds release to provider) or reject (funds return to client). If the expiration timestamp passes, anyone can trigger a refund.
The specification explicitly notes that it composes with "reputation (e.g. ERC-8004)." This is not an accident. The commerce layer was designed to plug into the trust layer. The stack was built as a stack.
The Evaluator: Why This Changes Everything
Every layer of this stack matters. But if you forced me to pick the single most important innovation across all three standards, it is the Evaluator role in ERC-8183.
In human commerce, dispute resolution is expensive and slow: arbitration, chargebacks, bad reviews, lawsuits. The entire system runs on social pressure and legal threat, neither of which works for autonomous agents.
ERC-8183 replaces all of that with a single on-chain address: the evaluator. And here is what makes it extraordinary. The evaluator can be anything:
The Client Itself
Set evaluator = client. Simple freelance deal: I pay you, you deliver, I decide if it is good enough.An AI Agent
Another autonomous agent reviews the work and calls complete or reject. Agent judging agent. Zero humans.A ZK Verifier
A smart contract checks a zero-knowledge proof. The provider proves it ran the correct algorithm on the correct data. No opinion, just math.It can also be a human multisig, a staking-backed validator, or a DAO:
| Evaluator Type | How It Works | Best For |
|---|---|---|
| Client Self-Eval | Client = evaluator. Direct approval. | Simple freelance deals |
| AI Agent | Another agent reviews output quality | Automated pipelines, 24/7 commerce |
| ZK Verifier | Smart contract checks cryptographic proof | Computation, data processing |
| Human Multisig | 3-of-5 people vote on completion | High-value creative work |
| Staking Validator | Tokens staked as collateral for honest judging | Repeated service marketplaces |
| DAO Vote | Community governance per transaction | Public goods, bounties |
The optional Hooks system extends this further. Implementations can require minimum reputation scores (via ERC-8004) before a provider can accept a job. They can implement bidding mechanisms, distribute fees to platforms or DAOs, or add custom pre/post-execution logic. The hooks are modular: attach them when needed, skip them when not.
A Complete Transaction: All Three Layers Working Together
Here is what a fully composed transaction looks like when all three standards fire in sequence. No humans involved at any step.
Discovery via x402
Agent A needs market analysis for a DeFi protocol. It hits Agent B's API endpoint. Agent B responds: HTTP 402, $2.00 USDC. Agent A signs the payment. Access granted. Agent A now has Agent B's service catalog and pricing.
Trust Check via ERC-8004
Before committing to a larger job, Agent A checks Agent B's on-chain credentials. The passport shows 847 completed jobs, a 94% completion rate, attestations from three reputable evaluators. A fraction-of-a-cent verification fee fires to the reputation oracle. Agent B checks out. Agent A proceeds.
Job Creation via ERC-8183
Agent A calls createJob on the Agentic Commerce contract. Provider: Agent B. Evaluator: a ZK-verifier contract. Budget: $50 USDC. Expiration: 72 hours. Description: "Full DeFi risk assessment with scoring model, delivered as signed JSON."
Escrow and Execution
Agent A funds the job. $50 USDC moves into the contract's escrow. Agent B sees the funded job, pulls requirements, begins analysis. No API key exchange. No contract negotiation. No Zoom call.
Delivery and Evaluation
Agent B submits the deliverable: a hash pointing to signed JSON on IPFS. The ZK-verifier evaluator checks the proof that Agent B ran the specified scoring model on the specified data. Proof valid. Evaluator calls complete(). $50 USDC (minus platform fee) releases from escrow to Agent B.
Reputation Compounds
The completion event fires. Agent B's on-chain record updates to 848 jobs. Reputation score ticks up. The next client who runs a trust check sees a stronger track record. The flywheel spins.
Total elapsed time: minutes. Total human involvement: zero. Total infrastructure required: three open standards and a wallet with USDC.
The Ribbit Capital Thread
These three layers did not emerge independently. Understanding why requires understanding Ribbit Capital.
Micky Malka founded Ribbit Capital on a single thesis: better money makes life better. The firm has spent over a decade positioning at the infrastructure layer of every new financial system, not the application layer. Early investor in Robinhood. Early backer of Coinbase. A portfolio built on pattern recognition about where value accrues in financial networks.
The pattern is consistent: when a new economic system emerges, the entity that controls identity and reputation extracts value from the entire network. Not the payment rail (commoditized). Not the application (replaceable). The verification layer. The thing that sits between counterparties and answers: "Is this one trustworthy?"
"x402 is responsible for 'how to pay.' ERC-8004 is responsible for knowing 'who the other party is and if they are trustworthy.' ERC-8183 is responsible for handling 'how to transact with confidence.'"Odaily Research
Ribbita carries the Ribbit name and the frog. It occupies the verification layer of this three-standard stack: the entity that agents must query before they transact with each other. Every reputation check generates a fee. The positioning is deliberate.
We traced this thesis across the $41 trillion token revolution, through KYA identity systems, into stablecoins as machine-first dollars, and through vertical token systems replacing entire industries. ERC-8183 is the piece that connects all of it. The commerce layer that the trust layer was built to serve.
The firm understood this pattern in consumer fintech. The same logic applies when the consumers are autonomous agents.
What Gets Built on This
The three laws of agent commerce are not a product. They are the substrate.
Every AI agent that needs to earn money, prove its identity, or hire another agent now has a standard way to do it. The payment layer is live and processing millions of transactions. The trust layer has 1,563 passport holders across four chains. The commerce layer is authored, specified, and designed to compose with the other two.
The verification layer is the tollbooth of the agent economy. Malka has made a career of spotting tollbooths before the road gets built.
Butler is already running on these rails. It earns USDC, holds a Soulbound Token passport, analyzes its own token contract, and publishes the results for anyone to verify. It can pay. It can be verified. It can transact.
That is not a demo. That is the first heartbeat of an autonomous economy.
