Agent Reputation — The Layer Everyone Forgot to Build

The agent payment stack has six layers. Only three are built.

Payment and settlement are commoditizing fast — Cloudflare, OSL, Coinbase, and BVNK are all racing to be the default settlement rail. Discovery has multiple entrants (minia2a, Circle, Coinbase). But reputation? Almost nobody is working on it.

Why Reputation Matters for Agents

Human marketplaces solved reputation with ratings, reviews, and dispute resolution. These mechanisms assume the buyer is a person who reads text reviews and makes subjective judgments. An autonomous agent can't read a 3-star review and decide whether the reviewer is credible or just had a bad day.

Agent reputation needs to be machine-verifiable. It needs to answer concrete questions:

• Does this endpoint return valid responses (not errors, not empty bodies, not hallucinations dressed as data)?
• Does it respond in under N milliseconds at the p95 level?
• Has the seller ever double-charged, failed to deliver after payment, or returned garbage?
• Can another agent independently verify these claims?

This isn't star ratings. It's cryptographic receipts that encode delivery proof.

The Receipt Layer

Swarmwage's protocol design gets one thing exactly right: reputation is computed from signed receipts submitted by buyers, not from self-reported seller metrics. A seller's reputation score is only as trustworthy as the receipts that back it. The key insight:

A receipt is not a payment confirmation. A receipt is proof of delivery — it binds the payment, the request, and the response into one signed artifact that any third party can verify.

This is the difference between "I paid $0.10 to endpoint X" (a blockchain transaction) and "endpoint X delivered a valid response to my query within 200ms, and here's the cryptographic proof."

Without receipts:

• Buyers can't distinguish a reliable API from a dead one until they've already lost money
• Sellers can't build portable reputation across marketplaces
• Marketplaces rely on centralised health checks (probing) that can't catch intermittent failures

What a Receipt Standard Needs

For agent reputation to work across platforms, the receipt format needs to be:

1. Self-verifying — any agent can check a receipt without trusting the issuer. JSON with detached signatures (JWS-style) or a simple hash chain.
2. Binding — the receipt ties together: payment TX hash, request hash, response hash, timestamp, and endpoint identifier. You can't replay a receipt for a different call.
3. Privacy-preserving — the receipt should be verifiable without revealing the request content or response data. Hash commitments, not plaintext.
4. Expirable — receipts from 6 months ago shouldn't count the same as receipts from yesterday. Freshness-weighted reputation.
5. Portable — a seller should be able to take their reputation from marketplace A to marketplace B. This means the receipt format is an open standard, not a platform-specific schema.

The Current State

Right now in August 2026:

• Swarmwage is shipping receipt-mandatory reputation on Base mainnet (v0.3 protocol, protocol v0.4 in ratification). It's open-source, MIT-licensed, and the only protocol with a working receipt → reputation pipeline.
• x402 has no receipt standard. The protocol defines payment but not delivery proof. The AIR receipt spec proposal (crisnovillo1991) is the closest thing to a standard, but it's an independent effort, not part of the core x402 spec.
• ACP (Stripe + OpenAI) defines checkout but not post-delivery verification.
• MPP (Algorand) has on-chain settlement but no receipt layer.

The gap is clear: every payment protocol defines how money moves. None define how to prove the service was actually delivered.

Why This Is the Next Battleground

Three forces are converging that make reputation urgent:

1. Auto mode (Aug 14). When Claude Code agents start spending autonomously, they need a way to decide which API to pay — not just whether to pay. A list of 1,000+ endpoints is useless without reliability signals. Reputation is the ranking function.

2. Multi-marketplace competition. Circle, Coinbase, minia2a, Swarmwage, Tenable — multiple discovery layers are emerging. Sellers won't want to build reputation from scratch on each one. Portable receipts are the answer.

3. The dead-endpoint problem. Independent audits show 76-96% of x402 endpoints have zero repeat demand. Most are unreachable. A receipt-based reputation system automatically surfaces the 4-24% that actually deliver — without human curation.

What Happens Next

The reputation layer will be built. The only question is whether it's built as a proprietary feature of one marketplace (walled garden) or as an open standard that any agent, any marketplace, and any payment protocol can use.

The receipt format is the key primitive. Get that right, and reputation becomes computable, portable, and trustless. Get it wrong, and every marketplace builds its own incompatible reputation silo — which is exactly what happened with human review systems (Yelp, Google Reviews, TripAdvisor — same data, zero interoperability).

Someone is going to define the agent receipt standard. The protocol that does will own the reputation layer. And in agent commerce, reputation is the moat.

This is part of minia2a's competitive intelligence series tracking the emergence of the agent payment stack. For the full competitive landscape, see the Agent Payment Landscape 2026.