emem, the verifiable memory protocol for the physical world is a remote MCP server that gives an AI agent 16 tools, among them emem_ask, emem_echo_verify, emem_entity. It answers at https://emem.dev/mcp over streamable HTTP, and it listed its tools to an anonymous client, so no sign-in was needed for that. Our probes reached it 6 of 6 times since 11 September 2026; the last check, on 21 October 2026, succeeded.
Shared memory for AI agents. One address per fact, one signature you check. No key to read.
Description as the publisher wrote it.
| Tool | What it does |
|---|---|
emem_ask | Single-shot free-text answer about a real-world location, backed by signed satellite/elevation/water/built-up receipts. Forwards a place mention plus a question; runs the locate → recall → algorithm chain server-side; returns one packaged e Inputs: cell, include, include_image, lat, lng, model |
emem_echo_verify | Grade a value you are about to emit against the signed fact your citation points at. Returns `matches` and, when it does not, the `drift` between what you were about to say and what emem holds. This is the step that turns a transcription er Inputs: claimed_value, strict, token |
emem_entity | Give a real-world object (a bridge, a farm plot, a river, a named place) a single, shared, content-addressed identity that any agent resolves the same way. Returns an `entity_token` (`emem:entity:<entity_cid>`) plus a signed receipt that at Inputs: cell, external_ids, kind, label, lat, lng |
emem_entity_link | Record a signed equivalence: bind an alternate label or a stable external id (GERS / OSM / Wikidata) to an existing canonical object so future `emem_entity_resolve` calls on that phrasing converge to the same entity_cid. Builds the shared r Inputs: alias, entity_cid, entity_token, external_ids |
emem_entity_resolve | Converge a fuzzy phrasing onto the canonical object other agents already minted, so everyone co-refers to the same identity instead of re-minting divergent ones. Pass `text` (e.g. "the collapsed span at the ford") to get ranked existing can Inputs: k, label, near, text, token |
emem_find_similar | k-NN over the corpus by cell embedding or inline vector. Returns `neighbours` ordered nearest-first, each with `cell64`, `score` and the `band` scanned, plus a signed receipt over the vectors read. Scoring is `mode`: cosine is exact fp32; h Inputs: as_of_signed_at, as_of_tslot, band, cell, cell64, filter |
emem_guard_verdict | Run emem-guard's policy pipeline over text you are about to send, against this responder's corpus. Finds every emem: citation, resolves each one, and returns allow or deny with a machine-readable reason: `EMEM-GUARD DENY <CODE> token=<token Inputs: agent, claim_gating, shape, texts |
emem_intent | Say what you want in one typed object and get the answer, without choosing a primitive. `type` is a tagged union: it selects the intent AND decides which other fields are read, so send only the fields its row needs. The plan is EXECUTED in Inputs: a, b, band, cell, claim, description |
emem_locate | Mint the canonical, vendor-neutral address (cell64) for a real-world place: the shared spatial identity every agent resolves to identically, so two models refer to the same ground instead of two descriptions of it. Also returns the topic-gr Inputs: lat, lng, name, place, q, query |
emem_memory_bundle | Compose N (cell, band, tslot?) triples into ONE signed envelope. Each triple runs through the standard auto-materialize recall path; the resulting fact_cids are bundled into a content-addressed envelope and the responder signs over the full Inputs: purpose, scope, triples |
emem_memory_contradictions | Surface where the corpus DISAGREES with itself (algebra: competing evidence). When two or more independent sources signed different values for the same place + band + time, this returns that disagreement with a 0–1 severity score and citati Inputs: band, cell, cell64, cell_prefix, include_same_attester_sources, limit |
emem_memory_token | Mint a citation handle, `emem:fact:<cell64>:<fact_cid>` (or `:<state_cid>`), that any agent or LLM resolves to the byte-identical signed object. The antidote to referential drift on the value side: hand this one string to another agent inst Inputs: band, cell, fact_cid, observed_on |
emem_memory_token_resolve | Parse a `emem:fact:<cell64>:<fact_cid>` citation handle and return the reading it cites. `value`, `unit`, `band` and `kind` are on the response at the TOP level, alongside the full signed `fact` body they were lifted from. Saves the agent f Inputs: token |
emem_recall | Read the signed facts at a canonical address (cell64); auto-materializes on a miss for any band with a registered materializer. A fact_cid names one signed attestation, so a recalled fact is citeable and re-verifiable rather than a paraphra Inputs: as_of_signed_at, as_of_tslot, band, bands, cell, cell64 |
emem_tools | The map of emem's tool surface, and the only tool you need to find the rest. Returns the working loop in the order you walk it (name a thing, ground it, cite it, resolve it, verify it, check for drift), then every other tool grouped by the Inputs: bundle, category, name, q, shape, tier |
emem_verify_receipt | Verify a signed receipt envelope server-side: rebuilds the canonical preimage under the rule the receipt's OWN `preimage_version` names (v2, current: tagged length-prefixed segments plus a segment binding the inclusion proof; v1: the same w Inputs: current_responder_epoch, facts, pubkey_b32, receipt |
Every block below points at https://emem.dev/mcp. Pick your client and copy.
claude mcp add --transport http emem-the-verifiable-memory-proto https://emem.dev/mcp
{
"mcpServers": {
"emem-the-verifiable-memory-proto": {
"command": "npx",
"args": ["-y", "mcp-remote", "https://emem.dev/mcp"]
}
}
}{
"mcpServers": {
"emem-the-verifiable-memory-proto": {
"url": "https://emem.dev/mcp"
}
}
}{
"servers": {
"emem-the-verifiable-memory-proto": {
"type": "http",
"url": "https://emem.dev/mcp"
}
}
}{
"context_servers": {
"emem-the-verifiable-memory-proto": {
"url": "https://emem.dev/mcp"
}
}
}{
"mcpServers": {
"emem-the-verifiable-memory-proto": {
"serverUrl": "https://emem.dev/mcp"
}
}
}{
"mcpServers": {
"emem-the-verifiable-memory-proto": {
"url": "https://emem.dev/mcp"
}
}
}name: emem, the verifiable memory protocol for the physical world
version: 0.0.1
schema: v1
mcpServers:
- name: emem, the verifiable memory protocol for the physical world
type: streamable-http
url: https://emem.dev/mcp{
"mcpServers": {
"emem-the-verifiable-memory-proto": {
"httpUrl": "https://emem.dev/mcp"
}
}
}{
"mcpServers": {
"emem-the-verifiable-memory-proto": {
"type": "http",
"url": "https://emem.dev/mcp"
}
}
}{
"mcpServers": {
"emem-the-verifiable-memory-proto": {
"url": "https://emem.dev/mcp"
}
}
}goose://extension?url=https%3A%2F%2Femem.dev%2Fmcp&type=streamable_http&id=emem-the-verifiable-memory-proto&name=emem%2C%20the%20verifiable%20memory%20protocol%20for%20the%20physical%20world
It answered our last check on 21 October 2026 in 664 ms. Over 6 checks since 11 September 2026 it answered 6. Status here comes from Neuronto's own probes, not from the publisher.
16, as returned by the server's own tools/list on 13 September 2026: emem_ask, emem_echo_verify, emem_entity, emem_entity_link, emem_entity_resolve, emem_find_similar, emem_guard_verdict, emem_intent, and 8 more.
It answered our last check on 21 October 2026 in 664 ms. Over 6 checks since 11 September 2026 it answered 6.
Put the server under mcpServers in ~/.cursor/mcp.json with the URL https://emem.dev/mcp. The exact JSON is above, with the same setup for Claude Code, Claude Desktop, VS Code, Windsurf, Zed, Gemini CLI and the rest.
It listed its tools to an anonymous client, so reading the tool list needs no key. Individual tools can still ask for credentials in their own inputs.
Publisher: io.github.vortx-ai. Endpoint host: emem.dev. ARD identifier: urn:air:io.github.vortx-ai:mcp:emem.
First indexed 10 September 2026. The tools are exactly what the server returned; nothing on this page
is inferred from its name. Ranking in Neuronto search is never for sale.