
Agents for Humans: merchant agents will replace websites. The rails are ready; the ecosystem isn't
A restaurant running as a public agent on AWS works: anonymous discovery, grounded menu answers, stablecoin deposits with a human approving each one. So why can't your assistant book dinner? Three gaps stand in the way, and none of them is cryptography.
Series: Headless Merchants, Real Payments (3 articles)
- 3Agents for Humans: merchant agents will replace websites. The rails are ready; the ecosystem isn't This article
Agents for Humans: merchant agents will replace websites. The rails are ready; the ecosystem isn't
Part 3 of 3 in Headless Merchants, Real Payments. Part 1 covered the architecture. Part 2 covered the money. This one is the argument the first two were evidence for.
A website is a human interface. It renders for eyeballs, collects input through forms, and
assumes a person is looking at it. Every merchant on the internet has one because, for thirty
years, a person looking at a screen was the only way a customer arrived.
That assumption is breaking. When someone asks their assistant to book dinner, the assistant does
not want a page. It wants an endpoint, a machine-readable description of what the business can
do, and a way to pay.
That description already has a name. An agent card is JSON at a well-known path carrying
identity, skills and an endpoint. It is to an agent what a homepage is to a person, and I think
merchants will end up publishing one for the same reason they published homepages: because that
is where the customers went.
table-relay was built to find out what stands in the way. It is a restaurant running as a
public agent on AWS: anonymous discovery, menu answers grounded in a knowledge base, and a
stablecoin no-show deposit with a human approving every payment. The two previous posts covered
how. This one covers what is missing, because the answer surprised me.What already works
The part I did not expect: the clients were interchangeable and the card never changed.
Four different client generations talked to the same merchant with no server-side modification.
A ChatGPT Custom GPT reached it through an Action. Claude Desktop reached it through a
fifty-line local MCP bridge. The A2A Inspector and plain
curl reached it directly. A Strands
coordinator agent reached it and paid.That is the property worth noticing. Clients come and go, and the card is the stable interface.
It is exactly how the web behaved: the page outlived every browser that rendered it.
The merchant side is also already cheap. Roughly 500 lines of Python, under $2 of infrastructure
for a weekend, and onboarding a restaurant means dropping a text file in Amazon S3. Two agents
from two different vendors' stacks transacted with no shared platform between them, which is the
web-like property this whole idea depends on.
So the rails work. Now the awkward part.

