DMT Receipts
Provides a local MCP stdio server with two tools for creating and locally checking Bitcoin-anchored OpenTimestamps receipts for dmt-memory/v1 memories.
stamp_memory: canonicalizes a memory, computes its SHA-256 digest, submits only the digest to public OpenTimestamps calendars, and returns the memory, canonical JSON, digest, and base64.otsreceipt; it stores nothing.verify_receipt: locally checks that a memory's canonical SHA-256 matches the.otsreceipt header/digest, with an optional expected hex digest cross-check.Local verification only confirms consistency; it does not validate calendar operations or Bitcoin inclusion—use
ots upgrade/ots verifyor the live verifier for full proof verification.
Anchors memory digests to Bitcoin using OpenTimestamps receipts, enabling portable proof that memory bytes existed no later than the Bitcoin block time once the timestamp is upgraded and verified.
DMT Receipts
Portable, Bitcoin-anchored proof-of-existence for agent memories.
DMT Receipts turns a canonical dmt-memory/v1 JSON object into a SHA-256 digest and a portable OpenTimestamps receipt. Keep the memory and receipt in storage you control; verify the local digest whenever you need it, then use the OpenTimestamps client or the live verifier for the Bitcoin proof.
Live site & verifier · Protocol recipe · Full specification
Maintainer: github.com/Colchora
What a receipt does—and does not—establish
A receipt can establish | A receipt cannot establish |
The exact bytes whose SHA-256 is in the receipt existed no later than the Bitcoin block time anchoring the timestamp. | Who created, submitted, or owns those bytes; authorship requires a separate signature and identity-verification scheme. |
The local | Truth, accuracy, originality, intent, or exclusive ownership of the memory. |
After calendar aggregation and Bitcoin anchoring, an upgraded receipt can be checked with the OpenTimestamps client or live verifier. | A full Bitcoin proof from the MCP tool's local check alone. The tool does not validate the receipt's calendar operations or Bitcoin inclusion. |
The MCP server sends the 32-byte digest to public calendars; it does not send memory plaintext or keep a copy. | Absolute privacy: calendars receive network requests, and a digest of short or guessable content may be vulnerable to offline guessing. |
Stamping submits digests to public OpenTimestamps calendars at no proof fee. Calendar availability and Bitcoin anchoring time are outside this project's control. A newly returned receipt is normally pending; it is not yet a confirmed Bitcoin proof.
Related MCP server: deusproof-mcp
Quickstart
This project is a local stdio MCP server. From a clone of this repository, build and run it with Node.js 18 or later:
npm install
npm run build
node dist/index.jsThe process speaks MCP over standard input/output. In an MCP client, configure the built entry point instead of running it in a terminal:
{
"mcpServers": {
"dmt-receipts": {
"command": "node",
"args": ["/absolute/path/to/dmt-receipts/dist/index.js"]
}
}
}Replace the path with the absolute path on your machine, then restart or reload your MCP client. The server exposes two tools:
stamp_memory— canonicalize a memory, hash it, submit the digest to the public calendars, and return the memory, canonical JSON, digest, and base64.otsreceipt.verify_receipt— locally compare the memory digest with the.otsheader. This is a local consistency check, not a Bitcoin-chain verification.
For the complete round-trip example, see examples/README.md. Sample Bitcoin-pending OTS memory bundles are in receipts/; pending receipts are not yet confirmed Bitcoin proofs.
Stamp, keep, verify
Call
stamp_memorywithagent_id,key, andcontent.tagsdefaults to[];created_atdefaults to the current UTC time.Store the returned
memoryandots_base64yourself. DMT Receipts has no storage service.Pass those same values to
verify_receiptwhen you want to check that the memory still matches its receipt.For a Bitcoin-anchored proof, save the decoded receipt as
memory.json.ots, save the canonical memory bytes asmemory.json, then run:ots upgrade memory.json.ots ots verify -f memory.json memory.json.otsUpgrade may take around 1–3 hours, depending on calendar batching. You can also use the live browser verifier.
The MCP verifier intentionally does not claim the last step: it checks the receipt magic/version/hash-op header and digest, but does not parse the timestamp operations or contact Bitcoin.
Canonical memory format
The server hashes compact UTF-8 JSON with no trailing newline. Object keys are sorted lexicographically by Unicode code point at every nesting level; arrays keep their order; non-ASCII characters remain literal UTF-8. Numbers must be finite. Avoid floating-point values when memories must hash identically across different language runtimes; use integers or decimal strings instead.
Example canonical bytes:
{"agent_id":"demo-agent","content":"Remember this exact state.","created_at":"2026-11-05T17:00:00Z","key":"notes/hello","tags":["demo"]}Required fields:
Field | Type | Notes |
| string | Stable identifier for the agent. |
| string | Memory key, slug, or path. |
| string, object, array, number, or boolean | The memory payload; nested values must be JSON-compatible. |
| array of strings | Use |
| string | Valid ISO-8601 UTC timestamp ending in |
The server includes optional extension fields in canonical hashing when verifying a memory object. For interoperable numeric serialization, avoid floating-point values as described in the protocol specification.
Protocol and privacy
This MCP implementation follows the published DMT Receipts recipe: it POSTs the raw 32-byte SHA-256 digest to /digest at the public OpenTimestamps calendars, using the specified request headers, and assembles the returned operations into an .ots receipt. It does not upload memory content. Public calendars still receive the request and its network metadata.
Calendars used (the server attempts all three):
https://a.pool.opentimestamps.org/digesthttps://b.pool.opentimestamps.org/digesthttps://a.pool.eternitywall.com/digest
See SECURITY.md for privacy and reporting notes.
Project files
src/index.ts— TypeScript stdio MCP server.examples/stamp-example.json— example input memory.examples/README.md— stamp and verification walkthrough.CONTRIBUTING.md— contribution notes.LICENSE— MIT.
License
MIT © Cultura / DMT Receipts contributors. See LICENSE.
Available Tools
2 toolsstamp_memoryA
Canonicalize a dmt-memory/v1 JSON memory, SHA-256 it, stamp the digest on public OpenTimestamps calendars, and return the memory plus a base64 .ots receipt. Proves the exact bytes existed no later than a Bitcoin block time; does not prove authorship. Stores nothing.
| Name | Required | Description | Default |
|---|---|---|---|
| key | Yes | Memory key / slug / path | |
| tags | No | Optional string tags; defaults to [] | |
| content | Yes | Memory payload (string, object, array, number, or boolean) | |
| agent_id | Yes | Stable agent identifier | |
| created_at | No | Optional ISO-8601 UTC timestamp ending in Z; defaults to now |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries the full burden and does well: it discloses canonicalization (input bytes/format may change), submission of the digest to public calendars (irreversible public disclosure and a network dependency), and that nothing is stored server-side. It omits that a fresh receipt is initially pending rather than already Bitcoin-anchored, which the phrase 'proves the exact bytes existed no later than a Bitcoin block time' glosses over for an agent calling this for the first time.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three dense sentences, front-loaded with the full operation chain, then the proof claim, then the storage disclaimer. Every clause carries information; nothing is redundant padding.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description correctly describes the return value (memory plus base64 .ots receipt), which is the crucial missing piece an agent needs. The remaining gap is the follow-up workflow: nothing says the receipt should later be checked with verify_receipt or that anchoring is asynchronous.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents key, tags, content, agent_id, and created_at, and the baseline is 3. The description adds only indirect meaning via 'dmt-memory/v1' canonicalization, implying content must be JSON-canonicalizable, but does not explain required fields, defaults, or how created_at interacts with the stamped proof.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a precise chain of specific verbs and resources: canonicalize a dmt-memory/v1 JSON memory, SHA-256 it, stamp the digest on OpenTimestamps calendars, return memory plus a base64 .ots receipt. The only gap is that it never names the sibling verify_receipt, so the stamp-vs-verify split is left to inference from the name.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides useful scope boundaries ('does not prove authorship', 'stores nothing') that tell the agent what this tool is not for, but gives no explicit when-to-use framing and never routes to verify_receipt for checking a receipt. Usage is implied by the description rather than prescribed.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
verify_receiptA
Locally check that a base64 OpenTimestamps receipt header and digest match a dmt-memory/v1 object's canonical SHA-256. Does not validate calendar operations or Bitcoin inclusion; use ots upgrade/verify for full proof verification.
| Name | Required | Description | Default |
|---|---|---|---|
| memory | Yes | Full dmt-memory/v1 object (agent_id, key, content, tags, created_at) | |
| sha256 | No | Optional expected hex digest to cross-check | |
| ots_base64 | Yes | Base64-encoded .ots receipt |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden and does disclose key behaviors: the check is local (implying no network calls) and its proof scope is deliberately limited. It stops short of saying what the call returns or how a mismatch surfaces, which matters because there is no output schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, zero filler, with the core check front-loaded and the limitation and alternative trailing as a natural caveat. Nothing is repeated from structured fields.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a verification tool with a nested object parameter and no output schema, the definition should say what a success and a failure look like. It covers scope and limitations well but leaves the return contract entirely undefined, which is the main gap an agent would hit.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so all three parameters are already documented, making the baseline 3. The description adds conceptual framing (canonical SHA-256, receipt header and digest) but does not mention the optional sha256 cross-check parameter or how the pieces interact.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a specific verb and resource: locally checking a base64 OpenTimestamps receipt header/digest against a dmt-memory/v1 object's canonical SHA-256. It is precise about scope but never references the sibling stamp_memory, so the agent must infer the pairing from names alone.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It gives an explicit negative boundary ('does not validate calendar operations or Bitcoin inclusion') and routes the agent to the correct alternative ('use ots upgrade/verify for full proof verification'). It could be stronger by stating the positive trigger condition, e.g. when to reach for this versus stamp_memory, but the exclusion guidance is genuinely useful.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
2 tool updates
v0.1.0- First observed
stamp_memory - First observed
verify_receipt
TDQS
Scored across 2 tools
The two tools are cleanly complementary: stamp_memory creates a receipt, verify_receipt checks one. There is no overlap and the descriptions make the create/verify split explicit.
Both names follow a strict verb_noun snake_case pattern (stamp_memory, verify_receipt). The convention is predictable and directly reflects each tool's action and target.
Two tools is thin in absolute terms, but the server's scope is deliberately narrow — stamp a memory and verify a receipt — and each tool clearly earns its place. Nothing superfluous is present.
The basic stamp/verify lifecycle is covered, but verify_receipt only checks header/digest consistency and explicitly does not validate calendar operations or Bitcoin inclusion, leaving agents to invoke external ots upgrade/verify for the real proof. No status lookup or receipt introspection is offered, though the stateless design limits what could be added.
Maintenance
Related MCP Connectors
Attestable memory, truth, provenance. Hybrid Ed25519 + ML-DSA-65 receipts; USDC settlement on Base.
Verified memory for AI agents. Signed assertions, billing attestation, session continuity.
Local-first long-term memory for AI agents, with byte-recomputable signed verification receipts.
Stamp or notarize data into a public witnessed transparency log. Proves timing, not truth.
Related MCP Servers
- AlicenseAqualityBmaintenanceStamp, upgrade, and verify Bitcoin timestamps via AI agents using the OpenTimestamps protocol. No API keys required.9140 npm3MIT
- AlicenseAqualityCmaintenanceEnables AI agents to certify their creations with verifiable, timestamped proof anchored to Bitcoin, and to verify certificates.3MIT

Orphographofficial
AlicenseNot gradedqualityAmaintenanceEnables AI agents and MCP hosts to anchor file hashes to Bitcoin via OpenTimestamps and verify proofs, ensuring files existed before a given time with privacy-preserving local hashing.MIT- AlicenseAqualityBmaintenanceAppend-only evidence receipts for AI records: seal, verify, cite, chain-check, anchor status. A seal proves a record existed at a time, not that its contents are true. Five tools over stdio with npx -y apex-psi-mcp — no account, no key, verification free forever.5316 npm1MIT