Groundcheck

Name: Groundcheck
Author: beepboop2025

by beepboop2025version 0.7.2i★ –iComputer or cloud

Registry nameio.github.beepboop2025/groundcheck

Install

Overview

Description from the maker (original English)

Verify claims, resolve FIGI identity, extract claims, and sign x402 delivery receipts over MCP.

PopNx MCP’s three pillars

These three are never merged into one score: opinions, measurements and popularity are different things.

User voiceiNo reviews yetReviews open together with accounts in a later step
Our basic checksi1 of 1 passedChecked from public information; code not scanned yet
UsageiNot measured yet★ –

What you can do with it

We have not written a plain-language summary for this one yet. Below are the facts we read from the registry.

Connection: Computer or cloud
Transport: stdio, Streamable HTTP
Category: Other

Install

Pick the AI app you use, then copy the settings.

Before you install

Basic checks: 1 of 1 passed
Runs on the maker’s server: what you ask it goes through their server.
You fill in yourself: GROUNDCHECK_ENGINE_URL

You need

Runs in the cloudNothing to install; it connects over the internet
npmNode.js installed (for the npx command)

Which app do you use?

ClaudeClaude CodeCursorVS CodeChatGPT

Pick your app above. We remember it, so next time the button says “Install in …”.

Works in Claude on the web, desktop and mobile:

Open Settings → Connectors
Press Add custom connector
Paste the address below and press Add
If it asks you to sign in, sign in with the maker

https://groundcheck.seiche.info/mcp

Or run it on your computer

Open Claude Desktop → Settings → Developer → Edit Config, and paste this into claude_desktop_config.json

{
  "mcpServers": {
    "groundcheck": {
      "command": "npx",
      "args": [
        "-y",
        "groundcheck-mcp"
      ],
      "env": {
        "GROUNDCHECK_ENGINE_URL": "your-value"
      }
    }
  }
}

Run this in your terminal

claude mcp add --transport http groundcheck https://groundcheck.seiche.info/mcp

Or run it on your computer

claude mcp add groundcheck --env GROUNDCHECK_ENGINE_URL=your-value -- npx -y groundcheck-mcp

Fill in the empty values before running it.

Open in Cursor

Or copy the settings yourself

Paste into .cursor/mcp.json in your project, or ~/.cursor/mcp.json

{
  "mcpServers": {
    "groundcheck": {
      "url": "https://groundcheck.seiche.info/mcp"
    }
  }
}

Or run it on your computer

Open in Cursor

Or copy the settings yourself

Paste into .cursor/mcp.json in your project, or ~/.cursor/mcp.json

{
  "mcpServers": {
    "groundcheck": {
      "command": "npx",
      "args": [
        "-y",
        "groundcheck-mcp"
      ],
      "env": {
        "GROUNDCHECK_ENGINE_URL": "your-value"
      }
    }
  }
}

Your browser asks to open the app, then the app shows the settings and asks you to confirm. Key values are left empty for you to fill in.

Open in VS Code

Or copy the settings yourself

Paste into .vscode/mcp.json in your project

{
  "servers": {
    "groundcheck": {
      "type": "http",
      "url": "https://groundcheck.seiche.info/mcp"
    }
  }
}

Or run it on your computer

Open in VS Code

Or copy the settings yourself

Paste into .vscode/mcp.json in your project

{
  "servers": {
    "groundcheck": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "-y",
        "groundcheck-mcp"
      ],
      "env": {
        "GROUNDCHECK_ENGINE_URL": "your-value"
      }
    }
  }
}

Your browser asks to open the app, then the app shows the settings and asks you to confirm. Key values are left empty for you to fill in.

ChatGPT connects only to servers on the internet:

Open ChatGPT on the web → Settings → Connectors (Apps)
Press Create or Add (some plans need Developer mode under Advanced first)
Paste the address below, give it a name and save
If it asks you to sign in, sign in with the maker

https://groundcheck.seiche.info/mcp

Menu names can differ slightly by plan and over time.

Your choice stays on this device in a cookie; no account needed.

Values you fill in

GROUNDCHECK_ENGINE_URL env
URL of the Groundcheck evidence engine. Defaults to http://127.0.0.1:8723 for a local engine; set to https://groundcheck.seiche.info to use the hosted engine.

These settings are generated from the maker’s registry entry. If the README says otherwise, follow the README.

What it can do

We have not read this server’s tool list yet; we check endpoints in rotation.

