AWS Builder Center
Agents for Humans: merchant agents will replace websites. The rails are ready; the ecosystem isn't

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)

  1. 3
    Agents for Humans: merchant agents will replace websites. The rails are ready; the ecosystem isn't This article
Solutions Architect DevOps AI Engineer and CTO of TeamWork Mauritius

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:
  1. Identifiers that control money travel in structured channels, never in model output.
  1. Merchant-side invariants trust no client, agent or human.
  1. 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)

  1. 3
    Agents for Humans: merchant agents will replace websites. The rails are ready; the ecosystem isn't This article
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article