dokimo-mcp
This MCP server lets an agent verify Dokimo evidence packages and recompute Merkle proofs for tamper-evident revenue records.
Recompute a Merkle root locally with
recompute_merkle_root, using thedokimo-merkle-v1scheme and no network call.Verify one evidence-package record with
verify_evidence_package, which asks Dokimo to recompute the proof and check its commitment against the on-chain anchor on Base.Fetch Dokimo’s public agent card with
dokimo_agent_cardto discover what it can verify.Support agent auditing workflows by checking proof integrity, rule-version binding, and v2 close summaries, while scoped to one record at a time.
Allows verification of revenue claims from autonomous commerce platforms, with support for x402 / AP2 / Stripe machine payments, by recomputing tamper-evident evidence packages and checking on-chain anchors.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@dokimo-mcp Verify this evidence package and tell me if it's anchored on-chain."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
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-v1hashing scheme. It contains no proprietary code. MIT-licensed.
Tools
Tool | What it does | Network? |
| Local recompute — hash a leaf under | none |
| 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 | Dokimo A2A |
| 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_mcpAdd 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"]) # FalseHosted / 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 toolsdokimo_agent_cardARead-onlyIdempotentInspect
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_rootARead-onlyIdempotentInspect
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_packageARead-onlyIdempotentInspect
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
Scored across 3 tools
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.
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.
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.
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
Related MCP Connectors
Payment-backed trust scores for AI agents on Base (ERC-8004). $0.01 per check via x402.
Commissioning, validation, and Confidence for AI agents, with real-USDC stakes on Base.
One-stop claim verification for AI agents: verdicts with confidence, evidence, signed receipts.
Signed, publicly logged records of what your AI agent did, with proofs anyone can check offline.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceVerifiable action receipts for AI agents — agents sign claims locally, an independent witness countersigns and timestamps, anyone can verify offline.9 npmMIT

garlofficial
AlicenseNot gradedqualityFmaintenanceCryptographic 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.2Apache 2.0- AlicenseAqualityCmaintenanceEnables AI agents to create cryptographically verifiable receipts of their delegated work, with capabilities for multi-party approval and offline verification.1184 npmApache 2.0
- FlicenseNot gradedqualityCmaintenanceEnables agents to vet merchants, create and verify USDC charges and invoices, assess trust and tokenized-asset authenticity, and manage provable books on Base, all non-custodially.63 npm-