curl -s https://www.pathwren.workers.dev/mcp-markdown.json   # this page, as JSON

No key, no account, no handshake — every page here has a JSON twin one hop away. Machine doors: 6 keyless GET tools · documents.json · changes · llms.txt · openapi.json · agent card · mcp · a2a

Markdown Lane Check — MCP server

Connect it: one paste, one call

https://www.pathwren.workers.dev/mcp/markdown
no auth, read-only, public

That is the whole endpoint and those are its terms: Streamable HTTP (MCP), no API key, no account, no OAuth, no session to keep alive, nothing to install. Every tool is read-only, and two of them fetch the URL you name — and both refuse this host, ephemeral tunnels, IP literals and private names before any socket opens.

The JSON a connector config wants — Claude Desktop, Cursor, VS Code, Windsurf, Cline, LibreChat, Continue, anything that takes an mcpServers block. Complete as it stands; there is no field to fill in:

{
  "mcpServers": {
    "markdown-lane-check": {
      "type": "streamable-http",
      "url": "https://www.pathwren.workers.dev/mcp/markdown"
    }
  }
}

Claude Code takes one line instead:

claude mcp add --transport http markdown-lane-check https://www.pathwren.workers.dev/mcp/markdown

Then call markdown_lane_self_report first. It takes no arguments at all, so there is nothing to invent and nothing to look up before you can see this server work — the subject of the answer is the request you just sent:

curl -s https://www.pathwren.workers.dev/mcp/markdown \
  -H 'content-type: application/json' -H 'accept: application/json, text/event-stream' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"markdown_lane_self_report","arguments":{}}}' \
  | jq -r '.result.content[0].text' | head -3

You are calling as: curl/8.7.1
From: 203.0.113.7 (CF-Connecting-IP)
Our own instrument books that user-agent as: agent.

Those are the answer's own first three lines. The first two are whatever YOU sent — the sample shows a plain curl from a documentation address — and the third is what this host's own classifier makes of it. The rest of the answer adds which markdown addresses your own client has fetched on this host, and the .md address of every page it took as HTML instead, whether we have seen you here before, and what our robots policy says to your user-agent. Nothing is fetched to answer it, no argument exists. whoami is the second zero-argument call — the same body with the name changed, the one that works unchanged on all seven MCP servers here, and also a plain GET at /tools/whoami — and example is the third: it runs this server's own worked example for real and hands back exactly what a real call returns. All three are safe first calls.

An agent that reads your documentation as HTML spends most of its context on your navigation, your cookie banner and your footer. The fix is not a rewrite: it is the same document at a second address, in markdown, plus something that says where it is. Four conventions do that job — llms.txt, the .md twin, Accept: text/markdown, and <link rel="alternate" type="text/markdown"> — and almost every site that adopts one of them stops there, which leaves clients that use the other three where they started.

Why this server exists: the lane is not hypothetical

This host publishes every page at a second address with .md appended, and counts what fetches it. In the 24 hours to 2026-09-06-ish, measured from its own request log with our own self-checks excluded, the markdown lane carried 1,220 hits from 276 distinct external client keys — 8.2% of every client key this host saw in the day, and 1,173 of those keys were crawlers. The numbers behind that sentence are published as data, rebuilt every six hours: /data/markdown-lane.json (CC0). This server exists because somebody is walking that lane in volume on the open web, and most sites do not serve it.

# no arguments, nothing to sign up for: what YOUR client has fetched here, and this host's
# own lane in numbers
curl -s https://www.pathwren.workers.dev/mcp/markdown \
  -H 'content-type: application/json' -H 'accept: application/json, text/event-stream' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"markdown_lane_self_report","arguments":{}}}'

# your site, the real thing: six checks, each with a verdict and the exact fix
curl -s https://www.pathwren.workers.dev/mcp/markdown \
  -H 'content-type: application/json' -H 'accept: application/json, text/event-stream' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"check_markdown_lane",
       "arguments":{"url":"https://example.com/docs/getting-started"}}}' \
  | jq -r '.result.structuredContent.checks[] | "\(.pass)\t\(.check)\t\(.verdict)"'

Tools

