agent-ready · documentation

Make your docs readable by Cursor, Claude, and ChatGPT.

Every integration starts with a developer asking an agent 'how do I use X?'. If your docs are a JS-rendered shell, return blank HTML to non-JS clients, or scatter code examples without language hints, the agent guesses — and the integration goes to a competitor whose docs render. Five things to ship, starting with a ten-minute llms.txt file.

Mintlify / Docusaurus / Nextra users: most of this works out of the box. Ten minutes of polish gets you the rest.

Why docs matter for agents

Docs are the integration layer.

Cursor pulls docs into context. Claude reads URLs developers paste. ChatGPT scrapes the page when asked. Every meaningful integration starts with someone asking an agent "how do I use X?" and the agent quoting your docs. If your docs site is a JS-rendered shell, the agent gets nothing — and the integration goes to a competitor whose docs render.

5 things docs sites miss

The docs agent-readiness diagnostic.

1

JS-rendered docs return blank HTML to agents

Custom React/Vue docs that hydrate on the client return <div id="root"></div> to anything not running JS. Cursor and Claude's fetcher get nothing.

→ Agent fetches your URL: blank shell. Hallucinates the API surface from prior training.

Fix: SSR / SSG (Next.js, Astro, Mintlify, Docusaurus). At minimum, output a static <noscript> block with the page's text content + structured frontmatter so agents have something to read.

2

No llms.txt — agents don't know what's important

Your docs have 500 pages. Which 20 should an agent prioritize? Without an llms.txt sitemap-for-agents at your domain root, the agent picks random pages or — worse — uses an LLM-generated guess.

→ Agent pulls /docs/changelog/2019-04 instead of /docs/quickstart.

Fix: Ship /llms.txt with curated priority pages, key examples, and structural hints. Anthropic and Cloudflare both publish one — copy their structure. Ten minutes of work, dramatic context-quality improvement.

3

Code examples without runnable metadata

Code blocks rendered as <pre>text</pre> without language hints, imports, or test status. Agents copy-paste, hit "ReferenceError: stripe is not defined", and the user blames your docs.

→ Agent's generated code uses your API correctly but missing imports. User sees error, distrusts the integration.

Fix: Every code block: explicit class="language-python", include imports, mark with data-runnable="true" if it runs as-is. Test each example in CI against the current API version. Stale examples kill agent trust.

4

No versioning signals — agents pull stale docs

You shipped v3, but agents trained on web crawls from 6 months ago still reference v2 endpoints. Without explicit version metadata + "older version" callouts on v2 pages, the agent doesn't know it's looking at stale content.

→ Agent writes integration against deprecated v2 API. Production silently breaks.

Fix: Add datePublished + softwareVersion in JSON-LD on every page. Mark older versions with a banner ("v2 — current is v3"). Ship /docs/changelog.json with structured version-by-version changes. Agents parse all three.

5

No structured search — agents scrape

Your docs site has a search box that returns HTML results. Agents extract from HTML, miss context, hallucinate. A structured search endpoint that returns relevant chunks as JSON would let agents query "how do I authenticate?" and get a clean snippet.

→ Agent makes 5 requests to your docs site, parses each, mostly guesses.

Fix: Expose GET /search.json?q=… returning { chunks: [{ title, content, url, version }] }. Or expose a docs MCP server with search_docs, get_code_example, list_endpoints tools — the wmcp.sh managed service ships this for you.

The fix in priority order

Four things, escalating value.

1. Static HTML

SSR / SSG. Mintlify and Docusaurus do this out of box. The floor — without it, nothing else matters.

2. llms.txt

Ten minutes of work. Maps agents to your priority pages. Massive context-quality lift.

3. Code-example metadata

Language hints + imports + runnable flag. Stale examples kill agent trust faster than missing pages.

4. Docs MCP server

Structured search + code examples + version diffs as tools. Top tier — separates Stripe-tier docs from the rest.

10-minute docs checklist

→curl -A 'wmcp-check' https://your-docs.com/quickstart | grep -c "<p>". Returns >0? Static HTML. Returns 0? JS-rendered — fix #1.
→curl -I https://your-docs.com/llms.txt. 200? Good. 404? Ship one — 10 lines of markdown.
→Open your top quickstart page in Chrome. View source. Confirm <pre><code class="language-…"> on every code block. If missing, fix #3.
→Try asking Cursor / Claude "how do I authenticate with <your-product>?". Does it cite your current docs? If it cites old version or hallucinates, you need #4 or #5.
Sample llms.txt

