WebMCP × AMS — Steve Madden
WebMCP lets an agent act on a page. AMS gives it something worth building.
Agenten stärken
Installation vom Herausgeber. Kein PlugMCP-Endpunkt.
Host a copy with our keys and logs.
Noch kein paketiertes Release in der Registry. Folgen Sie der README des Repositorys.
Remote-URL oder ein Befehl auf Ihrem Rechner? Worin sich die beiden Installationen unterscheiden
Auf PlugMCP ausführen
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
StartenVom Herausgeber
WebMCP lets an agent act on a page. AMS gives it something worth building.
WebMCP × AMS — a Steve Madden storefront that composes itself around what an agent asks for. One command, 19 declared tools, no build.
Open it in ChatGPT's browser or Codex, copy the prompt from the overlay, and paste
it into your agent with that tab active. The storefront declares 16 tools on
navigator.modelContext; the prompt runs a five-beat demo that rebuilds the store
three times.
git clone https://github.com/40RTY-ai/40rty-ams-webmcp-playground
cd 40rty-ams-webmcp-playground
node scripts/serve.mjs # → http://localhost:4040
Same storefront, served through a local proxy so this repo's chrome can run on it:
a panel that lists every registered tool and logs every call as it lands, plus
how_to_use_this_site and get_demo_script alongside the store's own 16 — 19 tools
on one document. That panel is the protocol made visible, and it is the reason to
clone rather than just open the link.
No build, no dependencies, no API keys. Node only.
WebMCP is the browser API that lets a page declare its own tools on
navigator.modelContext, so an agent calls what a site offers instead of
guessing at its buttons. It answers how does an agent act on the web.
But point an agent at an ordinary storefront and those tools are only a better remote control for a page somebody authored months ago. The protocol got sharper; the page didn't move.
This store has no authored pages. It composes itself per request, over a real catalogue, with the brand's own AI. So a tool call doesn't navigate the store — it changes what the store is. Ask for a different palette and the occasion holds. Move the venue and the palette survives. The agent isn't operating a storefront; it's helping compose one.
That's the pairing this repo exists to show: the protocol that lets an agent act, on a surface that changes when it does. Nineteen tools on one page, and an inspector that logs every call as it lands, so the protocol is visible rather than asserted.
The page is the real Steve Madden storefront — real brand shell, real catalogue, the brand's own composing AI — with this repo's overlay on top of it. The server reverse-proxies the live storefront and injects the demo's chrome, so everything runs on one origin:
localhost:4040 ─proxy─► app.40rty.ai/stevemadden
│
├── the storefront's 16 WebMCP tools
└── + how_to_use_this_site, get_demo_script, start_demo
+ the tool inspector, on the storefront itself
That last part is why it is a proxy rather than a page that links out. The storefront is another origin, so nothing of ours can run on it — no inspector, no guide, no overlay. An iframe would be worse: the storefront's tools would register inside the frame, where a top-level agent cannot see them, silently costing the whole point. Proxied, all 19 tools sit on one document.
The AMS API accepts a localhost origin, so the session and the agent WebSocket work from here exactly as in production.
The page starts on the store's own default layout, and nothing is added to the
URL — no intent, no ?webmcp=1, no redirect. Every layout you then see is
something the agent asked for, the first look included. That is the demo: five
beats, all of them a send_message on the page already open, nothing to navigate.
Two things the server does so the demo can't stumble:
send_message fired the instant tools appear returns
TURN_FAILED / no_response. The agent's first call lands exactly in that window.
Gated, the same call returns 592 characters in 21.3s.UPSTREAM=https://host node scripts/serve.mjs points it somewhere else; PORT
moves the port. Anything you do pass (?intent=, ?session=) is forwarded
untouched.
A website cannot talk to an agent. Only an agent can.
The demo is not the first prompt — it's the second.
send_message:
"Flats for the beach instead." — "Now something for the reception."The layout rearranging itself around that second sentence is the thing no page could have been authored for. Nothing was clicked. That is a new store.
assets/demo-script.js carries a five-beat demo — The Wedding That Kept
Changing. It's on the home screen, and an agent can read it with
get_demo_script.
The arc is built on two pivots rather than incremental tightening, because a pivot is what a filtered grid cannot survive:
Naming the categories in beat 1 is what makes the first turn big: "a dress and heels" composes a small card, the line above composes four categories over a grid and rails.
The beach pivot's exact wording matters more than it looks. Three phrasings, measured:
And an earlier attempt that elaborated on the situation instead — "the wedding moved to a beach party, rework the whole look for sand and heat" — returned good prose and no look card at all. More words about the scenario is not a clearer instruction. Name the slots.
If a pivot still lands as sections with no card, don't buy from them. Ask the store to commit first — "Commit those pieces as one featured look I can buy." — then read the card. The prompt carries this recovery step.
The beach beat flaked once in four early runs (~5s, empty, nothing recomposed), distinct from the 15s cap. Say so and send it again rather than narrating a change that didn't occur.
The demo crosses a navigation to another origin, so the home screen cannot follow
you — and doesn't need to. The storefront reports its own state: get_messages
says which beats have been spoken, get_visitor_context which constraints the
brand actually registered, get_cart what was really bought. An agent that loses
its place re-reads those three and knows exactly where it is. That's better than
a counter this page would have to keep honest.
send_message on a cold page returns empty in about two
seconds and nothing composes — the opening beat looks like a dud and the pink
look only appears on beat 2. Delivered as ?intent=, AMS waits for the session
and submits properly. The home screen's Start the demo button does this.get_products returned every product on the
canvas — alternates included — summing to $944.94. There is no tool for "the
look" or its total, so an agent cannot quote the number the audience is reading.add_to_cart works and returns the resolved
variant, but no tool reads the cart, so a claim about its contents can't be
verified through the surface.The last two are exactly what AMS_AGENT_COMMERCE_WORKFLOWS.md proposes to fix.
The panel in the corner is the point. WebMCP is invisible by nature — without it, a reviewer with no agent attached sees a storefront and no evidence of a protocol. The panel:
inputSchemaSixteen tools come from the AMS space itself — on the storefront and on
/instrumented alike:
Variant ids are deliberately withheld. They're unstable across the
optimistic-write window, so an id held across a beat can aim a write at a line
that's already been replaced. Cart verbs bind product × selections late, against
live state — a stale reference can only miss and fail loudly. Writes are
stamped origin: 'webmcp'.
The playground adds one more, registered before the space's tools so that an
agent scanning listTools() meets it first:
The home screen registers how_to_use_this_site plus two of its own, so that
starting a conversation is on-protocol rather than the one step that happens
outside it:
Actions route through the same signal handlers the UI uses, so a tool call and a click hit identical code. Reads return live session state.
An agent that reads only a behavioural contract knows the rules and nothing
about the capability — so it treats send_message as a search box, types
"boots", gets a competent answer, and never discovers that it can ask for a
presentation rather than a filter. The guide in assets/ams-guide.js is the part
that closes that gap. It covers:
gid:// forms, what each tool returns, and that
responseText is non-empty only mid-turn while latestResponse is committedTwo sections exist because a live AI over a live catalogue can answer in the wrong shape without anything having failed, and an agent that doesn't know that works around it instead of asking:
What else you can ask for — the capabilities agents routinely never try. Ask for a shape ("show me how these compare", "fewer, with the trade-offs"). Ask it to commit a look when a page is browsable but not buyable. Ask for one slot to change and leave the rest. State a standing constraint once and it survives every later recomposition.
When the answer looks wrong — situation to response, all observed:
The habit underneath all of it: when the store gives you something you can't use, ask it for what's missing rather than working around it. It will do it, and the asking is itself the demo.
Only one channel is guaranteed, and it is worth being precise about which:
So the handful of facts an agent will otherwise get wrong — rather than merely
miss — ride the guaranteed channel. As each tool passes through the host, a short
OPERATING NOTES: clause is appended to send_message and show_collection
covering the 5–20s latency and the retry trap, intent-over-keywords, that you can
ask for a presentation, that follow-ups refine, and that the guide exists. Nothing
else is touched, and re-registration does not stack copies.
That is a deliberate intervention on what the space declares. It is done here because the playground is the client and this is the only channel with a hard guarantee — but the durable home for it is the tool definitions in AMS itself.
Verify any of this yourself, on any brand page, with no tooling:
PlaygroundWebMCP.selfCheck()
It reports the host mode, which tools carry the notes, where the guide sits in the registry, and the caveat on each opt-in channel.
The guide's full text still reaches an agent three ways, all from that one source:
llms.txt is generated, not hand-written — three hand-maintained copies of one
document is three chances to drift:
node scripts/gen-llms-txt.mjs # after editing assets/ams-guide.js
Everything the guide asserts comes from the registered tool surface itself or was measured against the live deployment. Keep it that way: an agent-facing document that drifts from the tools is worse than none, because the agent will trust it over what it can see.
The playground installs its own instrumented host on navigator.modelContext
before the AMS embed loader boots, then injects the loader. Two cases:
registerTool is
recorded here and forwarded to the real host, with execute instrumented on
the way through. Tools reach the agent exactly as they would otherwise; the
inspector just gets to watch. Replacing the host would shadow the registry the
agent actually reads and the page would look broken to it.window.webmcp client so any agent that can run JavaScript can drive the page:await window.webmcp.listTools();
await window.webmcp.callTool('send_message', { message: 'wide-fit boots under $140' });
window.webmcp.instructions; // the operating contract for an external agent
Copy that contract straight from the inspector panel and paste it into a JS-capable browser agent.
Because tools register whenever a host exists, the surface comes up with or
without ?webmcp=1. The flag stays supported for parity with AMS (it also
reveals the embed's own copy-prompt pill), but dropping it costs you nothing.
index.html and space.html are the earlier flow: a static home screen that
hands off to the storefront in a new tab, plus an embedded view at
/instrumented. They still work and they deploy to static hosting, which the
proxy cannot. The proxy is the better demo — one origin, no handoff, the
inspector on the storefront itself — so it is what serve.mjs serves now. Keep
these for a shareable URL if one is needed.
No build, no dependencies, no secrets. Node is used only to serve files.
node scripts/serve.mjs # http://localhost:4040
The server mirrors the one rewrite in vercel.json (/instrumented →
space.html), which matters because the space is resolved from
location.pathname. Whether the page can reach the API from here depends on
that deployment accepting a localhost origin — see Deploying below.
This repo is a thin client over a live AMS deployment. It ships no catalog and no composer of its own: products, layouts and the composing AI all come from the AMS API, and the embed bundle itself is served from there (one self-contained file carrying React, the SDK, the component library and the compiled stylesheet). Clone-and-run works, but only against a reachable AMS.
Point it at yours in one place — assets/config.js:
window.PLAYGROUND_CONFIG = { apiBaseUrl: 'https://<your-ams-api>' };
The origin you serve this from must be accepted by that API. The same browser-origin check gates both the session request and the WebSocket upgrade that carries the agent channel, so on a hostname the API does not accept, the storefront never boots — and it fails quietly, which is the worst way for a demo to fail. Serve the playground from a hostname your AMS deployment already accepts rather than a fresh, unrelated one, and confirm it before you trust it:
curl -si -X OPTIONS https://<your-ams-api>/s/<space-slug> \
-H "Origin: https://<your-host>" \
-H "Access-Control-Request-Method: POST" | grep -i access-control-allow-origin
No Access-Control-Allow-Origin in the response means that origin is refused.
Check it again from a machine with no extensions and no browser flags before
sharing the link.
index.html the home screen — what AMS is, four intents, free text
space.html the instrumented view (/instrumented)
llms.txt the guide as a static document — GENERATED, do not hand-edit
assets/
config.js deployment values: the AMS API, and the storefront URL
intents.js the four intents, and how an intent becomes a storefront URL
brands.js the space the instrumented view embeds
ams-guide.js what AMS is and how to drive it — the agent-facing guide
operator-prompt.js the operating contract (mirrored) + guide composition
webmcp-host.js instrumented host — wraps a real one, or polyfills
inspector.js the visible tool + call-log panel
home-boot.js the home screen and its tool surface
space-boot.js instrumented view: host → gate → guide → inspector → embed
home.css home screen styling
scripts/
serve.mjs zero-dependency local server, mirrors the Vercel rewrite
gen-llms-txt.mjs regenerates llms.txt from ams-guide.js
vercel.json the /instrumented rewrite and cache headers
Every script is a classic, un-deferred <script> so execution order is exactly
source order. That is load-bearing: the host must be installed before anything
can call registerTool, and type="module" implies defer.
WebMCP × AMS — a Steve Madden storefront that composes itself around what an agent asks for. One command, 19 declared tools, no build.
Tools
Noch keine Tool-Liste. Remote-Server erhalten eine nach dem ersten Health-Check.
FAQ
Kopieren Sie auf dieser Seite die stdio-Konfiguration für Cursor, Claude Desktop, Claude Code oder VS Code. Sie nutzt die Installation des Herausgebers, keinen PlugMCP-Proxy.
In diesem Eintrag ist keine erforderliche Umgebungsvariable aufgeführt.
40rty Ams Webmcp Playground läuft lokal über stdio.
Zuletzt geprüft: 2026-10-26. WebMCP × AMS — a Steve Madden storefront that composes itself around what an agent asks for. One command, 19 declared tools, no build.