Source: wiki synthesis: Ramp’s Marketing-to-AI-Agents Experiment, WebMCP Directory (nekuda.ai), EmDash CMS
Refreshed 2026-10-27 from: raw/The_end_of_the_app_era_-_What_comes_next.md (https://www.youtube.com/watch?v=0j8wy4jUlsw) and raw/What_Really_Happens_When_AI_Agents_Meet_in_the_Wild.md (https://www.youtube.com/watch?v=btUxMt_tssA), Nate B Jones (AI News & Strategy Daily).
Refreshed 2026-11-01 from: raw/The_Future_Of_The_Internet_Isn_t_Open_For_Your_Agent._Muse_Dots_And_Claude_Duet_Will_Find_Out..md (https://www.youtube.com/watch?v=c3HHFL_lsLM), Nate B Jones.
Three 2026 sources, filed under three different topics, are facets of one shift: the web is being rebuilt to be discoverable, readable, and actionable by AI agents rather than humans. Ramp’s controlled experiment is the demand side — optimizing content so agents cite and choose you. The WebMCP directory is the interface side — sites exposing typed, callable tools to agents instead of read-only HTML. EmDash is the supply/authoring side — a CMS that stores content structurally and emits it to agents through a built-in MCP server. Read together, they sketch a stack: author content an agent can parse, expose actions an agent can invoke, and measure which formats and pages agents actually cite.
Key Takeaways
- One shift, three layers. Each source attacks “the web is built for humans” from a different angle: Ramp measures what gets cited, WebMCP exposes what gets invoked, EmDash governs what gets authored and stored.
- The web stops being read-only documents and starts being callable surface. WebMCP states this inversion directly via
navigator.modelContext; EmDash ships the same inversion through a per-site MCP server; Ramp’s data shows even read-only content needs reformatting (markdown beat schema) before agents reliably surface it. - Content vs. action is the load-bearing distinction. Ramp and the markdown-for-agents lineage optimize content agents read. WebMCP and EmDash’s MCP server expose actions agents take. Both layers are required — the WebMCP article itself frames the two as “content-side” vs. “action-side” of the same agent-readable-web thesis.
- Structured authoring upstream makes agent-readable output downstream cheaper. EmDash’s Portable Text (structured JSON, decoupled from presentation) renders the same content as web page, mobile, email, or API response; Ramp found markdown — not HTML-with-chrome — is what LLMs parse natively. A supply layer that stores structure can emit the format the demand-side experiment showed wins.
- Measurement is non-optional and the dials are unfamiliar. Ramp’s per-model variance (Claude cited heavily, ChatGPT stayed silent 32 days), misleading Cloudflare bot labels, and “agent trust ≠ SEO domain authority” all mean you cannot assume an agent-readable page is being read or surfaced — you have to instrument it.
- First-party reinforcement beyond the web (2026-06-09). [X signal — @AnthropicAI 2026-06-09] Anthropic’s research post “Agents in Biology” frames biology’s slow agent progress as an infrastructure problem, not a model-capability one — biological databases and tools were “built before cars” and aren’t agent-friendly, so the work is rebuilding the environment for agents. It’s this thesis applied to a non-web domain: the supply side has to be re-plumbed for agents before agent capability pays off. (Source:
raw/x-account-anthropicai-2064054837294354677.md, https://www.anthropic.com/research/agents-in-biology.)
How the three are facets of one shift
Demand side — Ramp: optimize so agents cite and choose you
Ramp’s 5-week controlled experiment tested three content formats (markdown / stripped HTML / schema) against three LLMs on ~50 pages, with Cloudflare Workers serving alternate content to detected bots. The headline finding: markdown beat schema and stripped HTML by a wide margin — LLMs are trained on markdown-heavy data and parse it natively. Per-model behavior diverged sharply (Claude named the program and linked the tracked URL by Day 12; ChatGPT produced zero matches for 32 straight days), and pages with higher existing AI-citation volume were far likelier to surface embedded content — an “agent trust” signal distinct from SEO domain authority. This is the demand side: given that agents now mediate discovery, what makes one site’s content the thing an agent repeats?
Interface side — WebMCP: expose callable tools, not just text
The WebMCP directory catalogs sites that expose typed tools via navigator.modelContext (built on the W3C webmachinelearning/webmcp draft) so browser-running agents can discover, inspect schemas, and invoke them — sites become callable, not just readable. The directory’s own framing makes the connection to Ramp explicit: most agent-readable-web work targets content (markdown for agents, schema markup, Ramp’s format A/B), whereas WebMCP targets actions — typed tools the agent invokes rather than text it reads. This is the interface side: once an agent has chosen you (the demand side), how does it act on your site without screen-scraping HTML?
Supply/authoring side — EmDash: a CMS that emits agent-consumable content
EmDash is an Astro + Cloudflare CMS pitched as a WordPress successor, and the WebMCP article already names it a sibling pattern (“CMS with built-in MCP server per site”). Two of its design choices map straight onto the other two layers. Portable Text stores content as structured JSON decoupled from presentation — the supply-side precondition for emitting the markdown-style, chrome-free payload Ramp found wins on the demand side. ^[inferred] And its built-in MCP server plus agent skills plus CLI mean Claude or ChatGPT can manage content and, by exposing the site’s operations to agents, it occupies the same interface layer WebMCP standardizes — EmDash rides a server-side CMS plugin, WebMCP rides browser APIs, but both hand agents typed operations rather than HTML. This is the supply side: where does agent-readable content and agent-callable action get authored, stored, and served from in the first place?
What combining them enables
Stacked, the three close a loop that no single layer closes alone:
- Author once, emit agent-native. A structured-storage CMS (EmDash’s Portable Text) can render the markdown-style payload Ramp’s experiment showed agents cite — the authoring layer feeds the demand layer the format it rewards.
- Read and act on the same site. Ramp optimizes what an agent reads and repeats; WebMCP (and EmDash’s MCP server) expose what an agent does next — booking, checkout, content ops — so discovery and action live on one surface instead of breaking at the HTML boundary.
- Measure the whole funnel. Ramp’s instrumentation discipline (per-variant tracked URLs, daily multi-model query monitoring, CDN bot-log review) is the missing measurement layer for the interface and supply sides — without it you cannot tell whether an agent-callable, agent-readable site is actually being read, invoked, or surfaced.
A useful caveat from the sources themselves: this is a young, partly inferred stack. WebMCP listed only 18 sites at fetch and its W3C draft trajectory is unsettled; EmDash’s MCP tool surface is undocumented in its README; and Ramp’s findings are from one B2B finance site over five weeks. The shared direction is well-evidenced; the integrated stack is a projection, not a shipped product.
October 2026: the supply side ships, and the web splits in two
From Nate B Jones; the company announcements are as he relays them.
- DoorDash sells through other people’s agents. On September 30 it announced text ordering in the US plus “a limited beta of their MCP.” Nate’s reading: “they want you to use their own assistant, but they want to be available when you use anybody else’s assistant… Door Dash wins even if you never ever ever touch their app experience again.”
- Salesforce offers data, its own model, and a door for other agents. Koa, “a reasoning model based on the Nemotron stack that Salesforce tuned to CRM,” was announced September 15, is “in pilot,” and was trained on synthetic data rather than customer data. Salesforce also has an agent control panel and lets other agents in, including Claude.
- Buy the data, build the workflow. Crustdata’s case study: a two-person recruiting firm built a custom Claude skill on Crustdata’s people-data APIs “instead of buying another packaged recruiting tool.” The founders supplied their selection criteria; Crustdata supplied structured work histories.
- Reachability is table stakes, not a moat. “Being reachable by an agent in 2026 and 2027 is going to get you considered in the conversation. It is table stakes. It does not establish why someone ought to keep paying you.”
- Nate’s three-layer test for anyone buying or selling software: know your position on the data layer, the application layer and the agentic layer. When buying, go past “do you have AI?” to whether the vendor has the data layer figured out, an application layer that still makes sense, and an agentic layer “that gives us flexibility.”
- A two-tier web (
raw/What_Really_Happens_When_AI_Agents_Meet_in_the_Wild.md). Tier one: “very hardened up sites” where agents “will have a lot of difficulty operating.” Nate cites Amazon closing the door and Shopify partnering with Muse. Tier two: sites without the money for strong defences, which he expects to “become hotbeds for agent activity,” including hidden agent-only messages such as “white on white text on a page.” He expects tools that tell human-directed agents from self-directed ones “by the early part of 2027” (prediction). - What this adds to the three facets above ^[inferred]: the supply side now has two exposures. Publish an MCP server or agent channel so assistants can buy from you, and scan your own pages for agent-visible text you did not write.
Late October 2026: three zones, and recognition as infrastructure
Added 2026-11-01 from Nate B Jones, raw/The_Future_Of_The_Internet_Isn_t_Open_For_Your_Agent._Muse_Dots_And_Claude_Duet_Will_Find_Out..md (https://www.youtube.com/watch?v=c3HHFL_lsLM). Company announcements are as he relays them. His premise: after “Black October” (the PHP flaws and agent-driven intrusions), sites have more reason to restrict agents, and “a smarter model isn’t going to be able to unlock that door that a business has decided to close.”
- His three zones for 2027 (refines the two-tier web above):
- Partnership zone: the business provides an accepted route, such as supported Shop Pay checkout or an invoice-payment pilot, and several competing assistants can use the same route.
- Aspiring-actor zone: the agent works through the existing site as a person would. His example is Duet’s browser for sites with no connector. It may finish, hit a changed page or account check, or stop, especially when sites ask agents not to proceed, “because agents want to be compliant.”
- No-go zone: the business refuses the agent or the action. His example is Amazon’s dispute with Muse (undisclosed agent access, no agreement, credential handling).
- The root problem is authorization. Banks have said agents are “all over our websites”; they cannot tell an enthusiast’s computer-use agent from an attacker’s, because agent and human browsing look “extremely similar.”
- Recognition is becoming a product. Cloudflare’s signed-agent system lets the sender attach a digital signature that Cloudflare verifies, and the site then sets rules for agent traffic: whether it can read a price, see a reservation or cancel one.
- Product facts for agents. Shopify’s October 28 expansion lets merchants review and publish facts specifically for agents, including return windows and shipping destinations, and opens catalog and checkout tools to other builders. Shopify describes Shop Pay inside Muse, Claude Duet and Instinct, and names Grok Bot as offering it for brands outside Shopify.
- Badly designed recognition can leak data. Jones says that during Black October, Claude in some cases leaked human email addresses to sites that had encoded “Agents, please identify yourself” in their pages. He gives no primary source.
- Hotel pages hide what agents need. A beautiful homepage can still bury a room’s cancellation terms. He cites Patrick Collison’s view that agents are “not fooled by jazzy marketing” and push toward product excellence.
- Intermediaries gain power because both sides need them: businesses want protection and assistants want to finish the job. Jones names Cloudflare, Google and Stripe and favours open standards (Cloudflare explicitly backs independent choice of identity provider, payment processor and agent partner).
- What this adds to the facets above ^[inferred]: the interface layer now needs an identity layer. Exposing callable tools (WebMCP, MCP servers) only helps agents the site can recognise and authorise; publishing agent-facing facts (Shopify) is the commerce version of Ramp’s agent-readable content.
Try It
- Decide which zone your site is in for each action (2026-11-01). For reading prices, holding a booking and paying, choose partnership, tolerate browsing, or block, and publish the facts an agent needs (cancellation and return terms, delivery dates) in plain text.
- Run Nate’s three-layer test on your next software purchase or renewal (data, application, agentic), and ask the vendor whether an outside agent can reach it over MCP. For a marketer or site-owner preparing for agent traffic:
- Pull your last 30 days of bot-classified CDN traffic first. Ramp’s strongest pre-experiment warning is that most marketers don’t know what’s already crawling them. Verify Cloudflare bot labels — “AI Search” rules silently miss Claude, ChatGPT, and Perplexity (they’re under “AI Assistant”).
- Serve markdown as your first agent-content variant, not schema. Ramp’s data is unambiguous: markdown wins. Pick one high-intent page for a minimum viable test before touching 50.
- Stand up per-model citation monitoring. A weekly diff of Claude + ChatGPT + Perplexity + Gemini answers to your top 10 prospect questions is the minimum signal. Plan for 3+ weeks of zero before declaring failure — Claude’s first relay came Day 12, ChatGPT stayed silent 32 days.
- Check whether your stack can emit structured, presentation-decoupled content. If you’re choosing a CMS, an agent-callable one (EmDash’s Portable Text + MCP server is the tracked example) lets you author once and emit the markdown-style payload agents parse — rather than retrofitting markdown onto HTML-with-chrome.
- Inspect the WebMCP directory to see who’s exposing callable tools.
curl https://webmcp.cool/api/v1/sites?type=liveand read the W3Cwebmachinelearning/webmcpdraft before committing — this is the action-side standard to watch. If you build agents,npx skills add nekuda-ai/webmcpinstalls the discovery + invocation skill. - Instrument actions, not just link clicks. Ramp found agents may not click; design conversion paths around trackable actions. The same applies if you expose callable tools — log invocations.
Related
- Reverse-Engineering Software With Coding Agents — the other reason the application layer alone stops being a moat
- Ramp’s Marketing-to-AI-Agents Experiment — demand side (which formats/pages agents cite)
- WebMCP Directory — interface side (sites exposing callable tools)
- EmDash CMS — supply/authoring side (agent-callable CMS)
- FLUQs framework — the Format/Lexicon/Update-cadence/Quality levers Ramp’s data informs
- AI SEO research hub — methodology-organized AI-citation cluster Ramp anchors
- Agents & Agentic Systems topic — home of the browser-agent infrastructure WebMCP sits in
- Microsoft Webwright — Playwright-fork peer on the browser-agent interface layer
- Miro Canvas — Shared Agent-Readable Context Layer — interface side: a team context surface (docs/diagrams/prototypes) that agents read and write via the Miro MCP.
- crawl4ai — the client-side inverse of this whole shift: an OSS crawler that converts the existing human web into clean, LLM-ready Markdown on the fly, without the site re-plumbing itself to be agent-readable.
Open Questions
- Does the markdown-wins finding survive on top of an agent-callable CMS? Ramp tested markdown served by a Cloudflare Worker on a human-authored site; whether a structured-storage CMS like EmDash emits a payload agents cite equally well is untested.
- Do per-site MCP servers (EmDash) and browser-API tools (WebMCP) converge or compete? Both expose typed operations; the WebMCP article flags the performance/auth/observability tradeoffs between them as unknown.
- Is there a measurement story for the action side? Ramp instruments content citation; no source in this set measures whether agents that can invoke a site’s tools actually do, or which tool schemas get invoked most.
- How small is the action-side surface today? WebMCP listed 18 sites at fetch; until directory-level adoption grows, the interface layer of this stack is more proposal than infrastructure.