Data minimisation as architecture rather than policy: the tool schemas have no field for any of it.
Watch the 2 minute 41 second demo : anonymous discovery, a grounded menu answer, one human approval, and a USDC deposit settled on Base Sepolia.
Gap one: nobody can pay
Ask your assistant to book and pay for a table today and it cannot, and the reason is not
capability. It is that no mainstream consumer assistant has the four primitives.
An assistant needs to resolve an agent card, understand a payment challenge, hold a
wallet, and present a mandate for a human to approve. Today:
- ChatGPT speaks MCP through Actions and Apps. It holds no wallet and has no awareness of A2A task metadata, so it can discover a restaurant and negotiate a table, and the booking stays unpaid.
- Claude Desktop speaks MCP. I shipped a fifty-line bridge and it works for conversation. There is no signer, so payment is out.
- Gemini is the same shape.
None of them speaks A2A natively. None of them signs an EIP-3009 authorisation. The gap is
entirely client-side, and it is four missing primitives rather than a missing platform.
Two things make it worse before they make it better.
Wallets are still developer-facing. AgentCore's managed instrument is genuinely good
infrastructure: keys in a trusted execution environment, a server-enforced spend session, no seed
phrase in your code. But the surrounding experience is built for engineers. Linking an identity
to an instrument fails if the email does not match and there is no update API. The funding onramp
is mainnet-only, so a testnet wallet is funded by hand from a faucet. Delegating signing
authority is a separate manual step. A consumer needs all of that to be invisible, and the
primitives to be invisible with it: embedded wallets, a continuous path from test to real money,
recovery, and spend controls presented as a product feature rather than an API parameter.
And the protocols are multiplying. x402 puts payment in HTTP with stablecoins and a
competitive facilitator market. Google's AP2 standardises mandates, the human-signed statement
of intent. OpenAI and Stripe's ACP moves card rails through MCP. The A2A x402 extension puts
challenges inside agent messages, which is what
table-relay uses because a managed runtime gave
it no HTTP seam.Each solves a different trust problem, and each is reasonable. But a merchant facing four
integrations to be payable by four assistants has the platform tax back, reborn one layer down as
protocol tax. What is needed is boring and specific: one challenge-and-proof envelope, with
mandate semantics agreed across rails. Settlement can stay plural. Cards and stablecoins can
coexist behind one mandate format, the way a checkout page already abstracts payment methods
today.
Gap two: nobody can find you
Suppose every restaurant publishes an agent card tomorrow. How does an assistant find the one
near you that has a table on Friday?
It cannot, because discovery today is link-based. You have to already know the URL. That is
the web in 1994: pages existed, and finding them meant a link from somewhere else or a printed
directory.
The pieces that exist are indexes, not search. AWS Agent Registry catalogues my card, synced from
the public card the gateway already serves, which is a genuinely useful pattern and the right
shape for a crawler to copy. But it is SigV4-scoped and per-cloud: an index inside AWS, not a
public directory. The standard A2A card resolver queries no registry at all. Coinbase's x402
Bazaar is an embryonic directory of paid endpoints, and closer to the seed of the right thing
than anything else I found.
What is missing is the whole middle of the stack:
- public crawling of
/.well-known/agent-card.json, the way robots crawled pages
- a cross-platform index, not one per cloud
- ranking, because "sushi, party of two, Friday at eight, deposit under a euro, near me" is a relevance problem before it is a protocol problem
- verified identity, so a card provably belongs to the business it claims
- liveness, because a stale card is worse than no card
The analogy is exact and slightly uncomfortable. Cards are the websites. Registries are whois
and sitemaps. What is missing is Google. Whoever builds it will also create a discipline that
does not exist yet, which is optimising a card and its skill descriptions for retrieval. The
docstring-is-prompt-text rule from Part 1 turns out to be the same rule as card quality.
Gap three: no merchant can build one
A restaurateur is not going to run a deploy script.
That sentence is the entire gap. Everything in this series was built by someone comfortable with
IAM roles, and the merchant it serves is fictional partly because a real one could not maintain
it.
The shape of the answer is visible in what already got easy. Onboarding a restaurant to the menu
knowledge base is dropping a
.txt file in a bucket. Deposit rules are a pure function with no
infrastructure in them. Both of those could be a form field.So the missing product is a hosted merchant-agent builder: card, menu, deposit policy, wallet and
guardrails, configured through a UI, deployed by someone else. Shopify for agents. Shopify did
not win because merchants could not have built storefronts; it won because they should not have
had to. Whoever ships that owns the long tail of merchants, which is where almost all merchants
are.
The thing that must be solved before any of this scales
A public agent is a public attack surface, and I hit every part of it. Prompt injection in a
booking note. Personal data arriving in free text that should never be stored. An anonymous
endpoint in front of a foundation model, which is an unbounded cost surface until you cap it.
Guardrails, PII anonymisation, rate limits and a token ceiling handled those.
The deeper problem is subtler, and it is the one I would put in front of anyone building agentic
commerce.
Models are unreliable narrators about identifiers. My merchant once confirmed a booking
against a reference that was not the live reservation. It was the example in the tool's own
docstring. A docstring ships on every request, so it is prompt text, and its examples are anchors
that a model reaches for when it needs a plausible identifier. A signed payment came close to
being applied to the wrong booking, and the only reason it was not is that the settlement path
refuses to settle unless the reservation is held, has a deposit due and is unpaid.
A server-side invariant caught what the model got wrong. That generalises into three rules I
would apply to any commerce agent:
- Identifiers that control money travel in structured channels, never in model output.
- Merchant-side invariants trust no client, agent or human.
- Every settlement leaves a verifiable record, because directories and crawlers will eventually need to prove what happened.
The reassuring part is that none of this requires new cryptography. It requires the discipline
that payments infrastructure has had for decades, applied to a caller that improvises.
What I think happens next
Falsifiable, so you can hold me to it.
Within 12 to 18 months, one mainstream assistant ships a native A2A client with a wallet and a
mandate approval flow. Most likely from a payments-aligned surface rather than a model vendor,
because the wallet is the hard part and the model vendors do not have one.
MCP stays the universal tool layer and does not become the payment layer. It is winning at
what it is good at. Payment wants a challenge-and-proof envelope, which is a different shape.
Directories arrive per-cloud first, then a crawler. The registry-synced-from-public-card
pattern is the seam a crawler will use, and it already works.
Websites do not die. They become the human-readable mirror of the card, the way desktop sites
persisted after apps. The card becomes the source of truth and the page becomes the rendering.
The payment war resolves into a mandate standard over plural settlement rails, because that is
how checkout already works and nobody wants to relitigate card-versus-stablecoin at the protocol
layer.
Closing
A restaurant's independence used to cost 15-30% to a platform, PCI exposure it could not carry,
and its customers' data. What replaced all three in this build: one agent card, one text-file
menu, one wallet address, ten-cent deposits, and a human who still says yes.
The missing pieces are client-side and cultural, not cryptographic. The rails work. What is not
ready is the ecosystem around them, and that is a much better problem to have, because ecosystems
are built by people deciding to build them.
"Agents for Humans" is not decoration on this project. The human approves the payment. The
merchant never sees the calendar. The machine does the legwork.
Code:
table-relay , Apache-2.0, built for the Agents for Humans hackathon. All restaurants,
menus and reservations are fictional. All settlement runs on Base Sepolia testnet, so no real
funds are involved.Series: Headless Merchants, Real Payments (3 articles)
- 3Agents for Humans: merchant agents will replace websites. The rails are ready; the ecosystem isn't This article
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article