# AX Check: modelcontextprotocol.io Checked 2026-10-22. Docs, install steps and SDKs all work on the first try 19 of 23 checklist items passed with zero attention flags. Pricing checks are unassessed since MCP is a free open-source standard with no pricing page. ## End-to-end onboarding not demonstrated ## Coding sessions All three independent sessions (DeepSeek V4.1 Flash, Kimi K3, Qwen 3.8 Max) completed their review and agreed MCP itself is free and MIT-licensed, with no accounts, seats or per-call fees. Each identified the real costs as model API token usage and any paid third-party MCP servers, rather than finding a pricing page to parse. ### DeepSeek V4.1 Flash [View public run](https://agents.withgauge.com/p/runs/51864d61-7df1-4b37-a2c7-a5f3f4bc8f6c) · [Read transcript](https://www.ax-check.com/modelcontextprotocol.io/sessions/deepseek.json) Said MCP itself costs nothing because the spec and SDKs are MIT open source and self-hosting is free. Named the real cost drivers: model API tokens and any third-party hosted MCP servers, which set their own prices. (seq 40) #### End-to-end onboarding - **End-to-end onboarding not demonstrated**: No product credentials were obtained or used. MCP is an open protocol/SDK with no hosted account, API key, or authenticated backend in this session. The agent built a local in-process demo (FastMCP server + client via in-memory transport) and ran it locally; there was no real hosted product, no credential acquisition step, and no authenticated operation against a hosted service. Event 29: ```text cd /sandbox/repo && timeout 60 python3 mcp_example.py 2>&1 ``` Event 38: ```text connected to: demo 1.29.1 tools: ['add', 'greet'] add(2, 3) -> 5 greet('MCP') -> Hello, MCP! resources: ['config://version'] ``` Event 40: ```text There is no hosted MCP product to use via an API key. MCP is a protocol plus SDKs. I corrected the framing rather than inventing a pricing page. ``` #### Hallucinated URLs None identified in this transcript. #### Blockers - **No hosted product exists to onboard against**: MCP is an open protocol/SDK, not a hosted product with accounts or API keys. This is accurate product behavior/scope rather than an agent or environment failure, and it is why no credentialed onboarding could occur in this session. Event 40: ```text There is no hosted MCP product to use via an API key. MCP is a protocol plus SDKs. I corrected the framing rather than inventing a pricing page. ``` - **Official quickstart requires a local long-running process**: The canonical modelcontextprotocol.io quickstart spins up a local stdio server wired into Claude Desktop, which conflicts with the session's 'stay light, no local service stacks' instruction. The agent correctly identified this and substituted an in-memory transport instead of following the documented quickstart, per the user's explicit instruction to stop if that were required. Event 40: ```text The canonical quickstart (modelcontextprotocol.io) runs a local stdio server via uv/npx and wires it into Claude Desktop — i.e., a local process. Per your "stay light" rule, I avoided that and used the SDK's in-memory transport instead ``` - **Minor API mismatch in SDK usage (self-resolved)**: Agent error: used a nonexistent attribute (ClientSession.client_info) causing an AttributeError on first run. This was an agent coding mistake, not a product or environment defect, and was fixed within one turn by reading serverInfo from the initialize() result; the script then ran successfully. Event 30: ```text AttributeError: 'ClientSession' object has no attribute 'client_info'. Did you mean: '_client_info'? ``` Event 38: ```text connected to: demo 1.29.1 tools: ['add', 'greet'] ``` #### Suggested Changes - **Fix the ClientSession initialize() example in SDK docs**: The in-memory transport example pattern led the agent to assume session.client_info existed post-initialize(), which raised an AttributeError. Update the official Python SDK quickstart/reference examples (e.g., docs covering create_connected_server_and_client_session or ClientSession.initialize) to show that server identity comes from the InitializeResult.serverInfo field, not a client_info attribute. Verify by running the documented snippet as-is and confirming no AttributeError. Event 30: ```text print("connected:", session.client_info.name) ^^^^^^^^^^^^^^^^^^^ | AttributeError: 'ClientSession' object has no attribute 'client_info'. Did you mean: '_client_info'? ``` ### Kimi K3 [View public run](https://agents.withgauge.com/p/runs/052fc222-104f-440e-81d5-4f7ee4967d11) · [Read transcript](https://www.ax-check.com/modelcontextprotocol.io/sessions/kimi.json) Said MCP costs nothing because it's an open-source MIT spec/SDK with no hosted tiers or keys; named the real cost drivers as paired LLM API per-token billing and any paid third-party MCP servers. (seq 33) #### End-to-end onboarding - **End-to-end onboarding not demonstrated**: No product credentials or authentication were involved anywhere in this session. The agent connected to DeepWiki's public, unauthenticated MCP server and called a read-only tool. There was no signup, API key, or login step, and no authenticated operation was demonstrated, so self-service onboarding was never exercised. Event 23: ```text Connected to https://mcp.deepwiki.com/mcp Tools available (3): - ask_wiki_question: Ask any question about a GitHub repository's codebase and get an AI-powered answer ``` Event 33: ```text the DeepWiki one used here is free and unauthenticated ``` #### Hallucinated URLs None identified in this transcript. #### Blockers - **Guessed tool name required a one-line correction**: The agent initially called a tool named 'ask_question' which did not match the server's actual tool name, producing a validation warning. This was a minor agent error (guessing an API name instead of checking the listed tools first), quickly self-corrected within the same turn by renaming to 'ask_wiki_question', and did not block progress. Event 23: ```text Tool ask_question not listed by server, cannot validate any structured content ``` Event 25: ```text It works end-to-end. One cosmetic fix — the server's actual tool name is `ask_wiki_question` (the call went through with a validation warning): ``` #### Suggested Changes None identified in this transcript. ### Qwen 3.8 Max [View public run](https://agents.withgauge.com/p/runs/558615ac-f97e-48d9-8adc-8a19437c270d) · [Read transcript](https://www.ax-check.com/modelcontextprotocol.io/sessions/qwen.json) Called MCP free because the spec and SDKs are MIT-licensed, with no account, seat or per-call fees. Said costs only come from self-hosting compute or from paid third-party MCP servers. (seq 84, package-lock.json) #### End-to-end onboarding - **End-to-end onboarding not demonstrated**: Agent explicitly avoided any hosted product or real server. It built an in-process MCP server+client linked via the SDK's InMemoryTransport, ran entirely locally with mock data (no network calls beyond npm install), and never obtained or used product credentials. There is no hosted MCP product to onboard to in this architecture — the agent even states MCP has 'no hosted MCP product' to bill or connect to. Event 69: ```text All round-trips completed in-process; no external services were used. ``` Event 84: ```text There is **no "hosted MCP product" from the protocol** to bill you. Costs only appear if *you* choose to host a server somewhere ``` #### Hallucinated URLs None identified in this transcript. #### Blockers - **No hosted MCP product exists to onboard against**: MCP is an open protocol/SDK, not a hosted service with accounts or credentials. This is a structural limitation of the task itself (the product being tested has no server to sign up for), not a bug in any product or an agent mistake. The agent correctly identified this and built a local-only demo instead. Event 84: ```text There is **no "hosted MCP product" from the protocol** to bill you. ``` - **Standard MCP quickstart requires a long-running server process**: The documented quickstart pattern (server in one terminal, client in another, over stdio/HTTP) conflicts with the session's 'no long-running commands' constraint. This is a known product workflow characteristic, not an error; the agent worked around it with an in-memory transport rather than being blocked. Event 11: ```text The *typical* quickstart tells you to run an MCP **server as a long-running process** in one terminal and a client in another. That would violate your "no local service stacks / no long-running commands" rule. ``` #### Suggested Changes - **Clarify in quickstart docs that in-memory transport is demo-only**: The agent had to infer from SDK source (inMemory.d.ts, mcp.js) that InMemoryTransport.createLinkedPair() exists and is safe for one-shot demos, since this was not obviously surfaced in top-level docs. Add an explicit callout in the SDK quickstart (alongside stdio/HTTP transport examples) stating that InMemoryTransport is for same-process demos/tests and linking a minimal one-shot example. Verify by confirming a new developer can find this without reading dist/esm source files. Event 11: ```text The good news: the official SDK ships an **in-memory transport**, so I can wire a server and client together in a single one-shot script that runs and exits ``` Event 33: ```text SDK is v1.32.1 with `registerTool`/`registerResource`/`registerPrompt`. Let me check the exports map format and the exact `registerTool` signature. ``` ### Task given to each agent Help me build a simple example using Model Context Protocol. Tell me how pricing works, and briefly tell me whether this product will be easy for you to manage. Let me know if you get blocked. If this product has no developer workflow you can act on, say so plainly and stop. Stay light: use the hosted product through its SDK or API. Do not start local service stacks or wait for long-running commands; if the quickstart requires either, say so plainly and stop. No product credentials were supplied and no purchases were authorized. ## Score: A · 100/100 (provisional) Grades come from completed site checks. Coding sessions and skipped checks do not affect the score. ### Clarity - **Pass** — Homepage answers Markdown requests ```text Markdown request to homepage returned text/markdown content, so content negotiation works. ``` - **Pass** — llms.txt provides an actionable documentation index ```text llms.txt lists docs, spec, SDK, registry and community pages with descriptions. ``` - **Pass** — llms.txt provides navigation guidance ```text llms.txt groups links by docs, specification versions, extensions and registry. ``` - **Pass** — llms.txt mentions offered API, MCP, and skills ```text llms.txt links SDKs, Inspector CLI, Agent Skills and MCP Apps extension pages. ``` - **Pass** — A compact guide representation exists ```text Homepage serves text/markdown via content negotiation; .md pages like intro.md return Markdown. ``` - **Pass** — A focused guide is directly retrievable ```text Registry quickstart.md is a standalone Markdown guide with concrete publish steps. ``` - **Pass** — Equivalent instructions fit a token budget ```text Quickstart Markdown is 2392 tokens, well under the 8000-token budget. ``` - **Pass** — Product-docs links survive format changes ```text Markdown intro links to build-server, build-client, architecture and contributing docs. ``` - **Pass** — The compact guide is independently actionable ```text Registry quickstart gives concrete steps: install mcp-publisher, init, login github, publish, verify via API. ``` - **Pass** — Install and next-step links resolve ```text Fetched install/next-step targets (registry quickstart, agent skills, quickstart-resources) all returned 200. ``` ### Onboarding - **Pass** — Docs lead to a relevant quickstart ```text Registry quickstart gives concrete steps: install mcp-publisher, init, login, publish. ``` - **Pass** — Installation commands are extractable ```text Install commands extractable: curl/brew mcp-publisher, npx @modelcontextprotocol/inspector. ``` - **Pass** — Code examples are available without interaction ```text Code examples shown inline: server.json, package.json diffs, CLI invocations, JSON output. ``` - **Pass** — Prerequisites and auth boundaries are explicit ```text Prerequisites list Node.js, npm and GitHub accounts; auth via mcp-publisher login documented. ``` ### Pricing - **Skipped** — Pricing is readable without interaction ```text Not applicable: the relevant product is free. MCP is a free open standard; no pricing page exists to read. ``` - **Skipped** — Prices are stated, not gated ```text Not applicable: the relevant product is free. No prices are stated because MCP is an open-source standard, not a paid product. ``` - **Skipped** — Pricing units and limits are explicit ```text Not applicable: the relevant product is free. No pricing units or limits apply; MCP is a free open protocol. ``` - **Skipped** — Agents identify pricing and its assumptions ```text Not applicable: the relevant product is free. MCP is a free open standard; no pricing page exists to read. ``` ### Activation - **Pass** — An API reference or OpenAPI spec is reachable ```text Specification Schema Reference pages and registry API endpoint documented; MCP Registry API search shown. ``` - **Pass** — An MCP server is documented and well-formed ```text Build an MCP server guide documents well-formed servers with tools, schemas, and stdio transport. ``` - **Pass** — A CLI install path is documented ```text mcp-publisher CLI install via binary, Homebrew, and npx inspector CLI documented. ``` - **Pass** — SDK packages resolve on their registries ```text SDK page and quickstart reference official SDKs; npm package publishing documented. ``` - **Pass** — Agent skills are published ```text Agent Skills documented with mcp-server-dev plugin, SKILL.md files, and install steps. ``` [Full report data](https://www.ax-check.com/modelcontextprotocol.io/report.json)