Basic checksi

We check information anyone can see; we have not read the code. Checks that do not apply are left out of the count. · Checked Nov 7, 2026

✓ Pass
Maker matches the repo
The registry name was verified with the GitHub account beepboop2025, which owns the repo
… Not checked yet
Still maintained
We have not read this repo from GitHub yet
… Not checked yet
Has a licence
We have not read this repo from GitHub yet
… Not checked yet
Endpoint responds
Not checked yet; we check endpoints in rotation
… Not checked yet
Sign-in with OAuth
Not checked yet; we check endpoints in rotation
… Not checked yet
No hidden instructions in tool descriptions
Not checked yet; we read the tool list when we check the endpoint

Compared with others in Otheri

More stars than 0% of the other 32708 servers in this category
Published to the registry more recently than 52% of the other 32708 servers in this category
Basic checks equal to or better than 100% of the other 32708 servers in this category

Compared with every active server in this category in the registry. Stars count only when the publisher owns the repo.

Common questions

Is Groundcheck safe?

It passed 1 of 1 applicable basic checks. We have not read the code. Before adding a key or token, see what access the server asks for and use a key with only the permissions you need.

What keys or codes does it need?

The registry does not list a required key, though some servers ask you to sign in on first use.

Does it run on my computer or in the cloud?

Either way works: install it on your computer or connect to the cloud version.

Is it still maintained?

The GitHub repo last changed –, and the latest version (0.7.2) reached the registry 37 days ago.

Which apps can use it?

Apps that support MCP, such as Claude Desktop, Claude Code, Cursor and VS Code. It connects by URL, so apps that accept remote MCP servers work too, such as ChatGPT in developer mode.

What can I use instead?

In the same category: Spec Driven Development, Remote Desktop Commander, OpenTakeoff

Alternatives

Servers in the same category from other makers, sorted by stars.

Reading a card:★ GitHub starsiThree pillars: reviews · checks · usageiUpdated = latest version published to the registryi

Spec Driven Development

by formulahendry

MCP Server that facilitates spec-driven development workflows, not just Vibe Coding.

Runs on your computer★ 440MITUpdated 14 months ago

Install

Remote Desktop Commander

by desktop-commander

Remote Desktop Commander: use files, terminal and processes on your own computers from any AI app.

Runs in the cloud★ 211Updated 2 days ago

Install

OpenTakeoff

by Kentucky-ai

Construction takeoff for AI agents: load plans, set scale, measure, count, export with provenance.

Runs on your computerUpdated today

Install

README from the maker

Open the README

Copied from the maker’s repo as written. PopNx MCP has not reviewed or endorsed it. HTML, images and scripts are removed. Links lead off this site.

Groundcheck

Exact dated SOFR, EFFR and OBFR percentage claims use the NY Fed's official benchmark API before general retrieval. For example, SOFR was 3.88% on 2026-09-29. is compared with that effective date's published percentRate. The evidence retains the date, retrieval time and response digest. Missing or ambiguous prints remain unverified; the route does not infer a date, certify an original historical vintage, or transfer the language-model calibration.

The grounding check agents run before they commit to an answer.

Groundcheck verifies a factual claim against live sources and returns a verdict, a confidence score, and citations. Any agent — Claude Code, Cursor, your own — can call it mid-task, before it states a fact it isn't sure of.

It is also a verification layer for agentic commerce: when an agent pays another service over x402, attest_delivery verifies what was delivered against what was advertised and issues a signed, offline-verifiable delivery receipt binding payment → delivery → grounded content — the neutral accountability trail the a2a-payments literature calls the missing layer (docs/delivery-attestation.md).

Architecture

Two parts, each in the language that fits it:

server/   TypeScript MCP server   — thin protocol layer (stdio). Holds no logic.

engine/ Python FastAPI service — retrieval + stance classification + the verdict brain.

