Vortx-AI/emem

emem is shared, verifiable memory for machines and AI. The proof travels; the files stay where they are.
Try it, no key · Quickstart · A worked example · Verify a token · Agent guide · Docs
Trust without moving the file
Today, to trust a piece of data you usually have to hold it. A satellite downlinks the whole capture, a lab emails the spreadsheet, a company uploads its documents to whichever AI is reading them, and every copy is one more place the data can leak or quietly change.
emem splits the job in two.
- **Encoding happens at the source, and stays private.** A file server, a lab, a camera or a payload computer hashes what it holds into units and signs a small record under its own key. The bytes do not have to leave. What leaves is a commitment to them: a content id, a Merkle root, a signature.
- **emem is the decoding half.** Any model, in Claude, in ChatGPT or in your own code, resolves a short token back to that exact record, checks who signed it, and proves that one unit belongs to the whole, without trusting the sender, and without trusting emem.
A token lets a reader resolve the published record and check content they are given against it. It does not reveal what you kept: a tree token over a private file exposes the units you chose to publish and nothing else.
What crosses, and what stays
| Source | Where it is encoded | What crosses | What stays | Status |
|---|---|---|---|---|
| **Documents, datasets, model weights, code** | the tokeniser on emem.dev (in your browser: code by definition, safetensors by tensor, zip and pptx by entry, PDF by page) or tree_proof.py on your machine | one emem:tree: token: each unit's BLAKE3 folded into a Merkle root, in an index you sign | every unit you do not choose to publish | shipped |
| **Your own algorithm** | wherever you run it | emem_derive: your value, the signed facts it read, and an optional code_cid, the hash of your code, all signed by your key | the code. emem never runs it; it pins it by hash | shipped; emem re-runs only pure operations (delta, mean, sum) |
| **A payload on a satellite, drone, camera or robot** | emem-airgap on the device, with no network; the emem-encode sidecar adds an execution trace | a signed custody record: these bytes, this name, this size, at this time, under this key | the payload | the encoders ship (arm64 and amd64); the public device gate admits no real hardware yet |
| **Open Earth archives** | emem's own readers of registered archives | signed facts, each naming its source bytes | nothing private: the archives are public, so anyone can recompute | shipped, the first corpus |
What each check proves is stated with it. A custody record says bytes arrived, not that the sensor was calibrated. A tree proves a unit was in the file you signed, not that the file is true. A code_cid says which code you claim produced a value; running arbitrary private code in a sandbox is not built.
Quickstart
No account and no API key to read.
**1. Connect an MCP host** (Claude Code here; every other host):
**2. Prove one part of a file without the rest of it.** This repository's LICENSE is published as a signed tree of six 2 KB units, so you can try the file path with nothing to set up. From a clone:
The index names every unit's hash and the root; the row carries unit 3 and its audit path. The check confirms bytes 6144 to 8191 are in the file the key k572x7go signed, by hashing those bytes and walking three steps to the root. For your own file, tree_proof.py build report.md cuts it into units and prints the index offline; sign and publish it under your own key (the skill walks through it). The file never leaves your machine.
**3. Read a signed measurement and check it offline** (curl, jq, Python):
The check uses the public key the receipt carries. To know it was emem that signed, pin emem's key from /.well-known/emem.json, or check the token at emem.dev/verify.
Or just ask, from the shell, Python or TypeScript
There is no rule for turning a tool name into a REST path, so do not guess one: emem_memory_search answers at POST /v1/memory/search and emem_verify_receipt at POST /v1/verify_receipt. The authority is /openapi.json; over MCP, call the tool by name.
**For agents.** Connect to https://emem.dev/mcp. It advertises the 18 tools of the core loop in one page, about 75 KB of context, not the whole catalog: loading all 115 descriptors costs about 324 KB. For the lightest first contact, emem_tools returns the loop and a menu in about 13 KB, and tools/call dispatches every tool by name, with or without its emem_ prefix. To hand records on, prefer a bundle: emem_memory_bundle names up to 256 facts in 38 characters.