Skip to content

MCP server

Verification Tools as an MCP Server

Last updated: 2026-07-034 min read

The Reality Graph MCP server brings AI coding verification knowledge into your AI assistant: a verification-debt calculator with a transparent calculation path, plus search over 50+ sourced articles, 40+ glossary definitions and the sector’s key statistics — in English and German. Free, read-only, no account, nothing stored. Add https://realitygraph.dev/api/mcp as a custom connector and ask away.

Contents

Seven tools, honestly scoped

ToolWhat it doesTry this prompt
check_verification_debtEstimates a team's verification debt from team parameters: the four published metrics, an annual cost range, the full calculation path, labeled assumptions, sources“We are 12 devs, about 60% of merges are AI-assisted, 25 reviewer hours a week. Check our verification debt.”
lint_task_specChecks whether a work order for an AI agent is verifiable before you hand it over: the four building blocks (goal, boundaries, criteria, validation), vague-adjective and unhappy-path checks, gap-closing questions, fill-in skeleton“Lint this task before I give it to the agent: ‘Make the login page faster and clean up the code.’”
get_task_contract_templateReturns the free fill-in template (v0) for a verifiable task contract — goal, non-goals, boundaries, acceptance criteria, validation plan, expected evidence — as markdown or machine-fillable JSON, with a filled example“Get the task contract template as JSON and fill it in for this feature request: …”
validate_task_contractValidates a filled task contract: verdict (PASS / PASS WITH WARNINGS / FAIL), four dimension scores, and a concrete fix per finding — deterministic form check“Validate this filled task contract before I hand it to the agent: {…}”
get_verification_report_templateThe fill-in template for the artifact you write right after a run: files changed and untouched, validation per criterion, skipped checks, limitations, explicit decision“Get the verification report template and pre-fill it from this diff and test output.”
searchFull-text search over the Reality Graph knowledge base: articles, glossary, FAQ answers and statistics on AI coding verification (EN + DE)“Search the Reality Graph knowledge base for the verification gap statistics.”
fetchRetrieves a document from a search result: summary, definitions, key facts, FAQ and sources, with the canonical URL“Fetch /verification-debt and summarize the countermeasures.”
The server's tools. All seven are read-only, deterministic, and free — no LLM runs on our side, so answers are fast and reproducible.

The calculator implements exactly the models published in Measuring Verification Debt and What Verification Debt Costs — same formulas, same thresholds, same sources. Every answer ends with its calculation path, because that is the point: claims should carry their evidence.

Connect from Claude (web, desktop, mobile)

Custom connectors are available from the Free plan (one custom connector; unlimited on Pro and above). In Claude, open Settings → Connectors → Add custom connector, paste the endpoint URL, and add it — no OAuth fields needed. Connectors added on the web also sync to the mobile apps.

claude-connector

Copy the URL
Settings → Connectors → Add custom connector

Name:  Reality Graph Verification Tools
URL:   https://realitygraph.dev/api/mcp

For Claude Code, one command is enough:

claude-code

Terminal
claude mcp add --transport http reality-graph https://realitygraph.dev/api/mcp

Connect from ChatGPT

Custom MCP connectors require developer mode (Plus, Pro, Business, Enterprise or Edu — on the web). Enable it under Settings → Apps & Connectors → Advanced settings → Developer mode, then create the connector:

chatgpt-connector

Developer mode
Settings → Connectors → Create

Name:            Reality Graph Verification Tools
MCP server URL:  https://realitygraph.dev/api/mcp
Authentication:  No authentication

Because the server exposes tools named search and fetch, it also works as a source in ChatGPT’s research-style connector mode, not just in developer mode.

Connect from Perplexity, Cursor and VS Code

Perplexity (Pro, Max, Enterprise): Settings → Connectors → Add custom connector → select Remote, paste the URL, set Authentication to None and Transport to Streamable HTTP.

Cursor — add to .cursor/mcp.json (project) or ~/.cursor/mcp.json (global):

mcp.json

Cursor
{
  "mcpServers": {
    "reality-graph": {
      "url": "https://realitygraph.dev/api/mcp"
    }
  }
}

