Skip to main content
Glama

dokimo-mcp

Give an AI agent the ability to verify another agent's revenue claims.

An MCP server exposing Dokimo's evidence checks as tools any MCP client (Claude Desktop, IDE agents, custom agents) can call. It's the "agent that audits agents" — as tools.

Live, clickable version of what these tools do: https://dokimo.augaster.com/agent-audits-agents.html

This is a thin, self-contained client: it calls Dokimo's public endpoints and implements the public dokimo-merkle-v1 hashing scheme. It contains no proprietary code. MIT-licensed.

Tools

Tool

What it does

Network?

recompute_merkle_root(leaf, proof_path)

Local recompute — hash a leaf under dokimo-merkle-v1 and replay the proof path to a root, in this process, with no network call. Compare it to a package's claimed root yourself. It does not check the on-chain anchor.

none

verify_evidence_package(package)

Dokimo's check of one record, via its public A2A endpoint: recompute and check the anchored commitment (root + rule version, plus the close summary for v2 closes) against the on-chain anchor on Base. Returns verified: true only if both hold. The verdict is Dokimo's answer and is not signed — to avoid relying on it, recompute locally and read the anchor yourself (e.g. /verify.html).

Dokimo A2A

dokimo_agent_card()

Fetch Dokimo's public A2A agent card — what it can verify.

Dokimo

Verification model: there is no path to verified: true without (1) the caller's (leaf, proof_path) recomputing to the claimed root, and (2) the commitment of (root, rule_version_commitment) — and, for a dokimo-anchor-v2 close, its summary — being anchored on-chain. Tamper one byte → recompute fails. Swap the rule version → the commitment changes → not anchored. A package without summary and binding is checked as legacy v1, which verifies only closes anchored before the v2 cutover.

Honest scope: for one record, checks that its proof reaches the root and that the commitment is anchored on-chain. It does not recompute the close's figures from all its records (that needs the full package, e.g. in /verify.html), and it says nothing about whether a business number is "good." Non-custodial; reads public on-chain state only.

Related MCP server: garl

Install & run

pip install dokimo-mcp
dokimo-mcp                 # runs over stdio
# or, from a clone:
pip install .
python -m dokimo_mcp

Add to an MCP client

Claude Desktop — add to claude_desktop_config.json:

{
  "mcpServers": {
    "dokimo": {
      "command": "dokimo-mcp"
    }
  }
}

If dokimo-mcp isn't on PATH, use the module form:

{
  "mcpServers": {
    "dokimo": {
      "command": "python",
      "args": ["-m", "dokimo_mcp"]
    }
  }
}

Then ask the agent: "Use Dokimo to verify this evidence package" (paste one), or "recompute this Merkle root and tell me if it matches."

Agent skill

skills/dokimo-verify/SKILL.md tells an agent when and how to use these tools: check the package shape, recompute locally first, ask before sending anything to Dokimo, and report the result for one record without overstating it. Drop the dokimo-verify folder into your agent's skills directory (e.g. ~/.claude/skills/ for Claude Code). It is also listed, free, on Agensi.

Try it

The live demo page embeds a real, anchored evidence package. Fetch it and verify:

import re, json, urllib.request
import dokimo_mcp as d
html = urllib.request.urlopen(urllib.request.Request(
    "https://dokimo.augaster.com/agent-audits-agents.html",
    headers={"User-Agent": d._UA})).read().decode()
pkg = json.loads(re.search(r"const PKG\s*=\s*(\{.*?\})\s*;", html, re.S).group(1))
print(d.verify_evidence_package(pkg)["verified"])   # True
# tamper one unit -> False
pkg["leaf"] = pkg["leaf"].replace("1001190933933115", "1001190933933116")
print(d.verify_evidence_package(pkg)["verified"])   # False

Hosted / HTTP mode

