Documesh

• 

  Documesh WebMCP App

Inspiration

When something breaks at 2 AM, the fix is buried somewhere in dozens of doc sites, each with its own search, its own format, and its own idea of what "current version" means. And when an AI agent hunts for that fix, it's even worse: crawling page after page, scraping prose built for humans, burning thousands of tokens to find one config key.

Then WebMCP shipped in Chrome, and I surveyed the ecosystem it created: 322 sites exposing 1,817 agent tools. The pattern was impossible to miss, more than thirty ship near-identical shallow search_docs wrappers, every one locked to a single vendor. Not one could answer a cross-vendor question, cite a doc version, or let an agent act on an answer safely. The docs layer of the agentic web was stuck in 2019: prose for humans, scraped or ignored by agents.

The insight that became Documesh had two halves. Agents are the new visitors. When they arrive at a debugging problem, they need one declared, machine-actionable interface to all the official documentation, not thirty-eight walled gardens. And attention is the real cost, every scraped page dumped into context is tokens spent on noise, when one structured call should return exactly the doc section that matters, with the version and license attached. So I built the mesh I wanted my agent to have: one WebMCP endpoint for the whole stack.

What it does

Documesh gives agents a single endpoint for debugging multi-stack applications: match any multi-stack error signature to the closest official documentation, cited, versioned, attributed. Every time.

• Federated search of 47 sources synced for now (from a 555-source verified registry), 36,000+ doc sections. Every result carries source, version, license, attribution, canonical URL, and last-updated.
• Error → docs bridge paste a stack trace; explain_error extracts error signatures and returns the closest official doc sections, with an honest disclaimer: closest matches, not a diagnosis.
• Chainable answers: every result carries a machine-actionable object: exact config keys, language-tagged code snippets, runnable CLI commands, version applicability. The agent orchestrates; Documesh makes answers reliable enough to chain.
• An act surface with one rule: verify configs against documented keys, compare config conventions across vendors, check provider status ("is it down, or is it me?" anw, it caught a real Cloudflare outage during testing), report outdated docs. Every write is an append-only proposal, agents never mutate the mesh directly.
• All exposed as 9 tools across three protocols: WebMCP in the browser, MCP over Streamable HTTP, and plain REST.

How we built it

License-aware from the first byte: a Python indexer crawls docs through five ingestion patterns only via vendor-consented interfaces (llms.txt) or permissive licenses (CC-BY-4.0, MIT, Apache-2.0). Terraform (BUSL) and copyrighted docs are documented exclusions, license awareness as a feature. Always

Search lives in the indexed, lived on Cloudflare. The extraction path has no LLM. deterministic extraction means excerpts are data, not instructions, and a hostile docs page can't prompt-inject through results. Provenance is enforced by schema audit (100% coverage), and search quality is CI-gated at ≥80% on real-world errors.

Challenges we ran into

The legal maze, most vendor docs are copyrighted with no agent interface; the rule that resolved it: vendor-consented interfaces or permissive licenses, excerpts + canonical links, never mirrors. Search architecture hit a wall 47 static shards loaded into Worker isolate memory (~65 MB) per query; D1 FTS5 dropped per-request memory to ~0. Honest machine-actionability the obvious shortcut was LLM extraction; deterministic is harder but never hallucinates a config key. Testing agents inside someone else's browser. WebMCP verification ultimately required a human, which is why the three-layer eval suite exists.

Accomplishments that we're proud of

• 47 sources / 36k+ sections / 555 registry
• 100% response provenance
• agent-readiness score 89/A
• eval gate 5/5, the act surface caught a real Cloudflare outage during testing
• three protocols, one mesh
• an npm SDK so others can chain on it. All solo, all on $0 infra.

What we learned

Declared contracts beat scraping, the agent doesn't break in, it's invited. Provenance is a feature, not overhead -> "cited, versioned, attributed" became a schema rule instead of a slogan. The agent is the orchestrator, tools should be structured enough to chain, not call each other. Honest abstention survived every skeptical reading. And every constraint became a documented next step instead of a dead end.

What's next for Documesh

547 verified sources queued for deep ingestion (47 live today) → /digest version-aware change feed → Vectorize hybrid search → webmcp-evals integration → MCP Apps UI → a contribution loop that makes the mesh self-correcting: documentation agents don't just read, but maintain.

Built With

• a2a-protocol
• cloudflare-d1
• cloudflare-workers
• document.modelcontext
• github-actions
• javascript
• json-rpc
• llms-txt
• mcp
• npm
• python
• rest-api
• typescript
• webmcp
• workers-ai
• x402