Skip to main content
Glama

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

MIT license Node.js 18+

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 verify_receipt tool can check the canonical memory digest against the digest in a well-formed OpenTimestamps header.

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.js

The 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 .ots receipt.

  • verify_receipt — locally compare the memory digest with the .ots header. 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

  1. Call stamp_memory with agent_id, key, and content. tags defaults to []; created_at defaults to the current UTC time.

  2. Store the returned memory and ots_base64 yourself. DMT Receipts has no storage service.

  3. Pass those same values to verify_receipt when you want to check that the memory still matches its receipt.

  4. For a Bitcoin-anchored proof, save the decoded receipt as memory.json.ots, save the canonical memory bytes as memory.json, then run:

    ots upgrade memory.json.ots
    ots verify -f memory.json memory.json.ots

    Upgrade 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

agent_id

string

Stable identifier for the agent.

key

string

Memory key, slug, or path.

content

string, object, array, number, or boolean

The memory payload; nested values must be JSON-compatible.

tags

array of strings

Use [] when there are no tags.

created_at

string

Valid ISO-8601 UTC timestamp ending in Z, with whole-second precision.

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/digest

  • https://b.pool.opentimestamps.org/digest

  • https://a.pool.eternitywall.com/digest

See SECURITY.md for privacy and reporting notes.

Project files

License

MIT © Cultura / DMT Receipts contributors. See LICENSE.

Available Tools

2 tools
stamp_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.

NameRequiredDescriptionDefault
keyYesMemory key / slug / path
tagsNoOptional string tags; defaults to []
contentYesMemory payload (string, object, array, number, or boolean)
agent_idYesStable agent identifier
created_atNoOptional ISO-8601 UTC timestamp ending in Z; defaults to now

TDQS

A3.8/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters3/5

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.

Purpose4/5

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.

Usage Guidelines3/5

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.

NameRequiredDescriptionDefault
memoryYesFull dmt-memory/v1 object (agent_id, key, content, tags, created_at)
sha256NoOptional expected hex digest to cross-check
ots_base64YesBase64-encoded .ots receipt

TDQS

A3.9/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness3/5

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.

Parameters3/5

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.

Purpose4/5

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.

Usage Guidelines4/5

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.

  1. 2 tool updatesv0.1.0
    • First observedstamp_memory
    • First observedverify_receipt

TDQS

A4/5.0

Scored across 2 tools

Disambiguation5/5

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.

Naming Consistency5/5

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.

Tool Count4/5

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.

Completeness3/5

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

ActivityMaintained
ResponsivenessNo recent community issues

Related MCP Connectors

Related MCP Servers

  • A
    license
    A
    quality
    B
    maintenance
    Stamp, upgrade, and verify Bitcoin timestamps via AI agents using the OpenTimestamps protocol. No API keys required.
    9
    140 npm
    3
    MIT
  • A
    license
    Not graded
    quality
    A
    maintenance
    Enables 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
  • A
    license
    A
    quality
    B
    maintenance
    Append-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.
    5
    316 npm
    1
    MIT