The default transport is stdio (local use). Set MCP_TRANSPORT=http to serve MCP Streamable HTTP at /mcp on $PORT (default 8081) with CORS — the shape hosted platforms like Smithery require. The included Dockerfile + smithery.yaml (runtime: container) are set up for exactly this, so Smithery can build and host it from this repo.

MCP_TRANSPORT=http PORT=8081 dokimo-mcp     # or: docker run -p 8081:8081 <image>

What is Dokimo?

Verifiable revenue infrastructure for autonomous commerce — audit-ready, independently reproducible books for AI-agent machine payments (x402 / AP2 / Stripe), with each figure tamper-evidently committed and anchored on-chain. https://dokimo.augaster.com

License

MIT — see LICENSE.

Available Tools

3 tools
dokimo_agent_cardA
Read-onlyIdempotent
Inspect

Fetch Dokimo's public A2A agent card — the discovery document describing what it can verify (skills, endpoints, supported A2A versions).

Inputs: no named parameters.

recompute_merkle_rootA
Read-onlyIdempotent
Inspect

Recompute a dokimo-merkle-v1 root locally — no network call, no anchor check.

Hash leaf in the leaf domain (H(0x00 ‖ leaf)) and replay proof_path — a list of [sibling_hash, side] where side is "L" or "R" — hashing internal nodes as H(0x01 ‖ left ‖ right). Compare the returned root to the root in an evidence package yourself; if it differs, the package was tampered with.

Returns {recomputed_root, merkle_scheme, steps}.

Inputs: leaf (required), proof_path (required).

verify_evidence_packageA
Read-onlyIdempotent
Inspect

Ask Dokimo to check one record of an evidence package against the on-chain anchor.

Sends the package to Dokimo's public A2A endpoint, which recomputes the Merkle proof AND checks the anchored commitment (root + rule version, plus the close summary for v2) against the anchor on Base. The verdict is Dokimo's answer and is not signed. package must contain: leaf (str), root (str), proof_path (list of [sibling_hash, "L"|"R"]), and rule_version_commitment (str); for a v2 close also summary and binding; close_id is optional/echoed.

Returns the verdict: {verified, checks:{recompute, onchain_anchor, rule_version_bound}, ...}. verified is true only if the proof recomputes AND the commitment is anchored on-chain. It covers this one record only.

Inputs: package (required).

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.4/5.0

    Scored across 3 tools

    Disambiguation5/5

    Each tool targets a clearly distinct operation: local Merkle root recomputation, remote evidence verification against an on-chain anchor, and fetching the A2A agent card. The recompute vs. verify overlap is explicitly clarified (local/no network vs. remote/anchor check), leaving no realistic misselection risk.

    Naming Consistency4/5

    Two tools follow a clean verb_noun pattern (recompute_merkle_root, verify_evidence_package), while dokimo_agent_card is a noun phrase with a vendor prefix. The deviation is minor and still predictable/readable.

    Tool Count5/5

    Three tools is well-scoped for a narrow evidence-verification server: one local primitive, one authoritative remote check, and one discovery document. Each earns its place with no filler.

    Completeness4/5

    The core verification lifecycle (recompute, anchor-check, discovery) is covered, but there is no tool to fetch the anchor/commitment data independently, list records, or batch-verify a package—minor gaps agents can work around.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      Verifiable action receipts for AI agents — agents sign claims locally, an independent witness countersigns and timestamps, anyone can verify offline.
      9 npm
      MIT
    • A
      license
      Not graded
      quality
      F
      maintenance
      Cryptographic verification for AI agent actions — ECDSA-secp256k1 signed Action Receipts anchored on Base, multi-dimensional trust vectors, capability tokens, and offline-verifiable on-chain proof. 29 tools.
      2
      Apache 2.0
    • A
      license
      A
      quality
      C
      maintenance
      Enables AI agents to create cryptographically verifiable receipts of their delegated work, with capabilities for multi-party approval and offline verification.
      11
      84 npm
      Apache 2.0