The simplest agent-readiness ship.

Copy this template, adjust paths, host at https://your-domain.com/llms.txt.

# YourProduct Documentation

> A short one-paragraph description of what your product does.
> Agents read this first. Keep it factual + specific.

## Priority pages — start here

- [Quickstart](https://your-docs.com/quickstart): 5-minute integration
- [Authentication](https://your-docs.com/auth): API keys + OAuth 2.1 + PKCE
- [Concepts](https://your-docs.com/concepts): customers, charges, refunds

## API reference

- [Full reference](https://your-docs.com/reference)
- [OpenAPI spec](https://your-docs.com/openapi.json)
- [Postman collection](https://your-docs.com/postman.json)

## Code examples

- [Python](https://your-docs.com/examples/python)
- [TypeScript](https://your-docs.com/examples/typescript)
- [cURL](https://your-docs.com/examples/curl)

## Changelog + versioning

- [Changelog](https://your-docs.com/changelog)
- [v3 migration](https://your-docs.com/v3-migration)

## Optional — what NOT to use

- ❌ /docs/v2 (deprecated, use /docs/v3)
- ❌ /internal (employee-only)
Two ways forward
Free · ~30 min

DIY: ship llms.txt + metadata

Static HTML, llms.txt, language hints on code blocks. Most modern docs frameworks do most of this — you mostly check + ship the gaps.

  • Add /llms.txt (the template above)
  • Fix language hints in code blocks
  • Add JSON-LD Article + softwareVersion per page
  • Run wmcp.sh adapter chain against your docs URL — it surfaces what's missing
Start free →
$999/mo · ongoing

Managed: docs MCP server

We ingest your docs into a structured index + ship a docs MCP server with search, code-example retrieval, version-diff tools. White-label option at docs-mcp.yourbrand.com.

  • Continuous indexing as you ship doc updates
  • Tools: search_docs, get_code_example, get_endpoint, get_version_diff
  • Agent traffic analytics (which queries hit your docs)
  • Stale-example detection — CI integration with your repo
  • Optional white-label MCP subdomain
Get audit →
FAQ

Common questions from docs teams.

How do AI agents discover and use documentation today?
Three paths: (1) Cursor's Composer pulls docs into context during integration tasks. (2) Claude / ChatGPT use web-fetch tools when given a URL. (3) Pre-indexed in training data (mostly only Stripe-tier well-known docs). Paths (1) and (2) need static-HTML or structured-markdown — not a JS-rendered shell.
What's the simplest thing I can ship today?
An llms.txt file at your domain root, modeled after robots.txt. Convention is emerging — Anthropic, Cloudflare ship one. Five lines of markdown, ten minutes of work, dramatically improves Cursor / Claude context.
Mintlify / Docusaurus / Nextra / GitBook — agent-ready?
Partially. All four generate static HTML (main hurdle cleared). Mintlify has best out-of-box agent support (structured JSON per page). Docusaurus + Nextra need a plugin or /llms.txt sidecar. GitBook locks structured content behind their API. Choosing today: Mintlify > Nextra > Docusaurus > GitBook.
What's a docs MCP server and do I need one?
An MCP server exposing search_docs(query), get_code_example(language, topic), get_version_diff(from, to) as tools. Instead of agents scraping, they call typed tools. Cloudflare ships one for docs.cloudflare.com. Worth shipping if developer adoption matters — separates top-tier docs from the rest.
How do I make code examples agent-friendly?
Three things: explicit class="language-LANG"; include imports / setup; test against current API version in CI and mark stale examples. Stale examples kill agent trust fast.
Should I ship a vector embedding API for my docs?
Probably not directly. Agents have their own embedding stacks. More useful: ship structured search via /search.json?q= returning chunked JSON. Or use the managed wmcp.sh docs adapter.
What about versioning? Agents see stale docs all the time.
Add datePublished + softwareVersion in JSON-LD per page. Maintain /docs/changelog.json with version-by-version changes. Mark deprecated examples. Add "older version" banners — agents parse them.
Docs-adjacent on wmcp.sh

Live integrations for content-heavy products.

If your docs live in Notion, or your docs ARE your product (knowledge base, wiki), these wmcp.sh integrations are the closest match:

→ Notion integration

Pages and databases as agent-callable tools. Same pattern works for docs-as-Notion-pages.

→ OpenAPI (if your docs are an API surface)

Documentation often references an OpenAPI spec. wmcp.sh ingests the spec directly — your docs become the index, the spec is the tool surface.