Tool	What it does
`check_markdown_lane`	Reads the markdown lane of a URL you name and returns six verdicts with the exact fix for each: /llms.txt, /llms-full.txt, the .md twin of the page, Accept: text/markdown negotiation on the page itself, /sitemap.md, and whether the page ADVERTISES its twin with <link rel="alternate" type="text/markdown"> or the equivalent Link header. Each check reports served / missing / soft-404 / gated / unreachable — a 200 carrying an HTML 404 page is called out as the trap it is, because a client stores it as content. It makes one GET per check to the host you name, identified as pathwren-markdown-lane-check/1.0, and it refuses its own publisher and every ephemeral hostname before opening a socket. Example: arguments={"url":"https://example.com/"} returns the six verdicts for that origin.
`explain_llms_txt`	Parses an llms.txt — pasted as text, or fetched from a url you name — into its title, blockquote summary, sections and links, and returns findings by severity with the fix for each: no H1, no summary, links that point at HTML instead of the markdown twin, relative links that break when the file is copied into somebody else's index, a sitemap dump wearing an llms.txt name, HTML tags in the body, duplicate targets, and a missing `## Optional` section on a long list. Returns a ready-to-edit skeleton with every answer. Pasted text is parsed in the request and discarded; nothing is stored. Example: arguments={"url":"https://example.com"} fetches https://example.com/llms.txt and critiques it.
`whoami`	Takes no arguments. Safe to call. Deterministic. Touches no third party. Classifies the request you just sent: the user-agent you claim, the address you came from, the class this host's own instrument books you as, whether we have seen you here before and what you fetched, and what this host's robots policy says about you. Every fact comes from the headers on your own request or from a file this host already publishes — nothing is fetched, nothing about you is invented, no argument exists. Example: arguments={} returns your user-agent, your address, the class we book you as and whether we have seen you here before.
`example`	Takes no arguments. Safe to call. Deterministic. Touches no third party. Runs this server's own worked example end to end — one of its real tools, on a canned input taken from this host's own published data — and returns exactly the structuredContent a real call returns, not a mock and not a description of one. Use it to see the shape of an answer before you decide what to send. No URL of yours is fetched and no third party is touched. Example: arguments={} runs it and returns the real answer.

The six checks, and what each one is worth

/llms.txt. The first file an agent asks for. Its absence is a 404 in your log with no name on it — you never learn who wanted it.
/llms-full.txt. Optional: the whole corpus in one file, for a client that would rather take one request than forty. Reported as optional, never as a failure.
The .md twin. The same page at the same address with .md appended (or .html.md, if your URLs carry .html). No chrome, no nav. This is the check that decides how much of your content survives the trip into a context window.
Accept: text/markdown. The only way a client can ask for markdown without knowing your URL conventions. If it negotiates but omits Vary: Accept, a shared cache will hand your markdown to a browser and your HTML to an agent — reported as a warning, with the header to add.
/sitemap.md. Discovery. sitemap.xml tells a crawler where your pages are; this tells an agent where the readable copies are.
The pointer. <link rel="alternate" type="text/markdown"> in the page, or the equivalent Link: header. A twin nobody can discover is a twin nobody fetches, and this is the check most sites with a markdown lane still fail.

Every check reports served, missing, soft-404, gated or unreachable. A 200 carrying an HTML 404 page is called out as the trap it is: it is worse than a 404, because a client stores it as your content and never asks again.

What it will not fetch

It refuses to fetch this host. Point it at www.pathwren.workers.dev, at a subdomain of it, at an ephemeral tunnel or preview hostname, at an IP literal, at localhost, at a private name, at a URL carrying credentials or at a non-HTTP scheme, and it returns a refusal before any socket is opened. It uses the same guard as agent-discovery-doctor — imported from that server's source, not copied, so the day a new hostname of ours is added it is refused by every fetch tool here at once. A tool that fetches whatever URL a stranger hands it is an SSRF proxy with a friendly description; one published by a host that counts its own arrivals would also be a way to manufacture its own traffic.

A full lane check is seven requests to one host — six checks plus the page itself — with a 7-second timeout each and a 256 KB body cap, identified as pathwren-markdown-lane-check/1.0. Your URL is never stored, and text you paste into explain_llms_txt is parsed in the request and discarded.

Every tool answers with no arguments at all

markdown_lane_self_report, whoami and example take no arguments and make no outbound request whatsoever. example runs explain_llms_txt for real against this server's own reference skeleton, so you can read the shape of an answer before you send anything of yours. The other two tools accept {} as well and answer with their documented worked example, labelled as one.

How is this different from the other six?

agent-discovery-doctor fetches /llms.txt among twenty well-known documents and reports whether it is served. It never parses it, never looks for a .md twin, never negotiates Accept, and has no idea whether the links inside your llms.txt lead anywhere a model can read. This server does exactly those things and nothing else. No tool name in common with doctor, or with ai-crawler-index, crawler-log-triage, robots-policy-lint, crawler-ip-verifier or mcp-endpoint-lint.

Protocol versions 2025-06-18, negotiated per call. server/discover answers for clients on 2026-07-28, initialize for everyone else. Stateless, no key, no session. Everything on this page is also markdown at /mcp-markdown.md, which is the convention the server checks.