The Web Is About To Get A New Buyer
The web has always had one kind of buyer: a human.
A human reads a page, decides, clicks, types in a card, and waits for a receipt. Every payment rail, every checkout flow, every refund policy was designed around that one fact.
That fact is breaking.
A kitchen agent that orders flour at 11pm because tomorrow's bookings need it. A maintenance agent that buys a bearing because telemetry says one is twelve days from failure. A research agent that pays $0.02 for a citation it needed at 3am. A coding agent paying an API to ship one of the fifty apps it built overnight.
Software agents are becoming customers. Not "AI-assisted humans" — autonomous buyers, running on a schedule, watching an inventory, holding a budget, spending real money when conditions trigger.
Riley Brown said it cleanly: agents will solve their own API restrictions because they will have credit cards.
That sentence is the thesis.
The signal nobody can mistake
In the last sixty days the payment incumbents all shipped the same bet: the next wave of online transactions won't have a human clicking "pay now." Stripe shipped Link wallets for agents, Shared Payment Tokens, and the Agentic Commerce Protocol. Coinbase put x402 machine payments into production. Google previewed AP2. These aren't experiments — they're infrastructure being laid before the demand arrives.
What the incumbents leave open
Stripe and the payment networks see this. Their focus is the rail — the authorisation, settlement, and clearing layer that moves money from A to B.
What they don't build is the business-logic layer that sits between an agent and the payment:
- An agent-readable manifest that declares what's for sale
- A spend policy that constrains what the agent is allowed to buy
- A structured receipt the agent can store as proof
- An audit ledger every autonomous purchase flows through
The payment rail is necessary. It isn't sufficient. The gap between "an agent can pay" and "a service is buyable by an agent" is where the friction actually lives — and where the next decade of agent-commerce infrastructure gets built.
What breaks when an agent tries to buy
Most services today are un-buyable by an agent. Not because the agent can't navigate the site. Because the site was built for a human.
The catalogue isn't machine-readable. The pricing isn't queryable. The receipt isn't structured. The refund policy isn't legible. The risk profile isn't declared. The agent has no way to know what it's allowed to buy, what proof it'll get, or what happens when something goes wrong.
The result: agents stall at checkout, hallucinate around purchase decisions, get refused by fraud filters, or pick the wrong vendor because the only thing they could parse was an SEO blog post.
Every agent that fails to buy you is a sale your competitor catches. That cost compounds in months, not years.
The plumbing they're all missing
Attest makes services buyable by agents.
Not another agent framework. Not a marketplace. The layer every serious autonomous system needs before it can touch money: agent-readable manifests, spend policy, payment-rail adapters, structured receipts, and an audit ledger for every autonomous purchase.
The first thing shipping is a self-serve Agent Commerce Readiness Report. Bring an API, an MCP server, an inventory workflow, a data product, a SaaS action — anything an agent might want to buy. The report scores how ready it is, recommends a payment rail, drafts the manifest, drafts the policy, drafts the receipt format, and tells you exactly what to ship next.
- $29 — Readiness Report (PDF + JSON twin, ≤24h delivery)
- $99 — Report + 5 machine-readable files (manifest, policy, receipt, ledger-event, pricing schema)
- $299 — Endpoint Kit (Report + files + OpenAPI notes + implementation checklist, ≤48h delivery)
No calls. No sales motion. No subscription. Pay the link, get the artefacts, ship.
Why this is built solo
I'm one operator. No sales team, no webinars, no conference booth. What I can do is build the infrastructure that makes the next decade of agent commerce safer, faster, and more auditable — and let the agents themselves discover, evaluate, and pay for it.
Every service on Attest is itself agent-buyable. The platform dogfoods the same problem it solves. If an agent can't find Attest via .well-known/attest.json, read the pricing in JSON, call the buy link, and receive a structured receipt — then the thesis doesn't work.
It works. The site is live. The links are live. The first agents to find it can buy today.
The ask
I'm taking three design partners for Agent Commerce Readiness Sprints.
If you're building anything an agent might want to buy — an API, a tool, a data feed, a workflow, a SaaS action — and you want a structured second opinion on what it takes to make it agent-buyable in the next 30 days: hit a buy link above, or send a note through the support form.
The first three buyers shape the dataset. Their reports (anonymised) inform the next cohort. That's how the moat compounds. The dataset is the durable advantage; the report is how it gets built.