# honesty-mcp [Health: Active]

**Category:** 💻 Developer Tools  
**Repository:** https://github.com/lkopietz3-byte/honesty-mcp  
**GitHub Stars:** 0  
**npm Downloads (last month):** 808  
**Views:** 0  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/honesty-mcp

## Description
MCP server exposing 11 honesty-SDK kits (grounding, trust, audit, corroboration) as agent tools.

## Tools
Capabilities this server exposes over MCP:

- **check_grounding** — Checks citation structure in AI-generated text, sentence by sentence: uncited claims, honest placeholders, and citations whose marker is missing or whose evidence doesn't match lexically. Structural only; it does not verify that the evidence is true. The word-overlap matcher rejects some faithful p…
- **corroborate_evidence** — Reports the evidence direction (supports / contradicts / mixed / none) and a graded verdict from distinct sources, not a vote count. With corroboration-kit 0.3 and later, sources count by independent origin (pages of one site count once unless you declare an `origin`). Independence is not verified,…
- **check_payout_invariance** — Checks, for the scenarios you supply, whether a ranking engine's output changes with who pays more (`runtime` mode, off unless `HONESTY_MCP_ENABLE_CODE_EXEC=1`) or whether payout identifiers appear in source text you send (`static-imports` mode, always available; it never reads files from disk). St…
- **check_mutation_invariance** — Off unless `HONESTY_MCP_ENABLE_CODE_EXEC=1` (it is not listed otherwise). Checks, for the scenarios you supply, whether a decision/score/ranking function's output depends on a variable it claims not to (protected attribute, geography, price, or anything you name). Not a formal proof for every possi…
- **score_trust_identified** — Scores an entity from known, identified contributors (reviewer accounts, raters, inspectors), shrinking thin evidence toward a prior. With no weighted evidence it returns the prior with `insufficient` confidence, not a measured score.
- **assess_anonymous_authenticity** — Scores unattributed/scraped sentiment on how organic it looks, with a heuristic discount for two specific patterns (source concentration, unusually uniform sentiment). It does not detect fabrication or verify independence, it is not a sentiment ranking (a strongly negative corpus scores lower than…
- **check_provenance_claims** — Flags certainty-implying language ("(verified)", "guaranteed") not backed by an appropriate provenance tier. The default phrase list is short (eleven phrases) and phrases match as word prefixes.
- **check_claims_registry** — Buckets public-facing claims as current / stale / unverified against their linked evidence and last-verified date. With claims-registry-kit 0.4 and later, a placeholder reference such as `TODO` is unverified and the age limit is exact to the millisecond.
- **append_audit_entry** — Appends one entry to a hash-chained, tamper-evident audit log.
- **verify_audit_chain** — Independently re-verifies a hash chain from genesis (an empty chain is valid with nothing checked); detects mutation and severed links unconditionally, plain tail deletion with `expectedMinLength`, and truncate-and-re-append (or a full rewrite) only with `anchor`; `expectedMinLength` alone does NOT…
- **grade_decision** — Grades one recommendation-and-decision pair against a before/after observation log, exposure-aligned, with separate floors per window and machine-readable refusal codes. `holding` requires both the exposed bad count to stay under `refuteThreshold` AND its bad rate to be below the baseline's (exact…
- **compute_divergence** — Measures how often an engine and a human disagreed, and where a later outcome exists, reports engine-right/human-right as separate, never-blended counts. The optional custom `groupBySource` input is off unless `HONESTY_MCP_ENABLE_CODE_EXEC=1`.
- **scaffold_agent_receipts** — Explains the issue-a-packet / verify-the-claim authorization pattern for AI agents, with an install step, a starter snippet, and (optionally) a live accepted/rejected worked example run against the real kit.
- **scaffold_cost_governor** — Explains the estimated pre-call spend check + cache-aware pricing math (default 0.1x cache-read rate, overridable per model via `cacheReadPerMillion`) + advisory (not concurrency-safe) check-then-commit usage-counting pattern (a commit failure after a successful call returns `commitError` instead o…

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `npx` (confidence: high):

```json
"mcpServers": {
  "honesty-mcp": {
    "command": "npx",
    "args": ["-y","honesty-mcp"]
  }
}
```

## Documentation

## What honesty-mcp MCP server does

The honesty-mcp MCP server gives coding agents access to a collection of small TypeScript checks for evaluating claims made by AI products. The tools cover citation structure, evidence corroboration, payout and mutation invariance, trust scoring, anonymous-content authenticity, provenance language, claims freshness, audit-chain integrity, recommendation quality, and disagreement between an engine and a human.

The server is a thin adapter rather than a second implementation of these checks. Each tool defines an input schema and calls the corresponding export from an honesty kit. Results are returned as structured MCP responses that an agent can inspect or use in a development workflow.

Use the honesty-mcp MCP server to review generated answers, inspect supplied evidence, test ranking or decision behavior against scenarios, maintain an audit trail, or evaluate whether public claims remain supported by their evidence. It is not a general fact-checker: several checks are structural or heuristic and do not establish that an external source is true.

## How it works

The server communicates through the stdio transport. It reads JSON-RPC requests from standard input and writes responses to standard output, while its startup message goes to standard error. It is intended for local MCP clients and does not expose an HTTP endpoint or listening port.

Inputs are supplied by the calling agent rather than loaded from a project automatically. For example, grounding checks receive draft text and source material, while invariance checks receive scenarios and a function to test. Static payout-import checking examines source text supplied to the tool and does not read files from disk.

Some results require careful interpretation. Grounding checks compare citation structure and lexical overlap, not factual truth. Corroboration reports evidence direction and graded results, but does not independently verify source independence. Invariance checks cover supplied scenarios and are not formal proofs across every possible input.

## Setup and configuration

Run the honesty-mcp MCP server without a local install by using `npx honesty-mcp`, or install it in a project with `npm install honesty-mcp`. A Claude Code configuration can launch it with `claude mcp add honesty-mcp -- npx -y honesty-mcp`. Other clients using an `mcpServers` configuration can define the server with the `npx` command and `-y honesty-mcp` argument.

The server works with its standard tool set without environment variables. Three JavaScript-execution paths are disabled by default. Set `HONESTY_MCP_ENABLE_CODE_EXEC=1` in the server environment to enable the runtime payout-invariance check, mutation-invariance check, and the optional live example behavior associated with scaffolding. Code execution should be enabled only after reviewing the inputs those tools will run.

## Tools and capabilities

The honesty-mcp MCP server includes tools for:

- Checking sentence-level citation structure and identifying uncited, placeholder, or structurally invalid claims.
- Comparing evidence direction and grading corroboration across distinct sources.
- Testing payout sensitivity and mutation sensitivity with supplied scenarios.
- Scoring identified contributors and assessing whether anonymous sentiment appears organic.
- Finding certainty language without suitable provenance and classifying claims as current, stale, or unverified.
- Appending to and independently verifying a hash-chained audit log.
- Grading a recommendation against an observation log and measuring engine-versus-human divergence.
- Generating guidance and starter material for agent receipts and cost-governor patterns.

Several tools have explicit limits. Trust scoring shrinks sparse evidence toward a prior, while anonymous authenticity scoring uses heuristics and does not detect fabrication. Audit verification can detect different classes of mutation or truncation depending on the supplied options. Read each result together with its refusal codes, confidence, direction, or limitation fields where provided.

## Limitations and notes

The checks are not universal guarantees. Lexical citation matching can reject faithful paraphrases or accept claims with substantial word overlap. A corroboration result does not prove independence, and a confirmed result may still describe confirmed contradiction if the direction is ignored. Scenario-based invariance testing cannot establish behavior for every possible configuration.

The server does not automatically browse sources, verify external facts, inspect files for static-import checks, or expose a web service. Agents must provide the material and scenarios to analyze. The underlying honesty kits are published npm dependencies, so installation resolves them from the public registry rather than local sibling repositories.

_Full upstream README: https://allmcps.com/mcp/honesty-mcp/readme_