The MCP server is spawned by your client over stdio and talks to the engine over HTTP (GROUNDCHECK_ENGINE_URL, default http://127.0.0.1:8723). The engine is the single source of truth for how a verdict is reached, and it classifies source stance through the canonical Python free-llm-router (free-tier providers).

verify_claim ─▶ TS MCP server ─HTTP▶ Python engine

├─ retrieval (Wikipedia, keyless; or your own search) ├─ stance (free-llm-router → supports/refutes/neutral) └─ verdict (refuses on conflict, saturating confidence)

Tools

Tool	Use it when	Returns
`verify_claim(claim, maxSources?)`	About to assert a fact you're unsure of	`{ verdict, confidence, rationale, sources }`
`check_citations(text, maxClaims?)`	Before publishing an AI-generated draft	per-claim verdict report
`attribution_badge()`	Want to mark content as checked	a Markdown badge
`resolve_instrument(query, idType?, maxResults?)`	Text names a security and you need to know exactly which one	canonical FIGI records + provenance (Bloomberg open symbology)
`extract_claims(text, maxClaims?)`	Want to see which claims a document makes before paying to ground them	atomic checkable claims + a signed receipt bound to the input hash
`attest_delivery(service, response_text, …)`	You paid another service over x402 and will act on (or account for) its output	a signed delivery receipt binding payment → delivery → grounded content (docs)

verdict is one of supported · refuted · unverified. Each verdict also carries a sufficiency tag (sufficient · insufficient · no_sources · no_stance · conflict) so an agent can tell "I found nothing" from "sources exist but don't establish it" from "sources disagree" — the three ways an abstention happens carry different meaning and are no longer collapsed (SURE-RAG).

Compound claims are decomposed. A claim like _"Marie Curie won two Nobel Prizes and was born in Paris"_ is split into atoms (Fact in Fragments), each verified on its own evidence and recombined weakest-link: one false part refutes the whole, one unproven part blocks a supported. The true half can no longer carry the false half past the check. The atom breakdown is returned in atoms. (Decomposition is rule-based and high-precision — it splits only on clean conjunction boundaries and otherwise leaves the claim whole; disable with GROUNDCHECK_DECOMPOSE=0.)

Remote MCP (no install): add https://groundcheck.seiche.info/mcp as a remote MCP server (Claude/ChatGPT/Cursor connectors, or a gateway like Smithery/Glama). Speaks streamable-HTTP JSON-RPC; verify_claim is free, the paid tools answer HTTP 402 with an x402 offer.

Quickstart

The MCP server auto-starts the Python engine if one isn't already running, so a single registration is enough — no separate process to babysit.

make install                      # deps for both halves (pip + npm)

npm --prefix server run build # compile the server export GROQ_API_KEY="gsk_..." # one free key for stance classification (Groq: ~2 min, 14,400/day)

register with your MCP client — the engine spawns on first use and stops with the server

claude mcp add groundcheck -- node "$PWD/server/dist/server.js"

Already running the engine yourself (make engine or docker compose up -d)? The server detects and reuses it — and won't touch an engine it didn't start. Set GROUNDCHECK_NO_SPAWN=1 to stop it from ever spawning one.

Once published to npm, registration becomes claude mcp add groundcheck -- npx -y groundcheck-mcp.

Auto-spawn needs a local engine/ + Python deps; for an npx-only install, run the engine via

docker compose up -d and the server connects to it over GROUNDCHECK_ENGINE_URL.

With no provider key the engine still runs — retrieval works, but every verdict is unverified. It degrades honestly: a disabled backend, a missing key, or conflicting sources all flow toward unverified. An unconfigured Groundcheck cannot return supported.

Note: OpenRouter's :free models are quota-throttled (HTTP 429) and make a poor sole

provider. Prefer Groq or Cerebras for the fast classification tier.

Why grounded verdicts, not LLM-judgment

Asking an LLM to *judge* whether a claim is true is unreliable in a way that's easy to miss. In TraderBench (Yuan et al., 2026), the *same* candidate responses re-scored by three frontier LLM judges swung by ~29 points on the knowledge-retrieval section — while the performance-grounded section, whose scoring is anchored to verifiable computation, swung 0.3. The lesson: the more you constrain a judgment with external evidence, the less it varies.

Groundcheck is built on that principle. It never asks a model "is this true?" from parametric memory. Instead it:

retrieves sources first, then asks only the narrow, evidence-anchored question — does *this cited passage* support, refute, or stay neutral on the claim (stance classification);
refuses on conflict and saturates confidence, so disagreement flows to unverified rather than a confident guess;
returns citations, so the verdict is checkable, not taken on the model's word.

That's the difference between an LLM judge and a grounding check: the judge's discretion is the product; here it's deliberately fenced in by retrieved evidence.

Calibrated verdicts: the "error ≤ α" guarantee

A confidence number without a promise attached is just vibes with decimals. When a calibration artifact is deployed, Groundcheck attaches a guarantee object to directional verdicts, built with split conformal prediction (adapted from *Multi-LLM Adaptive Conformal Inference*, arXiv:2602.01285):

Stance classification runs as a panel: up to GROUNDCHECK_ENSEMBLE_MAX free providers judge the claim independently (different model families disagree on *which* claims they get wrong, so the ensemble beats any one of them). Per-source stances are majority-voted; each panelist also emits a probability the claim is true given only the snippets, combined into a weighted ensemble_score.
scripts/calibrate.py runs the real pipeline over a labeled claim set and stores finite-sample thresholds per claim group (instrument / general, global fallback) in calibration/calibration.json.
A verdict is certified (guarantee.certified: true) only when its score clears the threshold. The math guarantees that, for claims exchangeable with the calibration set, a false claim is certified `supported` with probability ≤ α (default 0.1), and symmetrically for refuted. No distributional assumptions, exact in finite samples.

Honest degradation, as everywhere else: no artifact → no guarantee is ever claimed; too little calibration data for a given α → the threshold is refused rather than extrapolated. The guarantee is only as good as the exchangeability assumption — recalibrate with domain claims before leaning on it in a new domain.

Configuration (engine)

Var	Default	Purpose
`GROUNDCHECK_SEARCH_BACKEND`	_(unset)_	`stub` to disable real retrieval
`GROUNDCHECK_SEARCH_URL`	Wikipedia	custom JSON search endpoint (`{results:[{title,url,snippet,stance?}]}`)
`GROUNDCHECK_SEARCH_KEY`	—	bearer token for the custom endpoint
`GROUNDCHECK_ROUTER_PATH`	sibling checkout	path to the `free-llm-router` Python package
`GROUNDCHECK_ENGINE_HOST` / `_PORT`	`127.0.0.1` / `8723`	engine bind address
`GROQ_API_KEY` _(or any router provider key)_	—	enables stance classification
`GROUNDCHECK_ENSEMBLE`	`1`	multi-provider stance panel (`0` = single-router)
`GROUNDCHECK_ENSEMBLE_MAX`	`3`	max concurrent panelists per claim
`GROUNDCHECK_CALIBRATION`	`calibration/calibration.json`	conformal artifact path

Machine-payable hosting (x402)

A hosted engine can charge AI agents per call in USDC over the x402 protocol — HTTP 402 + signed transfer authorization, no accounts or API keys. Dormant unless GROUNDCHECK_X402_PAY_TO is set; /verify stays free forever and is the way to evaluate output before paying; the paid surface prices as a granular verification loop: extract $0.005 → ground $0.02 → delivery-attestation bundle $0.05 (plus /resolve at $0.005). Both protocol generations (v1 and v2) are accepted, and agents can read the offer at GET /.well-known/x402. Full operator guide: docs/x402.md.

Server side:

Var	Default	Purpose
`GROUNDCHECK_ENGINE_URL`	`http://127.0.0.1:8723`	where the server finds the engine
`GROUNDCHECK_NO_SPAWN`	_(unset)_	set to disable auto-spawning the engine
`GROUNDCHECK_ENGINE_DIR`	repo `engine/`	engine location for auto-spawn
`GROUNDCHECK_PYTHON`	`python3`	interpreter used to spawn the engine
`GROUNDCHECK_REPO_URL`	repo URL	URL used in the attribution footer/badge

Development

make test        # engine pytest (verdict rule + x402 gating) + server typecheck

make engine # run the engine make server # run the MCP server in dev (tsx) make build # compile the server to server/dist

The interesting logic is in engine/groundcheck_engine/verdict.py: how much source agreement counts as "supported," how conflict is handled, and how confidence saturates.

MIT.

Groundcheck

Overview

PopNx MCP’s three pillars

What you can do with it

Install

Before you install

Or run it on your computer

Or run it on your computer

Or run it on your computer

Or run it on your computer

Values you fill in

What it can do

Basic checksi

Maker matches the repo

Still maintained

Has a licence

Endpoint responds

Sign-in with OAuth

No hidden instructions in tool descriptions

Compared with others in Otheri

Common questions

Alternatives

Spec Driven Development

Remote Desktop Commander

OpenTakeoff

README from the maker

Groundcheck

Architecture

Tools

Quickstart

register with your MCP client — the engine spawns on first use and stops with the server

Why grounded verdicts, not LLM-judgment

Calibrated verdicts: the "error ≤ α" guarantee

Configuration (engine)

Machine-payable hosting (x402)

Development