VS Code (GitHub Copilot) — run MCP: Add Server from the command palette, or add to mcp.json:

mcp.json

VS Code
{
  "servers": {
    "reality-graph": {
      "type": "http",
      "url": "https://realitygraph.dev/api/mcp"
    }
  }
}

Security and privacy, by design

The server does

  • Answer read-only tool calls with published, sourced content
  • Process inputs statelessly in memory and discard them
  • Rate-limit requests and cap input sizes against abuse
  • State its assumptions and cite its sources in every answer

It does not

  • Store, log or reuse anything you send it
  • Require an account, API key, or OAuth
  • Set cookies or track users
  • Write, commit, or change anything anywhere

If these boundaries fit how your team wants to ship:

The endpoint is operated from Germany under GDPR by the operator named in the legal notice; details are in the privacy policy. The server follows the MCP specification’s stateless Streamable HTTP transport; tool descriptions are versioned in the open and never change at runtime. If you find a security issue, contact us via the contact page.

The free verification loop

The tools are designed as one loop around an AI coding run — the same loop the method articles describe, executable by hand and for free:

  1. Before: get_task_contract_template → fill it in → lint_task_spec / validate_task_contract until it passes.
  2. Run: your AI coding tool of choice does the work — the contract travels with the task.
  3. After: get_verification_report_template → record what was checked, what was skipped, and who decided.

Everything here is the manual edition of the loop Reality Graph runs locally as a product (private beta): evidence reports per run, with the same discipline and none of the typing. If the manual loop earns its keep in your team, that is the signal — early access is open.

WebMCP: the tools live inside the site, too

Beside the remote server, this site registers its tools in the browser via the emerging WebMCP standard (Chrome 149+ origin trial, document.modelContext): an in-browser AI agent visiting realitygraph.dev gets lint_task_spec, check_verification_debt and search_knowledge as callable page tools instead of guessing at the UI. Same implementation, same privacy posture — the page tools call the same stateless endpoint.

Why this exists

Reality Graph’s knowledge base — verification debt, the verification gap statistics, the glossary — is written to be quoted, with self-contained definitions and named sources. An MCP server is the shortest path from that knowledge to the place developers actually ask questions: their AI assistant. The product itself, a local-first verification layer for AI coding, stays local by design — this server only serves what is already public.

FAQ

What is the Reality Graph MCP server?
A free, public remote MCP (Model Context Protocol) server at https://realitygraph.dev/api/mcp. Once added as a connector, your AI assistant can estimate a team's verification debt with a transparent calculation path and search Reality Graph's knowledge base on AI coding verification — sourced statistics, glossary definitions, and methods — directly inside the chat.
Does it cost anything or require an account?
No. The server is free, requires no account, no API key and no OAuth. It is read-only and rate-limited against abuse. It exists so that the published knowledge base is usable where developers actually work: inside AI assistants.
What happens to the data I send to the tools?
Nothing is stored. The server is stateless: tool inputs are processed in memory to compute the answer and then discarded. There are no sessions, no cookies, no accounts, and request contents are never logged. Only anonymous operational metadata (tool name, response time, coarse client type) is kept transiently for capacity planning.
Which AI clients can use it?
Any MCP client that supports remote servers over Streamable HTTP: Claude (web, desktop and mobile — custom connectors are available from the Free plan), Claude Code, ChatGPT (developer mode, Plus and up), Perplexity (Pro and up), Cursor, VS Code with GitHub Copilot, Windsurf, and others. Connection steps for each are on this page.
How does the verification debt calculator work?
It is deterministic arithmetic, not an LLM: it implements the four published metrics (generation-to-verification ratio, review depth, unverified-merge rate, two-week churn) and the published cost model, and returns the full calculation path with every assumption labeled and every source cited. Only the team size is required; every additional parameter refines the estimate.
Can the tools change anything in my repository or account?
No. All seven tools are read-only and are declared as such via MCP tool annotations (readOnlyHint). The server computes and retrieves — it never writes, stores, or calls anything on your behalf.

Keep reading

Sources

Want to follow the beta, or test it when it opens?

Join early access