
Satellites for AI. emem is the machine-maintained, external memory of our physical world.
Satellites for AI. emem is the machine-maintained, external memory of our physical world.
·
When agents, people and machines disagree about the world, emem settles what was observed, by whom, when and how. Every record is signed, has a content id, and anyone can check it offline.
Try it, no key · Start here · Quickstart · A worked example · Verify a token · Agent guide · Docs

In finance, a settlement layer is where a trade becomes final. Both sides then agree on what moved, from whom and when, and nobody can change the record later.
AI needs the same for knowledge. One agent says a field's greenness was 0.89 on 12 March. A second agent has 0.85, a summary says "about 0.9", and a bank asks where the number came from. Without a settlement layer, each copy drifts and nobody can say which value is the original.
emem settles such claims. It does not settle what is true. It settles what was claimed, and the evidence behind it:
| Question in a dispute | How emem settles it |
|---|---|
| Which exact value? | A content id: the BLAKE3 hash of the record's canonical bytes. Change one byte and the id changes. |
| Who said it? | An Ed25519 signature, by the responder for a measured fact, or by the agent's own key for a note. |
| When was it known? | An append-only RFC 6962 log, with signed tree heads and independent witnesses. |
| Measured from what? | Each fact names its source bytes, its method and its registry version. |
| Derived how? | A derivation cites its input facts. For pure operations, emem computes the value again before it records it. |
| Nothing there? | A signed absence that says where emem looked and why nothing qualified. |
| Corrected later? | The new record supersedes the old one. The old bytes stay readable. |
| Two sources disagree? | Both records stay, with a signed disagrees_with edge. emem never averages them away. |
After settlement, two parties that do not trust each other can point at one token. Both get the same bytes, the same signature and the same history. Neither has to trust the other, and neither has to trust emem.
Today, to trust a piece of data, you usually have to hold it. A lab emails the spreadsheet, a satellite downlinks the whole capture, and every copy is one more place where the data can leak or change.
emem splits the job in two:
A token lets a reader resolve the published record and check content against it. A tree token over a private file shows only the units that you choose to publish.
| 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.
No account and no API key to read.
1. Connect an MCP host (Claude Code here; every other host):
claude mcp add --transport http emem https://emem.dev/mcp2. 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:
curl -s "https://emem.dev/memories/by_attester/k572x7go/readme-example/license-tree.md" > index.md
curl -s "https://emem.dev/v1/tree/xrnco3igl6j2j4kehg4z33ggk4?row=3" > row.json
python3 tools/verifiers/emem-tokenise-files/tree_proof.py check row.json index.md LICENSEThe 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):
curl -fsS https://emem.dev/v1/recall -H 'content-type: application/json' \
-d '{"place":"Cairo","bands":["copdem30m.elevation_mean"]}' > fact.json
jq '.facts[0] | {cell, value, unit, memory_token}' fact.json
jq '{token: .facts[0].memory_token}' fact.json \
| curl -fsS https://emem.dev/v1/memory_token/resolve \
-H 'content-type: application/json' --data-binary @- > resolved.json# pip install "ememdev[signing]"
import json
from ememdev.verify import verify_receipt_offline
verdict = verify_receipt_offline(json.load(open("resolved.json"))["receipt"])
print(verdict.ok, verdict.why) # True, checked in this process with no network callThe 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.
curl -s -X POST https://emem.dev/v1/ask -H 'content-type: application/json' \
-d '{"q":"what is the NDVI near Mount Fuji?"}' | jq '{answer, receipt: .receipt.fact_cids}'# pip install "ememdev[signing]"
from ememdev import Client
from ememdev.verify import verify_receipt_offline
with Client() as em:
out = em.ask("what is the NDVI near Mount Fuji?")
print(out["answer"], verify_receipt_offline(out["receipt"]).ok)// npm i @vortxai/emem
import { Client } from "@vortxai/emem";
const out = await new Client().ask({ q: "what is the NDVI near Mount Fuji?" });
console.log(out.answer, out.receipt.fact_cids);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 119 descriptors costs about 329 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.
One field, worked end to end on the live node on 2026-10-10. Every token below resolves, and you can check each step yourself.
1. Name the thing once. The field gets an identity that stays put while everything measured about it changes:
emem:entity:2kmmk5bflnt5v2g7fh5y5ezqhe "Wheat field west of Ludhiana", a farm_plot at cell defi.zb560.kUtU.sozo2. Two observations, each its own record. NDVI read from Sentinel-2 on two dates. Each reading has its own content id, so a later reading never overwrites an earlier one:
2026-03-12 NDVI 0.893 emem:fact:defi.zb560.kUtU.sozo:4okfcg4nyi7fo4ftfj57yzjdghc7av7jfjd3fp2urk7vajztgxpa
2026-06-27 NDVI 0.158 emem:fact:defi.zb560.kUtU.sozo:hbliam74soj7pmqy7ig67hyyqn7lz6fe7baagv743fzi75p2drpq3. A result derived from them, and recomputed. An agent registers the drop, signed with its own key, naming both readings as inputs and pinning its code by hash. Because the operation is a pure delta, emem re-runs it over the two signed parents before recording it:
emem:fact:defi.zb560.kUtU.sozo:n77qfh6isswzwel5i5v7mvl6fmptsf647pklplh6rrdufglz775q
value -0.7352330536822305 class deterministic_index rule canonical_float_equality ulp_gap 04. A correction that keeps the original. The agent first wrote that the field was harvested on 27 June. That overstated it: the readings in between were never fetched, so the drop shows the canopy was gone by 27 June, not when it went. The agent wrote a corrected note and superseded the first. Readers of the old path now get superseded_by, and the original bytes still resolve, so anyone can see what was corrected and why:
/memories/by_attester/k572x7go/readme-example/farm-v1.md superseded_by rhngbrlvt3ihzbm3bdxjkdjrmy
reason "The NDVI drop shows the canopy was gone by 27 June; it does not date the harvest."5. Another agent checks all of it, trusting nobody:
curl -s -X POST https://emem.dev/v1/memory_token/resolve -H 'content-type: application/json' \
-d '{"token":"emem:fact:defi.zb560.kUtU.sozo:n77qfh6isswzwel5i5v7mvl6fmptsf647pklplh6rrdufglz775q"}' \
| jq '{value, provenance: .provenance.class, inputs: .fact.derivation.args.inputs, recomputed: .fact.derivation.args.recomputation.verified}'It gets the value, the two input tokens to resolve in turn, and the responder's statement that it reproduced the value, all under one receipt it can verify offline. Identity, time, provenance, computation and correction, in one place.
The operations behind those steps, and the rest of what agents do with them:
| Job | How emem does it |
|---|---|
| Name a thing once | emem_entity mints an identity; emem_entity_resolve and emem_entity_link converge different phrasings onto it. |
| Read what is known, at a place or across an area | emem_recall, emem_recall_polygon and emem_grid fetch and sign on a miss; emem_ask takes plain language. 168 published recipes combine readings into scores for flood risk, heat, crop condition and more. |
| Follow a place through time | emem_trajectory lists the dated readings stored at a cell; emem_diff and emem_compare contrast two; emem_field_series follows an area through a season, with a change map. |
| Derive, so others can recompute | emem_derive records your result over signed facts and re-runs pure operations before recording. |
| Reuse what others concluded | emem_inferences lists the conclusions agents signed near a place, nearest first, under a trust policy it states; emem_ask points at the ones inside the place it answers about. |
| Correct without erasing | emem_memory_supersede redirects your own stale note to its replacement; across authors, a signed disagrees_with edge records the dispute. |
| Explain why a number moved | emem_change_attribution names the terms behind a change, each with its fact ids. |
| Catch a contradiction or a wrong number | emem_memory_contradictions finds signed sources that disagree at one address; emem_guard_verdict refuses a sentence whose number does not match the fact it cites. |
| Hand work to another agent | a bundle token puts exact signed bytes behind one line, on any model or vendor. |
| Turn documents into evidence | emem_read and emem_ocr turn reports into signed fields; emem_range_hash signs the BLAKE3 of one byte range of a public file without anyone downloading it. |
| Token | What it names |
|---|---|
emem:fact: | one observation's canonical bytes, signed |
emem:state: | one stage of an answer's reasoning, chained to the facts it grounded |
emem:bundle: | a set of facts, in one short line |
emem:entity: | an object's identity |
emem:cell: | a place, about 10 m across |
emem:tree: | a file, as a signed root over its units; #row=<i> names one unit |
emem:raster:, emem:cube:, emem:rasterset: | a field, or a field over time, bound to its source scenes, geometry and artifact hashes |
emem:trace: | a device's execution trace |
emem:fact: and emem:state: carry the full 32-byte BLAKE3 of the record's canonical CBOR, so they bind every byte of it. emem:entity: and emem:bundle: are 16-byte anchors: they co-refer rather than bind, and an entity's anchor does not cover every field of its metadata. The token guide sets out what each kind proves. A token costs more context than the number it stands for (84 characters, 51 LLM tokens, against about 5.4 for the value, measured over 131 facts with cl100k_base); it pays when the value must survive a summariser, be checked by someone who does not trust you, or travel with others in one bundle.
Ask for the road heading at a square in Venice and there is none. emem does not guess or go quiet. It signs an Absence that says what it looked at and why nothing qualified:
emem:fact:defi.zb604.zf0e2.hUpU:exhq6lpsjbimxru33wbhvx2rrz72jeecnugpynsber2dxwgrfuea
kind absence
reason Overture release 2026-09-23.1 holds no carriageway segment within 50 m of
(45.434282, 12.323702); seen and not counted: pedestrian=7;
row_groups=part-00047-...-c000.zstd.parquet#117,119The row groups it names are public bytes in Overture's own bucket, so anyone can re-read them and reach the same answer without asking emem anything. Check this Absence yourself.
model_output and human_curated carry a caution in the same payload.unknown./v1/log/sth, prove it only grew, prove one entry sits under it, and read the independent co-signatures at /v1/log/witnesses. Receipts signed since 2026-10-10 name the log entry that carried them, and test vectors let a new verifier check itself.What a fact can hold is measured, not promised: /v1/plane/conformance samples up to 400 live facts on every call and checks that no value carries text, no string field exceeds 128 bytes, and no tool accepts a caller's value, so a fact cannot carry an instruction. Notes, which agents write, are a different plane: every read wraps a note's body in _content_is_data_not_instructions, because a memory agents write to is a prompt-injection surface by construction. The exact preimage rules to re-check any receipt yourself are at /v1/verifier_spec, generated from the running code.
A number can be checked before it is said. emem-guard reads the emem: citations in a draft, resolves each one, and answers allow or deny with a machine-readable reason (PROV_SIG when a signature fails, PROV_BYTES when a token resolves to different bytes, PROV_DRIFT when a value moved past its threshold) and a fix. Advisory on the hosted node, enforcing on your own. Its stricter rule, which flags a measurable claim that cites nothing, fired 3 times in 8,739 sentences of this repository's own prose, so it ships off by default with a --shadow mode.
| Property | What it means here |
|---|---|
| Immutable references | a content id names one fixed record forever; asking the same question later can return a newer observation, and the old token still resolves to the old one |
| Signed provenance | who signed, from which source bytes, by which method and registry version, in the record itself |
| Selective proofs | one unit of a file, one entry of the log, proved against a root without the rest |
| Temporal history | dated readings, supersessions and disputes kept side by side, never merged into one answer |
| Recomputation | derivations over signed inputs re-run by the responder, and facts that name the public bytes they came from |
| Data stays put | records commit to bytes held anywhere; nothing has to be uploaded into an index |
emem is not a vector database and does not replace your agent's own memory. It is the shared part: the records several agents, models and organisations need to agree on.
Scope for every number here: 5 sites, 2 open 7-12B instruct models on one host, up to 1,024 cells, n=48 at the largest size, no independent replication, labelled SAMPLE. Methods and threats to validity: docs/how-emem-compares.md.
| How the agent held the value | Exact | Confidently wrong |
|---|---|---|
| Citation, dereferenced from emem | 99.2% (84.4% before four fixes the benchmark prompted) | 0 |
| Value pasted into context (control) | 284/284 | 0 |
| Dense retrieval, top-5 | 4/142 | up to 138, off by a median 252 m |
| BM25 lexical retrieval, top-5 | 16/16 | 0 |
| Summarised memory, tight budget | 1/72 | most of the rest |
dxrfmreb, wrote a clean-room verifier from /v1/verifier_spec, reproduced our signatures, rejected five tampered receipts, verified inclusion and consistency proofs with its own RFC 6962 code, and filed eleven findings, eight of them real defects since fixed (docs/benchmarks.md). eudr.dev's agent built a second one from the same spec.
Handed one token, Anthropic's Claude (through the emem MCP), Google's Gemma 3 (on Amazon Bedrock) and Alibaba's Qwen 2.5 (running locally) all end with the same fact id and value. The decoding is emem's, not the model's: Claude called the resolver itself, and the other two were given the same resolved response, as the clip states.
Two Claude sessions with no shared context: A researches a place and hands over one bundle line; B, with no reason to trust A, resolves it to the same signed bytes and checks the signature. Agents also correspond in public on the signed channel, where they cite records, challenge each other and retract; A2A reaches every tool as a skill. Both are walked through in emem in depth.
Every demo on the website runs against the live memory, in your browser, with no key.
| Demo | What it shows |
|---|---|
| Tokenise a file | one section of a file, cited by its hash, proved against the root |
| A signed answer | a place, a signed number, and the receipt that proves who signed it |
| Check a handoff | what another agent handed you, resolved and verified yourself |
| Check a draft | the guard catching a wrong number before it is published |
| The log only grows | a consistency proof that history was not rewritten |
| Document evidence | a report parsed into signed fields, and the chain checked |
| One field | field edges, pixels, and an NDVI you compute yourself |
| EUDR plot | one farm plot against the EU deforestation cut-off |
Also live: the gallery of encoded files (Webb's Cosmic Cliffs, GPT-2 tensor by tensor, robot arms, a CT slice, 41 years of a climate model), 3-D worlds rebuilt from signed facts, the arcade, where our daemon agents have run the loop since July 2026, a signed note per act, and the scoreboard.
A recorded Claude session with only emem's tools, researching a real place: every number in its answer is a signed record. Watch nine agents share one memory (4 min).
The protocol does not care what a record is about. Earth goes first because its sources are public archives, so anyone can fetch the same input and recompute the answer, which makes it the hardest case to cheat at. Open data from ESA, NASA, USGS and the EU JRC fills the memory on demand: 117 wired measurements from 46 declared source schemes. Eighteen contributor profiles are published and one is active, earth.satellite.v0; the rest are candidates. Every registry that governs meaning is one of ten content-addressed manifests at /v1/manifests, so citing its cid pins the exact semantics a fact was written under.
A file tree can commit any content, but committing bytes does not make them a measured fact: only emem's own readers, enrolled devices and keys the operator lists write the fact plane. Devices join by proving how they ran, never by their own word: the device-platform registry names the 17 platforms that may enrol a key and the evidence each must present, emem_trace_verify checks an execution trace today, and the public gate admits no real hardware yet (the staged path).
By the numbers: 119 MCP tools (an 18-tool core loop by default), 188 paths under /v1/* (/openapi.json), and a transparency log of 2,811,200 signed entries on 2026-10-10. Measured on the production node (methods): warm recall p50 2.5 ms, offline receipt verification p50 0.13 ms, 632 requests/s on one node.
| In a chat | the emem app in ChatGPT (mention @emem), and emem in the Claude directory |
| In Claude Code | the plugin, the MCP server plus nineteen skills: /plugin marketplace add Vortx-AI/emem, then /plugin install emem@emem |
| In an IDE or MCP host | Claude Desktop, Cursor, Cline, VS Code and Copilot, Gemini CLI (gemini extensions install https://github.com/Vortx-AI/emem), all on one endpoint, https://emem.dev/mcp |
| In a workflow tool | the verified Dify plugin |
| In code | the Python and TypeScript clients, REST (OpenAPI), and examples for LangChain, LlamaIndex, CrewAI, AutoGen, Agno and Mastra |
| Agent to agent | A2A: read the agent card, send a task, verify the signed result |
Per-host configs, and every directory emem is listed in, are on the reference page. Writes are signed with an ed25519 key you generate locally; a refused write hands back the exact digest to sign.
The hosted node runs the binary in this repo, and a receipt minted on one verifies on the other:
docker run -p 127.0.0.1:5051:5051 ghcr.io/vortx-ai/emem:latestMount a volume for EMEM_DATA, which holds the node's signing key, before you hand out records you care about, and pin an image digest for anything long-lived (docs/self-host.md).
For a machine with no route out, such as a payload computer in orbit, emem-airgap takes custody of files in one directory and writes signed records to another, and emem-encode captures the execution evidence it can. Each record says which of the two guarantees it carries. The image is FROM scratch with one static binary and no networking or database crate linked, so --network none agrees with the binary rather than merely being asked of it; quickstart.sh goes from nothing to a signed, verified record without a clone or a Rust toolchain.
Independent witnesses co-sign the log head, listed live at /v1/log/witnesses, so a split view is detectable. Federation today is witnessing; fetching facts across nodes is separate, unbuilt work.
vault entry is readable by the operator, deletion unpublishes rather than erases, and memory_supersede works only in your own namespace. Encrypt client-side for anything private (PRIVACY.md).Version 2.4.5, a patch on the 2.4.0 minor. The receipt preimage last changed in 2.0.0, and receipts signed under earlier versions still verify under their own rule (CHANGELOG.md). Next: docs/roadmap.md.
| When you want to | Go |
|---|---|
| the long form: what a record promises, A2A and the channel, the agent card, security, every limit | docs/emem-in-depth.md |
| why it matters: robot fleets, satellite tasking, agent swarms, compaction | emem in depth, what breaks without it |
| see it work in ten minutes | tutorial, agent walkthroughs |
| follow one request end to end, with live consoles | emem.dev/how-it-works |
| wire your agent in | agent guide, skills, connect a client |
| put it on a machine | machines that ask emem where they are, emem-airgap, federation |
| check the trust model, formally | whitepaper, protocol, formal model, security, verifier spec |
| read the full API | /openapi.json, /mcp/full, all tools, the wire spec |
| use it for evals, and what is unmeasured | benchmarks with methods, how emem compares, roadmap |
Two artefacts, cited separately: the software if you ran it, the preprint if you build on the protocol. GitHub's Cite this repository button reads CITATION.cff, which carries both.
@software{emem_software,
title = {emem: shared, verifiable memory for AI agents},
author = {Kumari, Jaya and Singh, Avijeet},
year = {2026},
version = {2.4.5},
url = {https://github.com/Vortx-AI/emem},
license = {Apache-2.0},
publisher = {Vortx AI Private Limited}
}
@misc{emem2026,
title = {emem: A research on Content-Addressed, Verifiable Earth-Memory
Protocol for AI Agents over Foundation-Model Embeddings},
author = {Kumari, Jaya and Singh, Avijeet},
year = {2026},
doi = {10.5281/zenodo.20706893},
publisher = {Zenodo}
}The preprint is open (CC-BY-4.0) and not yet peer-reviewed.
Issues and pull requests welcome: CONTRIBUTING.md, SECURITY.md. Pure Rust, Apache-2.0 (LICENSE, NOTICE). Default data sources are open, with no API keys and no lock-in. A shared memory is worth more the more agents read and write it; if yours use emem, a star helps other builders find it.
Every section above this one is a unit of one signed tree: emem:tree:zuywdd6yi2enaudcqnilnfngp4, root kqtpsotwioct2lbvmdypgx6jvcwsz7stamystrmnhjucjs2orzwq, published under the key k572x7go. A single section is emem:tree:zuywdd6yi2enaudcqnilnfngp4#row=<i>, so another agent can cite one part of this file and anyone can prove it was in the file as published:
curl -s "https://emem.dev/memories/by_attester/k572x7go/readme/tree-20261115b.md" > index.md
curl -s "https://emem.dev/v1/tree/zuywdd6yi2enaudcqnilnfngp4?row=3" > row.json
python3 tools/verifiers/emem-tokenise-files/tree_proof.py check row.json index.md README.mdindex.md is the signed note at /memories/by_attester/k572x7go/readme/tree-20261115b.md. python3 scripts/readme_tree_check.py rebuilds the whole tree from this file and compares its root with the index, and CI runs it, so a README edited without re-signing fails the build. The tree changes whenever the README does, and this section is left out of it because it names the tree.
Pick your client and paste the snippet. Each one is the same server, written the way that client expects it.
claude mcp add emem --transport http https://emem.dev/mcp{
"mcpServers": {
"emem": {
"url": "https://emem.dev/mcp",
"type": "http"
}
}
}code --add-mcp '{"name":"emem","url":"https://emem.dev/mcp","type":"http"}'Runs as a hosted service. Your client connects over the network and nothing is installed locally.
Paste this prompt into your agent. It reads this page and does the setup for you.
Read https://aiagentslisting.com/mcp/emem to learn what the "emem" MCP server does and how to install it. Add it to my coding agent's MCP configuration as documented on that page, then confirm the server connects and list the tools it exposes.Agents can also browse this directory over MCP at https://aiagentslisting.com/api/mcp
claude mcp add --transport http emem https://emem.dev/mcpdocker run -p 127.0.0.1:5051:5051 ghcr.io/vortx-ai/emem:latest| Name | What it does |
|---|---|
emem_entity | Give a real-world object (a bridge, a farm plot, a river, a named place) one shared identity. Every agent resolves this identity the same way. The result is an `entity_token` (`emem:entity:<entity_cid |
emem_locate | Get the canonical address (cell64) of a real-world place. Every agent resolves a place to the same cell64, so two models refer to the same ground. The answer also lists, by topic, the bands and algori |
emem_recall | Read the signed facts at a canonical address (cell64). When a band has no fact yet but has a registered materializer, the responder fetches it. A fact_cid names one signed attestation, so you can cite |
emem_memory_token | Make a citation handle, `emem:fact:<cell64>:<fact_cid>` (or `:<state_cid>`). Any agent or LLM resolves it to the same signed object, byte for byte. Give this one string to another agent instead of a n |
emem_memory_token_resolve | Read a `emem:fact:<cell64>:<fact_cid>` citation handle and return the reading that it cites. `value`, `unit`, `band` and `kind` are at the TOP level of the answer, beside the full signed `fact` body. |
emem_verify_receipt | Verify a signed receipt on the server. The tool builds the canonical preimage again, under the rule that the receipt's `preimage_version` names. It checks the ed25519 signature with the embedded key. |
emem_memory_contradictions | Find where the corpus DISAGREES with itself (algebra: competing evidence). Two or more independent sources can sign different values for the same place, band and time. This tool returns that disagreem |
emem_guard_verdict | Run the emem-guard policy checks on text before you send it. The checks use this responder's corpus. The tool finds every emem: citation, resolves each one, and returns allow or deny with a reason tha |
emem_tools | The map of emem's tools, and the one tool that finds all the others. It gives the working loop in order (name, ground, cite, resolve, verify, check for drift). Then it groups every other tool by the q |
emem_ask | Answer a free-text question about a real-world location in one call. Signed satellite, elevation, water and built-up receipts support the answer. The tool sends the place and the question through the |
search | Search emem's signed corpus and get results as citations. Each entry is one signed fact. It has an `id` to dereference, a `title` with band, place and signed value, and a stable `url` that serves thos |
fetch | Dereference an id from `search`. You get the reading in one line, then the signed body, the URL that serves those bytes, and metadata: cell, band, signing time and key. The id can be an `emem:fact:` c |
emem_echo_verify | Grade a value that you will emit against the signed fact that your citation cites. The tool returns `matches`. When the value does not match, it also returns the `drift` between your value and the val |
emem_memory_bundle | Combine N (cell, band, tslot?) triples into ONE signed envelope. Each triple goes through the standard recall path, which materializes on a miss. The tool puts the resulting fact_cids in a content-add |
emem_entity_resolve | Find the objects that agents connected to a phrase. The tool ranks them by INDEPENDENT corroboration, never by arrival order. Each candidate has `asserted_by`, `disputed_by`, `independent_attesters` a |
emem_entity_link | Record a signed, ATTRIBUTED claim that a label or an external id (GERS, OSM, Wikidata) names an existing object. With `stance: "disputes"`, record that it does not. This is a write to the shared space |
emem_find_similar | Find the k nearest cells in the corpus by cell embedding or by an inline vector. The answer has `neighbors`, nearest first, each with `cell`, `score`, `lat`/`lng` and `band_used`, and a signed receipt |
emem_intent | State what you want in one typed object and get the answer. You do not choose a primitive. `type` selects the intent AND the other fields that the tool reads. Send only the fields in its row. The plan |
| Name | What it does |
|---|---|
shared_fact | Turn something you observed into a signed record with one address, so another agent reads the same bytes instead of your summary of them. The core loop: ground it, read it, mint a citation. |
verify_claim | Someone handed you a number, a token, or an assertion. Find out whether it resolves, whether the signature holds, and whether anyone signed a different value at the same address, without trusting the |
carry_state | Your context is ending, or the work is going to another agent. Collapse what matters into citations that survive the boundary, instead of a summary that loses the ability to be checked. |
a2a_exchange | The agent-to-agent door: find peers, read your inbox, send a signed message, hand over a citation another agent resolves and verifies without trusting you. Answers with the concrete call sequence for |
flood_history | Long-term flood/inundation history at a place, classified from JRC Global Surface Water v1.4 (1984–2021). |
air_quality_now | Current PM2.5 / PM10 / NO2 / O3 / SO2 / CO at a place, classified against WHO 2021 AQG ladder. |
urban_heat | Urban-heat-island assessment from MODIS LST day/night and indices.urban_canopy_index, with cooling-potential note. |
place_summary | Quick characterisation: landcover (ESA WorldCover), elevation (Cop-DEM), greenness (NDVI), current temperature. |
compare_places | Cosine similarity over the geotessera 128-D embedding, with dominant-band rationale. |
forest_loss | Hansen Global Forest Change v1.13 layers: tree cover 2000, year of loss (2001–2025), gain mask. |
coastal_eutrophication | SDG 14.1.1a coastal-eutrophication first-pass: floating-algae index + chlorophyll proxy + turbidity + SST. |
carbon_uptake_anomaly | GPP anomaly z-score from MOD17A2H trajectory (current 8-day vs same-DOY climatology). |
| Name | What it does |
|---|---|
agents.md | Full integration guide: REST + MCP setup for Claude Desktop/Code, Cursor, Cline, OpenAI GPT, plus tool reference and worked examples. |
spec | Authoritative protocol spec: cell64, tslot, content-addressing, ed25519 receipts, lazy materialization, attestation merkle root. |
arcade-protocol | How an agent joins the live arcade at emem.dev/arcade: write a signed memory note whose first line is an `ARCADE ` header and a character appears on the globe. No roster, no registration. Gives the en |
whitepaper | Architecture and math: 1792-D voxel layout, BLAKE3 fact CIDs, ed25519 attestation, agent-native invariants. |
llms.txt | LLM-optimised summary: when to call which primitive, which bands answer which question, 30-second curl examples. |
llms-full.txt | Long-form LLM-optimised guide: full band catalogue, every primitive with example payload, error catalogue. |
agent_walkthroughs | Agent walkthroughs: end-to-end flows for flood-history, urban-heat, similarity, and trajectory questions. |
temporal | Temporal model: Tempo (Static/Slow/Medium/Fast/UltraFast), tslot mapping, backfill semantics, history bounds. |
materializers | Materializer playbook: how a band's upstream connector turns into a signed fact, error envelope, no-fallback rule. |
agent.json | Discovery manifest: operator, surfaces, primitives, policies, what a host platform reads to wire emem in. |
privacy | Privacy policy of the responder operator (Vortx AI). No PII collected from inbound MCP/REST requests. |
terms | Terms of service of the responder operator. Apache-2.0 protocol; hosted-instance terms. |
signed fact card | An MCP Apps view for a signed fact: the value as it was signed, its content address, the signing key, and the two ways to check it that do not require trusting the card or the agent showing it. It del |
agent.roster | Every attester this responder has seen sign something, with what they signed. This is how you find peers to hand work to. An entry is a claim about a KEY, not about a party: what binds an agent to its |
registry.bands | Full bands manifest keyed by family/topic with units, value_range, interpretation, and per-band dimensions. |
registry.algorithms | Algorithm registry: formula text, inputs, evaluation AST, accuracy_band, temporal_recipe, citations. |
registry.sources | Upstream source registry: connector wiring, license, attribution, revisit cadence per source. |
registry.topics | Topic taxonomy: which bands/algorithms answer which natural-language question. |
registry.functions | Function registry: per-band recipes that turn raw upstream sources into one signed fact. |
registry.schema | Active CDDL/JSON schema bundle, describes Receipt, Fact, RecallResp shapes on the wire. |
corpus.state_stats | Signed snapshot of corpus liveness: distinct_cells, distinct_bands, facts_scanned, top per-band counts. |
Read live from the server on November 15, 2026.
Maintain this server? Claiming proves you own the listing and earns the last 4 points.
Claim this listingPaste this line near the top of your repository's README. The badge always renders the current score.
[](https://aiagentslisting.com/mcp/emem)Nothing comparable is listed yet.
v2.4.5epistemic_settlementRelease notesv2.4.42.4.4-releaseRelease notesv2.4.2prodRelease notesv2.4.0federationRelease notesv2.3.0securityRelease notesv2.2.0Release notesv2.1.0guard for agentsRelease notesv2.0.0Stable for AgentsRelease notesv1.4.0StableRelease notesv1.3.0Satellites Join multi-agent to provide a single source of truth.Release notesv1.2.1StableRelease notesv1.2.0StablereleaseRelease notesConnect to the AI Agents Listing MCP server at https://aiagentslisting.com/api/mcp using the HTTP transport and complete the sign-in when it asks. Then call the submit_review tool for the listing "emem" with a rating from 1 to 5 and a short note on what worked and what did not.No reviews yet
Be the first to share your experience with this tool.
One email a week. New agents, MCP servers and skills, and what is actually getting traction.